Roo Code：开源 AI 编程助手的深度解析
NOTE
本文档最后更新于 2026年4月，深入剖析 Roo Code 的技术架构、与 Cline 的渊源、核心功能配置及与主流 AI 编程工具的对比分析。
目录
- 概述与历史渊源
- 与 Cline 的关系解析
- 核心功能详解
- 安装与配置指南
- 高级配置与自定义
- MCP 协议集成
- 自定义 Prompt 工程
- 协作模式与团队使用
- 与主流工具的对比分析
- 开源优势与局限性
- 实战场景与最佳实践
- 常见问题与故障排除
- 选型建议
- 参考资料
概述与历史渊源
什么是 Roo Code
Roo Code（前身为 “Cline”）是一款运行在 VS Code 和 JetBrains IDE 中的开源 AI 编程助手。它允许开发者通过自然语言描述直接生成代码、修改文件、执行终端命令、操作浏览器等操作。与传统的代码补全工具不同，Roo Code 以自主代理（Autonomous Agent） 的形式工作，能够理解项目上下文、规划任务步骤、调用多种工具来完成复杂编程任务。
Roo Code 的核心设计理念是让 AI 成为真正的编程搭档，而非仅仅是一个代码片段生成器。它支持多文件编辑、Git 操作、文件系统操作，并能访问 Web 通过 browser 工具搜索信息或验证事实。
项目背景
Roo Code 由独立开发者 saoud（网名）于 2023 年创建，最初命名为 Cline（Claude Line 的缩写）。2024 年底，由于与 Anthropic 公司就商标问题进行协商，Cline 正式更名为 Roo Code（Roo 取自袋鼠，呼应 Anthropic 的 Claude 命名体系）。
更名后项目继续保持高速发展，截至 2026 年初：
- GitHub Stars: 55,000+
- 周下载量: 200,000+
- 活跃贡献者: 100+
- 支持的模型: 15+
核心理念
# Roo Code 设计哲学
┌─────────────────────────────────────────────────────────────┐
│ 核心理念 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 1. 开发者优先 │
│ ├─ 开发者保持对代码的完全控制 │
│ ├─ AI 是协作者而非替代者 │
│ └─ 决策权始终在开发者手中 │
│ │
│ 2. 透明可控 │
│ ├─ 开源代码，完全可审计 │
│ ├─ 可配置的权限和安全设置 │
│ └─ 清晰的操作日志 │
│ │
│ 3. 开放生态 │
│ ├─ 支持多种 AI 模型 │
│ ├─ MCP 协议扩展 │
│ └─ 完全可定制的工作流 │
│ │
│ 4. 隐私保护 │
│ ├─ 支持本地模型运行 │
│ ├─ 代码不强制上传到云端 │
│ └─ 敏感项目可完全离线 │
│ │
└─────────────────────────────────────────────────────────────┘与传统工具的区别
| 维度 | 传统代码补全 | Roo Code |
|---|---|---|
| 交互方式 | 自动补全 | 对话式交互 |
| 上下文 | 当前文件 | 整个项目 |
| 操作能力 | 仅生成代码 | 执行文件操作 |
| 任务处理 | 单次请求 | 多步骤任务 |
| 自主性 | 无 | 可配置自主级别 |
| 学习方式 | 无 | 理解项目结构 |
与 Cline 的关系解析
命名变更始末
2024 年 11 月，Anthropic 向 Cline 项目发送了商标侵权通知，要求项目更名。理由是 “Cline” 与 “Claude” 在视觉和听觉上存在混淆可能。项目维护者经过慎重考虑后决定配合更名，将项目改名为 Roo Code。
IMPORTANT
更名仅涉及品牌层面，核心代码保持不变。用户无需担心功能缺失或数据迁移问题，所有 Cline 的配置和历史记录均可无缝迁移至 Roo Code。
变更时间线
| 时间 | 事件 | 影响 |
|---|---|---|
| 2023.12 | Cline v1 发布 | 初始版本 |
| 2024.03 | Cline v2 | MCP 支持 |
| 2024.07 | Cline v3 | JetBrains 支持 |
| 2024.11 | 收到商标通知 | 开始更名讨论 |
| 2024.12 | Roo Code v3.5 | 正式更名 |
| 2025.01 | Roo Code v4.0 | 全新品牌 |
| 2026.01 | Roo Code v5.0 | 多 Agent 支持 |
Fork 分支生态
Cline 更名后，社区出现了多个 Fork 分支，形成了一个有趣的开源生态：
| 分支名称 | 维护者 | 特点 | 状态 |
|---|---|---|---|
| Roo Code | سعود | 官方主分支，持续更新 | 活跃维护 |
| Cline Fork | community | 保持原名，部分功能增强 | 社区维护 |
| Roo Code Pro | community | 添加高级功能 | 独立分支 |
| Roo Code Plus | community | 性能优化 | 独立分支 |
TIP
用户应优先选择 Roo Code 官方版本，以获得最稳定的功能更新和安全补丁。
核心功能详解
1. 多步骤任务执行
Roo Code 的核心能力在于能够将复杂任务分解为多个步骤，并自主执行：
用户请求 → 任务规划 → 工具调用 → 结果验证 → 迭代优化
任务循环机制
# 任务执行流程
1. 理解阶段
├─ 分析用户输入
├─ 提取关键信息
└─ 识别约束条件
2. 规划阶段
├─ 拆解子任务
├─ 确定执行顺序
└─ 预估风险
3. 执行阶段
├─ 调用适当工具
├─ 处理中间结果
└─ 错误处理
4. 验证阶段
├─ 检查执行结果
├─ 确认任务完成
└─ 生成报告示例工作流
用户：创建一个用户注册功能，包含邮箱验证和密码加密
Roo Code 分析：
1. 检查现有数据库 Schema
└─ Read: prisma/schema.prisma
2. 创建用户表迁移文件
└─ Write: prisma/migrations/xxx_create_user.sql
3. 实现注册 API 路由
└─ Write: src/routes/auth/register.ts
4. 添加邮箱格式验证
└─ Edit: src/validators/email.ts
5. 集成 bcrypt 密码加密
└─ Edit: src/services/authService.ts
6. 编写单元测试
└─ Write: src/__tests__/auth.test.ts
7. 更新 API 文档
└─ Edit: docs/api/auth.md
✅ 任务完成！
2. 工具生态系统
Roo Code 内置了丰富的工具，能够完成多种开发任务：
| 工具名称 | 功能描述 | 使用场景 |
|---|---|---|
read | 读取文件内容 | 理解现有代码 |
write | 写入或创建文件 | 生成新代码 |
edit | 精确修改文件 | 局部代码调整 |
delete | 删除文件或目录 | 清理冗余代码 |
bash | 执行 Shell 命令 | 运行测试、构建 |
browser | 访问网页 | 搜索文档、验证 API |
grep | 全文搜索 | 定位代码位置 |
glob | 文件模式匹配 | 批量文件操作 |
工具使用示例
// 读取文件
Read: src/utils/format.ts
// 返回文件内容供分析
// 写入文件
Write: src/components/UserCard.tsx
---
import React from 'react';
interface UserProps {
name: string;
email: string;
avatar?: string;
}
export const UserCard: React.FC<UserProps> = ({ name, email, avatar }) => {
return (
<div className="user-card">
{avatar && <img src={avatar} alt={name} />}
<h3>{name}</h3>
<p>{email}</p>
</div>
);
};
---
// 编辑文件
Edit:
File: src/utils/format.ts
Old: return value.toLowerCase();
New: return value.trim().toLowerCase();
// 执行命令
Terminal: npm test -- user.test.ts
// 搜索代码
Grep: "useAuth"
In: src/
// 文件模式匹配
Glob: src/**/*.test.ts3. MCP 协议支持
Roo Code 原生支持 Model Context Protocol（MCP），可以连接外部工具和服务：
// .roo/mcp.json 配置示例
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "./src"]
},
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": {
"GITHUB_TOKEN": "your-token-here"
}
},
"memory": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-memory"]
},
"slack": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-slack"],
"env": {
"SLACK_BOT_TOKEN": "xoxb-..."
}
}
}
}4. 多模型支持
Roo Code 不绑定特定 AI 提供商，支持多种模型：
| 提供商 | 支持模型 | API 格式 |
|---|---|---|
| Anthropic | Claude 3.5/3.7 Sonnet, Opus, Haiku | Anthropic API |
| OpenAI | GPT-4o, o1, o3 | OpenAI Compatible |
| Gemini 2.0 Pro/Flash | Google AI API | |
| Ollama | Llama, Qwen, Mistral 等 | Ollama Local |
| LM Studio | 本地量化模型 | OpenAI Compatible |
| OpenRouter | 聚合多模型 | OpenAI Compatible |
| DeepSeek | DeepSeek V3/R1 | DeepSeek API |
TIP
使用 Ollama 或 LM Studio 运行本地模型，数据完全保留在本地，适合处理敏感代码或离线开发场景。
5. 成本控制机制
Roo Code 内置详细的 Token 计数和成本追踪功能：
会话统计：
├─ 输入 Token：12,450
├─ 输出 Token：3,280
├─ 预估成本：$0.08
└─ 速率限制：安全（低于阈值）
用户可以设置每会话或每日成本上限，防止意外超支：
{
"roo-code": {
"costControl": {
"enabled": true,
"maxCostPerSession": 5.0,
"maxCostPerDay": 50.0,
"alertThreshold": 0.8
}
}
}6. 对话管理
# 对话功能
## 基本操作
├─ 新建会话：/new
├─ 继续对话：继续输入即可
├─ 清空对话：/clear
└─ 导出对话：/export
## 上下文管理
├─ @file: 添加文件到上下文
├─ @folder: 添加文件夹到上下文
├─ @search: 添加搜索结果到上下文
└─ @git: 添加 Git 信息到上下文
## 对话技巧
├─ 使用 "继续" 执行上一个命令的后续步骤
├─ 使用 "撤销" 回退上一步操作
└─ 使用 "解释" 请求解释生成的代码安装与配置指南
环境要求
| 要求 | 最低配置 | 推荐配置 |
|---|---|---|
| IDE | VS Code 1.75+ / WebStorm 2024+ | VS Code 最新版 |
| 网络 | 能访问 AI API | 稳定快速连接 |
| 内存 | 4GB 可用 | 8GB+ 可用 |
| 磁盘 | 200MB 可用 | 无特殊要求 |
安装步骤
VS Code 安装
- 打开 VS Code，进入 Extensions（扩展）面板
- 搜索 “Roo Code” 或 “Roo Code”
- 点击安装（注意识别官方发布者）
- 安装完成后，按
Cmd/Ctrl + Shift + P打开命令面板 - 输入 “Roo Code: Open Settings” 打开配置
# 或者使用命令行安装
code --install-extension saoudrizwan.roo-code
# VSIX 文件安装
code --install-extension roo-code-*.vsixJetBrains 安装
- 打开 JetBrains IDE，进入 Settings → Plugins
- 搜索 “Roo Code” 或 “Roo Code”
- 安装插件并重启 IDE
NOTE
JetBrains 版本功能可能略有不同，部分功能在 JetBrains 上可能不可用。
API Key 配置
Roo Code 需要配置 AI API Key 才能工作：
1. Anthropic API Key（推荐）
// 设置页面配置
{
"apiProvider": "anthropic",
"apiKey": "sk-ant-xxxxx",
"model": "claude-sonnet-4-20250514"
}获取方式：
- 访问 https://console.anthropic.com/
- 注册账户并登录
- 进入 API Keys 页面
- 点击 “Create Key” 生成新的 API Key
2. OpenAI API Key
{
"apiProvider": "openai",
"apiKey": "sk-xxxxx",
"model": "gpt-4o"
}获取方式：
- 访问 https://platform.openai.com/
- 注册账户并登录
- 进入 API Keys 页面
- 创建新的 Secret Key
3. OpenRouter（聚合方案）
{
"apiProvider": "openrouter",
"apiKey": "sk-or-xxxxx",
"model": "anthropic/claude-sonnet-4"
}IMPORTANT
API Key 应妥善保管，切勿提交至代码仓库。建议使用环境变量或 IDE 的 Secrets Storage。
高级配置与自定义
系统提示词定制
Roo Code 允许通过自定义系统提示词来调整 AI 行为：
# .roo/system_prompt.md
# cursorules
# 角色定义
你是一个经验丰富的前端架构师，专注于 React 和 TypeScript。
# 约束条件
- 优先使用函数式组件和 Hooks
- 所有组件必须编写 PropTypes 或 TypeScript 类型
- 遵循 Airbnb JavaScript Style Guide
- 组件文件不超过 200 行，超出则必须拆分
- 使用 Tailwind CSS 进行样式设计
- 遵循原子化 CSS 原则
# 代码规范
- 变量命名：camelCase
- 组件命名：PascalCase
- 常量命名：UPPER_SNAKE_CASE
- 文件命名：kebab-case.tsx
# 输出格式
- 代码块必须标注语言类型
- 复杂逻辑需附加注释
- 最后给出时间复杂度分析
# 错误处理
- 所有异步操作必须使用 try-catch
- 统一使用自定义 Error 类
- 添加适当的日志记录
# 性能优化
- 优先使用 React.memo
- 使用 useMemo 和 useCallback
- 实现虚拟滚动优化长列表任务批准模式
Roo Code 提供三种任务批准模式，平衡自动化与安全性：
| 模式 | 描述 | 适用场景 |
|---|---|---|
| Auto Approve | 所有操作自动执行 | 简单任务、熟悉代码库 |
| Ask After Every Tool Call | 每个工具调用前询问 | 谨慎开发、数据敏感 |
| Never Approve | 完全手动模式 | 审计需求、完全控制 |
配置方式
{
"roo-code": {
"autoApprove": "ask",
"autoApproveExportFunctions": true,
"autoApproveIntelligent": false,
"askForDrafts": true,
"maxAutoApproveEdits": 5
}
}任务模板
定义可复用的任务模板，加速常见开发流程：
// .roo/templates/react-component.json
{
"name": "创建 React 组件",
"description": "生成标准化的 React 函数组件",
"prompt": "创建一个新的 React 函数组件，名为 {componentName}，包含：
1. TypeScript Props 接口
2. 使用 useState 和 useEffect
3. 导出默认组件和命名组件
4. 包含 Jest 测试文件
5. 使用 CSS Modules 样式",
"variables": [
{
"name": "componentName",
"type": "string",
"required": true,
"description": "组件名称（PascalCase）"
}
]
}快捷键配置
优化工作流程的快捷键设置：
// keybindings.json
{
"roo-code.keybindings": [
{
"key": "cmd+shift+r",
"command": "roo-code.new-task"
},
{
"key": "cmd+shift+a",
"command": "roo-code.accept-suggestion"
},
{
"key": "cmd+shift+d",
"command": "roo-code.discard"
},
{
"key": "cmd+shift+c",
"command": "roo-code.toggle-panel"
}
]
}高级设置
{
"roo-code": {
"general": {
"model": "claude-sonnet-4-20250514",
"temperature": 0.7,
"maxTokens": 8192,
"stream": true
},
"sandbox": {
"dangerouslySkipParse": false,
"maxWorkspaceSize": "500MB",
"allowedPaths": ["${workspaceFolder}"]
},
"tools": {
"bash": {
"timeout": 60,
"cwd": "${workspaceFolder}"
},
"browser": {
"headless": true,
"viewport": { "width": 1280, "height": 720 }
}
},
"ui": {
"showWelcomeMessage": true,
"showTokenCount": true,
"showCostEstimate": true
}
}
}MCP 协议集成
MCP 简介
Model Context Protocol (MCP) 是一个开放标准，允许 AI 系统与外部工具进行标准化交互。Roo Code 原生支持 MCP，可以连接各种服务扩展功能。
常用 MCP 服务器
1. 文件系统服务器
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem"],
"allowedDirectories": ["/path/to/project"]
}
}
}2. GitHub 服务器
{
"mcpServers": {
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": {
"GITHUB_TOKEN": "${GITHUB_TOKEN}"
}
}
}
}3. Memory 服务器
{
"mcpServers": {
"memory": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-memory"]
}
}
}MCP 工具使用示例
# GitHub 集成示例
用户: 创建 GitHub issue 报告这个 bug
Roo Code:
Tool: use_mcp_tool
Server: github
Tool: create_issue
Arguments:
{
"owner": "username",
"repo": "my-project",
"title": "Bug: Login fails with special characters",
"body": "## Description\n\nLogin fails when username contains... ",
"labels": ["bug", "high-priority"]
}
# Slack 通知示例
用户: 通知团队新版本已部署
Roo Code:
Tool: use_mcp_tool
Server: slack
Tool: send_message
Arguments:
{
"channel": "#engineering",
"text": "🚀 Version 2.0.0 deployed to production!"
}自定义 Prompt 工程
Prompt 设计原则
# 有效的 Prompt 设计
## 1. 清晰的结构
├─ 角色定义（可选）
├─ 任务描述
├─ 约束条件
├─ 输出格式
└─ 示例（可选）
## 2. 具体的要求
├─ 使用具体而非抽象
├─ 提供足够的上下文
├─ 说明预期结果
└─ 指定限制条件
## 3. 迭代优化
├─ 从简单开始
├─ 根据结果调整
├─ 添加更多细节
└─ 持续改进常用 Prompt 模板
1. 代码生成模板
# 代码生成 Prompt
请生成 [编程语言] 代码，实现 [功能描述]。
## 技术要求
- 语言：[具体语言和版本]
- 框架：[使用的框架]
- 类型系统：[是否需要类型]
## 功能要求
[详细描述需要实现的功能]
## 约束条件
- 性能要求：[如有]
- 安全性：[如有]
- 兼容性：[如有]
## 输出格式
- 完整可运行的代码
- 包含必要的注释
- 附带使用示例2. 代码重构模板
# 代码重构 Prompt
请重构以下代码，目标：
1. 提高可读性
2. 优化性能
3. 提升可维护性
4. 保持功能不变
## 当前代码
[粘贴代码]
## 重构要求
- 保持 API 兼容性
- 不改变外部行为
- 添加适当的测试
## 关注点
[指定需要特别关注的方面]3. Bug 修复模板
# Bug 修复 Prompt
我遇到了一个问题，请帮忙分析和修复。
## 错误信息
[粘贴错误日志或描述]
## 相关代码
[粘贴相关代码片段]
## 复现步骤
[描述如何复现这个问题]
## 环境信息
- 语言/框架版本：
- 操作系统：
- 其他相关依赖：项目级 Prompt
# .roo/project-prompt.md
## 项目信息
- 项目名称：[项目名称]
- 技术栈：[技术栈描述]
- 代码风格：[风格指南]
## 架构规范
- 目录结构：[描述]
- 模块划分：[描述]
- 设计模式：[描述]
## 代码规范
[详细的代码规范]
## 安全要求
[安全相关的约束]协作模式与团队使用
个人使用模式
# 个人使用配置
## 基本设置
- 批准模式：Ask After Every Tool Call
- 日志记录：全部记录
- 成本追踪：启用
## 常用任务
1. 代码生成
2. Bug 修复
3. 重构
4. 测试生成
5. 文档编写团队协作配置
{
"roo-code": {
"team": {
"sharedRules": true,
"rulesPath": ".roo/team-rules",
"approvalWorkflow": {
"enabled": true,
"requireApprovalFor": [
"delete",
"bash"
],
"approvers": ["team-lead", "senior-dev"]
}
}
}
}团队规则示例
# .roo/team-rules/default.mdc
## 团队代码规范
### TypeScript
- 严格模式
- 禁止 any
- 必须有类型注解
### React
- 函数组件
- Hooks 优先
- 组件拆分原则
### Git
- 提交信息格式
- 分支命名规范
- Code Review 要求与主流工具的对比分析
功能矩阵对比
| 功能 | Roo Code | Cursor | GitHub Copilot | Claude Code |
|---|---|---|---|---|
| 代码生成 | ✅ | ✅ | ✅ | ✅ |
| 多文件编辑 | ✅ | ✅ | ✅ | ✅ |
| 终端命令执行 | ✅ | ❌ | ❌ | ✅ |
| Web 搜索 | ✅ | ❌ | ❌ | ✅ |
| Git 操作 | ✅ | 部分 | ❌ | ✅ |
| MCP 扩展 | ✅ | ✅ | ❌ | ❌ |
| 本地模型 | ✅ | ❌ | ❌ | ❌ |
| 价格 | 免费 | $20/月 | $10/月 | $25/月 |
| 开源 | ✅ | ❌ | ❌ | ❌ |
成本对比
| 工具 | 订阅费用 | API 成本 | 总成本 |
|---|---|---|---|
| Roo Code | 免费 | 按量付费（自选模型） | 极低 |
| Cursor Pro | $20/月 | 包含在订阅内 | $20/月 |
| Copilot | 19/月（企业） | 包含在订阅内 | $10-19/月 |
| Claude Code | $25/月 | 包含在订阅内 | $25/月 |
TIP
使用 Roo Code + Ollama 本地模型，总成本趋近于零，且数据完全隐私。
适用场景推荐
| 场景 | 推荐工具 | 理由 |
|---|---|---|
| 个人开发者、低预算 | Roo Code | 完全免费，灵活配置 |
| 企业团队、安全合规 | Copilot Business | SOC 认证、权限管理 |
| 快速原型、创意工作 | Cursor | 优秀 UX、Tab 补全 |
| 深度代码分析、审计 | Claude Code | 最强代码理解能力 |
| 隐私敏感、离线开发 | Roo Code + Ollama | 完全本地、数据不出境 |
详细对比
Roo Code vs Cline
| 维度 | Roo Code | Cline |
|---|---|---|
| 品牌 | Roo Code | Cline |
| 核心功能 | 相同 | 相同 |
| 维护者 | سعود | سعود |
| 社区 | 活跃 | 活跃 |
| 更新频率 | 每周 | 每周 |
| 建议选择 | 新用户 | 老用户可继续使用 |
Roo Code vs Cursor
| 维度 | Roo Code | Cursor |
|---|---|---|
| 许可证 | MIT | 专有 |
| 价格 | 免费 | $20/月 |
| IDE | VS Code/JetBrains 扩展 | 自有 IDE |
| Tab 补全 | ❌ | ✅ |
| 实时补全 | ❌ | ✅ |
| 多模型支持 | ✅ | ✅ |
| 本地模型 | ✅ | ❌ |
| 学习曲线 | 中等 | 低 |
开源优势与局限性
开源优势
1. 透明性与可审计性
开源意味着任何人都可以审查代码逻辑：
代码审计路径：
1. GitHub 仓库 → 完整源代码
2. 提交历史 → 变更追踪
3. Issue 区 → 已知问题
4. PR 区 → 社区审核
NOTE
对于企业用户，可自行审计代码确保无后门或数据泄露风险，这是闭源工具无法提供的保障。
2. 社区驱动创新
开源社区持续贡献新功能和改进：
- 第三方 MCP 服务器：社区开发的 Salesforce、Notion 等集成
- 主题和 UI 改进：用户贡献的界面优化
- 功能增强分支：实验性功能的试验田
3. 数据隐私
完全本地运行的能力：
# 使用 Ollama 完全离线
ollama pull llama3.2
# Roo Code 配置
{
"apiProvider": "ollama",
"apiBase": "http://localhost:11434"
}所有代码和对话都在本地处理，不经过任何第三方服务器。
4. 社区支持
# 社区资源
## 官方渠道
├─ GitHub Issues：Bug 报告和功能请求
├─ GitHub Discussions：使用讨论
└─ Discord：实时交流
## 社区资源
├─ Awesome Roo Code：精选资源列表
├─ Roo Code Templates：模板分享
└─ 博客教程：用户分享经验局限性
1. 用户体验
| 局限 | 说明 | 影响 |
|---|---|---|
| 无 Tab 补全 | 缺乏实时代码补全 | 需要主动触发对话 |
| 界面简陋 | 功能优先于界面 | 学习成本略高 |
| 需要配置 | 非开箱即用 | 初始设置时间 |
2. 功能深度
| 局限 | 说明 | 影响 |
|---|---|---|
| Agent 稳定性 | 不如 Claude Code | 复杂任务可能失败 |
| 多模态 | 图片理解较弱 | 视觉相关任务受限 |
| 代码索引 | 无内置语义搜索 | 大项目查询受限 |
3. 生态整合
| 局限 | 说明 | 影响 |
|---|---|---|
| IDE 深度 | 无原生 IDE 集成 | 某些功能受限 |
| 协作功能 | 无内置协作 | 依赖外部工具 |
| 企业支持 | 无官方企业版 | 大企业采购受限 |
实战场景与最佳实践
场景一：快速构建 CRUD API
Prompt 示例：
使用 Express + TypeScript 创建一个用户管理 API，包含：
1. 用户注册（POST /users/register）
2. 用户登录（POST /users/login）
3. 获取用户信息（GET /users/:id）
4. 更新用户信息（PUT /users/:id）
5. 删除用户（DELETE /users/:id）
要求：
- 使用 Prisma ORM
- JWT 认证
- 输入验证（Zod）
- 统一错误处理
- Swagger 文档执行流程：
- Roo Code 分析项目结构
- 创建
src/routes/users.ts - 创建
src/controllers/userController.ts - 创建
src/services/userService.ts - 添加
src/middleware/auth.ts - 更新
app.ts注册路由 - 创建
prisma/schema.prisma - 编写单元测试
场景二：代码重构与迁移
Prompt 示例：
将项目中的 JavaScript 代码迁移到 TypeScript，具体要求：
1. 为所有函数添加 TypeScript 类型
2. 使用 interface 替代 PropTypes
3. 将 .js 文件重命名为 .ts
4. 更新 import 语句
5. 修复类型错误
6. 运行 tsc --noEmit 验证
注意保持原有功能和测试通过。场景三：Bug 定位与修复
Prompt 示例：
用户在注册时遇到 "Email already exists" 错误，但数据库中并无该邮箱记录。
请：
1. 检查注册 API 的邮箱验证逻辑
2. 查看数据库查询语句
3. 检查是否存在大小写敏感问题
4. 验证请求参数是否正确处理
5. 定位问题并提供修复方案场景四：性能优化
Prompt 示例：
分析 src/services/userService.ts 中 getUserById 函数的性能问题：
当前实现：
[粘贴代码]
已知问题：
- 数据库查询 N+1 问题
- 缺少缓存
- 响应时间 > 500ms
请：
1. 识别性能瓶颈
2. 优化查询逻辑
3. 添加缓存机制
4. 提供优化前后的性能对比场景五：测试生成
Prompt 示例：
为 src/utils/validator.ts 中的 validateEmail 函数生成完整的测试用例：
要求：
- 使用 Vitest 框架
- 测试用例命名清晰
- 包含正常情况和边界情况
- 包含错误情况
- 测试覆盖率 > 90%常见问题与故障排除
安装问题
问题 1：扩展安装失败
解决方案：
- 确认 VS Code 版本 ≥ 1.75
- 检查网络连接
- 清除扩展缓存
- 重启 VS Code
问题 2：扩展不显示
解决方案：
- 检查扩展是否启用
- 尝试重新加载窗口
- 检查控制台错误
配置问题
问题 3：API 密钥无效
解决方案：
- 确认 API 密钥正确
- 检查 API 额度
- 确认 API 权限
- 尝试重新生成密钥
问题 4：模型连接失败
解决方案：
- 确认模型服务运行
- 检查端口配置
- 确认防火墙设置
- 查看日志
使用问题
问题 5：任务执行失败
解决方案：
- 简化任务描述
- 提供更多上下文
- 分解为多个小任务
- 开始新的对话
问题 6：文件操作失败
解决方案：
- 确认文件路径正确
- 检查文件权限
- 确认目录存在
- 手动创建目录
选型建议
何时选择 Roo Code
- ✅ 预算有限，无法承担每月 $10-25 的订阅费用
- ✅ 数据隐私要求严格，代码不能上传至第三方
- ✅ 需要高度自定义的 AI 行为
- ✅ 希望使用本地开源模型（如 Llama、Qwen）
- ✅ 欣赏开源文化，愿意参与社区建设
- ✅ 技术能力强，愿意配置和维护
何时选择其他工具
- ❌ 希望获得开箱即用的优秀体验 → 选择 Cursor
- ❌ 企业采购、需要 SLA 支持 → 选择 Copilot Business
- ❌ 主要进行深度代码分析和重构 → 选择 Claude Code
- ❌ 缺乏配置意愿，需要”傻瓜式”工具 → 选择 Copilot
混合使用策略
许多开发者采用组合策略：
日常简单任务：GitHub Copilot（实时补全）
复杂任务：Roo Code（自主代理）
深度分析：Claude Code（代码理解）
原型开发：Cursor（快速迭代）
隐私项目：Roo Code + Ollama（完全本地）
快速入门路径
- 第一天：安装 Roo Code，配置 API 密钥
- 第一周：完成几个小型任务，熟悉工具调用
- 第二周：尝试本地模型（Ollama）
- 第三周：自定义系统提示和工作流
- 第四周：探索 MCP 扩展
参考资料
官方资源
| 资源 | 链接 |
|---|---|
| 官方文档 | https://roocode.com/docs |
| GitHub 仓库 | https://github.com/saoudrizwan/roo-code |
| VS Code Market | https://marketplace.visualstudio.com/items?itemName=saoudrizwan.roo-code |
| JetBrains Plugin | https://plugins.jetbrains.com/plugin/roo-code |
| MCP 协议 | https://modelcontextprotocol.io |
社区资源
| 资源 | 说明 |
|---|---|
| Discord | 官方社区讨论 |
| GitHub Issues | Bug 反馈和功能请求 |
| r/roocode | |
| 官方更新 |
学习资源
# 推荐学习路径
## 入门
1. 官方文档快速入门
2. 基础配置教程
3. 第一个任务实战
## 进阶
1. 自定义 Prompt 工程
2. MCP 服务器配置
3. 工作流自动化
## 高级
1. 本地模型部署
2. 企业级配置
3. 自定义 MCP 开发API 提供商
| 提供商 | 定价页面 |
|---|---|
| Anthropic | https://www.anthropic.com/pricing |
| OpenAI | https://openai.com/api/pricing |
| https://ai.google.dev/pricing | |
| DeepSeek | https://api-docs.deepseek.com |
| Ollama | https://ollama.com |
| LM Studio | https://lmstudio.ai |
SUCCESS
Roo Code 作为开源 AI 编程助手的代表，以其高度可定制性、本地运行能力和零成本优势，成为 Copilot 和 Cursor 的有力替代方案。对于注重隐私、预算有限或热爱开源文化的开发者，Roo Code 是 vibecoding 工作流中不可或缺的工具。
Roo Code 高级配置与优化
1. 性能优化配置
// 性能优化配置
{
"roo-code": {
"performance": {
"maxConcurrentTools": 3,
"toolTimeout": 60,
"responseTimeout": 120,
"cacheEnabled": true,
"cacheSize": "100MB",
"streamResponses": true
},
"context": {
"maxFiles": 50,
"maxTokens": 100000,
"priorityFiles": ["*.ts", "*.tsx", "*.js"],
"excludePatterns": ["node_modules/**", "dist/**", "*.test.ts"]
}
}
}2. 安全强化配置
// 安全配置
{
"roo-code": {
"security": {
"allowedDirectories": ["${workspaceFolder}"],
"blockedCommands": [
"rm -rf /*",
"format C:",
"del /f /s /q"
],
"requireConfirmation": {
"delete": true,
"bash": true,
"network": true
},
"auditLogging": {
"enabled": true,
"path": ".roo/audit.log",
"includeContext": true
}
}
}
}3. 高级 MCP 配置
// MCP 服务器高级配置
{
"roo-code": {
"mcpServers": {
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem"],
"allowedDirectories": [
"${workspaceFolder}/src",
"${workspaceFolder}/tests"
],
"maxFileSize": "10MB"
},
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": {
"GITHUB_TOKEN": "${GITHUB_TOKEN}"
},
"scopes": ["repo", "read:user"]
},
"slack": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-slack"],
"env": {
"SLACK_BOT_TOKEN": "${SLACK_BOT_TOKEN}"
}
},
"database": {
"command": "node",
"args": ["./mcp-servers/database-server.js"],
"env": {
"DATABASE_URL": "${DATABASE_URL}"
}
}
}
}
}4. 自定义 MCP 服务器
// mcp-servers/database-server.ts
import { McpServer } from '@modelcontextprotocol/sdk/server';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio';
import { z } from 'zod';
import { PrismaClient } from '@prisma/client';
const prisma = new PrismaClient();
const server = new McpServer({
name: 'Database Server',
version: '1.0.0',
});
// 查询工具
server.tool(
'db-query',
'Execute a database query',
{
query: z.string().describe('SQL query to execute'),
params: z.array(z.any()).optional(),
},
async ({ query, params = [] }) => {
try {
const result = await prisma.$queryRawUnsafe(query, ...params);
return {
content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
};
} catch (error) {
return {
content: [{ type: 'text', text: `Error: ${error.message}` }],
isError: true,
};
}
}
);
// 查询用户
server.tool(
'db-get-user',
'Get a user by ID or email',
{
identifier: z.string().describe('User ID or email'),
},
async ({ identifier }) => {
const user = identifier.includes('@')
? await prisma.user.findUnique({ where: { email: identifier } })
: await prisma.user.findUnique({ where: { id: identifier } });
if (!user) {
return { content: [{ type: 'text', text: 'User not found' }], isError: true };
}
return {
content: [{ type: 'text', text: JSON.stringify(user, null, 2) }],
};
}
);
// 列出表
server.tool('db-list-tables', 'List all database tables', {}, async () => {
const tables = await prisma.$queryRaw`
SELECT table_name
FROM information_schema.tables
WHERE table_schema = 'public'
`;
return {
content: [{ type: 'text', text: JSON.stringify(tables, null, 2) }],
};
});
const transport = new StdioServerTransport();
server.run(transport);Roo Code 企业级部署
1. 企业配置示例
# .roo/enterprise-config.yaml
# 组织配置
organization:
name: "Acme Corporation"
domain: "acme.com"
sso:
enabled: true
provider: "okta"
clientId: "${OKTA_CLIENT_ID}"
clientSecret: "${OKTA_CLIENT_SECRET}"
# 用户管理
users:
defaultRole: "developer"
roles:
- name: "admin"
permissions: ["*"]
- name: "developer"
permissions:
- "read"
- "write"
- "execute"
- "test"
- name: "viewer"
permissions:
- "read"
# 安全策略
security:
audit:
enabled: true
retentionDays: 90
exportFormat: "json"
dataProtection:
encryptionEnabled: true
maskSensitiveData: true
sensitivePatterns:
- "password"
- "secret"
- "token"
- "apiKey"
# 成本控制
costControl:
enabled: true
budgetPerUser: 100.00
budgetPerMonth: 5000.00
alertThresholds:
- 50%
- 75%
- 90%
# 集成
integrations:
github:
enabled: true
autoSyncRules: true
slack:
enabled: true
channel: "#devops"
jira:
enabled: true
projectKey: "DEV"2. 团队规则模板
# .roo/team-rules/frontend.md
## React 组件规范
### 组件结构ComponentName/ ├── ComponentName.tsx # 主组件 ├── ComponentName.module.css # CSS 模块 ├── ComponentName.test.tsx # 测试 ├── index.ts # 导出 └── types.ts # 类型定义
### 命名规范
- 组件：PascalCase
- 文件：kebab-case
- 测试：ComponentName.test.tsx
- CSS 类：kebab-case
### 代码规范
- 使用函数组件
- Props 接口命名：ComponentNameProps
- 使用 React.FC 或直接函数声明
- 组件最大行数：200 行
- 提取自定义 Hooks
### 性能要求
- 大列表使用虚拟滚动
- 使用 React.memo 优化
- useCallback 和 useMemo 适当使用
- 懒加载组件
### 测试要求
- 覆盖率 > 80%
- 测试用户交互
- 测试边界情况
3. 审计日志配置
// .roo/audit-logger.ts
interface AuditEntry {
timestamp: string;
userId: string;
action: string;
target: string;
details?: Record<string, unknown>;
duration: number;
success: boolean;
error?: string;
}
class AuditLogger {
private entries: AuditEntry[] = [];
private flushInterval: number;
constructor(flushInterval = 60000) {
this.flushInterval = flushInterval;
setInterval(() => this.flush(), this.flushInterval);
}
log(entry: Omit<AuditEntry, 'timestamp'>) {
this.entries.push({
...entry,
timestamp: new Date().toISOString(),
});
}
async flush() {
if (this.entries.length === 0) return;
const entries = [...this.entries];
this.entries = [];
await fetch('/api/audit', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(entries),
});
}
}
export const auditLogger = new AuditLogger();Roo Code 最佳实践
1. 项目结构最佳实践
最佳项目结构示例：
project/
├── .roo/
│ ├── rules/ # 项目规则
│ │ ├── default.mdc
│ │ ├── typescript.mdc
│ │ └── react.mdc
│ ├── templates/ # 任务模板
│ │ ├── component.json
│ │ └── api.json
│ ├── workflows/ # 工作流
│ │ └── ci.yml
│ └── mcp.json # MCP 配置
├── src/
│ ├── components/
│ ├── hooks/
│ ├── services/
│ └── utils/
├── tests/
├── docs/
└── package.json
2. Prompt 工程最佳实践
# 高效 Prompt 设计原则
## 1. 结构化 Prompt
```markdown
## 角色
你是一个 [角色]，专注于 [领域]。
## 上下文
[提供项目背景和相关信息]
## 任务
[明确描述需要完成的任务]
## 约束
- [约束条件 1]
- [约束条件 2]
## 输出
[期望的输出格式]
## 示例
[提供参考示例]2. 渐进式 Prompt
阶段 1：基础需求
"创建一个 React 组件显示用户信息"
阶段 2：详细需求
"基于刚才的组件，添加：
- 头像显示
- 加载状态
- 错误处理"
阶段 3：优化需求
"现在优化这个组件：
- 使用 React.memo
- 添加 TypeScript 类型
- 包含测试"
3. 上下文管理
好实践：
- 使用 @ 引用文件
- 提供相关的代码片段
- 说明项目的技术栈
差实践：
- 不提供任何上下文
- 引用太多无关文件
- 描述过于笼统
### 3. 安全最佳实践
```markdown
# 使用 Roo Code 的安全准则
## 敏感操作
- 所有删除操作需要确认
- 网络请求需要确认
- Bash 命令需要确认
## 敏感信息
- 永远不在对话中分享密钥
- 使用环境变量存储敏感信息
- 定期轮换 API 密钥
## 代码审查
- AI 生成的代码必须审查
- 特别关注安全相关代码
- 运行安全扫描工具
## 本地模型
- 处理敏感代码时使用本地模型
- 确保 Ollama 正确配置
- 验证数据不出本地
4. 性能优化技巧
# 提升 Roo Code 性能
## 1. 减少上下文
- 只引用相关文件
- 避免加载整个目录
- 及时清空对话
## 2. 选择合适的模型
- 简单任务用轻量模型
- 复杂任务用强大模型
- 平衡速度和效果
## 3. 优化请求
- 简洁的 Prompt
- 明确的指令
- 避免重复
## 4. 本地缓存
- 使用 Ollama 缓存
- 减少 API 调用
- 提升响应速度
---
## Roo Code 与 DevOps 集成
### 1. Docker 集成
```dockerfile
# Dockerfile 示例
FROM node:20-alpine AS base
# Install dependencies
FROM base AS deps
RUN apk add --no-cache libc6-compat
WORKDIR /app
COPY package.json package-lock.json* ./
RUN npm ci --only=production
# Development
FROM base AS development
WORKDIR /app
COPY package.json package-lock.json* ./
RUN npm ci
COPY . .
CMD ["npm", "run", "dev"]
# Build
FROM development AS builder
WORKDIR /app
RUN npm run build
# Production
FROM base AS production
WORKDIR /app
COPY --from=deps /app/node_modules ./node_modules
COPY --from=builder /app/dist ./dist
COPY package.json ./
EXPOSE 3000
CMD ["node", "dist/index.js"]
# docker-compose.yml
version: '3.8'
services:
app:
build:
context: .
target: development
ports:
- "3000:3000"
volumes:
- .:/app
- /app/node_modules
environment:
- NODE_ENV=development
- DATABASE_URL=postgresql://postgres:secret@db:5432/myapp
depends_on:
- db
- redis
db:
image: postgres:15-alpine
environment:
POSTGRES_PASSWORD: secret
POSTGRES_DB: myapp
volumes:
- postgres-data:/var/lib/postgresql/data
ports:
- "5432:5432"
redis:
image: redis:7-alpine
ports:
- "6379:6379"
volumes:
- redis-data:/data
volumes:
postgres-data:
redis-data:2. Kubernetes 集成
# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: myapp
labels:
app: myapp
version: v1
spec:
replicas: 3
selector:
matchLabels:
app: myapp
template:
metadata:
labels:
app: myapp
version: v1
spec:
containers:
- name: myapp
image: myregistry/myapp:latest
ports:
- containerPort: 3000
env:
- name: DATABASE_URL
valueFrom:
secretKeyRef:
name: myapp-secrets
key: database-url
- name: REDIS_URL
valueFrom:
secretKeyRef:
name: myapp-secrets
key: redis-url
resources:
requests:
memory: "256Mi"
cpu: "250m"
limits:
memory: "512Mi"
cpu: "500m"
livenessProbe:
httpGet:
path: /health
port: 3000
initialDelaySeconds: 10
periodSeconds: 10
readinessProbe:
httpGet:
path: /ready
port: 3000
initialDelaySeconds: 5
periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
name: myapp-service
spec:
selector:
app: myapp
ports:
- port: 80
targetPort: 3000
type: LoadBalancer
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
name: myapp-hpa
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: myapp
minReplicas: 3
maxReplicas: 10
metrics:
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 703. CI/CD 流水线
# .github/workflows/deploy.yml
name: Deploy
on:
push:
branches: [main]
pull_request:
branches: [main]
env:
REGISTRY: ghcr.io
IMAGE_NAME: ${{ github.repository }}
jobs:
build:
runs-on: ubuntu-latest
outputs:
image-tag: ${{ steps.meta.outputs.tags }}
steps:
- uses: actions/checkout@v4
- name: Set up Docker Buildx
uses: docker/setup-buildx-action@v3
- name: Login to Container Registry
uses: docker/login-action@v3
with:
registry: ${{ env.REGISTRY }}
username: ${{ github.actor }}
password: ${{ secrets.GITHUB_TOKEN }}
- name: Extract metadata
id: meta
uses: docker/metadata-action@v5
with:
images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
tags: |
type=ref,event=branch
type=sha,prefix={{branch}}-
type=raw,value=latest,enable={{is_default_branch}}
- name: Build and push
uses: docker/build-push-action@v5
with:
context: .
push: ${{ github.event_name != 'pull_request' }}
tags: ${{ steps.meta.outputs.tags }}
cache-from: type=gha
cache-to: type=gha,mode=max
test:
needs: build
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Run tests
run: npm test -- --coverage
- name: Upload coverage
uses: codecov/codecov-action@v4
deploy-staging:
needs: [build, test]
if: github.ref == 'refs/heads/main'
runs-on: ubuntu-latest
environment: staging
steps:
- name: Deploy to staging
run: |
kubectl config use-context staging
kubectl set image deployment/myapp app=${{ needs.build.outputs.image-tag }}
kubectl rollout status deployment/myapp
deploy-production:
needs: [build, test]
if: github.ref == 'refs/heads/main'
runs-on: ubuntu-latest
environment: production
steps:
- name: Deploy to production
run: |
kubectl config use-context production
kubectl set image deployment/myapp app=${{ needs.build.outputs.image-tag }}
kubectl rollout status deployment/myapp
kubectl rollout status deployment/myapp --timeout=5m4. 监控与日志
// src/monitoring/index.ts
import { metrics, Counter, Histogram, Logger } from '@opentelemetry/api';
import { NodeSDK } from '@opentelemetry/sdk-node';
import { JaegerExporter } from '@opentelemetry/exporter-jaeger';
import { HttpInstrumentation } from '@opentelemetry/instrumentation-http';
import { ExpressInstrumentation } from '@opentelemetry/instrumentation-express';
const logger = new Logger({ name: 'monitoring' });
// 初始化 OpenTelemetry
const sdk = new NodeSDK({
traceExporter: new JaegerExporter({
endpoint: process.env.JAEGER_ENDPOINT,
}),
instrumentations: [
new HttpInstrumentation(),
new ExpressInstrumentation(),
],
});
sdk.start();
// 自定义指标
const httpRequestsTotal = new Counter('http_requests_total', {
description: 'Total number of HTTP requests',
});
const httpRequestDuration = new Histogram('http_request_duration_seconds', {
description: 'HTTP request duration in seconds',
boundaries: [0.01, 0.05, 0.1, 0.5, 1, 5],
});
export { httpRequestsTotal, httpRequestDuration, logger };// src/logging/index.ts
import { createLogger, transports, format } from 'winston';
export const logger = createLogger({
level: process.env.LOG_LEVEL || 'info',
format: format.combine(
format.timestamp(),
format.errors({ stack: true }),
format.json()
),
transports: [
new transports.Console({
format: format.combine(
format.colorize(),
format.simple()
),
}),
new transports.File({
filename: 'logs/error.log',
level: 'error',
}),
new transports.File({
filename: 'logs/combined.log',
}),
],
});
// 结构化日志
export function logRequest(req: Request, res: Response, duration: number) {
logger.info('HTTP Request', {
method: req.method,
url: req.url,
status: res.statusCode,
duration,
userAgent: req.headers['user-agent'],
ip: req.ip,
});
}Roo Code 与云服务集成
1. AWS 集成
// src/services/aws.ts
import { S3Client, PutObjectCommand, GetObjectCommand } from '@aws-sdk/client-s3';
import { LambdaClient, InvokeCommand } from '@aws-sdk/client-lambda';
import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
import { SQSClient, SendMessageCommand } from '@aws-sdk/client-sqs';
const s3Client = new S3Client({ region: process.env.AWS_REGION });
const lambdaClient = new LambdaClient({ region: process.env.AWS_REGION });
const dynamoClient = new DynamoDBClient({ region: process.env.AWS_REGION });
const sqsClient = new SQSClient({ region: process.env.AWS_REGION });
export const s3Service = {
async upload(key: string, body: Buffer, contentType: string) {
const command = new PutObjectCommand({
Bucket: process.env.S3_BUCKET,
Key: key,
Body: body,
ContentType: contentType,
});
await s3Client.send(command);
return `https://${process.env.S3_BUCKET}.s3.amazonaws.com/${key}`;
},
async download(key: string) {
const command = new GetObjectCommand({
Bucket: process.env.S3_BUCKET,
Key: key,
});
const response = await s3Client.send(command);
return response.Body;
},
};
export const lambdaService = {
async invoke(functionName: string, payload: object) {
const command = new InvokeCommand({
FunctionName: functionName,
Payload: JSON.stringify(payload),
});
const response = await lambdaClient.send(command);
return JSON.parse(new TextDecoder().decode(response.Payload));
},
};
export const sqsService = {
async sendMessage(queueUrl: string, message: object) {
const command = new SendMessageCommand({
QueueUrl: queueUrl,
MessageBody: JSON.stringify(message),
});
return sqsClient.send(command);
},
};2. Azure 集成
// src/services/azure.ts
import { BlobServiceClient } from '@azure/storage-blob';
import { CosmosClient } from '@azure/cosmos';
import { QueueServiceClient } from '@azure/storage-queue';
const blobServiceClient = new BlobServiceClient(
process.env.AZURE_STORAGE_CONNECTION_STRING!
);
export const azureBlobService = {
async upload(containerName: string, blobName: string, data: Buffer) {
const containerClient = blobServiceClient.getContainerClient(containerName);
const blobClient = containerClient.getBlockBlobClient(blobName);
await blobClient.uploadData(data);
return blobClient.url;
},
async download(containerName: string, blobName: string) {
const containerClient = blobServiceClient.getContainerClient(containerName);
const blobClient = containerClient.getBlobClient(blobName);
const downloadResponse = await blobClient.download();
return downloadResponse.blobBody;
},
};
// Cosmos DB
const cosmosClient = new CosmosClient(process.env.AZURE_COSMOS_CONNECTION!);
const database = cosmosClient.database(process.env.AZURE_COSMOS_DATABASE!);
const container = database.container(process.env.AZURE_COSMOS_CONTAINER!);
export const cosmosService = {
async create(item: object) {
const { resource } = await container.items.create(item);
return resource;
},
async read(id: string, partitionKey: string) {
const { resource } = await container.item(id, partitionKey).read();
return resource;
},
async query(query: string) {
const { resources } = await container.items
.query(query)
.fetchAll();
return resources;
},
};3. Google Cloud 集成
// src/services/gcp.ts
import { Storage } from '@google-cloud/storage';
import { BigQuery } from '@google-cloud/bigquery';
import { PubSub } from '@google-cloud/pubsub';
const storage = new Storage();
const bigquery = new BigQuery();
const pubsub = new PubSub();
export const gcsService = {
async upload(bucketName: string, fileName: string, data: Buffer) {
const bucket = storage.bucket(bucketName);
const file = bucket.file(fileName);
await file.save(data);
return `gs://${bucketName}/${fileName}`;
},
async download(bucketName: string, fileName: string) {
const bucket = storage.bucket(bucketName);
const file = bucket.file(fileName);
const [exists] = await file.exists();
if (!exists) throw new Error('File not found');
return file.download();
},
};
export const bigqueryService = {
async query(sql: string, params?: object[]) {
const options = {
query: sql,
location: 'US',
params: params,
};
const [job] = await bigquery.createJob(options);
const [rows] = await job.getQueryResults();
return rows;
},
async insert(datasetId: string, tableId: string, rows: object[]) {
const dataset = bigquery.dataset(datasetId);
const table = dataset.table(tableId);
await table.insert(rows);
},
};
export const pubsubService = {
async publish(topicName: string, message: object) {
const topic = pubsub.topic(topicName);
await topic.publishMessage({
data: Buffer.from(JSON.stringify(message)),
});
},
async subscribe(subscriptionName: string, callback: (message: object) => Promise<void>) {
const subscription = pubsub.subscription(subscriptionName);
subscription.on('message', async (message) => {
try {
await callback(JSON.parse(message.data.toString()));
message.ack();
} catch (error) {
console.error('Error processing message:', error);
message.nack();
}
});
},
};Roo Code 高级使用案例
1. 微服务架构开发
# 使用 Roo Code 开发微服务架构
## 项目结构
microservices/ ├── user-service/ │ ├── src/ │ │ ├── controllers/ │ │ ├── services/ │ │ ├── models/ │ │ ├── routes/ │ │ └── index.ts │ ├── tests/ │ ├── Dockerfile │ └── package.json ├── order-service/ ├── payment-service/ └── notification-service/
## Roo Code 辅助开发
用户: 为这个微服务项目创建统一的错误处理中间件
Roo Code 输出：
```typescript
// src/middleware/errorHandler.ts
import { Request, Response, NextFunction } from 'express';
export class AppError extends Error {
statusCode: number;
isOperational: boolean;
constructor(message: string, statusCode: number) {
super(message);
this.statusCode = statusCode;
this.isOperational = true;
Error.captureStackTrace(this, this.constructor);
}
}
export class ValidationError extends AppError {
constructor(message: string) {
super(message, 400);
}
}
export class NotFoundError extends AppError {
constructor(resource: string) {
super(`${resource} not found`, 404);
}
}
export class UnauthorizedError extends AppError {
constructor(message = 'Unauthorized') {
super(message, 401);
}
}
export class ForbiddenError extends AppError {
constructor(message = 'Forbidden') {
super(message, 403);
}
}
export function errorHandler(
err: Error | AppError,
req: Request,
res: Response,
next: NextFunction
) {
if (err instanceof AppError) {
return res.status(err.statusCode).json({
success: false,
error: {
message: err.message,
statusCode: err.statusCode,
},
});
}
// 未知错误
console.error('Unexpected error:', err);
return res.status(500).json({
success: false,
error: {
message: 'Internal server error',
statusCode: 500,
},
});
}
服务间通信
// src/services/grpc-client.ts
import * as grpc from '@grpc/grpc-js';
import * as protoLoader from '@grpc/proto-loader';
const PROTO_PATH = './proto/user.proto';
const packageDefinition = protoLoader.loadSync(PROTO_PATH, {
keepCase: true,
longs: String,
enums: String,
defaults: true,
oneofs: true,
});
const userProto = grpc.loadPackageDefinition(packageDefinition) as any;
export class UserServiceClient {
private client: any;
constructor(address: string) {
this.client = new userProto.UserService(
address,
grpc.credentials.createInsecure()
);
}
async getUser(id: string): Promise<User> {
return new Promise((resolve, reject) => {
this.client.GetUser({ id }, (err: Error, response: User) => {
if (err) reject(err);
else resolve(response);
});
});
}
async createUser(data: CreateUserDto): Promise<User> {
return new Promise((resolve, reject) => {
this.client.CreateUser(data, (err: Error, response: User) => {
if (err) reject(err);
else resolve(response);
});
});
}
}
### 2. 事件驱动架构
```typescript
// src/events/index.ts
import { EventEmitter } from 'events';
export const eventBus = new EventEmitter();
export const Events = {
USER_CREATED: 'user:created',
USER_UPDATED: 'user:updated',
USER_DELETED: 'user:deleted',
ORDER_CREATED: 'order:created',
ORDER_COMPLETED: 'order:completed',
PAYMENT_PROCESSED: 'payment:processed',
} as const;
export type EventPayload = {
[Events.USER_CREATED]: { id: string; email: string; name: string };
[Events.USER_UPDATED]: { id: string; updates: Partial<User> };
[Events.USER_DELETED]: { id: string };
[Events.ORDER_CREATED]: { id: string; userId: string; items: OrderItem[] };
[Events.ORDER_COMPLETED]: { id: string; total: number };
[Events.PAYMENT_PROCESSED]: { orderId: string; success: boolean };
};
// 事件处理器
export const handlers = {
async onUserCreated(payload: EventPayload[typeof Events.USER_CREATED]) {
// 发送欢迎邮件
await emailService.sendWelcomeEmail(payload.email);
// 创建默认设置
await settingsService.createDefault(payload.id);
// 记录审计日志
await auditLogService.log('user_created', payload);
},
async onOrderCompleted(payload: EventPayload[typeof Events.ORDER_COMPLETED]) {
// 更新统计数据
await analyticsService.trackOrder(payload);
// 发送通知
await notificationService.sendOrderConfirmation(payload.id);
// 触发后续流程
await fulfillmentService.processOrder(payload.id);
},
};
// 注册处理器
Object.entries(handlers).forEach(([event, handler]) => {
eventBus.on(event, handler);
});
// 发布事件
export function publishEvent<K extends keyof typeof Events>(
event: K,
payload: EventPayload[typeof Events[K]]
) {
eventBus.emit(event, payload);
}
3. GraphQL API 开发
// src/graphql/schema.ts
import { gql } from 'apollo-server-express';
export const typeDefs = gql`
type User {
id: ID!
email: String!
name: String!
avatar: String
role: UserRole!
createdAt: DateTime!
updatedAt: DateTime!
posts: [Post!]!
comments: [Comment!]!
}
enum UserRole {
USER
ADMIN
MODERATOR
}
type Post {
id: ID!
title: String!
content: String!
published: Boolean!
author: User!
comments: [Comment!]!
createdAt: DateTime!
updatedAt: DateTime!
}
type Comment {
id: ID!
content: String!
author: User!
post: Post!
createdAt: DateTime!
}
input CreateUserInput {
email: String!
password: String!
name: String!
}
input UpdateUserInput {
name: String
avatar: String
}
type Query {
users: [User!]!
user(id: ID!): User
me: User
posts: [Post!]!
post(id: ID!): Post
}
type Mutation {
createUser(input: CreateUserInput!): User!
updateUser(id: ID!, input: UpdateUserInput!): User!
deleteUser(id: ID!): Boolean!
publishPost(id: ID!): Post!
}
type Subscription {
userCreated: User!
postPublished: Post!
}
`;
export const resolvers = {
Query: {
users: () => userService.findAll(),
user: (_, { id }) => userService.findById(id),
me: (_, __, { user }) => user,
posts: () => postService.findAll(),
post: (_, { id }) => postService.findById(id),
},
Mutation: {
createUser: (_, { input }) => userService.create(input),
updateUser: (_, { id, input }) => userService.update(id, input),
deleteUser: (_, { id }) => userService.delete(id),
publishPost: (_, { id }) => postService.publish(id),
},
User: {
posts: (user) => postService.findByAuthor(user.id),
comments: (user) => commentService.findByAuthor(user.id),
},
Post: {
author: (post) => userService.findById(post.authorId),
comments: (post) => commentService.findByPost(post.id),
},
Subscription: {
userCreated: {
subscribe: (_, __, { pubsub }) =>
pubsub.asyncIterableIterator(['USER_CREATED']),
},
postPublished: {
subscribe: (_, __, { pubsub }) =>
pubsub.asyncIterableIterator(['POST_PUBLISHED']),
},
},
};附录：Roo Code 命令参考
CLI 命令
# 常用 CLI 命令
roo-code --help # 显示帮助
roo-code init # 初始化项目配置
roo-code config # 打开配置编辑器
roo-code models # 列出可用模型
roo-code models set <name> # 设置默认模型
roo-code history # 查看对话历史
roo-code history clear # 清除历史
roo-code template list # 列出模板
roo-code template create <name> # 创建模板
roo-code workflow list # 列出工作流
roo-code workflow run <name> # 运行工作流
roo-code mcp list # 列出 MCP 服务器
roo-code mcp add <name> # 添加 MCP 服务器
roo-code mcp remove <name> # 移除 MCP 服务器
roo-code stats # 显示使用统计
roo-code export <file> # 导出对话
roo-code import <file> # 导入对话配置命令
# 配置管理
roo-code config get <key> # 获取配置值
roo-code config set <key> <value> # 设置配置值
roo-code config reset # 重置配置
roo-code config export <file> # 导出配置
roo-code config import <file> # 导入配置调试命令
# 调试命令
roo-code debug on # 开启调试模式
roo-code debug off # 关闭调试模式
roo-code debug log <file> # 导出日志
roo-code debug inspect # 检查状态Roo Code 完整安装与配置指南
系统要求
环境要求
| 配置项 | 最低要求 | 推荐配置 |
|---|---|---|
| 操作系统 | macOS 10.15 / Windows 10 / Linux Ubuntu 18.04 | macOS 12+ / Windows 11 |
| VS Code | 1.75.0+ | 最新版本 |
| JetBrains | 2023.1+ | 最新版本 |
| 内存 | 4GB RAM | 8GB+ RAM |
| 网络 | 能访问 AI API | 稳定快速连接 |
VS Code 安装
方法一：扩展市场
# 安装步骤
1. 打开 VS Code
2. 按 Cmd/Ctrl + P 打开命令面板
3. 输入以下命令：
ext install saoudrizwan.roo-code
4. 等待安装完成
5. 重启 VS Code
6. 按 Cmd/Ctrl + Shift + I 打开 Roo Code方法二：VSIX 文件
# 1. 下载最新版本
# 访问 https://github.com/saoudrizwan/roo-code/releases
# 2. 安装 VSIX
code --install-extension roo-code-*.vsix
# 3. 重启 VS Code方法三：命令行安装
# macOS
brew install --cask roo-code
# Linux
curl -L https://github.com/saoudrizwan/roo-code/releases/latest/download/roo-code-linux-x64.vsix -o roo-code.vsix
code --install-extension roo-code.vsixJetBrains 安装
# JetBrains IDE 中安装 Roo Code
1. 打开 JetBrains IDE
2. 进入 Settings → Plugins
3. 搜索 "Roo Code" 或 "Roo Code"
4. 点击 Install
5. 重启 IDE
6. Tools → Roo Code → Open SettingsAPI Key 配置
Anthropic Claude API
// .vscode/settings.json
{
"roo-code": {
"apiProvider": "anthropic",
"apiKey": "sk-ant-xxxxxxxxxxxxxxxxxxxx",
"model": "claude-sonnet-4-20250514"
}
}获取方式：
- 访问 https://console.anthropic.com/
- 注册并登录
- 进入 API Keys 页面
- 创建新的 API Key
OpenAI API
{
"roo-code": {
"apiProvider": "openai",
"apiKey": "sk-xxxxxxxxxxxxxxxxxxxxxxxx",
"model": "gpt-4o"
}
}OpenRouter（聚合方案）
{
"roo-code": {
"apiProvider": "openrouter",
"apiKey": "sk-or-xxxxx",
"model": "anthropic/claude-sonnet-4"
}
}本地模型配置
Ollama 配置
{
"roo-code": {
"apiProvider": "ollama",
"apiBase": "http://localhost:11434/v1",
"model": "llama3.2"
}
}Ollama 常用命令：
# 拉取模型
ollama pull llama3.2 # 通用
ollama pull qwen2.5:14b # 中文支持好
ollama pull codellama:34b # 代码能力强
ollama pull mistral:7b # 通用能力强
# 查看已安装模型
ollama list
# 启动服务
ollama serve
# 运行模型
ollama run llama3.2 "Hello"LM Studio 配置
{
"roo-code": {
"apiProvider": "openai-compatible",
"apiBase": "http://localhost:1234/v1",
"model": "mistral-7b-instruct-v0.3"
}
}代理配置
{
"roo-code": {
"proxy": {
"enabled": true,
"url": "http://proxy.example.com:8080",
"bypass": [
"localhost",
"127.0.0.1"
]
}
}
}Roo Code 快捷键大全
VS Code 默认快捷键
| 功能 | macOS | Windows/Linux | 说明 |
|---|---|---|---|
| 打开 Roo Code | Cmd + Shift + I | Ctrl + Shift + I | 打开对话面板 |
| 新建任务 | Cmd + Shift + R | Ctrl + Shift + R | 开始新任务 |
| 接受建议 | Tab | Tab | 接受 AI 建议 |
| 拒绝建议 | Esc | Esc | 拒绝建议 |
| 终端执行 | Cmd + Shift + T | Ctrl + Shift + T | 执行终端命令 |
JetBrains 快捷键
| 功能 | 默认快捷键 | 说明 |
|---|---|---|
| 打开 Roo Code | Shift + Ctrl + I | 打开对话面板 |
| 新建任务 | Shift + Ctrl + R | 开始新任务 |
| 接受建议 | Tab | 接受建议 |
自定义快捷键
// keybindings.json
[
{
"key": "cmd+shift+i",
"command": "roo-code.open",
"when": "editorTextFocus"
},
{
"key": "cmd+shift+r",
"command": "roo-code.newTask",
"when": "editorTextFocus"
},
{
"key": "cmd+shift+a",
"command": "roo-code.acceptSuggestion",
"when": "suggestionVisible"
},
{
"key": "cmd+shift+d",
"command": "roo-code.rejectSuggestion",
"when": "suggestionVisible"
}
]Roo Code 高级配置
任务批准模式
Roo Code 提供三种任务批准模式：
{
"roo-code": {
"autoApprove": "ask",
"autoApproveExportFunctions": true,
"autoApproveIntelligent": false,
"askForDrafts": true,
"maxAutoApproveEdits": 5
}
}| 模式 | 说明 | 适用场景 |
|---|---|---|
| Auto Approve | 所有操作自动执行 | 简单任务、熟悉代码库 |
| Ask After Every Tool Call | 每个工具调用前询问 | 谨慎开发、数据敏感 |
| Never Approve | 完全手动模式 | 审计需求、完全控制 |
成本控制配置
{
"roo-code": {
"costControl": {
"enabled": true,
"maxCostPerSession": 5.0,
"maxCostPerDay": 50.0,
"alertThreshold": 0.8,
"modelFallback": {
"enabled": true,
"fallbackModel": "claude-haiku-4-20250514",
"fallbackThreshold": 0.5
}
}
}
}上下文配置
{
"roo-code": {
"context": {
"maxFiles": 50,
"maxTokens": 100000,
"priorityFiles": [
"*.ts",
"*.tsx",
"*.js",
"*.jsx"
],
"excludePatterns": [
"node_modules/**",
"dist/**",
"*.test.ts",
"coverage/**"
]
}
}
}性能配置
{
"roo-code": {
"performance": {
"maxConcurrentTools": 3,
"toolTimeout": 60,
"responseTimeout": 120,
"cacheEnabled": true,
"cacheSize": "100MB",
"streamResponses": true
}
}
}Roo Code 云服务集成
AWS 集成
S3 服务
// src/services/aws/s3.ts
import { S3Client, PutObjectCommand, GetObjectCommand, DeleteObjectCommand } from '@aws-sdk/client-s3';
const s3Client = new S3Client({ region: process.env.AWS_REGION });
export const s3Service = {
async upload(key: string, body: Buffer, contentType: string): Promise<string> {
const command = new PutObjectCommand({
Bucket: process.env.S3_BUCKET,
Key: key,
Body: body,
ContentType: contentType,
});
await s3Client.send(command);
return `https://${process.env.S3_BUCKET}.s3.${process.env.AWS_REGION}.amazonaws.com/${key}`;
},
async download(key: string): Promise<Buffer> {
const command = new GetObjectCommand({
Bucket: process.env.S3_BUCKET,
Key: key,
});
const response = await s3Client.send(command);
const chunks: Buffer[] = [];
for await (const chunk of response.Body as any) {
chunks.push(chunk);
}
return Buffer.concat(chunks);
},
async delete(key: string): Promise<void> {
const command = new DeleteObjectCommand({
Bucket: process.env.S3_BUCKET,
Key: key,
});
await s3Client.send(command);
},
async list(prefix: string): Promise<string[]> {
const command = new ListObjectsV2Command({
Bucket: process.env.S3_BUCKET,
Prefix: prefix,
});
const response = await s3Client.send(command);
return response.Contents?.map(obj => obj.Key || '') || [];
}
};Lambda 服务
// src/services/aws/lambda.ts
import { LambdaClient, InvokeCommand } from '@aws-sdk/client-lambda';
const lambdaClient = new LambdaClient({ region: process.env.AWS_REGION });
export const lambdaService = {
async invoke<T = any>(functionName: string, payload: object): Promise<T> {
const command = new InvokeCommand({
FunctionName: functionName,
Payload: JSON.stringify(payload),
InvocationType: 'RequestResponse',
});
const response = await lambdaClient.send(command);
const decoder = new TextDecoder();
return JSON.parse(decoder.decode(response.Payload));
},
async invokeAsync(functionName: string, payload: object): Promise<void> {
const command = new InvokeCommand({
FunctionName: functionName,
Payload: JSON.stringify(payload),
InvocationType: 'Event',
});
await lambdaClient.send(command);
}
};DynamoDB 服务
// src/services/aws/dynamodb.ts
import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
import { DynamoDBDocumentClient, PutCommand, GetCommand, QueryCommand, DeleteCommand } from '@aws-sdk/lib-dynamodb';
const ddbClient = new DynamoDBClient({});
const docClient = DynamoDBDocumentClient.from(ddbClient);
export const dynamoService = {
async put<T>(tableName: string, item: T): Promise<void> {
await docClient.send(new PutCommand({
TableName: tableName,
Item: item,
}));
},
async get<T>(tableName: string, key: Record<string, any>): Promise<T | null> {
const result = await docClient.send(new GetCommand({
TableName: tableName,
Key: key,
}));
return result.Item as T || null;
},
async query<T>(
tableName: string,
params: {
indexName?: string;
keyCondition: string;
expressionValues: Record<string, any>;
expressionNames?: Record<string, string>;
filter?: string;
}
): Promise<T[]> {
const result = await docClient.send(new QueryCommand({
TableName: tableName,
IndexName: params.indexName,
KeyConditionExpression: params.keyCondition,
ExpressionAttributeValues: params.expressionValues,
ExpressionAttributeNames: params.expressionNames,
FilterExpression: params.filter,
}));
return result.Items as T[] || [];
},
async delete(tableName: string, key: Record<string, any>): Promise<void> {
await docClient.send(new DeleteCommand({
TableName: tableName,
Key: key,
}));
}
};Azure 集成
Blob Storage 服务
// src/services/azure/blob.ts
import { BlobServiceClient, StorageSharedKeyCredential } from '@azure/storage-blob';
const blobServiceClient = new BlobServiceClient(
process.env.AZURE_STORAGE_CONNECTION_STRING!
);
export const azureBlobService = {
async upload(containerName: string, blobName: string, data: Buffer, contentType: string): Promise<string> {
const containerClient = blobServiceClient.getContainerClient(containerName);
const blobClient = containerClient.getBlockBlobClient(blobName);
await blobClient.uploadData(data, { blobHTTPHeaders: { blobContentType: contentType } });
return blobClient.url;
},
async download(containerName: string, blobName: string): Promise<Buffer> {
const containerClient = blobServiceClient.getContainerClient(containerName);
const blobClient = containerClient.getBlobClient(blobName);
const downloadResponse = await blobClient.download();
const downloaded = await streamToBuffer(downloadResponse.readableStreamBody);
return downloaded;
},
async delete(containerName: string, blobName: string): Promise<void> {
const containerClient = blobServiceClient.getContainerClient(containerName);
const blobClient = containerClient.getBlobClient(blobName);
await blobClient.delete();
},
async list(containerName: string, prefix?: string): Promise<string[]> {
const containerClient = blobServiceClient.getContainerClient(containerName);
const blobs: string[] = [];
for await (const blob of containerClient.listBlobsFlat({ prefix })) {
blobs.push(blob.name);
}
return blobs;
}
};
async function streamToBuffer(stream: NodeJS.ReadableStream): Promise<Buffer> {
const chunks: Buffer[] = [];
for await (const chunk of stream as any) {
chunks.push(Buffer.from(chunk));
}
return Buffer.concat(chunks);
}Cosmos DB 服务
// src/services/azure/cosmos.ts
import { CosmosClient, Container } from '@azure/cosmos';
const cosmosClient = new CosmosClient(process.env.AZURE_COSMOS_CONNECTION!);
const container: Container = cosmosClient
.database(process.env.AZURE_COSMOS_DATABASE!)
.container(process.env.AZURE_COSMOS_CONTAINER!);
export const cosmosService = {
async create<T extends object>(item: T): Promise<T> {
const { resource } = await container.items.create(item);
return resource as T;
},
async read<T>(id: string, partitionKey: string): Promise<T | null> {
try {
const { resource } = await container.item(id, partitionKey).read();
return resource as T || null;
} catch {
return null;
}
},
async update<T extends { id: string }>(item: T): Promise<T> {
const { resource } = await container.item(item.id, item.id).replace(item);
return resource as T;
},
async delete(id: string, partitionKey: string): Promise<void> {
await container.item(id, partitionKey).delete();
},
async query<T>(
query: string,
parameters?: { name: string; value: any }[]
): Promise<T[]> {
const { resources } = await container.items.query({
query,
parameters: parameters?.map(p => ({ ...p, value: p.value }))
}).fetchAll();
return resources as T[];
}
};Google Cloud 集成
Cloud Storage 服务
// src/services/gcp/storage.ts
import { Storage } from '@google-cloud/storage';
const storage = new Storage({
projectId: process.env.GCP_PROJECT_ID,
keyFilename: process.env.GCP_KEY_FILE,
});
export const gcsService = {
async upload(bucketName: string, fileName: string, data: Buffer, options?: {
contentType?: string;
metadata?: Record<string, string>;
}): Promise<string> {
const bucket = storage.bucket(bucketName);
const file = bucket.file(fileName);
await file.save(data, {
contentType: options?.contentType,
metadata: options?.metadata,
});
return `gs://${bucketName}/${fileName}`;
},
async download(bucketName: string, fileName: string): Promise<Buffer> {
const bucket = storage.bucket(bucketName);
const file = bucket.file(fileName);
const [exists] = await file.exists();
if (!exists) throw new Error('File not found');
const [data] = await file.download();
return data;
},
async delete(bucketName: string, fileName: string): Promise<void> {
const bucket = storage.bucket(bucketName);
await bucket.file(fileName).delete();
},
async list(bucketName: string, prefix?: string): Promise<string[]> {
const bucket = storage.bucket(bucketName);
const [files] = await bucket.getFiles({ prefix });
return files.map(file => file.name);
}
};BigQuery 服务
// src/services/gcp/bigquery.ts
import { BigQuery } from '@google-cloud/bigquery';
const bigquery = new BigQuery({
projectId: process.env.GCP_PROJECT_ID,
keyFilename: process.env.GCP_KEY_FILE,
});
export const bigqueryService = {
async query<T = any>(
sql: string,
params?: Record<string, any>,
options?: { location?: string; timeout?: number }
): Promise<T[]> {
const [rows] = await bigquery.query({
query: sql,
params: params,
location: options?.location,
timeout: options?.timeout,
});
return rows as T[];
},
async insert(datasetId: string, tableId: string, rows: object[]): Promise<void> {
await bigquery
.dataset(datasetId)
.table(tableId)
.insert(rows);
},
async createDataset(datasetId: string): Promise<void> {
await bigquery.createDataset(datasetId);
},
async createTable(
datasetId: string,
tableId: string,
schema: { name: string; type: string; mode?: string }[]
): Promise<void> {
await bigquery
.dataset(datasetId)
.createTable(tableId, {
schema: schema.reduce((acc, col) => {
acc[col.name] = { type: col.type, mode: col.mode as any };
return acc;
}, {} as any),
});
}
};Roo Code 企业级部署
企业配置示例
# .roo/enterprise/enterprise.yaml
organization:
name: "Acme Corporation"
domain: "acme.com"
sso:
enabled: true
provider: "okta"
client_id: "${OKTA_CLIENT_ID}"
client_secret: "${OKTA_CLIENT_SECRET}"
users:
default_role: "developer"
roles:
- name: "admin"
permissions:
- "*"
- name: "developer"
permissions:
- "read"
- "write"
- "execute"
- "test"
- name: "viewer"
permissions:
- "read"
security:
audit:
enabled: true
retention_days: 90
export_format: "json"
data_protection:
encryption_enabled: true
mask_sensitive_data: true
sensitive_patterns:
- "password"
- "secret"
- "token"
- "api_key"
- "credit_card"
cost_control:
enabled: true
budget_per_user: 100.00
budget_per_month: 5000.00
alert_thresholds:
- 0.5
- 0.75
- 0.9
integrations:
github:
enabled: true
auto_sync_rules: true
slack:
enabled: true
channel: "#devops"
jira:
enabled: true
project_key: "DEV"团队规则示例
TypeScript 规范
# .roo/team-rules/typescript.md
## TypeScript 规范
### 基本规则
- 严格模式：true
- 禁用 any，使用 unknown 代替
- 所有函数必须有返回类型
- 优先使用 interface
### 命名规范
- 变量/函数：camelCase
- 类型/接口/类：PascalCase
- 常量：UPPER_SNAKE_CASE
- 文件：kebab-case.ts
### 类型定义
```typescript
// ✅ 好的示例
interface User {
id: string;
name: string;
email: Email;
}
type Email = string & { __brand: 'email' };
// ❌ 差的示例
interface User {
id: any;
name: any;
}错误处理
// ✅ 好的示例
async function fetchUser(id: string): Promise<Result<User, Error>> {
try {
const user = await db.users.findById(id);
return { ok: true, value: user };
} catch (error) {
return { ok: false, error: error as Error };
}
}
#### React 规范
```markdown
# .roo/team-rules/react.md
## React 规范
### 组件结构
ComponentName/ ├── ComponentName.tsx # 主组件 ├── ComponentName.module.css # CSS 模块 ├── ComponentName.test.tsx # 测试 ├── index.ts # 导出 └── types.ts # 类型定义
### 命名规范
- 组件文件：PascalCase.tsx
- Hooks：useCamelCase.ts
- 工具函数：camelCase.ts
- 常量：UPPER_SNAKE_CASE
### 代码规范
- 使用函数组件
- 使用 Hooks 而非类组件
- Props 接口命名：ComponentNameProps
- 组件最大行数：200 行
### 性能优化
- 列表渲染使用 key
- 使用 React.memo 优化重渲染
- 合理使用 useMemo/useCallback
- 大列表使用虚拟滚动
Git 规范
# .roo/team-rules/git.md
## Git 提交规范
### 提交信息格式