claude-coder 1.7.0 → 1.8.0

package/src/common/assets.js

@@ -0,0 +1,192 @@
+'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([
+  // Templates
+  ['agentProtocol',  { file: 'agentProtocol.md',          kind: 'template' }],
+  ['scanProtocol',   { file: 'scanProtocol.md',           kind: 'template' }],
+  ['addGuide',       { file: 'addGuide.md',               kind: 'template' }],
+  ['codingUser',     { file: 'codingUser.md',              kind: 'template' }],
+  ['scanUser',       { file: 'scanUser.md',                kind: 'template' }],
+  ['addUser',        { file: 'addUser.md',                 kind: 'template' }],
+  ['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' }],
+  ['tests',          { file: 'tests.json',                 kind: 'data' }],
+  ['testEnv',        { file: 'test.env',                   kind: 'data' }],
+  ['playwrightAuth', { file: 'playwright-auth.json',       kind: 'data' }],
+
+  // Runtime files (.claude-coder/.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);
+  }
+
+  init(projectRoot) {
+    this.projectRoot = projectRoot || process.cwd();
+    this.loopDir = path.join(this.projectRoot, '.claude-coder');
+    this.assetsDir = path.join(this.loopDir, 'assets');
+  }
+
+  _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 filePath = this._resolveTemplate(entry.file);
+      if (!filePath) return '';
+      return fs.readFileSync(filePath, 'utf8');
+    }
+
+    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;
+  }
+
+}
+
+const assets = new AssetManager();
+
+module.exports = { AssetManager, assets, renderTemplate };

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

@@ -1,201 +1,138 @@
-'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',
-  reset: '\x1b[0m',
-};
-
-function log(level, msg) {
-  const tags = {
-    info:  `${COLOR.blue}[INFO]${COLOR.reset} `,
-    ok:    `${COLOR.green}[OK]${COLOR.reset}   `,
-    warn:  `${COLOR.yellow}[WARN]${COLOR.reset} `,
-    error: `${COLOR.red}[ERROR]${COLOR.reset}`,
-  };
-  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) {
-  if (!fs.existsSync(filepath)) return {};
-  const content = fs.readFileSync(filepath, 'utf8');
-  const vars = {};
-  for (const line of content.split('\n')) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith('#')) continue;
-    const match = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
-    if (match) {
-      vars[match[1]] = match[2].trim().replace(/^["']|["']$/g, '');
-    }
-  }
-  return vars;
-}
-
-// --------------- Model mapping ---------------
-
-function loadConfig() {
-  const p = paths();
-  const env = parseEnvFile(p.envFile);
-  const config = {
-    provider: env.MODEL_PROVIDER || 'claude',
-    baseUrl: env.ANTHROPIC_BASE_URL || '',
-    apiKey: env.ANTHROPIC_API_KEY || '',
-    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,
-    completionTimeout: parseInt(env.SESSION_COMPLETION_TIMEOUT, 10) || 300,
-    maxTurns: parseInt(env.SESSION_MAX_TURNS, 10) || 0,
-    editThreshold: parseInt(env.EDIT_THRESHOLD, 10) || 15,
-    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') {
-    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';
-  }
-
-  return config;
-}
-
-function buildEnvVars(config) {
-  const env = { ...process.env };
-  if (config.baseUrl) env.ANTHROPIC_BASE_URL = config.baseUrl;
-  if (config.apiKey) env.ANTHROPIC_API_KEY = config.apiKey;
-  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;
-  if (config.defaultSonnet) env.ANTHROPIC_DEFAULT_SONNET_MODEL = config.defaultSonnet;
-  if (config.defaultHaiku) env.ANTHROPIC_DEFAULT_HAIKU_MODEL = config.defaultHaiku;
-  if (config.thinkingBudget) env.ANTHROPIC_THINKING_BUDGET = config.thinkingBudget;
-  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 regex = new RegExp(`^${key}=.*$`, 'm');
-  if (regex.test(content)) {
-    content = content.replace(regex, `${key}=${value}`);
-  } else {
-    const suffix = content.endsWith('\n') ? '' : '\n';
-    content += `${suffix}${key}=${value}\n`;
-  }
-  fs.writeFileSync(p.envFile, content, 'utf8');
-  return true;
-}
-
-module.exports = {
-  COLOR,
-  log,
-  getProjectRoot,
-  getLoopDir,
-  ensureLoopDir,
-  getTemplatePath,
-  getPromptPath,
-  paths,
-  parseEnvFile,
-  loadConfig,
-  buildEnvVars,
-  getAllowedTools,
-  updateEnvVar,
-};
+'use strict';
+
+const fs = require('fs');
+
+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',
+};
+
+function log(level, msg) {
+  const tags = {
+    info:  `${COLOR.blue}[INFO]${COLOR.reset} `,
+    ok:    `${COLOR.green}[OK]${COLOR.reset}   `,
+    warn:  `${COLOR.yellow}[WARN]${COLOR.reset} `,
+    error: `${COLOR.red}[ERROR]${COLOR.reset}`,
+  };
+  console.error(`${tags[level] || ''} ${msg}`);
+}
+
+// --------------- .env parsing ---------------
+
+function parseEnvFile(filepath) {
+  if (!fs.existsSync(filepath)) return {};
+  const content = fs.readFileSync(filepath, 'utf8');
+  const vars = {};
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const match = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+    if (match) {
+      vars[match[1]] = match[2].trim().replace(/^["']|["']$/g, '');
+    }
+  }
+  return vars;
+}
+
+// --------------- Model mapping ---------------
+
+function loadConfig() {
+  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 || '',
+    apiKey: env.ANTHROPIC_API_KEY || '',
+    authToken: env.ANTHROPIC_AUTH_TOKEN || '',
+    model: env.ANTHROPIC_MODEL || '',
+    timeoutMs: parseInt(env.API_TIMEOUT_MS, 10) || 3000000,
+    mcpPlaywright: env.MCP_PLAYWRIGHT === 'true',
+    playwrightMode: env.MCP_PLAYWRIGHT_MODE || 'persistent',
+    disableNonessential: env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC || '',
+    effortLevel: env.CLAUDE_CODE_EFFORT_LEVEL || '',
+    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) || 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,
+  };
+
+  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.thinkingBudget = '0';
+  }
+
+  return config;
+}
+
+function buildEnvVars(config) {
+  const env = { ...process.env };
+  if (config.baseUrl) env.ANTHROPIC_BASE_URL = config.baseUrl;
+  if (config.apiKey) env.ANTHROPIC_API_KEY = config.apiKey;
+  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.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;
+  if (config.defaultSonnet) env.ANTHROPIC_DEFAULT_SONNET_MODEL = config.defaultSonnet;
+  if (config.defaultHaiku) env.ANTHROPIC_DEFAULT_HAIKU_MODEL = config.defaultHaiku;
+  if (config.thinkingBudget) env.ANTHROPIC_THINKING_BUDGET = config.thinkingBudget;
+  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 { 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}`);
+  } else {
+    const suffix = content.endsWith('\n') ? '' : '\n';
+    content += `${suffix}${key}=${value}\n`;
+  }
+  fs.writeFileSync(envPath, content, 'utf8');
+  return true;
+}
+
+module.exports = {
+  COLOR,
+  log,
+  parseEnvFile,
+  loadConfig,
+  buildEnvVars,
+  getAllowedTools,
+  updateEnvVar,
+};

package/src/common/constants.js

@@ -0,0 +1,57 @@
+'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',
+  TESTS: 'tests.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,
+};