claude-coder 1.8.4 → 1.9.0

package/src/core/init.js

@@ -6,15 +6,27 @@ const http = require('http');
 const { spawn, execSync } = require('child_process');
 const { log } = require('../common/config');
 const { assets } = require('../common/assets');
-const { scan } = require('./scan');
+const { isGitRepo, ensureGitignore } = require('../common/utils');
+
+function ensureEnvironment(projectRoot) {
+  ensureGitignore(projectRoot);
+  if (!isGitRepo(projectRoot)) {
+    log('info', '初始化 git 仓库...');
+    execSync('git init', { cwd: projectRoot, stdio: 'inherit' });
+    execSync('git add -A && git commit -m "init: 项目初始化" --allow-empty', {
+      cwd: projectRoot,
+      stdio: 'inherit',
+    });
+  }
+}
 
-function loadProfile() {
-  const data = assets.readJson('profile', null);
-  if (!data) {
-    log('error', 'project_profile.json 读取失败或已损坏');
-    process.exit(1);
+function runCmd(cmd, cwd) {
+  try {
+    execSync(cmd, { cwd: cwd || assets.projectRoot, stdio: 'inherit', shell: true });
+    return true;
+  } catch {
+    return false;
   }
-  return data;
 }
 
 function isPortFree(port) {
@@ -31,9 +43,7 @@ function waitForHealth(url, timeoutMs = 15000) {
   return new Promise(resolve => {
     const check = () => {
       if (Date.now() - start > timeoutMs) { resolve(false); return; }
-      const req = http.get(url, res => {
-        resolve(res.statusCode < 500);
-      });
+      const req = http.get(url, res => { resolve(res.statusCode < 500); });
       req.on('error', () => setTimeout(check, 1000));
       req.setTimeout(3000, () => { req.destroy(); setTimeout(check, 1000); });
     };
@@ -41,116 +51,104 @@ function waitForHealth(url, timeoutMs = 15000) {
   });
 }
 
-function runCmd(cmd, cwd) {
-  try {
-    execSync(cmd, { cwd: cwd || assets.projectRoot, stdio: 'inherit', shell: true });
-    return true;
-  } catch {
-    return false;
+function buildEnvSteps(profile, projectRoot) {
+  const steps = [];
+  const envSetup = profile.env_setup || {};
+
+  if (envSetup.python_env && !['system', 'none'].includes(envSetup.python_env)) {
+    if (envSetup.python_env.startsWith('conda:')) {
+      const name = envSetup.python_env.slice(6);
+      steps.push({ label: `Python 环境: conda activate ${name}`, cmd: `conda activate ${name}` });
+    } else if (envSetup.python_env === 'venv') {
+      steps.push({ label: 'Python 环境: venv', cmd: 'source .venv/bin/activate || .venv\\Scripts\\activate' });
+    }
   }
-}
 
-function deployAssets() {
-  const deployed = assets.deployAll();
-  if (deployed.length > 0) {
-    for (const file of deployed) {
-      log('ok', `已部署 → .claude-coder/assets/${file}`);
+  if (envSetup.node_version && envSetup.node_version !== 'none') {
+    steps.push({ label: `Node.js: v${envSetup.node_version}`, cmd: `nvm use ${envSetup.node_version}` });
+  }
+
+  const pkgManagers = profile.tech_stack?.package_managers || [];
+  for (const pm of pkgManagers) {
+    if (['npm', 'yarn', 'pnpm'].includes(pm)) {
+      if (fs.existsSync(`${projectRoot}/node_modules`)) {
+        steps.push({ label: `${pm} 依赖已安装，跳过`, skip: true });
+      } else {
+        steps.push({ label: `安装依赖: ${pm} install`, cmd: `${pm} install`, cwd: projectRoot });
+      }
+    } else if (pm === 'pip' && fs.existsSync(`${projectRoot}/requirements.txt`)) {
+      steps.push({ label: '安装依赖: pip install -r requirements.txt', cmd: 'pip install -r requirements.txt', cwd: projectRoot });
     }
   }
+
+  for (const cmd of (profile.custom_init || [])) {
+    steps.push({ label: `自定义: ${cmd}`, cmd, cwd: projectRoot });
+  }
+
+  return steps;
 }
 
-function deployRecipes() {
-  const deployed = assets.deployRecipes();
-  if (deployed.length > 0) {
-    log('ok', `已部署 ${deployed.length} 个食谱文件 → .claude-coder/recipes/`);
+async function startService(svc, projectRoot, stepNum) {
+  const free = await isPortFree(svc.port);
+  if (!free) {
+    log('ok', `[${stepNum}] ${svc.name} 已在端口 ${svc.port} 运行，跳过`);
+    return;
+  }
+
+  log('info', `[${stepNum}] 启动 ${svc.name} (端口 ${svc.port})...`);
+  const cwd = svc.cwd ? `${projectRoot}/${svc.cwd}` : projectRoot;
+  const child = spawn(svc.command, { cwd, shell: true, detached: true, stdio: 'ignore' });
+  child.unref();
+
+  if (svc.health_check) {
+    const healthy = await waitForHealth(svc.health_check);
+    log(healthy ? 'ok' : 'warn',
+      healthy ? `${svc.name} 就绪: ${svc.health_check}` : `${svc.name} 健康检查超时 (${svc.health_check})，继续执行`);
   }
 }
 
-async function init() {
-  assets.ensureDirs();
+async function executeInit(config, opts = {}) {
   const projectRoot = assets.projectRoot;
 
+  ensureEnvironment(projectRoot);
+
   if (!assets.exists('profile')) {
     log('info', 'profile 不存在，正在执行项目扫描...');
-    const scanResult = await scan({ projectRoot });
+    const { executeScan } = require('./scan');
+    const scanResult = await executeScan(config, opts);
     if (!scanResult.success) {
-      log('error', '项目扫描失败');
-      process.exit(1);
+      throw new Error('项目扫描失败');
     }
   }
 
-  const profile = loadProfile();
-  let stepCount = 0;
-
-  deployAssets();
-  deployRecipes();
-
-  const envSetup = profile.env_setup || {};
-  if (envSetup.python_env && envSetup.python_env !== 'system' && envSetup.python_env !== 'none') {
-    stepCount++;
-    if (envSetup.python_env.startsWith('conda:')) {
-      const envName = envSetup.python_env.slice(6);
-      log('info', `[${stepCount}] Python 环境: conda activate ${envName}`);
-      runCmd(`conda activate ${envName}`);
-    } else if (envSetup.python_env === 'venv') {
-      log('info', `[${stepCount}] Python 环境: venv`);
-      runCmd('source .venv/bin/activate || .venv\\Scripts\\activate');
-    }
-  }
-  if (envSetup.node_version && envSetup.node_version !== 'none') {
-    stepCount++;
-    log('info', `[${stepCount}] Node.js: v${envSetup.node_version}`);
-    runCmd(`nvm use ${envSetup.node_version}`);
+  const profile = assets.readJson('profile', null);
+  if (!profile) {
+    throw new Error('project_profile.json 读取失败或已损坏');
   }
 
-  const pkgManagers = (profile.tech_stack && profile.tech_stack.package_managers) || [];
-  for (const pm of pkgManagers) {
-    stepCount++;
-    if (pm === 'npm' || pm === 'yarn' || pm === 'pnpm') {
-      if (fs.existsSync(`${projectRoot}/node_modules`)) {
-        log('ok', `[${stepCount}] ${pm} 依赖已安装，跳过`);
-      } else {
-        log('info', `[${stepCount}] 安装依赖: ${pm} install`);
-        runCmd(`${pm} install`, projectRoot);
-      }
-    } else if (pm === 'pip') {
-      const reqFile = fs.existsSync(`${projectRoot}/requirements.txt`);
-      if (reqFile) {
-        log('info', `[${stepCount}] 安装依赖: pip install -r requirements.txt`);
-        runCmd('pip install -r requirements.txt', projectRoot);
-      }
-    }
+  if (opts.deployTemplates) {
+    for (const file of assets.deployAll()) log('ok', `已部署 → .claude-coder/assets/${file}`);
+    const recipes = assets.deployRecipes();
+    if (recipes.length > 0) log('ok', `已部署 ${recipes.length} 个食谱文件 → .claude-coder/recipes/`);
   }
 
-  const customInit = profile.custom_init || [];
-  for (const cmd of customInit) {
+  const envSteps = buildEnvSteps(profile, projectRoot);
+  let stepCount = 0;
+
+  for (const step of envSteps) {
     stepCount++;
-    log('info', `[${stepCount}] 自定义: ${cmd}`);
-    runCmd(cmd, projectRoot);
+    if (step.skip) {
+      log('ok', `[${stepCount}] ${step.label}`);
+    } else {
+      log('info', `[${stepCount}] ${step.label}`);
+      runCmd(step.cmd, step.cwd);
+    }
   }
 
   const services = profile.services || [];
   for (const svc of services) {
     stepCount++;
-    const free = await isPortFree(svc.port);
-    if (!free) {
-      log('ok', `[${stepCount}] ${svc.name} 已在端口 ${svc.port} 运行，跳过`);
-      continue;
-    }
-
-    log('info', `[${stepCount}] 启动 ${svc.name} (端口 ${svc.port})...`);
-    const cwd = svc.cwd ? `${projectRoot}/${svc.cwd}` : projectRoot;
-    const child = spawn(svc.command, { cwd, shell: true, detached: true, stdio: 'ignore' });
-    child.unref();
-
-    if (svc.health_check) {
-      const healthy = await waitForHealth(svc.health_check);
-      if (healthy) {
-        log('ok', `${svc.name} 就绪: ${svc.health_check}`);
-      } else {
-        log('warn', `${svc.name} 健康检查超时 (${svc.health_check})，继续执行`);
-      }
-    }
+    await startService(svc, projectRoot, stepCount);
   }
 
   if (stepCount === 0) {
@@ -159,13 +157,9 @@ async function init() {
     log('ok', `初始化完成 (${stepCount} 步)`);
   }
 
-  if (services.length > 0) {
-    console.log('');
-    for (const svc of services) {
-      console.log(`  ${svc.name}: http://localhost:${svc.port}`);
-    }
-    console.log('');
+  for (const svc of services) {
+    console.log(`  ${svc.name}: http://localhost:${svc.port}`);
   }
 }
 
-module.exports = { init };
+module.exports = { executeInit };

package/src/core/plan.js

@@ -4,126 +4,36 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const readline = require('readline');
-const { runSession } = require('./session');
-const { buildQueryOptions } = require('./query');
 const { buildSystemPrompt, buildPlanPrompt } = require('./prompts');
-const { log, loadConfig } = require('../common/config');
+const { log } = require('../common/config');
 const { assets } = require('../common/assets');
-const { extractResultText } = require('../common/logging');
 const { printStats } = require('../common/tasks');
-const { syncAfterPlan } = require('./harness');
+const { syncAfterPlan } = require('./state');
+const { Session } = require('./session');
 
-const EXIT_TIMEOUT_MS = 300000;
 const PLANS_DIR = path.join(os.homedir(), '.claude', 'plans');
 
-function buildPlanOnlyPrompt(instruction, opts = {}) {
+function buildPlanOnlySystem(opts = {}) {
   const interactive = opts.interactive || false;
-  const reqFile = opts.reqFile || null;
-
-  const inputSection = reqFile
-    ? `需求文件路径: ${reqFile}\n先读取该文件，理解用户需求和约束。`
-    : `用户需求:\n${instruction}`;
-
   const interactionRule = interactive
-    ? '如有不确定的关键决策点，向用户提问对话确认方案。'
+    ? '如有不确定的关键决策点，使用 AskUserQuestion 工具向用户提问，对话确认方案。'
     : '不要提问，默认使用最佳推荐方案。';
 
-  return `你是一个资深技术架构师。根据以下需求，探索项目代码库后输出完整的技术方案文档。
-
-${inputSection}
+  return `你是一个资深技术架构师。根据用户需求，探索项目代码库后输出完整的技术方案文档。
 
 【流程】
 1. 探索项目代码库，理解结构和技术栈
 2. ${interactionRule}
 3. 使用 Write 工具将完整计划写入 ~/.claude/plans/ 目录（.md 格式）
 4. 写入后输出标记（独占一行）：PLAN_FILE_PATH: <计划文件绝对路径>
-5. 简要总结计划要点
-`;
-}
-
-/**
- * 从文本中提取计划文件路径
- * 优先级：PLAN_FILE_PATH 标记 > .claude/plans/*.md > 反引号包裹 .md > 任意绝对 .md
- */
-function extractPlanPath(text) {
-  if (!text) return null;
-
-  const tagMatch = text.match(/PLAN_FILE_PATH:\s*(\S+\.md)/);
-  if (tagMatch) return tagMatch[1];
-
-  const plansMatch = text.match(/([^\s`'"(]*\.claude\/plans\/[^\s`'"()]+\.md)/);
-  if (plansMatch) return plansMatch[1];
-
-  const backtickMatch = text.match(/`([^`]+\.md)`/);
-  if (backtickMatch) return backtickMatch[1];
-
-  const absMatch = text.match(/(\/[^\s`'"]+\.md)/);
-  if (absMatch) return absMatch[1];
-
-  return null;
+5. 简要总结计划要点`;
 }
 
-/**
- * 多源提取计划路径（按可靠性从高到低）
- * 1. Write 工具调用参数（最可靠）
- * 2. assistant 消息流文本
- * 3. result.result 文本
- * 4. plans 目录最新文件（兜底）
- */
-function extractPlanPathFromCollected(collected, startTime) {
-  // 第一层：从 Write 工具调用参数中直接获取
-  for (const msg of collected) {
-    if (msg.type !== 'assistant' || !msg.message?.content) continue;
-    for (const block of msg.message.content) {
-      if (block.type === 'tool_use' && block.name === 'Write') {
-        const target = block.input?.file_path || block.input?.path || '';
-        if (target.includes('.claude/plans/') && target.endsWith('.md')) {
-          if (fs.existsSync(target)) return target;
-        }
-      }
-    }
-  }
-
-  // 第二层：从所有 assistant 文本中提取
-  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;
-      }
-    }
-  }
-  if (fullText) {
-    const p = extractPlanPath(fullText);
-    if (p && fs.existsSync(p)) return p;
-  }
-
-  // 第三层：从 result.result 中提取
-  const resultText = extractResultText(collected);
-  if (resultText) {
-    const p = extractPlanPath(resultText);
-    if (p && fs.existsSync(p)) return p;
-  }
-
-  // 第四层：扫描 plans 目录，找 session 期间新建的文件
-  if (fs.existsSync(PLANS_DIR)) {
-    try {
-      const files = fs.readdirSync(PLANS_DIR)
-        .filter(f => f.endsWith('.md'))
-        .map(f => {
-          const fp = path.join(PLANS_DIR, f);
-          return { path: fp, mtime: fs.statSync(fp).mtimeMs };
-        })
-        .filter(f => f.mtime >= startTime)
-        .sort((a, b) => b.mtime - a.mtime);
-      if (files.length > 0) {
-        log('info', `从 plans 目录发现新文件: ${path.basename(files[0].path)}`);
-        return files[0].path;
-      }
-    } catch { /* ignore */ }
-  }
-
-  return null;
+function buildPlanOnlyPrompt(instruction, opts = {}) {
+  const reqFile = opts.reqFile || null;
+  return reqFile
+    ? `需求文件路径: ${reqFile}\n先读取该文件，理解用户需求和约束。`
+    : instruction;
 }
 
 function copyPlanToProject(generatedPath) {
@@ -142,57 +52,43 @@ function copyPlanToProject(generatedPath) {
   }
 }
 
-async function _executePlanGen(sdk, ctx, instruction, opts = {}) {
+async function _executePlanGen(session, instruction, opts = {}) {
+  const interactive = opts.interactive || false;
   const prompt = buildPlanOnlyPrompt(instruction, opts);
   const queryOpts = {
     permissionMode: 'plan',
+    systemPrompt: buildPlanOnlySystem(opts),
     cwd: opts.projectRoot || assets.projectRoot,
-    hooks: ctx.hooks,
+    hooks: session.hooks,
   };
-  if (!opts.interactive) {
+  if (!interactive) {
     queryOpts.disallowedTools = ['askUserQuestion'];
   }
   if (opts.model) queryOpts.model = opts.model;
 
-  const startTime = Date.now();
-  let exitPlanModeDetected = false;
-  let exitPlanModeTime = null;
-
-  const collected = [];
-  const session = sdk.query({ prompt, options: queryOpts });
-
-  for await (const msg of session) {
-    if (ctx._isStalled && ctx._isStalled()) {
-      log('warn', '停顿超时，中断 plan 生成');
-      break;
-    }
-
-    if (exitPlanModeDetected && exitPlanModeTime) {
-      const elapsed = Date.now() - exitPlanModeTime;
-      if (elapsed > EXIT_TIMEOUT_MS && msg.type !== 'result') {
-        log('warn', '检测到 ExitPlanMode，等待审批超时，尝试从已收集消息中提取路径');
-        break;
-      }
-    }
-
-    collected.push(msg);
-    ctx._logMessage(msg);
-
-    if (msg.type === 'assistant' && msg.message?.content) {
-      for (const block of msg.message.content) {
-        if (block.type === 'tool_use' && block.name === 'ExitPlanMode') {
-          exitPlanModeDetected = true;
-          exitPlanModeTime = Date.now();
+  let capturedPlanPath = null;
+
+  const { success } = await session.runQuery(prompt, queryOpts, {
+    onMessage(message) {
+      if (message.type !== 'assistant' || !message.message?.content) return;
+      for (const block of message.message.content) {
+        if (block.type === 'tool_use' && block.name === 'Write') {
+          const target = block.input?.file_path || block.input?.path || '';
+          if (target.includes('.claude/plans/') && target.endsWith('.md')) {
+            capturedPlanPath = target;
+          }
         }
       }
-    }
-  }
+    },
+  });
 
-  const planPath = extractPlanPathFromCollected(collected, startTime);
+  if (!success) {
+    log('warn', '计划生成查询未正常结束');
+  }
 
-  if (planPath) {
-    const targetPath = copyPlanToProject(planPath);
-    return { success: true, targetPath, generatedPath: planPath };
+  if (capturedPlanPath && fs.existsSync(capturedPlanPath)) {
+    const targetPath = copyPlanToProject(capturedPlanPath);
+    return { success: true, targetPath, generatedPath: capturedPlanPath };
   }
 
   log('warn', '无法从输出中提取计划路径');
@@ -200,23 +96,53 @@ async function _executePlanGen(sdk, ctx, instruction, opts = {}) {
   return { success: false, reason: 'no_path', targetPath: null };
 }
 
-async function runPlanSession(instruction, opts = {}) {
-  const planOnly = opts.planOnly || false;
-  const interactive = opts.interactive || false;
+async function promptAutoRun() {
+  if (!process.stdin.isTTY) return false;
+  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()));
+    });
+  });
+}
+
+// ─── Main Entry ──────────────────────────────────────────
+
+async function executePlan(config, input, opts = {}) {
+  const instruction = input || '';
+
+  if (opts.reqFile && instruction) {
+    log('info', `-r 模式下忽略文本输入，使用需求文件: ${opts.reqFile}`);
+  } else if (opts.reqFile) {
+    console.log(`需求文件: ${opts.reqFile}`);
+  }
+
+  if (!instruction && !opts.reqFile) {
+    throw new Error('用法: claude-coder plan "需求内容"  或  claude-coder plan -r [requirements.md]');
+  }
+
+  if (opts.interactive) {
+    log('info', '交互模式已启用，模型可能会向您提问');
+  }
+
+  let shouldAutoRun = false;
+  if (!opts.planOnly) {
+    shouldAutoRun = await promptAutoRun();
+  }
+
+  const hookType = opts.interactive ? 'plan_interactive' : 'plan';
   const ts = new Date().toISOString().replace(/[-:T]/g, '').slice(0, 12);
-  const label = planOnly ? 'plan_only' : 'plan_tasks';
-  const hookType = interactive ? 'plan_interactive' : 'plan';
+  const label = opts.planOnly ? 'plan_only' : 'plan_tasks';
 
-  return runSession(hookType, {
-    opts,
-    sessionNum: 0,
+  const result = await Session.run(hookType, config, {
     logFileName: `plan_${ts}.log`,
     label,
 
-    async execute(sdk, ctx) {
+    async execute(session) {
       log('info', '正在生成计划方案...');
 
-      const planResult = await _executePlanGen(sdk, ctx, instruction, opts);
+      const planResult = await _executePlanGen(session, instruction, opts);
 
       if (!planResult.success) {
         log('error', `\n计划生成失败: ${planResult.reason || planResult.error}`);
@@ -225,90 +151,26 @@ async function runPlanSession(instruction, opts = {}) {
 
       log('ok', `\n计划已生成: ${planResult.targetPath}`);
 
-      if (planOnly) {
+      if (opts.planOnly) {
         return { success: true, planPath: planResult.targetPath };
       }
 
       log('info', '正在生成任务列表...');
 
       const tasksPrompt = buildPlanPrompt(planResult.targetPath);
-      const queryOpts = buildQueryOptions(ctx.config, opts);
+      const queryOpts = session.buildQueryOptions(opts);
       queryOpts.systemPrompt = buildSystemPrompt('plan');
-      queryOpts.hooks = ctx.hooks;
-      queryOpts.abortController = ctx.abortController;
 
-      await ctx.runQuery(sdk, tasksPrompt, queryOpts);
+      const { success } = await session.runQuery(tasksPrompt, queryOpts);
+      if (!success) {
+        log('warn', '任务分解查询未正常结束');
+      }
 
       syncAfterPlan();
       log('ok', '任务追加完成');
       return { success: true, planPath: planResult.targetPath };
     },
   });
-}
-
-async function promptAutoRun() {
-  if (!process.stdin.isTTY) return false;
-  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()));
-    });
-  });
-}
-
-async function run(input, opts = {}) {
-  const instruction = input || '';
-
-  assets.ensureDirs();
-  const projectRoot = assets.projectRoot;
-
-  if (opts.readFile) {
-    const reqPath = path.resolve(projectRoot, opts.readFile);
-    if (!fs.existsSync(reqPath)) {
-      log('error', `文件不存在: ${reqPath}`);
-      process.exit(1);
-    }
-    opts.reqFile = reqPath;
-    if (instruction) {
-      log('info', `-r 模式下忽略文本输入，使用需求文件: ${reqPath}`);
-    } else {
-      console.log(`需求文件: ${reqPath}`);
-    }
-  }
-
-  if (!instruction && !opts.reqFile) {
-    log('error', '用法: claude-coder plan "需求内容"  或  claude-coder plan -r [requirements.md]');
-    process.exit(1);
-  }
-
-  const config = loadConfig();
-  // if opts.model is not set, use the default opus model or default model, make sure the model is set.
-  if (!opts.model) {
-    if (config.defaultOpus) {
-      opts.model = config.defaultOpus;
-    } else if (config.model) {
-      opts.model = config.model;
-    }
-  }
-
-  const displayModel = opts.model || config.model || '(default)';
-  log('ok', `模型配置已加载: ${config.provider || 'claude'} (plan 使用: ${displayModel})`);
-  if (opts.interactive) {
-    log('info', '交互模式已启用，模型可能会向您提问');
-  }
-
-  if (!assets.exists('profile')) {
-    log('error', 'profile 不存在，请先运行 claude-coder init 初始化项目');
-    process.exit(1);
-  }
-
-  let shouldAutoRun = false;
-  if (!opts.planOnly) {
-    shouldAutoRun = await promptAutoRun();
-  }
-
-  const result = await runPlanSession(instruction, { projectRoot, ...opts });
 
   if (result.success) {
     printStats();
@@ -316,10 +178,10 @@ async function run(input, opts = {}) {
     if (shouldAutoRun) {
       console.log('');
       log('info', '开始自动执行任务...');
-      const { run: runCoding } = require('./runner');
-      await runCoding(opts);
+      const { executeRun } = require('./runner');
+      await executeRun(config, opts);
     }
   }
 }
 
-module.exports = { runPlanSession, run };
+module.exports = { executePlan };