claude-coder 1.8.3 → 1.9.0

package/src/core/scan.js

@@ -1,13 +1,29 @@
 'use strict';
 
+const fs = require('fs');
+const path = require('path');
 const { log } = require('../common/config');
 const { assets } = require('../common/assets');
-const { runSession } = require('./session');
-const { buildQueryOptions, hasCodeFiles } = require('./query');
 const { buildSystemPrompt, buildScanPrompt } = require('./prompts');
-const { extractResult } = require('../common/logging');
+const { Session } = require('./session');
 const { RETRY } = require('../common/constants');
 
+function hasCodeFiles(projectRoot) {
+  const markers = [
+    'package.json', 'pyproject.toml', 'requirements.txt', 'setup.py',
+    'Cargo.toml', 'go.mod', 'pom.xml', 'build.gradle',
+    'Makefile', 'Dockerfile', 'docker-compose.yml',
+    'README.md', 'main.py', 'app.py', 'index.js', 'index.ts',
+  ];
+  for (const m of markers) {
+    if (fs.existsSync(path.join(projectRoot, m))) return true;
+  }
+  for (const d of ['src', 'lib', 'app', 'backend', 'frontend', 'web', 'server', 'client']) {
+    if (fs.existsSync(path.join(projectRoot, d)) && fs.statSync(path.join(projectRoot, d)).isDirectory()) return true;
+  }
+  return false;
+}
+
 function validateProfile() {
   if (!assets.exists('profile')) return { valid: false, issues: ['profile 不存在'] };
 
@@ -28,41 +44,30 @@ function validateProfile() {
   return { valid: issues.length === 0, issues };
 }
 
-async function _runScanSession(opts = {}) {
-  const projectType = hasCodeFiles(opts.projectRoot || assets.projectRoot) ? 'existing' : 'new';
-  const dateStr = new Date().toISOString().slice(0, 10).replace(/-/g, '');
-
-  return runSession('scan', {
-    opts,
-    sessionNum: 0,
-    logFileName: `scan_${dateStr}.log`,
-    label: `scan (${projectType})`,
-
-    async execute(sdk, ctx) {
-      log('info', `正在调用 Claude Code 执行项目扫描（${projectType}项目）...`);
+async function executeScan(config, opts = {}) {
+  const maxAttempts = RETRY.SCAN_ATTEMPTS;
 
-      const prompt = buildScanPrompt(projectType);
-      const queryOpts = buildQueryOptions(ctx.config, opts);
-      queryOpts.systemPrompt = buildSystemPrompt('scan');
-      queryOpts.hooks = ctx.hooks;
-      queryOpts.abortController = ctx.abortController;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    log('info', `初始化尝试 ${attempt} / ${maxAttempts} ...`);
 
-      const collected = await ctx.runQuery(sdk, prompt, queryOpts);
-      const result = extractResult(collected);
+    const projectType = hasCodeFiles(opts.projectRoot || assets.projectRoot) ? 'existing' : 'new';
+    const dateStr = new Date().toISOString().slice(0, 10).replace(/-/g, '');
 
-      return { cost: result?.total_cost_usd ?? null };
-    },
-  });
-}
+    const result = await Session.run('scan', config, {
+      logFileName: `scan_${dateStr}.log`,
+      label: `scan (${projectType})`,
 
-async function scan(opts = {}) {
-  assets.ensureDirs();
+      async execute(session) {
+        log('info', `正在调用 Claude Code 执行项目扫描（${projectType}项目）...`);
 
-  const maxAttempts = RETRY.SCAN_ATTEMPTS;
-  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-    log('info', `初始化尝试 ${attempt} / ${maxAttempts} ...`);
+        const prompt = buildScanPrompt(projectType);
+        const queryOpts = session.buildQueryOptions(opts);
+        queryOpts.systemPrompt = buildSystemPrompt('scan');
 
-    const result = await _runScanSession(opts);
+        const { cost } = await session.runQuery(prompt, queryOpts);
+        return { cost };
+      },
+    });
 
     if (assets.exists('profile')) {
       const profileCheck = validateProfile();
@@ -83,7 +88,6 @@ async function scan(opts = {}) {
 }
 
 module.exports = {
-  scan,
+  executeScan,
   validateProfile,
-  _runScanSession,
 };

package/src/core/session.js

@@ -1,57 +1,271 @@
 'use strict';
 
-const { loadSDK } = require('../common/sdk');
-const { writeSessionSeparator } = require('../common/logging');
-const { SessionContext } = require('./context');
+const fs = require('fs');
+const path = require('path');
+const { buildEnvVars, log } = require('../common/config');
+const { Indicator } = require('../common/indicator');
+const { logMessage: baseLogMessage, extractResult, writeSessionSeparator } = require('../common/logging');
+const { createHooks } = require('./hooks');
+const { assets } = require('../common/assets');
 
 /**
- * 通用 Session 执行器
- * @param {string} type - session 类型
- * @param {object} config - 配置
- * @param {object} [config.externalCtx] - 外部传入的 SessionContext（共享日志和 indicator）
+ * @typedef {Object} SessionRunOptions
+ * @property {string} logFileName - 日志文件名
+ * @property {import('fs').WriteStream} [logStream] - 外部日志流（与 logFileName 二选一）
+ * @property {number} [sessionNum=0] - 会话编号
+ * @property {string} [label=''] - 会话标签
+ * @property {(session: Session) => Promise<Object>} execute - 执行回调，接收 session 实例
  */
-async function runSession(type, config) {
-  const sdk = await loadSDK();
-  const ctx = config.externalCtx || new SessionContext(type, config.opts);
 
-  if (!config.externalCtx) {
-    ctx.initLogging(config.logFileName, config.logStream);
-    writeSessionSeparator(ctx.logStream, config.sessionNum || 0, config.label);
-  }
+/**
+ * @typedef {Object} QueryResult
+ * @property {Array<Object>} messages - 所有 SDK 消息
+ * @property {boolean} success - 是否成功完成
+ * @property {string|null} subtype - 结果子类型
+ * @property {number|null} cost - 美元费用
+ * @property {Object|null} usage - token 用量 { input_tokens, output_tokens }
+ * @property {number|null} turns - 对话轮次
+ */
+
+/**
+ * @typedef {Object} RunQueryOpts
+ * @property {(message: Object, messages: Array<Object>) => void|'break'} [onMessage] - 每条消息的回调，返回 'break' 中断
+ */
 
-  const stallTimeoutMin = ctx.initHooks(type);
-  ctx.startIndicator(config.sessionNum || 0, stallTimeoutMin);
+/**
+ * SDK 会话管理类。通过 Session.run() 创建和管理一次完整的 AI 会话生命周期。
+ *
+ * 使用方式：
+ * ```js
+ * const result = await Session.run('coding', config, {
+ *   logFileName: 'coding.log',
+ *   async execute(session) {
+ *     const queryOpts = session.buildQueryOptions();
+ *     const { messages, success } = await session.runQuery(prompt, queryOpts);
+ *     return { success };
+ *   },
+ * });
+ * ```
+ */
+class Session {
+  /** @type {Object|null} SDK 单例 */
+  static _sdk = null;
 
-  try {
-    const result = await config.execute(sdk, ctx);
-    if (config.onSuccess) {
-      await config.onSuccess(result, ctx);
+  /**
+   * 确保 SDK 已加载（懒加载单例）
+   * @param {Object} config - 项目配置
+   * @returns {Promise<Object>} SDK 实例
+   */
+  static async ensureSDK(config) {
+    if (!Session._sdk) {
+      Object.assign(process.env, buildEnvVars(config));
+      const { loadSDK } = require('../common/sdk');
+      Session._sdk = await loadSDK();
     }
-    // 只有非外部 ctx 才执行 finish
-    if (!config.externalCtx) {
-      ctx.finish();
+    return Session._sdk;
+  }
+
+  /**
+   * 创建 Session 实例并执行回调，自动管理生命周期（日志、hooks、indicator）
+   * @param {string} type - 会话类型（coding | plan | scan | go | simplify | repair 等）
+   * @param {Object} config - 项目配置
+   * @param {SessionRunOptions} options - 运行选项
+   * @returns {Promise<Object>} 包含 exitCode、logFile、stalled 以及 execute 返回值
+   */
+  static async run(type, config, { logFileName, logStream, sessionNum = 0, label = '', execute }) {
+    await Session.ensureSDK(config);
+    const session = new Session(type, config, { logFileName, logStream, sessionNum, label });
+    try {
+      const result = await execute(session);
+      session.finish();
+      return {
+        exitCode: session.isStalled() ? 2 : 0,
+        logFile: session.logFile,
+        stalled: session.isStalled(),
+        ...result,
+      };
+    } catch (err) {
+      session.finish();
+      throw err;
     }
-    return {
-      exitCode: ctx.isStalled() ? 2 : 0,
-      logFile: ctx.logFile,
-      stalled: ctx.isStalled(),
-      ...result,
+  }
+
+  /**
+   * @param {string} type - 会话类型
+   * @param {Object} config - 项目配置
+   * @param {Object} options
+   * @param {string} options.logFileName - 日志文件名
+   * @param {import('fs').WriteStream} [options.logStream] - 外部日志流
+   * @param {number} [options.sessionNum=0]
+   * @param {string} [options.label='']
+   */
+  constructor(type, config, { logFileName, logStream, sessionNum = 0, label = '' }) {
+    this.config = config;
+    this.type = type;
+    this.indicator = new Indicator();
+    /** @type {import('fs').WriteStream|null} */
+    this.logStream = null;
+    /** @type {string|null} */
+    this.logFile = null;
+    /** @type {Object|null} */
+    this.hooks = null;
+    /** @type {Function|null} */
+    this.cleanup = null;
+    this._isStalled = () => false;
+    this.abortController = new AbortController();
+
+    this._initLogging(logFileName, logStream);
+    writeSessionSeparator(this.logStream, sessionNum, label);
+    const stallTimeoutMin = this._initHooks(type);
+    this._startIndicator(sessionNum, stallTimeoutMin);
+  }
+
+  /**
+   * 构建 SDK query 选项，自动附加 hooks、abortController、权限模式
+   * @param {Object} [overrides={}] - 覆盖选项（permissionMode, projectRoot, model 等）
+   * @returns {Object} SDK query options
+   */
+  buildQueryOptions(overrides = {}) {
+    const mode = overrides.permissionMode || 'bypassPermissions';
+    const base = {
+      permissionMode: mode,
+      cwd: overrides.projectRoot || assets.projectRoot,
+      env: buildEnvVars(this.config),
+      settingSources: ['project'],
+      hooks: this.hooks,
+      abortController: this.abortController,
     };
-  } catch (err) {
-    if (config.onError) {
-      try { config.onError(err, ctx); } catch { /* ignore callback errors */ }
+    if (mode === 'bypassPermissions') {
+      base.allowDangerouslySkipPermissions = true;
     }
-    if (!config.externalCtx) {
-      ctx.errorFinish(err);
+    if (this.config.maxTurns > 0) base.maxTurns = this.config.maxTurns;
+    if (overrides.model) base.model = overrides.model;
+    else if (this.config.model) base.model = this.config.model;
+    return base;
+  }
+
+  /**
+   * 执行一次 SDK 查询，遍历消息流并收集结果
+   * @param {string} prompt - 用户提示
+   * @param {Object} queryOpts - SDK query 选项（通常来自 buildQueryOptions）
+   * @param {RunQueryOpts} [opts={}] - 额外选项（onMessage 回调）
+   * @returns {Promise<QueryResult>}
+   */
+  async runQuery(prompt, queryOpts, opts = {}) {
+    if (this.logStream?.writable) {
+      const sep = '-'.repeat(40);
+      if (queryOpts.systemPrompt) {
+        this.logStream.write(`\n${sep}\n[SYSTEM_PROMPT]\n${sep}\n${queryOpts.systemPrompt}\n`);
+      }
+      this.logStream.write(`\n${sep}\n[USER_PROMPT]\n${sep}\n${prompt}\n${sep}\n\n`);
     }
+
+    const sdk = Session._sdk;
+    const messages = [];
+    const querySession = sdk.query({ prompt, options: queryOpts });
+
+    for await (const message of querySession) {
+      if (this._isStalled()) {
+        log('warn', '停顿超时，中断消息循环');
+        break;
+      }
+      messages.push(message);
+      this._logMessage(message);
+
+      if (opts.onMessage) {
+        const action = opts.onMessage(message, messages);
+        if (action === 'break') break;
+      }
+    }
+
+    const sdkResult = extractResult(messages);
+    const cost = sdkResult?.total_cost_usd || null;
+    const usage = sdkResult?.usage || null;
+    const turns = sdkResult?.num_turns || null;
+
+    if (cost != null || turns != null) {
+      const parts = [];
+      if (turns != null) parts.push(`turns: ${turns}`);
+      if (cost != null) parts.push(`cost: $${cost}`);
+      if (usage) {
+        const inp = usage.input_tokens || 0;
+        const out = usage.output_tokens || 0;
+        parts.push(`tokens: ${inp}+${out}`);
+      }
+      const summary = parts.join(', ');
+      console.log('----- SESSION END -----');
+      log('info', `session 统计: ${summary}`);
+      if (this.logStream?.writable) {
+        this.logStream.write(`[SESSION_STATS] ${summary}\n`);
+      }
+    }
+
     return {
-      exitCode: 1,
-      error: err.message,
-      logFile: ctx.logFile,
+      messages,
+      success: sdkResult?.subtype === 'success',
+      subtype: sdkResult?.subtype || null,
+      cost, usage, turns,
     };
   }
+
+  /** 检查会话是否因停顿超时 */
+  isStalled() {
+    return this._isStalled();
+  }
+
+  /** 结束会话：清理 hooks、关闭日志流、停止 indicator */
+  finish() {
+    if (this.cleanup) this.cleanup();
+    if (this.logStream && !this._externalLogStream) this.logStream.end();
+    this.indicator.stop();
+  }
+
+  // ─── Private ────────────────────────────────────────────
+
+  _initLogging(logFileName, externalLogStream) {
+    if (externalLogStream) {
+      this.logStream = externalLogStream;
+      this._externalLogStream = true;
+    } else {
+      const logsDir = assets.dir('logs');
+      this.logFile = path.join(logsDir, logFileName);
+      this.logStream = fs.createWriteStream(this.logFile, { flags: 'a' });
+      this._externalLogStream = false;
+    }
+  }
+
+  _initHooks(hookType) {
+    const stallTimeoutMs = this.config.stallTimeout * 1000;
+    const result = createHooks(hookType, this.indicator, this.logStream, {
+      stallTimeoutMs,
+      abortController: this.abortController,
+      editThreshold: this.config.editThreshold,
+    });
+    this.hooks = result.hooks;
+    this.cleanup = result.cleanup;
+    this._isStalled = result.isStalled;
+    return Math.floor(stallTimeoutMs / 60000);
+  }
+
+  _startIndicator(sessionNum, stallTimeoutMin) {
+    this.indicator.start(sessionNum, stallTimeoutMin, assets.projectRoot);
+  }
+
+  _logMessage(message) {
+    const hasText = message.type === 'assistant'
+      && message.message?.content?.some(b => b.type === 'text' && b.text);
+
+    if (hasText && this.indicator) {
+      this.indicator.pauseRendering();
+      process.stderr.write('\r\x1b[K');
+    }
+
+    baseLogMessage(message, this.logStream, this.indicator);
+
+    if (hasText && this.indicator) {
+      this.indicator.resumeRendering();
+    }
+  }
 }
 
-module.exports = {
-  runSession,
-};
+module.exports = { Session };

package/src/core/simplify.js

@@ -1,53 +1,74 @@
 'use strict';
 
-const { runSession } = require('./session');
-const { buildQueryOptions } = require('./query');
 const { log } = require('../common/config');
 const { assets } = require('../common/assets');
+const { Session } = require('./session');
 const { execSync } = require('child_process');
 
-async function _runSimplifySession(n = 3, focus = null, opts = {}) {
+const AUTO_COMMIT_MSG = 'style: auto simplify';
+
+function getSmartDiffRange(projectRoot, fallbackN) {
+  try {
+    const hash = execSync(
+      `git log --grep='${AUTO_COMMIT_MSG}' -1 --format='%H'`,
+      { cwd: projectRoot, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] },
+    ).trim();
+    if (hash) return { range: `${hash}..HEAD`, label: `自上次 auto simplify 以来` };
+  } catch { /* ignore */ }
+  return { range: `HEAD~${fallbackN}..HEAD`, label: `最近 ${fallbackN} 个 commit` };
+}
+
+function commitIfDirty(projectRoot) {
+  try {
+    execSync('git diff --quiet HEAD', { cwd: projectRoot, stdio: 'pipe' });
+  } catch {
+    execSync(`git add -A && git commit -m "${AUTO_COMMIT_MSG}"`, { cwd: projectRoot, stdio: 'pipe' });
+    log('ok', `代码优化已提交: ${AUTO_COMMIT_MSG}`);
+  }
+}
+
+async function executeSimplify(config, focus = null, opts = {}) {
+  const n = opts.n || 3;
   const projectRoot = assets.projectRoot;
+
+  const { range, label } = getSmartDiffRange(projectRoot, n);
+
   let diff = '';
   try {
-    diff = execSync(`git diff HEAD~${n}..HEAD`, { cwd: projectRoot, encoding: 'utf8', maxBuffer: 50 * 1024 * 1024 });
+    diff = execSync(`git diff ${range}`, { cwd: projectRoot, encoding: 'utf8', maxBuffer: 50 * 1024 * 1024 });
   } catch (err) {
-    log('warn', `无法获取最近 ${n} 个 commit 的 diff: ${err.message}`);
+    log('warn', `无法获取 diff (${label}): ${err.message}`);
+  }
+
+  if (!diff.trim()) {
+    log('info', `无变更需要审查 (${label})`);
+    return { success: true };
   }
 
   const focusLine = focus ? `\n审查聚焦方向：${focus}` : '';
-  const prompt = `/simplify\n\n审查范围：最近 ${n} 个 commit${focusLine}\n\n${diff.slice(0, 50000)}`;
+  const prompt = `/simplify\n\n审查范围：${label}${focusLine}\n\n${diff.slice(0, 50000)}`;
   const dateStr = new Date().toISOString().replace(/[-:T]/g, '').slice(0, 12);
 
-  return runSession('simplify', {
-    opts,
-    sessionNum: 0,
+  const result = await Session.run('simplify', config, {
     logFileName: `simplify_${dateStr}.log`,
     label: 'simplify',
 
-    async execute(sdk, ctx) {
-      log('info', `正在审查最近 ${n} 个 commit 的代码变更...`);
+    async execute(session) {
+      log('info', `正在审查代码变更 (${label})...`);
 
-      const queryOpts = buildQueryOptions(ctx.config, opts);
-      queryOpts.hooks = ctx.hooks;
-      queryOpts.abortController = ctx.abortController;
+      const queryOpts = session.buildQueryOptions(opts);
       queryOpts.disallowedTools = ['askUserQuestion'];
 
-      await ctx.runQuery(sdk, prompt, queryOpts);
+      await session.runQuery(prompt, queryOpts);
       log('ok', '代码审查完成');
 
       return {};
     },
   });
-}
 
-async function simplify(focus = null, opts = {}) {
-  assets.ensureDirs();
-  const n = opts.n || 3;
-  return _runSimplifySession(n, focus, opts);
+  commitIfDirty(projectRoot);
+
+  return result;
 }
 
-module.exports = {
-  simplify,
-  _runSimplifySession,
-};
+module.exports = { executeSimplify };

package/src/core/state.js

@@ -0,0 +1,105 @@
+'use strict';
+
+const { assets } = require('../common/assets');
+const { getFeatures } = require('../common/tasks');
+const { TASK_STATUSES } = require('../common/constants');
+
+// ─── Harness State (harness_state.json) ───────────────────
+
+const DEFAULT_STATE = Object.freeze({
+  version: 1,
+  next_task_id: 1,
+  next_priority: 1,
+  session_count: 0,
+  last_simplify_session: 0,
+  current_task_id: null,
+});
+
+function loadState() {
+  return assets.readJson('harnessState', { ...DEFAULT_STATE });
+}
+
+function saveState(data) {
+  assets.writeJson('harnessState', data);
+}
+
+function extractIdNum(id) {
+  const m = String(id).match(/(\d+)$/);
+  return m ? parseInt(m[1], 10) : 0;
+}
+
+function syncAfterPlan() {
+  const state = loadState();
+  const tasks = assets.readJson('tasks', null);
+  if (!tasks || !tasks.features) return state;
+
+  const features = tasks.features;
+  state.next_task_id = features.reduce((max, f) => Math.max(max, extractIdNum(f.id)), 0) + 1;
+  state.next_priority = features.reduce((max, f) => Math.max(max, f.priority || 0), 0) + 1;
+  saveState(state);
+  return state;
+}
+
+// ─── Task Scheduling ──────────────────────────────────────
+
+function selectNextTask(taskData) {
+  const features = getFeatures(taskData);
+
+  const failed = features.filter(f => f.status === 'failed')
+    .sort((a, b) => (a.priority || 999) - (b.priority || 999));
+  if (failed.length > 0) return failed[0];
+
+  const pending = features.filter(f => f.status === 'pending')
+    .filter(f => {
+      const deps = f.depends_on || [];
+      return deps.every(depId => {
+        const dep = features.find(x => x.id === depId);
+        return dep && dep.status === 'done';
+      });
+    })
+    .sort((a, b) => (a.priority || 999) - (b.priority || 999));
+  if (pending.length > 0) return pending[0];
+
+  const inProgress = features.filter(f => f.status === 'in_progress')
+    .sort((a, b) => (a.priority || 999) - (b.priority || 999));
+  return inProgress[0] || null;
+}
+
+function isAllDone(taskData) {
+  const features = getFeatures(taskData);
+  return features.length > 0 && features.every(f => f.status === 'done');
+}
+
+// ─── Progress & Counters ──────────────────────────────────
+
+function appendProgress(entry) {
+  let progress = assets.readJson('progress', { sessions: [] });
+  if (!Array.isArray(progress.sessions)) progress.sessions = [];
+  progress.sessions.push(entry);
+  assets.writeJson('progress', progress);
+}
+
+function incrementSession() {
+  const state = loadState();
+  state.session_count++;
+  saveState(state);
+}
+
+function markSimplifyDone() {
+  const state = loadState();
+  state.last_simplify_session = state.session_count;
+  saveState(state);
+}
+
+module.exports = {
+  DEFAULT_STATE,
+  loadState,
+  saveState,
+  syncAfterPlan,
+  selectNextTask,
+  isAllDone,
+  appendProgress,
+  incrementSession,
+  markSimplifyDone,
+  TASK_STATUSES,
+};