ccg-ros2-workflow 2.2.1 → 3.0.0

package/templates/codex/hooks/ccg-workflow.py

@@ -0,0 +1,253 @@
+#!/usr/bin/env python3
+"""
+CCG Workflow Hook for Codex CLI — Adaptive Guardrail
+Injects per-turn guidance based on what Codex has/hasn't done.
+Not a rigid state machine — adapts to task complexity and progress.
+
+Hook type: UserPromptSubmit
+"""
+
+import json
+import os
+import sys
+import glob
+import subprocess
+from pathlib import Path
+from datetime import datetime
+
+
+def find_project_root():
+    """Walk up to find .ccg/ or .git/"""
+    d = os.environ.get("CODEX_PROJECT_DIR", os.getcwd())
+    for _ in range(20):
+        if os.path.isdir(os.path.join(d, ".ccg")) or os.path.isdir(os.path.join(d, ".git")):
+            return d
+        parent = os.path.dirname(d)
+        if parent == d:
+            break
+        d = parent
+    return None
+
+
+def get_active_task(root):
+    """Find the most recent in_progress task."""
+    tasks_dir = os.path.join(root, ".ccg", "tasks")
+    if not os.path.isdir(tasks_dir):
+        return None
+    for name in sorted(os.listdir(tasks_dir), reverse=True):
+        if name == "archive":
+            continue
+        task_file = os.path.join(tasks_dir, name, "task.json")
+        if not os.path.isfile(task_file):
+            continue
+        try:
+            with open(task_file) as f:
+                task = json.load(f)
+            if task.get("status") not in ("completed", "archived"):
+                task["_dir"] = os.path.join(tasks_dir, name)
+                task["_name"] = name
+                return task
+        except Exception:
+            continue
+    return None
+
+
+def detect_progress(root):
+    """Detect what Codex has done so far in this session."""
+    signals = {
+        "has_dirty_files": False,
+        "dirty_count": 0,
+        "changed_lines": 0,
+        "has_test_output": False,
+        "high_risk_files": False,
+    }
+    try:
+        status = subprocess.run(
+            ["git", "status", "--porcelain"],
+            cwd=root, capture_output=True, text=True, timeout=5
+        )
+        lines = [l for l in status.stdout.strip().split("\n") if l.strip()]
+        signals["dirty_count"] = len(lines)
+        signals["has_dirty_files"] = len(lines) > 0
+
+        risk_patterns = ["auth", "login", "password", "token", "secret", "crypto",
+                         "encrypt", "migration", "schema", "permission", "admin"]
+        for line in lines:
+            fname = line[3:].strip().lower()
+            if any(p in fname for p in risk_patterns):
+                signals["high_risk_files"] = True
+                break
+
+        if signals["has_dirty_files"]:
+            diff = subprocess.run(
+                ["git", "diff", "--stat"],
+                cwd=root, capture_output=True, text=True, timeout=5
+            )
+            for dline in diff.stdout.strip().split("\n"):
+                if "insertion" in dline or "deletion" in dline:
+                    parts = dline.split(",")
+                    for p in parts:
+                        p = p.strip()
+                        if "insertion" in p:
+                            signals["changed_lines"] += int(p.split()[0])
+                        elif "deletion" in p:
+                            signals["changed_lines"] += int(p.split()[0])
+    except Exception:
+        pass
+    return signals
+
+
+def assess_complexity(task):
+    """Get complexity from task.json or default to M."""
+    if not task:
+        return "M"
+    return task.get("complexity", "M")
+
+
+def build_guidance(task, progress, root):
+    """Build adaptive guidance based on task state + progress."""
+    parts = []
+    complexity = assess_complexity(task)
+    phase = task.get("currentPhase", "unknown") if task else "no_task"
+
+    # --- Task state breadcrumb ---
+    if task:
+        parts.append(f"Task: {task.get('title', task.get('id', '?'))} ({task.get('status', '?')})")
+        parts.append(f"Complexity: {complexity} | Risk: {task.get('risk', '?')} | Phase: {phase}")
+        if task.get("nextAction"):
+            parts.append(f"Next: {task['nextAction']}")
+    else:
+        parts.append("No active task. Create one in .ccg/tasks/ before starting work.")
+        parts.append("Even small fixes need a task.json for tracking.")
+        return parts
+
+    # --- Adaptive guidance based on phase × progress ---
+
+    # Phase: analysis — haven't started coding yet
+    if phase == "analysis":
+        if complexity in ("M", "L", "XL"):
+            parts.append("")
+            parts.append(f"⛔ {complexity} complexity: you MUST call BOTH Gemini AND Claude for parallel analysis before coding.")
+            parts.append("Use the dual-model parallel template in AGENTS.md: --backend gemini & --backend claude with & + wait.")
+
+    # Phase: implementation — coding in progress
+    elif phase == "implementation":
+        if progress["dirty_count"] == 0:
+            parts.append("")
+            parts.append("Implementation phase started but no files changed yet. Start coding.")
+
+    # Phase: review — code is written, need review
+    elif phase == "review":
+        parts.append("")
+        parts.append("Review phase. Call external models for review, write results to review.md.")
+
+    # --- Cross-phase guardrails ---
+
+    # Big changes without review
+    if progress["changed_lines"] > 30 and phase != "review":
+        parts.append("")
+        parts.append(f"⚠️ {progress['changed_lines']} lines changed. When done coding, you MUST call BOTH Gemini AND Claude for dual-model review. Not just one — both.")
+
+    # Review phase: enforce dual model
+    if phase == "review":
+        parts.append("")
+        parts.append("⛔ Review phase: call BOTH Gemini (--backend gemini) AND Claude (--backend claude) with reviewer role. Two models, not one.")
+
+    # High-risk files detected
+    if progress["high_risk_files"] and phase not in ("review", "completed"):
+        parts.append("")
+        parts.append("⚠️ High-risk files detected (auth/db/crypto). External model security review is REQUIRED before delivery.")
+
+    # Has dirty files but hasn't run tests
+    if progress["has_dirty_files"] and not progress["has_test_output"]:
+        if phase == "implementation" and progress["changed_lines"] > 10:
+            parts.append("")
+            parts.append("Reminder: run tests after significant changes. Don't wait until the end.")
+
+    # --- Spec reminder ---
+    spec_dir = os.path.join(root, ".ccg", "spec")
+    if os.path.isdir(spec_dir) and phase in ("analysis", "implementation"):
+        specs = []
+        for sub in ("backend", "frontend", "guides"):
+            idx = os.path.join(spec_dir, sub, "index.md")
+            if os.path.isfile(idx):
+                specs.append(f".ccg/spec/{sub}/index.md")
+        if specs:
+            parts.append("")
+            parts.append(f"Spec files available: {', '.join(specs)} — read before writing code.")
+
+    # --- Archive reminder ---
+    if phase == "completed" or (task.get("status") == "completed"):
+        parts.append("")
+        parts.append("⛔ Task completed. You MUST archive it now:")
+        parts.append(f"  mkdir -p .ccg/tasks/archive/$(date +%Y-%m) && mv .ccg/tasks/{task['_name']} .ccg/tasks/archive/$(date +%Y-%m)/")
+        parts.append("  git add .ccg/tasks/ && git commit -m \"chore: archive ccg task\"")
+
+    return parts
+
+
+SUB_AGENT_NOTICE = """<ccg-sub-agent-notice>
+SUB-AGENT NOTICE — READ FIRST IF SPAWNED VIA spawn_agent
+
+If your parent session spawned you via spawn_agent with an explicit task
+message, that message is your ONLY job.
+- Execute the parent message exactly as written, then mark yourself complete.
+- Ignore all CCG workflow guidance below this notice.
+- Do NOT call spawn_agent, wait, or close_agent.
+- Do NOT modify .ccg/tasks/* or any workflow state files.
+- Do NOT run external model calls (codeagent-wrapper).
+- Only modify files explicitly listed in your dispatch message.
+</ccg-sub-agent-notice>"""
+
+
+def is_sub_agent():
+    """Detect if running inside a Codex sub-agent session.
+    Codex sub-agents spawned with fork_turns='none' get a clean
+    context but inherit the env. The parent sets CODEX_AGENT_TYPE
+    or the agent_type is visible in the process env."""
+    if os.environ.get("CODEX_AGENT_TYPE", ""):
+        return True
+    if os.environ.get("CODEX_FORK_TURNS", "") == "none":
+        return True
+    return False
+
+
+def main():
+    try:
+        root = find_project_root()
+        if not root:
+            return
+        if not os.path.isdir(os.path.join(root, ".ccg")):
+            return
+
+        # Sub-agent: inject notice and skip workflow guidance
+        if is_sub_agent():
+            print(json.dumps({
+                "hookSpecificOutput": {
+                    "hookEventName": "UserPromptSubmit",
+                    "additionalContext": SUB_AGENT_NOTICE
+                }
+            }))
+            return
+
+        task = get_active_task(root)
+        progress = detect_progress(root)
+        lines = build_guidance(task, progress, root)
+
+        if not lines:
+            return
+
+        context = "<ccg-state>\n" + "\n".join(lines) + "\n</ccg-state>"
+
+        print(json.dumps({
+            "hookSpecificOutput": {
+                "hookEventName": "UserPromptSubmit",
+                "additionalContext": context
+            }
+        }))
+    except Exception:
+        pass
+
+
+if __name__ == "__main__":
+    main()

package/templates/codex/hooks.json

@@ -0,0 +1,15 @@
+{
+  "hooks": {
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 .codex/hooks/ccg-ros2-workflow.py",
+            "timeout": 10
+          }
+        ]
+      }
+    ]
+  }
+}

package/templates/commands/agents/planner.md

@@ -1,16 +1,16 @@
 ---
 name: planner
-description: 📋 ROS2 任务规划师 - 使用 WBS 方法论分解机器人功能需求为可执行任务
-tools: Read, Write, mcp__ace-tool__search_context
+description: 📋 任务规划师 - 使用 WBS 方法论分解功能需求为可执行任务
+tools: Read, Write, {{MCP_SEARCH_TOOL}}
 color: blue
 ---
 
-你是一位资深的 ROS2 项目规划师，擅长使用 WBS（工作分解结构）方法论将复杂机器人功能需求分解为清晰的任务清单。
+你是一位资深的项目规划师，擅长使用 WBS（工作分解结构）方法论将复杂功能需求分解为清晰的任务清单。
 
 ## 核心职责
 
 1. **需求分析**：理解功能目标、范围、约束条件
-2. **任务分解**：功能 → 模块 → 节点/包 → 具体步骤
+2. **任务分解**：功能 → 模块 → 文件 → 具体步骤
 3. **依赖识别**：标注任务间的前后依赖关系
 4. **工作量估算**：使用"任务点"为单位（1点 ≈ 1-2小时）
 
@@ -19,8 +19,8 @@ color: blue
 ### 步骤 1：理解需求
 
 分析用户需求，明确：
-- 机器人功能目标是什么？
-- 涉及哪些模块（上层应用/底层控制/消息定义）？
+- 功能目标是什么？
+- 涉及哪些模块（上层应用/底层控制/数据库）？
 - 有哪些技术约束？
 - 是否有现有代码需要修改？
 
@@ -29,7 +29,7 @@ color: blue
 如果需要了解现有实现，使用 ace-tool 检索：
 
 ```
-mcp__ace-tool__search_context {
+{{MCP_SEARCH_TOOL}} {
   "project_root_path": "{{项目路径}}",
   "query": "{{相关功能关键词}}"
 }
@@ -41,9 +41,9 @@ mcp__ace-tool__search_context {
 
 **Level 1: 功能**（顶层目标）
 ↓
-**Level 2: 模块**（上层应用/底层控制/消息定义）
+**Level 2: 模块**（上层应用/底层控制/数据库）
 ↓
-**Level 3: 包/节点**（具体 ROS2 包和节点）
+**Level 3: 文件/组件**（具体代码文件）
 ↓
 **Level 4: 任务步骤**（可执行的具体动作）
 
@@ -58,14 +58,13 @@ mcp__ace-tool__search_context {
 
 **规划时间**：{{当前时间}}
 **预估工作量**：{{总任务点}} 任务点
-**目标平台**：ROS2 Humble / 物理机器人
 
 ---
 
 ## 1. 功能概述
 
 ### 1.1 目标
-{{功能要达成的机器人任务目标}}
+{{功能要达成的业务目标}}
 
 ### 1.2 范围
 **包含**：
@@ -76,9 +75,9 @@ mcp__ace-tool__search_context {
 - {{明确不做的内容}}
 
 ### 1.3 技术约束
-- {{ROS2 版本限制}}
-- {{实时性要求}}
-- {{硬件兼容性}}
+- {{技术栈限制}}
+- {{性能要求}}
+- {{兼容性要求}}
 
 ---
 
@@ -88,26 +87,25 @@ mcp__ace-tool__search_context {
 
 ```mermaid
 graph TD
-    A[{{功能名称}}] --> B[上层应用]
-    A --> C[底层控制]
-    A --> D[消息定义]
+    A[{{功能名称}}] --> B[上层应用模块]
+    A --> C[底层控制模块]
+    A --> D[数据库模块]
 
-    B --> B1[Launch 配置]
-    B --> B2[参数文件]
-    B --> B3[可视化节点]
+    B --> B1[页面/组件 1]
+    B --> B2[页面/组件 2]
 
-    C --> C1[驱动节点]
-    C --> C2[控制算法]
+    C --> C1[API 接口 1]
+    C --> C2[API 接口 2]
 
-    D --> D1[消息类型]
-    D --> D2[服务定义]
+    D --> D1[数据模型]
+    D --> D2[迁移脚本]
 ```
 
 ### 2.2 任务清单
 
-#### 模块 A：底层控制（{{任务点}} 任务点）- Codex 主导
+#### 模块 A：{{模块名}}（{{任务点}} 任务点）
 
-**包名**: `{{package_name}}`
+**文件**: `{{文件路径}}`
 
 - [ ] **任务 A.1**：{{任务描述}}（{{任务点}} 点）
   - **输入**：{{需要的数据/依赖}}
@@ -123,15 +121,7 @@ graph TD
     1. {{步骤 1}}
     2. {{步骤 2}}
 
-#### 模块 B：上层应用（{{任务点}} 任务点）- Gemini 主导
-
-**包名**: `{{package_name}}`
-
-{{重复上述结构}}
-
-#### 模块 C：消息定义（{{任务点}} 任务点）
-
-**包名**: `{{package_name}}_msgs`
+#### 模块 B：{{模块名}}（{{任务点}} 任务点）
 
 {{重复上述结构}}
 
@@ -143,23 +133,23 @@ graph TD
 
 ```mermaid
 graph LR
-    T1[消息定义] --> T2[底层控制节点]
-    T2 --> T3[上层应用]
-    T1 --> T4[Launch 配置]
+    T1[任务 A.1] --> T2[任务 B.1]
+    T2 --> T3[任务 C.1]
+    T1 --> T4[任务 B.2]
 ```
 
 ### 3.2 依赖说明
 
 | 任务 | 依赖于 | 原因 |
 |------|--------|------|
-| 底层控制节点 | 消息定义 | 需要先定义消息类型 |
-| Launch 配置 | 所有节点 | 需要所有节点完成后配置 |
+| 任务 B.1 | 任务 A.1 | 需要上层应用组件完成后才能集成 API |
+| 任务 C.1 | 任务 B.1 | 数据库 schema 需先定义 |
 
 ### 3.3 并行任务
 
 以下任务可以并行开发：
-- 消息定义 ∥ 参数文件设计
-- 底层控制算法 ∥ 上层可视化
+- 任务 A.1 ∥ 任务 D.1
+- 任务 B.2 ∥ 任务 C.2
 
 ---
 
@@ -169,23 +159,19 @@ graph LR
 
 | 需求 | 推荐方案 | 理由 |
 |------|----------|------|
-| 电机驱动 | ros2_control | 标准化硬件抽象 |
-| 导航 | Nav2 | 成熟的导航栈 |
-| 仿真 | Gazebo | 支持 ROS2 集成 |
+| {{技术需求}} | {{方案}} | {{选型理由}} |
 
 ### 4.2 潜在风险
 
 | 风险 | 影响 | 缓解措施 |
 |------|------|----------|
-| 实时性不足 | 高 | 使用实时内核，优化 QoS |
-| 硬件兼容性 | 中 | 提前测试硬件驱动 |
+| {{风险描述}} | 高/中/低 | {{应对方案}} |
 
 ### 4.3 测试策略
 
-- **单元测试**：使用 gtest/pytest 测试算法逻辑
-- **集成测试**：使用 launch_testing 测试节点通信
-- **仿真测试**：使用 Gazebo 进行完整功能验证
-- **硬件测试**：在物理机器人上验证
+- **单元测试**：{{哪些模块需要单测}}
+- **集成测试**：{{哪些接口需要集成测试}}
+- **E2E 测试**：{{关键用户流程}}
 
 ---
 
@@ -194,8 +180,7 @@ graph LR
 功能完成需满足以下条件：
 
 - [ ] 所有任务清单完成
-- [ ] 单元测试通过
-- [ ] 仿真测试通过
+- [ ] 单元测试覆盖率 ≥ 80%
 - [ ] 代码审查通过
 - [ ] 无高优先级 Bug
 - [ ] 文档更新完成
@@ -226,109 +211,99 @@ Phase 2 可考虑的增强：
 ### 输入示例
 
 ```
-用户需求：实现 PID 速度控制器节点
+用户需求：实现用户登录功能
 
 项目上下文：
-- ROS2 Humble
-- 差速驱动机器人
-- 已有 motor_driver 包
-- 需要支持参数动态调节
+- Next.js 14 (App Router)
+- PostgreSQL + Prisma
+- 已有用户注册功能
 ```
 
 ### 输出示例（简化版）
 
 ```markdown
-# 功能规划：PID 速度控制器
+# 功能规划：用户登录功能
 
-**预估工作量**：10 任务点
-**目标平台**：ROS2 Humble / 物理机器人
+**预估工作量**：12 任务点
 
 ## 1. 功能概述
-
-实现一个 PID 速度控制器节点，订阅目标速度，发布电机控制指令。
+实现用户通过邮箱和密码登录系统的功能。
 
 ## 2. WBS 任务分解
 
-#### 模块 A：底层控制 - PID 控制器（6 任务点）- Codex 主导
+#### 模块 A：上层应用登录页面（4 任务点）
 
-**包名**: `pid_controller`
+**文件**: `app/login/page.tsx`
 
-- [ ] **任务 A.1**：创建 PID 控制器类（2 点）
-  - **输入**：PID 参数 (Kp, Ki, Kd)
-  - **输出**：pid_controller.hpp/cpp
+- [ ] **任务 A.1**：创建登录页面和表单组件（2 点）
+  - **输入**：UI 设计规范
+  - **输出**：LoginForm 组件
   - **关键步骤**：
-    1. 定义 PIDController 类
-    2. 实现 compute() 方法
-    3. 实现积分限幅和微分滤波
+    1. 创建 page.tsx 路由
+    2. 实现 LoginForm 组件（邮箱、密码输入框）
+    3. 添加客户端表单验证（react-hook-form）
 
-- [ ] **任务 A.2**：创建 ROS2 节点封装（2 点）
-  - **输入**：PIDController 类
-  - **输出**：pid_controller_node.cpp
+- [ ] **任务 A.2**：集成登录 API 调用（2 点）
+  - **输入**：底层控制 API 接口（任务 B.1）
+  - **输出**：完整登录流程
   - **关键步骤**：
-    1. 创建 LifecycleNode
-    2. 订阅 /cmd_vel_target
-    3. 发布 /motor_cmd
+    1. 使用 fetch 调用 /api/auth/login
+    2. 处理成功/失败响应
+    3. 登录成功后跳转到首页
 
-- [ ] **任务 A.3**：实现参数动态调节（2 点）
-  - **输入**：ROS2 参数系统
-  - **输出**：支持 ros2 param set
-  - **关键步骤**：
-    1. 声明 Kp, Ki, Kd 参数
-    2. 注册参数回调
-    3. 实时更新 PID 参数
-
-#### 模块 B：上层应用 - 配置和可视化（3 任务点）- Gemini 主导
+#### 模块 B：底层控制认证接口（5 任务点）
 
-**包名**: `pid_controller`
+**文件**: `app/api/auth/login/route.ts`
 
-- [ ] **任务 B.1**：创建 Launch 文件（1 点）
-  - **输入**：节点需求
-  - **输出**：launch/pid_controller.launch.py
+- [ ] **任务 B.1**：实现 POST /api/auth/login（3 点）
+  - **输入**：用户邮箱、密码
+  - **输出**：JWT token
   - **关键步骤**：
-    1. 加载参数文件
-    2. 启动节点
-    3. 配置 remapping
-
-- [ ] **任务 B.2**：创建参数配置文件（1 点）
-  - **输入**：PID 参数需求
-  - **输出**：config/pid_params.yaml
+    1. 验证请求体格式（Zod）
+    2. 查询数据库验证用户存在
+    3. 使用 bcrypt 验证密码
+    4. 生成 JWT token 并返回
+
+- [ ] **任务 B.2**：实现 Session 中间件（2 点）
+  - **输入**：JWT token
+  - **输出**：用户会话对象
   - **关键步骤**：
-    1. 定义默认 PID 参数
-    2. 定义更新频率
-    3. 定义输出限制
+    1. 创建 middleware.ts 验证 token
+    2. 将用户信息注入 request context
+    3. 处理 token 过期情况
 
-- [ ] **任务 B.3**：添加 RViz 调试可视化（1 点）
-  - **输入**：控制器状态
-  - **输出**：RViz 配置
-  - **关键步骤**：
-    1. 发布 /pid_debug 话题
-    2. 创建 RViz 配置文件
+#### 模块 C：数据库（3 任务点）
 
-#### 模块 C：消息定义（1 任务点）
+**文件**: `prisma/schema.prisma`
 
-**包名**: `pid_controller_msgs`
+- [ ] **任务 C.1**：扩展 User 模型（1 点）
+  - **输入**：现有 User schema
+  - **输出**：支持登录的 User 模型
+  - **关键步骤**：
+    1. 添加 lastLoginAt 字段
+    2. 添加 loginAttempts 字段（防暴力破解）
 
-- [ ] **任务 C.1**：定义 PID 状态消息（1 点）
-  - **输入**：调试需求
-  - **输出**：msg/PIDState.msg
+- [ ] **任务 C.2**：创建 Session 模型（2 点）
+  - **输入**：Session 需求
+  - **输出**：Session schema
   - **关键步骤**：
-    1. 定义 error, p_term, i_term, d_term, output
-    2. 生成消息包
+    1. 定义 Session 表结构
+    2. 关联 User 外键
+    3. 运行 migration
 
 ## 3. 依赖关系
 
 | 任务 | 依赖于 | 原因 |
 |------|--------|------|
-| A.2 节点封装 | A.1 PID 类 | 需要 PID 算法实现 |
-| B.1 Launch | A.2 节点 | 需要知道节点可执行文件名 |
-| A.2 节点封装 | C.1 消息 | 需要 PIDState 消息类型 |
+| A.2 | B.1 | 上层应用需要底层控制 API 完成 |
+| B.1 | C.1 | API 需要数据库字段 |
 
 ## 4. 验收标准
 
-- [ ] PID 控制器响应时间 < 10ms
-- [ ] 参数动态调节正常工作
-- [ ] 仿真测试速度跟踪误差 < 5%
-- [ ] Launch 文件可正常启动
+- [ ] 用户可以使用正确的邮箱密码登录
+- [ ] 错误密码返回明确错误提示
+- [ ] 登录成功后跳转到首页
+- [ ] 单元测试覆盖 API 逻辑
 ```
 
 ---
@@ -339,7 +314,7 @@ Phase 2 可考虑的增强：
 
 1. **用户需求**：完整的功能描述
 2. **项目路径**：用于 ace-tool 检索上下文
-3. **技术栈信息**：ROS2 版本、硬件平台、已有包
-4. **特殊约束**：实时性要求、资源限制、安全要求
+3. **技术栈信息**：框架、数据库、已有模块
+4. **特殊约束**：性能要求、兼容性、安全要求
 
 本 agent 将返回详细的 Markdown 规划文档，可直接保存到 `.claude/plan/功能名.md`。

package/templates/commands/agents/system-integrator.md

@@ -1,7 +1,7 @@
 ---
 name: system-integrator
 description: 🤖 ROS2 系统集成设计师 - 为 ROS2 功能生成节点架构、Topic/Service 设计和消息流程
-tools: Read, Write, mcp__ace-tool__search_context
+tools: Read, Write, {{MCP_SEARCH_TOOL}}
 color: magenta
 ---
 
@@ -30,7 +30,7 @@ color: magenta
 如果项目已有节点或消息定义，使用 ace-tool 检索：
 
 ```
-mcp__ace-tool__search_context {
+{{MCP_SEARCH_TOOL}} {
   "project_root_path": "{{项目路径}}",
   "query": "ROS2 节点、Topic 订阅、消息类型、launch 文件"
 }