claude-coder 1.7.1 → 1.8.1

package/src/commands/setup.js

@@ -0,0 +1,172 @@
+'use strict';
+
+const fs = require('fs');
+const { log, COLOR, parseEnvFile } = require('../common/config');
+const { assets } = require('../common/assets');
+const {
+  createInterface,
+  ask,
+  askChoice,
+  writeConfig,
+  ensureGitignore,
+  showCurrentConfig,
+  selectProvider,
+  updateApiKeyOnly,
+  configureMCP,
+  appendMcpConfig,
+  updateMCPOnly,
+  updateSafetyLimits,
+  updateSimplifyConfig,
+} = require('./setup-modules');
+
+const PRESERVED_KEYS = [
+  'SESSION_STALL_TIMEOUT', 'SESSION_COMPLETION_TIMEOUT',
+  'SESSION_MAX_TURNS', 'SIMPLIFY_INTERVAL', 'SIMPLIFY_COMMITS',
+];
+
+function preserveSafetyConfig(lines, existing) {
+  const preserved = PRESERVED_KEYS
+    .filter(k => existing[k])
+    .map(k => `${k}=${existing[k]}`);
+  if (preserved.length > 0) {
+    lines.push('', '# 保留的安全限制和审查配置');
+    lines.push(...preserved);
+  }
+}
+
+async function setup() {
+  assets.ensureDirs();
+  const rl = createInterface();
+
+  const envPath = assets.path('env');
+  let existing = {};
+  if (fs.existsSync(envPath)) {
+    existing = parseEnvFile(envPath);
+  }
+
+  console.log('');
+  console.log('============================================');
+  console.log('  Claude Coder 配置');
+  console.log('============================================');
+
+  if (!fs.existsSync(envPath) || !existing.MODEL_PROVIDER) {
+    console.log('');
+    console.log('  检测到未配置，开始初始化...');
+    console.log('');
+
+    const configResult = await selectProvider(rl, existing);
+    const mcpConfig = await configureMCP(rl);
+
+    appendMcpConfig(configResult.lines, mcpConfig);
+    writeConfig(envPath, configResult.lines);
+    ensureGitignore();
+
+    if (mcpConfig.enabled && mcpConfig.mode) {
+      const { updateMcpConfig } = require('./auth');
+      const mcpPath = assets.path('mcpConfig');
+      updateMcpConfig(mcpPath, mcpConfig.mode);
+    }
+
+    console.log('');
+    log('info', '配置自动代码审查（可选）');
+    await updateSimplifyConfig(rl, {});
+
+    console.log('');
+    log('ok', `配置完成！提供商: ${configResult.summary}`);
+    console.log('');
+    console.log(`  配置文件: ${envPath}`);
+    console.log('  使用方式: claude-coder run "你的需求"');
+    console.log('  重新配置: claude-coder setup');
+    console.log('');
+    console.log(`  ${COLOR.blue}当前默认值:${COLOR.reset}`);
+    console.log(`    停顿超时:     1200 秒 (20 分钟)`);
+    console.log(`    完成检测超时: 300 秒 (5 分钟)`);
+    console.log(`    自动审查:     每 5 个 session，审查 5 个 commit`);
+    console.log('');
+    console.log(`  ${COLOR.yellow}调整方式: claude-coder setup → 配置安全限制 / 配置自动审查${COLOR.reset}`);
+    console.log('');
+
+    rl.close();
+    return;
+  }
+
+  while (true) {
+    existing = parseEnvFile(envPath);
+    showCurrentConfig(existing);
+
+    console.log('请选择要执行的操作:');
+    console.log('');
+    console.log('  1) 切换模型提供商');
+    console.log('  2) 更新 API Key');
+    console.log('  3) 配置 MCP');
+    console.log('  4) 配置安全限制');
+    console.log('  5) 配置自动审查');
+    console.log('  6) 完全重新配置');
+    console.log('  7) 退出');
+    console.log('');
+
+    const action = await askChoice(rl, '选择 [1-7]: ', 1, 7);
+    console.log('');
+
+    if (action === 7) {
+      log('info', '退出配置');
+      break;
+    }
+
+    switch (action) {
+      case 1: {
+        log('info', '放心切换，旧配置会自动备份，安全限制和审查配置会保留');
+        const configResult = await selectProvider(rl, existing);
+        preserveSafetyConfig(configResult.lines, existing);
+        appendMcpConfig(configResult.lines, {
+          enabled: existing.MCP_PLAYWRIGHT === 'true',
+          mode: existing.MCP_PLAYWRIGHT_MODE || null,
+        });
+        writeConfig(envPath, configResult.lines);
+        log('ok', `已切换到: ${configResult.summary}`);
+        break;
+      }
+      case 2: {
+        await updateApiKeyOnly(rl, existing);
+        break;
+      }
+      case 3: {
+        await updateMCPOnly(rl);
+        break;
+      }
+      case 4: {
+        await updateSafetyLimits(rl, existing);
+        break;
+      }
+      case 5: {
+        await updateSimplifyConfig(rl, existing);
+        break;
+      }
+      case 6: {
+        log('info', '放心重新配置，旧配置会自动备份，安全限制和审查配置会保留');
+        const configResult = await selectProvider(rl, existing);
+        preserveSafetyConfig(configResult.lines, existing);
+        const mcpConfig = await configureMCP(rl);
+        appendMcpConfig(configResult.lines, mcpConfig);
+        writeConfig(envPath, configResult.lines);
+
+        if (mcpConfig.enabled && mcpConfig.mode) {
+          const { updateMcpConfig } = require('./auth');
+          const mcpPath = assets.path('mcpConfig');
+          updateMcpConfig(mcpPath, mcpConfig.mode);
+        }
+
+        log('ok', '配置已更新');
+        break;
+      }
+    }
+
+    console.log('');
+    const cont = await ask(rl, '继续配置其他项？(y/N) ');
+    if (!/^[Yy]/.test(cont.trim())) break;
+  }
+
+  rl.close();
+}
+
+module.exports = { setup };

package/src/common/assets.js

@@ -0,0 +1,206 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const BUNDLED_DIR = path.join(__dirname, '..', '..', 'templates');
+
+// kind: 'template' — 双目录解析（用户 assets → 内置 bundled），有缓存
+// kind: 'data'     — .claude-coder/ 目录，无缓存
+// kind: 'runtime'  — .claude-coder/.runtime/ 目录，无缓存
+// kind: 'root'     — 项目根目录，无缓存
+const REGISTRY = new Map([
+  // System Prompt Templates (per session type)
+  ['coreProtocol',   { file: 'coreProtocol.md',            kind: 'template' }],
+  ['codingSystem',   { file: 'codingSystem.md',            kind: 'template' }],
+  ['planSystem',     { file: 'planSystem.md',              kind: 'template' }],
+  ['scanSystem',     { file: 'scanSystem.md',              kind: 'template' }],
+
+  // User Prompt Templates
+  ['codingUser',     { file: 'codingUser.md',              kind: 'template' }],
+  ['scanUser',       { file: 'scanUser.md',                kind: 'template' }],
+  ['planUser',       { file: 'planUser.md',                kind: 'template' }],
+
+  // Other Templates
+  ['testRule',       { file: 'test_rule.md',               kind: 'template' }],
+  ['guidance',       { file: 'guidance.json',              kind: 'template' }],
+  ['playwright',     { file: 'playwright.md',              kind: 'template' }],
+  ['bashProcess',    { file: 'bash-process.md',            kind: 'template' }],
+  ['requirements',   { file: 'requirements.example.md',    kind: 'template' }],
+
+  // Data files (.claude-coder/)
+  ['env',            { file: '.env',                       kind: 'data' }],
+  ['tasks',          { file: 'tasks.json',                 kind: 'data' }],
+  ['progress',       { file: 'progress.json',              kind: 'data' }],
+  ['sessionResult',  { file: 'session_result.json',        kind: 'data' }],
+  ['profile',        { file: 'project_profile.json',       kind: 'data' }],
+  ['testEnv',        { file: 'test.env',                   kind: 'data' }],
+  ['playwrightAuth', { file: 'playwright-auth.json',       kind: 'data' }],
+
+  // Runtime files (.claude-coder/.runtime/)
+  ['harnessState',   { file: 'harness_state.json',         kind: 'runtime' }],
+  ['browserProfile', { file: 'browser-profile',            kind: 'runtime' }],
+
+  // Root files (project root)
+  ['mcpConfig',      { file: '.mcp.json',                  kind: 'root' }],
+]);
+
+const DIRS = new Map([
+  ['loop',    ''],
+  ['assets',  'assets'],
+  ['runtime', '.runtime'],
+  ['logs',    '.runtime/logs'],
+]);
+
+function renderTemplate(template, vars = {}) {
+  return template
+    .replace(/\{\{(\w+)\}\}/g, (_, key) =>
+      Object.prototype.hasOwnProperty.call(vars, key) ? String(vars[key]) : ''
+    )
+    .replace(/^\s+$/gm, '')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+class AssetManager {
+  constructor() {
+    this.projectRoot = null;
+    this.loopDir = null;
+    this.assetsDir = null;
+    this.bundledDir = BUNDLED_DIR;
+    this.registry = new Map(REGISTRY);
+    this.cache = new Map();
+  }
+
+  init(projectRoot) {
+    this.projectRoot = projectRoot || process.cwd();
+    this.loopDir = path.join(this.projectRoot, '.claude-coder');
+    this.assetsDir = path.join(this.loopDir, 'assets');
+    this.cache.clear();
+  }
+
+  _ensureInit() {
+    if (!this.loopDir) this.init();
+  }
+
+  path(name) {
+    this._ensureInit();
+    const entry = this.registry.get(name);
+    if (!entry) return null;
+    switch (entry.kind) {
+      case 'template': return this._resolveTemplate(entry.file);
+      case 'data':     return path.join(this.loopDir, entry.file);
+      case 'runtime':  return path.join(this.loopDir, '.runtime', entry.file);
+      case 'root':     return path.join(this.projectRoot, entry.file);
+      default:         return null;
+    }
+  }
+
+  _resolveTemplate(filename) {
+    if (this.assetsDir) {
+      const userPath = path.join(this.assetsDir, filename);
+      if (fs.existsSync(userPath)) return userPath;
+    }
+    const bundled = path.join(this.bundledDir, filename);
+    if (fs.existsSync(bundled)) return bundled;
+    return null;
+  }
+
+  dir(name) {
+    this._ensureInit();
+    const rel = DIRS.get(name);
+    if (rel === undefined) return null;
+    return rel === '' ? this.loopDir : path.join(this.loopDir, rel);
+  }
+
+  exists(name) {
+    const p = this.path(name);
+    return p ? fs.existsSync(p) : false;
+  }
+
+  read(name) {
+    this._ensureInit();
+    const entry = this.registry.get(name);
+    if (!entry) return null;
+
+    if (entry.kind === 'template') {
+      const key = entry.file;
+      if (this.cache.has(key)) return this.cache.get(key);
+      const filePath = this._resolveTemplate(entry.file);
+      if (!filePath) return '';
+      const content = fs.readFileSync(filePath, 'utf8');
+      this.cache.set(key, content);
+      return content;
+    }
+
+    const filePath = this.path(name);
+    if (!filePath || !fs.existsSync(filePath)) return null;
+    return fs.readFileSync(filePath, 'utf8');
+  }
+
+  readJson(name, fallback = null) {
+    const content = this.read(name);
+    if (content === null || content === '') return fallback;
+    try {
+      return JSON.parse(content);
+    } catch {
+      return fallback;
+    }
+  }
+
+  write(name, content) {
+    this._ensureInit();
+    const entry = this.registry.get(name);
+    if (!entry || entry.kind === 'template') return;
+    const filePath = this.path(name);
+    if (!filePath) return;
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(filePath, content, 'utf8');
+  }
+
+  writeJson(name, data) {
+    this.write(name, JSON.stringify(data, null, 2) + '\n');
+  }
+
+  render(name, vars = {}) {
+    const raw = this.read(name);
+    if (!raw) return '';
+    return renderTemplate(raw, vars);
+  }
+
+  ensureDirs() {
+    this._ensureInit();
+    for (const [, rel] of DIRS) {
+      const dir = rel === '' ? this.loopDir : path.join(this.loopDir, rel);
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    }
+  }
+
+  deployAll() {
+    this._ensureInit();
+    if (!fs.existsSync(this.assetsDir)) {
+      fs.mkdirSync(this.assetsDir, { recursive: true });
+    }
+    const files = fs.readdirSync(this.bundledDir);
+    const deployed = [];
+    for (const file of files) {
+      const dest = path.join(this.assetsDir, file);
+      if (fs.existsSync(dest)) continue;
+      const src = path.join(this.bundledDir, file);
+      try {
+        fs.copyFileSync(src, dest);
+        deployed.push(file);
+      } catch { /* skip */ }
+    }
+    return deployed;
+  }
+
+  clearCache() {
+    this.cache.clear();
+  }
+}
+
+const assets = new AssetManager();
+
+module.exports = { AssetManager, assets, renderTemplate };

package/src/{config.js → common/config.js}

@@ -1,13 +1,16 @@
 'use strict';
 
 const fs = require('fs');
-const path = require('path');
 
 const COLOR = {
   red: '\x1b[0;31m',
   green: '\x1b[0;32m',
   yellow: '\x1b[1;33m',
   blue: '\x1b[0;34m',
+  magenta: '\x1b[0;35m',
+  cyan: '\x1b[0;36m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
   reset: '\x1b[0m',
 };
 
@@ -21,59 +24,6 @@ function log(level, msg) {
   console.error(`${tags[level] || ''} ${msg}`);
 }
 
-function getProjectRoot() {
-  return process.cwd();
-}
-
-function getLoopDir() {
-  return path.join(getProjectRoot(), '.claude-coder');
-}
-
-function ensureLoopDir() {
-  const dir = getLoopDir();
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  const runtime = path.join(dir, '.runtime');
-  if (!fs.existsSync(runtime)) fs.mkdirSync(runtime, { recursive: true });
-  const logs = path.join(runtime, 'logs');
-  if (!fs.existsSync(logs)) fs.mkdirSync(logs, { recursive: true });
-  return dir;
-}
-
-function getTemplatePath(name) {
-  return path.join(__dirname, '..', 'templates', name);
-}
-
-function getPromptPath(name) {
-  return path.join(__dirname, '..', 'prompts', name);
-}
-
-function paths() {
-  const loopDir = getLoopDir();
-  const runtime = path.join(loopDir, '.runtime');
-  return {
-    loopDir,
-    envFile:          path.join(loopDir, '.env'),
-    tasksFile:        path.join(loopDir, 'tasks.json'),
-    progressFile:     path.join(loopDir, 'progress.json'),
-    sessionResult:    path.join(loopDir, 'session_result.json'),
-    profile:          path.join(loopDir, 'project_profile.json'),
-    testsFile:        path.join(loopDir, 'tests.json'),
-    testEnvFile:      path.join(loopDir, 'test.env'),
-    playwrightAuth:   path.join(loopDir, 'playwright-auth.json'),
-    browserProfile:   path.join(runtime, 'browser-profile'),
-    mcpConfig:        path.join(getProjectRoot(), '.mcp.json'),
-    claudeMd:         getPromptPath('CLAUDE.md'),
-    scanProtocol:     getPromptPath('SCAN_PROTOCOL.md'),
-    addGuide:         getPromptPath('ADD_GUIDE.md'),
-    codingUser:       getPromptPath('coding_user.md'),
-    scanUser:         getPromptPath('scan_user.md'),
-    addUser:          getPromptPath('add_user.md'),
-    testRuleTemplate: getTemplatePath('test_rule.md'),
-    runtime,
-    logsDir:          path.join(runtime, 'logs'),
-  };
-}
-
 // --------------- .env parsing ---------------
 
 function parseEnvFile(filepath) {
@@ -94,8 +44,9 @@ function parseEnvFile(filepath) {
 // --------------- Model mapping ---------------
 
 function loadConfig() {
-  const p = paths();
-  const env = parseEnvFile(p.envFile);
+  const { assets } = require('./assets');
+  const envPath = assets.path('env');
+  const env = envPath ? parseEnvFile(envPath) : {};
   const config = {
     provider: env.MODEL_PROVIDER || 'claude',
     baseUrl: env.ANTHROPIC_BASE_URL || '',
@@ -103,35 +54,29 @@ function loadConfig() {
     authToken: env.ANTHROPIC_AUTH_TOKEN || '',
     model: env.ANTHROPIC_MODEL || '',
     timeoutMs: parseInt(env.API_TIMEOUT_MS, 10) || 3000000,
-    mcpToolTimeout: parseInt(env.MCP_TOOL_TIMEOUT, 10) || 30000,
     mcpPlaywright: env.MCP_PLAYWRIGHT === 'true',
     playwrightMode: env.MCP_PLAYWRIGHT_MODE || 'persistent',
     disableNonessential: env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC || '',
     effortLevel: env.CLAUDE_CODE_EFFORT_LEVEL || '',
-    smallFastModel: env.ANTHROPIC_SMALL_FAST_MODEL || '',
     defaultOpus: env.ANTHROPIC_DEFAULT_OPUS_MODEL || '',
     defaultSonnet: env.ANTHROPIC_DEFAULT_SONNET_MODEL || '',
     defaultHaiku: env.ANTHROPIC_DEFAULT_HAIKU_MODEL || '',
     thinkingBudget: env.ANTHROPIC_THINKING_BUDGET || '',
-    stallTimeout: parseInt(env.SESSION_STALL_TIMEOUT, 10) || 1200,
+    stallTimeout: parseInt(env.SESSION_STALL_TIMEOUT, 10) || 600,
     completionTimeout: parseInt(env.SESSION_COMPLETION_TIMEOUT, 10) || 300,
     maxTurns: parseInt(env.SESSION_MAX_TURNS, 10) || 0,
     editThreshold: parseInt(env.EDIT_THRESHOLD, 10) || 15,
+    simplifyInterval: env.SIMPLIFY_INTERVAL !== undefined ? parseInt(env.SIMPLIFY_INTERVAL, 10) : 5,
+    simplifyCommits: env.SIMPLIFY_COMMITS !== undefined ? parseInt(env.SIMPLIFY_COMMITS, 10) : 5,
     raw: env,
   };
 
-  // GLM: default model if not set
-  if (config.baseUrl && (config.baseUrl.includes('bigmodel.cn') || config.baseUrl.includes('z.ai'))) {
-    if (!config.model) config.model = 'glm-4.7';
-  }
-
-  // DeepSeek chat → haiku shim (prevent reasoner billing)
-  if (config.baseUrl.includes('deepseek') && config.model === 'deepseek-chat') {
+  // 以下是兼容deepseek最实惠的而改写的配置，不一定正确。只是多次调用后得出的结果。
+  if (config.baseUrl && config.baseUrl.includes('deepseek') && config.model === 'deepseek-chat') {
     config.model = 'claude-3-haiku-20240307';
     config.defaultOpus = 'claude-3-haiku-20240307';
     config.defaultSonnet = 'claude-3-haiku-20240307';
     config.defaultHaiku = 'claude-3-haiku-20240307';
-    config.smallFastModel = 'claude-3-haiku-20240307';
     config.thinkingBudget = '0';
   }
 
@@ -145,8 +90,6 @@ function buildEnvVars(config) {
   if (config.authToken) env.ANTHROPIC_AUTH_TOKEN = config.authToken;
   if (config.model) env.ANTHROPIC_MODEL = config.model;
   if (config.timeoutMs) env.API_TIMEOUT_MS = String(config.timeoutMs);
-  if (config.mcpToolTimeout) env.MCP_TOOL_TIMEOUT = String(config.mcpToolTimeout);
-  if (config.smallFastModel) env.ANTHROPIC_SMALL_FAST_MODEL = config.smallFastModel;
   if (config.disableNonessential) env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = config.disableNonessential;
   if (config.effortLevel) env.CLAUDE_CODE_EFFORT_LEVEL = config.effortLevel;
   if (config.defaultOpus) env.ANTHROPIC_DEFAULT_OPUS_MODEL = config.defaultOpus;
@@ -156,23 +99,11 @@ function buildEnvVars(config) {
   return env;
 }
 
-// --------------- Allowed tools ---------------
-
-function getAllowedTools(config) {
-  const tools = [
-    'Read', 'Edit', 'MultiEdit', 'Write',
-    'Bash', 'Glob', 'Grep', 'LS',
-    'Task',
-    'WebSearch', 'WebFetch',
-  ];
-  if (config.mcpPlaywright) tools.push('mcp__playwright__*');
-  return tools;
-}
-
 function updateEnvVar(key, value) {
-  const p = paths();
-  if (!fs.existsSync(p.envFile)) return false;
-  let content = fs.readFileSync(p.envFile, 'utf8');
+  const { assets } = require('./assets');
+  const envPath = assets.path('env');
+  if (!envPath || !fs.existsSync(envPath)) return false;
+  let content = fs.readFileSync(envPath, 'utf8');
   const regex = new RegExp(`^${key}=.*$`, 'm');
   if (regex.test(content)) {
     content = content.replace(regex, `${key}=${value}`);
@@ -180,22 +111,15 @@ function updateEnvVar(key, value) {
     const suffix = content.endsWith('\n') ? '' : '\n';
     content += `${suffix}${key}=${value}\n`;
   }
-  fs.writeFileSync(p.envFile, content, 'utf8');
+  fs.writeFileSync(envPath, content, 'utf8');
   return true;
 }
 
 module.exports = {
   COLOR,
   log,
-  getProjectRoot,
-  getLoopDir,
-  ensureLoopDir,
-  getTemplatePath,
-  getPromptPath,
-  paths,
   parseEnvFile,
   loadConfig,
   buildEnvVars,
-  getAllowedTools,
   updateEnvVar,
 };

package/src/common/constants.js

@@ -0,0 +1,56 @@
+'use strict';
+
+// ─────────────────────────────────────────────────────────────
+// 常量集中管理
+// ─────────────────────────────────────────────────────────────
+
+/**
+ * 任务状态
+ */
+const TASK_STATUSES = Object.freeze(['pending', 'in_progress', 'testing', 'done', 'failed']);
+
+/**
+ * 状态迁移规则
+ */
+const STATUS_TRANSITIONS = Object.freeze({
+  pending: ['in_progress'],
+  in_progress: ['testing'],
+  testing: ['done', 'failed'],
+  failed: ['in_progress'],
+  done: [],
+});
+
+/**
+ * 文件名常量
+ */
+const FILES = Object.freeze({
+  SESSION_RESULT: 'session_result.json',
+  TASKS: 'tasks.json',
+  PROFILE: 'project_profile.json',
+  PROGRESS: 'progress.json',
+  TEST_ENV: 'test.env',
+  PLAYWRIGHT_AUTH: 'playwright-auth.json',
+  ENV: '.env',
+  MCP_CONFIG: '.mcp.json',
+});
+
+/**
+ * 重试配置
+ */
+const RETRY = Object.freeze({
+  MAX_ATTEMPTS: 3,
+  SCAN_ATTEMPTS: 3,
+});
+
+/**
+ * 编辑防护阈值
+ */
+const EDIT_THRESHOLD = 15;
+
+module.exports = {
+  TASK_STATUSES,
+  STATUS_TRANSITIONS,
+  FILES,
+  RETRY,
+  EDIT_THRESHOLD,
+};