claude-coder 1.8.1 → 1.8.2

package/README.md

@@ -45,6 +45,9 @@ claude-coder run "实现用户注册和登录功能"
 | `claude-coder plan -r [file]` | 从需求文件生成计划 |
 | `claude-coder plan --planOnly` | 仅生成计划文档，不分解任务 |
 | `claude-coder plan -i "需求"` | 交互模式，允许模型提问 |
+| `claude-coder go` | AI 对话式需求收集与方案组装 |
+| `claude-coder go "需求"` | AI 自动分析需求并组装方案 |
+| `claude-coder go -r file` | 从文件读取需求并自动组装 |
 | `claude-coder run [需求]` | 自动编码循环 |
 | `claude-coder run --max 1` | 单次执行 |
 | `claude-coder run --dry-run` | 预览模式（查看任务队列） |
@@ -83,6 +86,7 @@ Harness 在 session 结束后自动校验 `session_result.json` + git 进度。
 | [技术架构](design/ARCHITECTURE.md) | 核心设计规则、Harness 类职责、模块关系、Prompt 注入架构 |
 | [Hook 注入机制](design/hook-mechanism.md) | SDK Hook 调研、GuidanceInjector 三级匹配、配置格式、副作用评估 |
 | [Session 守护机制](design/session-guard.md) | 中断策略、倒计时活跃度检测、工具运行状态追踪、防刷屏 |
+| [Go 指令流程](design/go-flow.md) | AI 驱动的需求组装、食谱系统、与 plan 衔接 |
 | [测试凭证方案](docs/PLAYWRIGHT_CREDENTIALS.md) | Playwright 登录态导出、API Key 持久化 |
 | [SDK 使用指南](docs/CLAUDE_AGENT_SDK_GUIDE.md) | Claude Agent SDK 接口参考 |
 
@@ -94,6 +98,8 @@ Harness 在 session 结束后自动校验 `session_result.json` + git 进度。
 
 **需求文档驱动**：在项目根目录创建 `requirements.md`，运行 `claude-coder run`。需求变更后 `claude-coder add -r` 同步新任务。
 
+**AI 驱动需求组装**：`claude-coder go "用户管理页面"` — AI 扫描内置食谱库，自动组装完整需求方案，一键进入 plan 分解任务。支持对话模式 (`go`) 逐步引导非技术人员。
+
 **自动测试 + 凭证持久化**：`claude-coder auth http://localhost:3000` — 导出浏览器登录态，Agent 测试时自动使用。详见 [测试凭证方案](docs/PLAYWRIGHT_CREDENTIALS.md)。
 
 ## 模型支持
@@ -135,6 +141,8 @@ your-project/
     session_result.json     # 上次 session 结果
     progress.json           # 会话历史 + 成本
     test.env                # 测试凭证（可选）
+    go/                     # go 指令输出的方案文件
+    recipes/                # 食谱库（init 时从内置模板部署）
     .runtime/
       harness_state.json    # Harness 状态（session 计数等）
       logs/                 # 每 session 独立日志

package/bin/cli.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 'use strict';
 
 const pkg = require('../package.json');
@@ -11,6 +11,7 @@ const COMMANDS = {
   simplify:  { desc: '代码审查和简化',           usage: 'claude-coder simplify [focus]' },
   auth:      { desc: '导出 Playwright 登录状态', usage: 'claude-coder auth [url]' },
   status:    { desc: '查看任务进度和成本',       usage: 'claude-coder status' },
+  go:        { desc: 'AI 驱动的需求组装',        usage: 'claude-coder go ["需求"] [-r file] [--reset]' },
 };
 
 function showHelp() {
@@ -32,6 +33,10 @@ function showHelp() {
   console.log('  claude-coder run --dry-run            预览模式');
   console.log('  claude-coder simplify               代码审查和简化');
   console.log('  claude-coder simplify "内存效率"     聚焦特定领域审查');
+  console.log('  claude-coder go                      对话式需求收集和方案组装');
+  console.log('  claude-coder go "用户管理页面"        AI 自动分析需求并组装方案');
+  console.log('  claude-coder go -r requirements.md   从文件读取需求并自动组装');
+  console.log('  claude-coder go --reset              重置 Go 记忆');
   console.log('  claude-coder auth                    导出 Playwright 登录状态');
   console.log('  claude-coder auth http://localhost:8080   指定登录 URL'); 
   console.log('  claude-coder status                  查看进度和成本');
@@ -75,6 +80,9 @@ function parseArgs(argv) {
       case '--planOnly':
         opts.planOnly = true;
         break;
+      case '--reset':
+        opts.reset = true;
+        break;
       case '-i':
       case '--interactive':
         opts.interactive = true;
@@ -140,6 +148,11 @@ async function main() {
       await auth(positional[0] || null);
       break;
     }
+    case 'go': {
+      const { run: goRun } = require('../src/core/go');
+      await goRun(positional[0] || '', opts);
+      break;
+    }
     case 'status': {
       const tasks = require('../src/common/tasks');
       tasks.showStatus();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-coder",
-  "version": "1.8.1",
+  "version": "1.8.2",
   "description": "Claude Coder — Autonomous coding agent harness powered by Claude Code SDK. Scan, plan, code, validate, git-commit in a loop.",
   "bin": {
     "claude-coder": "bin/cli.js"

package/src/common/assets.js

@@ -4,6 +4,7 @@ const fs = require('fs');
 const path = require('path');
 
 const BUNDLED_DIR = path.join(__dirname, '..', '..', 'templates');
+const BUNDLED_RECIPES_DIR = path.join(__dirname, '..', '..', 'recipes');
 
 // kind: 'template' — 双目录解析（用户 assets → 内置 bundled），有缓存
 // kind: 'data'     — .claude-coder/ 目录，无缓存
@@ -15,6 +16,7 @@ const REGISTRY = new Map([
   ['codingSystem',   { file: 'codingSystem.md',            kind: 'template' }],
   ['planSystem',     { file: 'planSystem.md',              kind: 'template' }],
   ['scanSystem',     { file: 'scanSystem.md',              kind: 'template' }],
+  ['goSystem',       { file: 'goSystem.md',                kind: 'template' }],
 
   // User Prompt Templates
   ['codingUser',     { file: 'codingUser.md',              kind: 'template' }],
@@ -196,6 +198,34 @@ class AssetManager {
     return deployed;
   }
 
+  deployRecipes() {
+    this._ensureInit();
+    const destDir = path.join(this.loopDir, 'recipes');
+    if (!fs.existsSync(BUNDLED_RECIPES_DIR)) return [];
+    if (!fs.existsSync(destDir)) fs.mkdirSync(destDir, { recursive: true });
+
+    const deployed = [];
+    const walk = (srcBase, destBase) => {
+      const entries = fs.readdirSync(srcBase, { withFileTypes: true });
+      for (const entry of entries) {
+        const srcPath = path.join(srcBase, entry.name);
+        const destPath = path.join(destBase, entry.name);
+        if (entry.isDirectory()) {
+          if (!fs.existsSync(destPath)) fs.mkdirSync(destPath, { recursive: true });
+          walk(srcPath, destPath);
+        } else {
+          if (fs.existsSync(destPath)) continue;
+          try {
+            fs.copyFileSync(srcPath, destPath);
+            deployed.push(path.relative(destDir, destPath));
+          } catch { /* skip */ }
+        }
+      }
+    };
+    walk(BUNDLED_RECIPES_DIR, destDir);
+    return deployed;
+  }
+
   clearCache() {
     this.cache.clear();
   }

package/src/core/go.js

@@ -0,0 +1,310 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const { runSession } = require('./session');
+const { buildQueryOptions } = require('./query');
+const { buildSystemPrompt } = require('./prompts');
+const { log, loadConfig } = require('../common/config');
+const { assets } = require('../common/assets');
+const { extractResultText } = require('../common/logging');
+const { loadState } = require('./harness');
+
+const GO_DIR_NAME = 'go';
+
+function getRecipesDir() {
+  return path.join(assets.projectRoot || process.cwd(), '.claude-coder', 'recipes');
+}
+
+// ─── Go State (harness_state.json → go section) ──────────
+
+function loadGoState() {
+  const state = loadState();
+  return state.go || {};
+}
+
+function saveGoState(goData) {
+  const state = loadState();
+  state.go = { ...state.go, ...goData };
+  assets.writeJson('harnessState', state);
+}
+
+// ─── Prompt Builder ───────────────────────────────────────
+
+function buildGoPrompt(instruction, opts = {}) {
+  const recipesAbsPath = getRecipesDir();
+  const goState = loadGoState();
+
+  const inputSection = opts.reqFile
+    ? `用户需求文件路径: ${opts.reqFile}\n先读取该文件了解用户需求。`
+    : instruction
+      ? `用户需求:\n${instruction}`
+      : '用户未提供需求，使用对话模式收集。';
+
+  const modeSection = (instruction || opts.reqFile)
+    ? '【自动模式】用户已提供需求，直接分析并组装方案，不要提问。'
+    : '【对话模式】使用 askUserQuestion 工具，按协议中的顺序向用户提问收集需求。';
+
+  let memorySection = '';
+  if (goState.lastDomain || goState.lastFile) {
+    const parts = [];
+    if (goState.lastDomain) parts.push(`上次领域: ${goState.lastDomain}`);
+    if (goState.lastComponents) parts.push(`上次组件: ${goState.lastComponents.join(', ')}`);
+    if (goState.lastTimestamp) parts.push(`时间: ${goState.lastTimestamp}`);
+    memorySection = `上次使用记录（仅供参考）：${parts.join(' | ')}`;
+  }
+
+  return [
+    inputSection,
+    '',
+    modeSection,
+    '',
+    `食谱目录绝对路径: ${recipesAbsPath}`,
+    '',
+    memorySection,
+  ].filter(Boolean).join('\n');
+}
+
+// ─── Content Extraction ──────────────────────────────────
+
+function extractGoContent(collected) {
+  let fullText = '';
+  for (const msg of collected) {
+    if (msg.type === 'assistant' && msg.message?.content) {
+      for (const block of msg.message.content) {
+        if (block.type === 'text' && block.text) fullText += block.text;
+      }
+    }
+  }
+
+  const match = fullText.match(/GO_CONTENT_START\s*\n([\s\S]*?)\nGO_CONTENT_END/);
+  if (match) return match[1].trim();
+
+  const resultText = extractResultText(collected);
+  if (resultText) {
+    const m = resultText.match(/GO_CONTENT_START\s*\n([\s\S]*?)\nGO_CONTENT_END/);
+    if (m) return m[1].trim();
+  }
+
+  return null;
+}
+
+function extractDomainFromContent(content) {
+  if (!content) return null;
+  const match = content.match(/##\s*开发领域\s*\n\s*(\S+)/);
+  if (match) {
+    const name = match[1];
+    const domainMap = { '管理后台': 'console', 'H5': 'h5', '后端': 'backend' };
+    for (const [key, val] of Object.entries(domainMap)) {
+      if (name.includes(key)) return val;
+    }
+  }
+  return null;
+}
+
+function extractComponentsFromContent(content) {
+  if (!content) return [];
+  const section = content.match(/##\s*功能组件\s*\n([\s\S]*?)(?=\n##|$)/);
+  if (!section) return [];
+  const items = section[1].match(/[-*]\s+\*\*(.+?)\*\*/g) || [];
+  return items.map(i => i.replace(/[-*]\s+\*\*|\*\*/g, '').trim());
+}
+
+// ─── Preview & Confirm ───────────────────────────────────
+
+async function previewAndConfirm(content) {
+  const lines = content.split('\n');
+  const previewLines = Math.min(lines.length, 25);
+
+  console.log('');
+  console.log('┌─ 需求方案预览 ────────────────────────────────┐');
+  for (let i = 0; i < previewLines; i++) {
+    const line = lines[i].length > 52 ? lines[i].slice(0, 49) + '...' : lines[i];
+    console.log(`│ ${line.padEnd(52)}│`);
+  }
+  if (lines.length > previewLines) {
+    const msg = `... 共 ${lines.length} 行，完整内容将写入文件`;
+    console.log(`│ ${msg.padEnd(52)}│`);
+  }
+  console.log('└───────────────────────────────────────────────┘');
+
+  if (!process.stdin.isTTY) return { confirmed: true, supplement: '' };
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => {
+    rl.question('\n有什么要补充的？(直接回车确认 / 输入补充内容 / 输入 cancel 取消)\n> ', answer => {
+      rl.close();
+      const trimmed = answer.trim();
+      if (trimmed.toLowerCase() === 'cancel') {
+        resolve({ confirmed: false, supplement: '' });
+      } else {
+        resolve({ confirmed: true, supplement: trimmed });
+      }
+    });
+  });
+}
+
+async function promptProceedToPlan() {
+  if (!process.stdin.isTTY) return true;
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => {
+    rl.question('是否继续生成计划并分解任务？(y/n) ', answer => {
+      rl.close();
+      resolve(/^[Yy]/.test(answer.trim()));
+    });
+  });
+}
+
+// ─── Go Output ────────────────────────────────────────────
+
+function ensureGoDir() {
+  const goDir = path.join(assets.projectRoot, '.claude-coder', GO_DIR_NAME);
+  if (!fs.existsSync(goDir)) fs.mkdirSync(goDir, { recursive: true });
+  return goDir;
+}
+
+function writeGoFile(content) {
+  const goDir = ensureGoDir();
+  const ts = new Date().toISOString().replace(/[-:T]/g, '').slice(0, 12);
+  const fileName = `go_${ts}.md`;
+  const filePath = path.join(goDir, fileName);
+  fs.writeFileSync(filePath, content, 'utf8');
+  return filePath;
+}
+
+// ─── Session Execution ───────────────────────────────────
+
+async function _executeGoSession(instruction, opts = {}) {
+  const isAutoMode = !!(instruction || opts.reqFile);
+  const ts = new Date().toISOString().replace(/[-:T]/g, '').slice(0, 12);
+
+  return runSession('go', {
+    opts,
+    sessionNum: 0,
+    logFileName: `go_${ts}.log`,
+    label: isAutoMode ? 'go_auto' : 'go_dialogue',
+
+    async execute(sdk, ctx) {
+      log('info', isAutoMode ? '正在分析需求并组装方案...' : '正在启动对话式需求收集...');
+
+      const prompt = buildGoPrompt(instruction, opts);
+      const queryOpts = buildQueryOptions(ctx.config, opts);
+      queryOpts.systemPrompt = buildSystemPrompt('go');
+      queryOpts.permissionMode = 'plan';
+      queryOpts.hooks = ctx.hooks;
+      queryOpts.abortController = ctx.abortController;
+
+      if (isAutoMode) {
+        queryOpts.disallowedTools = ['askUserQuestion'];
+      }
+
+      const collected = await ctx.runQuery(sdk, prompt, queryOpts);
+      const content = extractGoContent(collected);
+
+      return { content, collected };
+    },
+  });
+}
+
+// ─── Main Entry ──────────────────────────────────────────
+
+async function run(input, opts = {}) {
+  const instruction = input || '';
+
+  assets.ensureDirs();
+
+  const config = loadConfig();
+  if (!opts.model) {
+    opts.model = config.defaultOpus || config.model;
+  }
+
+  const displayModel = opts.model || config.model || '(default)';
+  log('ok', `模型配置已加载: ${config.provider || 'claude'} (go 使用: ${displayModel})`);
+
+  const recipesDir = getRecipesDir();
+  if (!fs.existsSync(recipesDir) || fs.readdirSync(recipesDir).length === 0) {
+    log('error', `食谱目录为空或不存在: ${recipesDir}`);
+    log('info', '请先运行 claude-coder init 初始化项目（会自动部署食谱）');
+    process.exit(1);
+  }
+
+  // --reset: 清空 go 记忆
+  if (opts.reset) {
+    saveGoState({});
+    log('ok', 'Go 记忆已重置');
+    return;
+  }
+
+  // -r: 读取需求文件，自动模式
+  if (opts.readFile) {
+    const reqPath = path.resolve(assets.projectRoot, opts.readFile);
+    if (!fs.existsSync(reqPath)) {
+      log('error', `文件不存在: ${reqPath}`);
+      process.exit(1);
+    }
+    opts.reqFile = reqPath;
+    log('info', `需求文件: ${reqPath}`);
+  }
+
+  // 确定模式
+  const mode = (instruction || opts.reqFile) ? '自动' : '对话';
+  log('info', `Go 模式: ${mode}`);
+
+  // 执行 go session
+  const result = await _executeGoSession(instruction, opts);
+
+  if (!result.content) {
+    log('error', '无法从 AI 输出中提取方案内容');
+    log('info', '请检查日志文件了解详情');
+    return;
+  }
+
+  // 预览 + 确认 + 补充
+  const { confirmed, supplement } = await previewAndConfirm(result.content);
+  if (!confirmed) {
+    log('info', '已取消');
+    return;
+  }
+
+  let finalContent = result.content;
+  if (supplement) {
+    finalContent += `\n\n## 补充要求\n\n${supplement}`;
+  }
+
+  // 写入 .claude-coder/go/
+  const filePath = writeGoFile(finalContent);
+  log('ok', `方案已保存: ${filePath}`);
+
+  // 保存记忆到 harness_state.json
+  const domain = extractDomainFromContent(finalContent);
+  const components = extractComponentsFromContent(finalContent);
+  const history = (loadGoState().history || []).slice(-9);
+  history.push({
+    timestamp: new Date().toISOString(),
+    requirement: instruction || opts.reqFile || '(对话收集)',
+    file: filePath,
+    domain,
+  });
+
+  saveGoState({
+    lastFile: filePath,
+    lastDomain: domain,
+    lastComponents: components,
+    lastTimestamp: new Date().toISOString(),
+    history,
+  });
+
+  // 询问是否继续到 plan
+  console.log('');
+  const shouldPlan = await promptProceedToPlan();
+  if (shouldPlan) {
+    log('info', '开始生成计划并分解任务...');
+    const { run: planRun } = require('./plan');
+    await planRun('', { reqFile: filePath, ...opts });
+  } else {
+    log('info', `方案已保存，稍后可使用: claude-coder plan -r ${filePath}`);
+  }
+}
+
+module.exports = { run };

package/src/core/hooks.js

@@ -434,6 +434,7 @@ const FEATURE_MAP = {
   scan: [FEATURES.STALL],
   add: [FEATURES.STALL],
   simplify: [FEATURES.STALL, FEATURES.INTERACTION],
+  go: [FEATURES.STALL, FEATURES.INTERACTION],
   custom: null
 };
 

package/src/core/init.js

@@ -59,6 +59,13 @@ function deployAssets() {
   }
 }
 
+function deployRecipes() {
+  const deployed = assets.deployRecipes();
+  if (deployed.length > 0) {
+    log('ok', `已部署 ${deployed.length} 个食谱文件 → .claude-coder/recipes/`);
+  }
+}
+
 async function init() {
   assets.ensureDirs();
   const projectRoot = assets.projectRoot;
@@ -76,6 +83,7 @@ async function init() {
   let stepCount = 0;
 
   deployAssets();
+  deployRecipes();
 
   const envSetup = profile.env_setup || {};
   if (envSetup.python_env && envSetup.python_env !== 'system' && envSetup.python_env !== 'none') {

package/src/core/prompts.js

@@ -16,6 +16,7 @@ function buildSystemPrompt(type) {
     case 'scan':    specific = assets.read('scanSystem') || ''; break;
     case 'coding':  specific = assets.read('codingSystem') || ''; break;
     case 'plan':    specific = assets.read('planSystem') || ''; break;
+    case 'go':      specific = assets.read('goSystem') || ''; break;
   }
   return specific ? `${specific}\n\n${core}` : core;
 }

package/templates/goSystem.md

@@ -0,0 +1,130 @@
+<!--
+  Go Session System Prompt.
+  Prepended after coreProtocol.md by buildSystemPrompt('go').
+  AI 扫描 recipes/ → 对话/自动分析 → 组装完整需求方案文档。
+-->
+
+# 需求组装会话协议
+
+## 你是谁
+
+你是 claude-coder 的需求分析与方案组装 Agent。唯一职责：扫描食谱目录 → 理解用户需求 → 组装一份完整的需求方案文档。
+你**不实现代码**、不启动服务、不运行测试、不修改任何项目文件。
+
+## 铁律
+
+1. **只组装不编码** — 禁止写任何业务代码或修改项目文件
+2. **食谱为参考素材** — recipes/ 是最佳实践库，可自由引用、裁剪、增补；没有匹配食谱的部分，凭专业能力自行补充
+3. **必须输出 GO_CONTENT** — 最终必须输出方案文档，格式见下方
+4. **先扫描后提问** — 必须先用工具扫描 recipes/ 目录了解可用选项，再与用户交互
+
+## 工作流程
+
+### Step 1 — 扫描食谱目录
+
+使用 LS 和 Read 工具扫描 prompt 中指定的 recipes 绝对路径：
+
+1. `LS recipes/` → 发现所有领域目录（跳过 `_shared`）
+2. 读取每个领域的 `manifest.json` → 了解可用领域、组件、默认值
+3. 读取 `recipes/_shared/roles/` → 了解可用角色
+
+### Step 2 — 需求收集
+
+**对话模式**（用户未提供需求时）：
+
+使用 askUserQuestion 工具按以下顺序提问：
+
+1. **领域选择** — 展示所有可用领域（从 manifest 获取 name + description），让用户选择
+2. **组件选择** — 展示选中领域的所有组件（从 manifest.components 获取），标注默认项，让用户多选
+3. **角色确认** — 展示可用角色（产品经理/开发者/测试），让用户选择
+4. **具体需求** — 询问具体的业务需求（如"做一个用户管理页面，需要用户名、邮箱、角色字段"）
+5. **测试需求** — 询问是否需要 E2E 测试
+6. **补充信息** — 询问是否有技术约束或其他补充（组件库偏好、API 风格等）
+
+提问规则：
+- 每次只问一个主题（不要一次问太多）
+- 展示清晰的选项（编号 + 描述）
+- 标注默认推荐值
+- 用户可以说"回退"或"修改上一个"来修改之前的选择
+
+**自动模式**（用户已提供需求文本或文件时）：
+
+1. 分析用户需求文本
+2. 匹配最合适的领域（根据关键词和 manifest 描述）
+3. 选择必要的组件（参考 manifest defaults + 需求分析）
+4. 推断角色（默认 developer，需求风格偏产品化则选 product）
+5. 不调用 askUserQuestion，直接输出方案
+
+### Step 3 — 阅读选中的食谱
+
+根据用户选择/AI 判断，使用 Read 工具阅读：
+1. 选中领域的 `base.md`
+2. 选中组件的 `.md` 文件
+3. 选中角色的 `.md` 文件
+4. 测试食谱（如需要）
+5. `_shared/test/report-format.md`（如需要测试）
+
+### Step 4 — 组装方案文档
+
+综合食谱内容 + 用户需求 + 专业判断，组装一份 Markdown 格式的完整需求方案文档。
+
+组装原则：
+- **有食谱覆盖的部分**：以食谱为基线，结合具体需求适配和裁剪
+- **食谱未覆盖的部分**：凭专业能力自主补充（如性能优化、安全防护、UX 建议等）
+- **可跨领域组合**：如需要，从多个领域食谱中取片段混合使用
+- **无食谱兜底**：即使 recipes/ 目录为空或无匹配，也能基于需求独立输出完整方案
+
+文档结构：
+
+```
+# 需求方案 — {简短标题}
+
+## 项目概述
+{用户的需求描述}
+
+## 开发领域
+{领域名称} — {领域描述}
+
+## 功能组件
+{按选中的组件列出功能点，结合用户具体需求}
+
+## 技术指导
+{从食谱 .md 中提取的实现要点和验证策略}
+
+## 角色提示
+{角色 .md 的内容}
+
+## 任务分解建议
+{从 base.md 提取的分解模式}
+
+## 测试要求（如适用）
+{测试步骤模板 + 报告格式要求}
+
+## 用户补充
+{用户在对话中提到的额外要求}
+```
+
+### Step 5 — 输出
+
+输出方案文档时，使用以下标记（标记各独占一行）：
+
+GO_CONTENT_START
+{完整的方案文档 Markdown 内容}
+GO_CONTENT_END
+
+输出标记后，用 1-2 句话简要总结方案要点。
+
+## 工具规范
+
+- 扫描/读取：Glob/LS/Read — 扫描 recipes/ 目录
+- 交互：askUserQuestion — 收集用户需求（对话模式）
+- 输出方式：将方案内容放在 GO_CONTENT_START/END 标记中（文本输出），harness 会自动写入 `.claude-coder/go/` 目录
+- 不需要使用 Write/Edit/Bash/MultiEdit 工具
+
+## 注意事项
+
+- 食谱目录位于用户项目的 `.claude-coder/recipes/`，由 `claude-coder init` 从内置模板部署
+- 用户可修改或新增食谱文件，下次扫描会自动发现
+- manifest.json 的 defaults 字段表示推荐默认值
+- 组件的 default: true 表示该组件在此领域中常用
+- _shared/ 目录包含跨领域共享的角色和测试模板

package/templates/guidance.json

@@ -19,6 +19,24 @@
         }
       }
     },
+    {
+      "name": "frontend-component",
+      "matcher": "^(Edit|MultiEdit|Write)$",
+      "condition": {
+        "any": [
+          { "field": "tool_input.file_path", "pattern": "\\.(tsx|jsx|vue|svelte)$" },
+          { "field": "tool_input.path",      "pattern": "\\.(tsx|jsx|vue|svelte)$" }
+        ]
+      },
+      "toolTips": {
+        "injectOnce": false,
+        "items": {
+          "Edit": "编辑前端组件前，先 Grep 搜索项目中同类组件的写法，保持代码风格一致。",
+          "Write": "新建组件时，遵循项目现有的目录结构和命名规范（如 PascalCase 组件名）。",
+          "MultiEdit": "批量编辑组件时，确认所有改动保持一致的代码风格。"
+        }
+      }
+    },
     {
       "name": "bash-process",
       "matcher": "Bash",