clawt 2.10.0 → 2.11.0

package/src/utils/task-executor.ts

@@ -0,0 +1,365 @@
+import type { ChildProcess } from 'node:child_process';
+import { logger } from '../logger/index.js';
+import { MESSAGES } from '../constants/index.js';
+import type { ClaudeCodeResult, TaskResult, TaskSummary, WorktreeInfo } from '../types/index.js';
+import { spawnProcess, killAllChildProcesses } from './shell.js';
+import { cleanupWorktrees } from './worktree.js';
+import { getConfigValue } from './config.js';
+import { printSuccess, printWarning, printInfo, printDoubleSeparator, confirmAction } from './formatter.js';
+import { ProgressRenderer } from './progress.js';
+
+/** executeClaudeTask 的返回结构，包含子进程引用和结果 Promise */
+interface ClaudeTaskHandle {
+  /** 子进程实例，用于在中断时终止 */
+  child: ChildProcess;
+  /** 任务结果 Promise */
+  promise: Promise<TaskResult>;
+}
+
+/**
+ * 在指定 worktree 中执行 Claude Code 任务，由于是--output-format json形式，所以这里固定claude code cli的启动命令
+ * @param {WorktreeInfo} worktree - worktree 信息
+ * @param {string} task - 任务描述
+ * @returns {ClaudeTaskHandle} 包含子进程引用和结果 Promise
+ */
+function executeClaudeTask(worktree: WorktreeInfo, task: string): ClaudeTaskHandle {
+  const child = spawnProcess(
+    'claude',
+    ['-p', task, '--output-format', 'json', '--permission-mode', 'bypassPermissions'],
+    {
+      cwd: worktree.path,
+      // stdin 必须设置为 'ignore'，不能用 'pipe'
+      // 原因：claude -p 是非交互模式，不需要 stdin 输入。如果 stdin 为 'pipe'，
+      // 父进程会创建一个可写流连接到子进程但从不写入也不关闭，
+      // claude 检测到 stdin 是管道后会尝试读取输入，导致进程永远卡住
+      stdio: ['ignore', 'pipe', 'pipe'],
+    },
+  );
+
+  const promise = new Promise<TaskResult>((resolve) => {
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout?.on('data', (data: Buffer) => {
+      stdout += data.toString();
+    });
+
+    child.stderr?.on('data', (data: Buffer) => {
+      stderr += data.toString();
+    });
+
+    child.on('close', (code) => {
+      let result: ClaudeCodeResult | null = null;
+      let success = code === 0;
+
+      try {
+        if (stdout.trim()) {
+          result = JSON.parse(stdout.trim()) as ClaudeCodeResult;
+          success = !result.is_error;
+        }
+      } catch {
+        logger.warn(`解析 Claude Code 输出失败: ${stdout.substring(0, 200)}`);
+      }
+
+      resolve({
+        task,
+        branch: worktree.branch,
+        worktreePath: worktree.path,
+        success,
+        result,
+        error: success ? undefined : stderr || '任务执行失败',
+      });
+    });
+
+    child.on('error', (err) => {
+      resolve({
+        task,
+        branch: worktree.branch,
+        worktreePath: worktree.path,
+        success: false,
+        result: null,
+        error: err.message,
+      });
+    });
+  });
+
+  return { child, promise };
+}
+
+/**
+ * 输出所有任务的汇总信息
+ * @param {TaskSummary} summary - 汇总信息
+ */
+function printTaskSummary(summary: TaskSummary): void {
+  printDoubleSeparator();
+  printInfo(`全部任务已完成 (${summary.total}/${summary.total})`);
+  printInfo(`  成功: ${summary.succeeded}`);
+  printInfo(`  失败: ${summary.failed}`);
+  printInfo(`  总耗时: ${(summary.totalDurationMs / 1000).toFixed(1)}s`);
+  printInfo(`  总花费: $${summary.totalCostUsd.toFixed(2)}`);
+  printDoubleSeparator();
+}
+
+/**
+ * 处理用户中断（Ctrl+C）后的清理流程
+ * 根据全局配置决定自动清理或交互式确认
+ * @param {WorktreeInfo[]} worktrees - 本次创建的 worktree 列表
+ */
+async function handleInterruptCleanup(worktrees: WorktreeInfo[]): Promise<void> {
+  const autoDelete = getConfigValue('autoDeleteBranch');
+
+  if (autoDelete) {
+    // 全局配置了自动删除，直接清理
+    cleanupWorktrees(worktrees);
+    printSuccess(MESSAGES.INTERRUPT_AUTO_CLEANED(worktrees.length));
+    return;
+  }
+
+  // 交互式确认是否清理
+  const shouldClean = await confirmAction(MESSAGES.INTERRUPT_CONFIRM_CLEANUP);
+
+  if (shouldClean) {
+    cleanupWorktrees(worktrees);
+    printSuccess(MESSAGES.INTERRUPT_CLEANED(worktrees.length));
+  } else {
+    printInfo(MESSAGES.INTERRUPT_KEPT);
+  }
+}
+
+/**
+ * 更新进度面板中指定任务的完成/失败状态
+ * @param {ProgressRenderer} renderer - 进度面板渲染器
+ * @param {number} index - 任务索引（从 0 开始）
+ * @param {TaskResult} result - 任务执行结果
+ * @param {number} startTime - 任务批次启动时间戳
+ */
+function updateRendererStatus(renderer: ProgressRenderer, index: number, result: TaskResult, startTime: number): void {
+  if (result.success) {
+    renderer.markDone(
+      index,
+      result.result?.duration_ms ?? (Date.now() - startTime),
+      result.result?.total_cost_usd ?? 0,
+    );
+  } else {
+    renderer.markFailed(
+      index,
+      result.result?.duration_ms ?? (Date.now() - startTime),
+    );
+  }
+}
+
+/**
+ * 以并发限制模式执行任务队列
+ * 维护活跃任务池，某个任务完成后立即启动队列中下一个
+ * @param {WorktreeInfo[]} worktrees - worktree 列表
+ * @param {string[]} tasks - 任务描述列表
+ * @param {number} concurrency - 最大并发数
+ * @param {ProgressRenderer} renderer - 进度面板渲染器
+ * @param {number} startTime - 任务批次启动时间戳
+ * @param {() => boolean} isInterrupted - 检查是否已中断的函数
+ * @param {ChildProcess[]} childProcesses - 共享子进程数组，执行过程中动态追加
+ * @returns {Promise<TaskResult[]>} 所有任务结果
+ */
+async function executeWithConcurrency(
+  worktrees: WorktreeInfo[],
+  tasks: string[],
+  concurrency: number,
+  renderer: ProgressRenderer,
+  startTime: number,
+  isInterrupted: () => boolean,
+  childProcesses: ChildProcess[],
+): Promise<TaskResult[]> {
+  const total = tasks.length;
+  const results: TaskResult[] = new Array(total);
+  let nextIndex = 0;
+  let completedCount = 0;
+
+  return new Promise((resolve) => {
+    /**
+     * 启动下一个排队中的任务
+     * 从队列中取出任务并启动执行，完成时递归调用自身
+     */
+    function launchNext(): void {
+      if (nextIndex >= total || isInterrupted()) return;
+
+      const index = nextIndex;
+      nextIndex++;
+
+      const wt = worktrees[index];
+      const task = tasks[index];
+      logger.info(`启动任务 ${index + 1}: ${task} (worktree: ${wt.path})`);
+
+      // 标记为运行中
+      renderer.markRunning(index);
+
+      const handle = executeClaudeTask(wt, task);
+      childProcesses.push(handle.child);
+
+      // 监听 stderr 输出，更新任务活动时间戳
+      handle.child.stderr?.on('data', () => {
+        renderer.updateActivity(index);
+      });
+
+      handle.promise.then((result) => {
+        results[index] = result;
+        completedCount++;
+
+        // 被中断时不再更新面板
+        if (!isInterrupted()) {
+          updateRendererStatus(renderer, index, result, startTime);
+        }
+
+        // 启动下一个排队任务
+        launchNext();
+
+        // 所有任务完成时 resolve
+        if (completedCount === total) {
+          resolve(results);
+        }
+      });
+    }
+
+    // 初始启动 concurrency 个任务
+    const initialBatch = Math.min(concurrency, total);
+    for (let i = 0; i < initialBatch; i++) {
+      launchNext();
+    }
+  });
+}
+
+/**
+ * 以全量并行模式执行所有任务
+ * @param {WorktreeInfo[]} worktrees - worktree 列表
+ * @param {string[]} tasks - 任务描述列表
+ * @param {ProgressRenderer} renderer - 进度面板渲染器
+ * @param {number} startTime - 任务批次启动时间戳
+ * @param {() => boolean} isInterrupted - 检查是否已中断的函数
+ * @param {ChildProcess[]} childProcesses - 共享子进程数组，启动时追加
+ * @returns {Promise<TaskResult[]>} 所有任务结果
+ */
+async function executeAllParallel(
+  worktrees: WorktreeInfo[],
+  tasks: string[],
+  renderer: ProgressRenderer,
+  startTime: number,
+  isInterrupted: () => boolean,
+  childProcesses: ChildProcess[],
+): Promise<TaskResult[]> {
+  const handles = worktrees.map((wt, index) => {
+    const task = tasks[index];
+    logger.info(`启动任务 ${index + 1}: ${task} (worktree: ${wt.path})`);
+    const handle = executeClaudeTask(wt, task);
+    childProcesses.push(handle.child);
+
+    // 监听 stderr 输出，更新任务活动时间戳
+    handle.child.stderr?.on('data', () => {
+      renderer.updateActivity(index);
+    });
+
+    return handle;
+  });
+
+  const results = await Promise.all(
+    handles.map((handle, index) =>
+      handle.promise.then((result) => {
+        // 被中断时不再更新面板
+        if (!isInterrupted()) {
+          updateRendererStatus(renderer, index, result, startTime);
+        }
+        return result;
+      }),
+    ),
+  );
+
+  return results;
+}
+
+/**
+ * 批量任务执行的公共逻辑
+ * 负责进度面板、SIGINT 处理、并发控制、汇总输出
+ * @param {WorktreeInfo[]} worktrees - worktree 列表
+ * @param {string[]} tasks - 任务描述列表
+ * @param {number} concurrency - 最大并发数，0 表示不限制
+ */
+export async function executeBatchTasks(
+  worktrees: WorktreeInfo[],
+  tasks: string[],
+  concurrency: number,
+): Promise<void> {
+  const count = tasks.length;
+
+  // 有并发限制时输出提示
+  if (concurrency > 0) {
+    printInfo(MESSAGES.CONCURRENCY_INFO(concurrency, count));
+    printInfo('');
+  }
+
+  // 实例化进度面板渲染器
+  const startTime = Date.now();
+  const branches = worktrees.map((wt) => wt.branch);
+  const paths = worktrees.map((wt) => wt.path);
+  // 有并发限制时任务初始化为 pending 状态，否则初始化为 running
+  const allRunning = concurrency === 0;
+  const renderer = new ProgressRenderer(branches, paths, allRunning);
+
+  // 启动进度面板渲染
+  renderer.start();
+
+  // 共享中断状态标志和子进程引用数组
+  let interrupted = false;
+  const isInterrupted = () => interrupted;
+  const childProcesses: ChildProcess[] = [];
+
+  // 监听 SIGINT（Ctrl+C），终止所有子进程并触发清理流程
+  const sigintHandler = async () => {
+    if (interrupted) return;
+    interrupted = true;
+
+    // 停止进度面板渲染
+    renderer.stop();
+
+    printInfo('');
+    printWarning(MESSAGES.INTERRUPTED);
+    killAllChildProcesses(childProcesses);
+
+    // 等待所有已启动的子进程退出后再执行清理
+    await Promise.allSettled(childProcesses.map((cp) =>
+      new Promise<void>((resolve) => {
+        if (cp.exitCode !== null) {
+          resolve();
+        } else {
+          cp.on('close', () => resolve());
+        }
+      }),
+    ));
+
+    await handleInterruptCleanup(worktrees);
+    process.exit(1);
+  };
+  process.on('SIGINT', sigintHandler);
+
+  // 根据并发限制选择执行模式
+  const results = concurrency > 0
+    ? await executeWithConcurrency(worktrees, tasks, concurrency, renderer, startTime, isInterrupted, childProcesses)
+    : await executeAllParallel(worktrees, tasks, renderer, startTime, isInterrupted, childProcesses);
+
+  // 正常完成，停止进度面板并移除 SIGINT 监听器
+  renderer.stop();
+  process.removeListener('SIGINT', sigintHandler);
+
+  // 被中断时不输出汇总（已在 sigintHandler 中处理退出）
+  if (interrupted) return;
+
+  const totalDurationMs = Date.now() - startTime;
+
+  // 汇总
+  const summary: TaskSummary = {
+    total: results.length,
+    succeeded: results.filter((r) => r.success).length,
+    failed: results.filter((r) => !r.success).length,
+    totalDurationMs,
+    totalCostUsd: results.reduce((sum, r) => sum + (r.result?.total_cost_usd ?? 0), 0),
+  };
+
+  printTaskSummary(summary);
+}

package/src/utils/task-file.ts

@@ -0,0 +1,87 @@
+import { resolve } from 'node:path';
+import { existsSync, readFileSync } from 'node:fs';
+import { ClawtError } from '../errors/index.js';
+import { MESSAGES } from '../constants/index.js';
+import type { TaskFileEntry, ParseTaskFileOptions } from '../types/index.js';
+
+/** 匹配任务块的正则：<!-- CLAWT-TASKS:START --> ... <!-- CLAWT-TASKS:END --> */
+const TASK_BLOCK_REGEX = /<!-- CLAWT-TASKS:START -->([\s\S]*?)<!-- CLAWT-TASKS:END -->/g;
+
+/** 匹配分支名行的正则：# branch: <name> */
+const BRANCH_LINE_REGEX = /^#\s*branch:\s*(.+)$/;
+
+/**
+ * 解析任务文件内容，提取所有任务块
+ * 每个块内 `# branch: <name>` 为分支名，其余行为任务描述
+ * @param {string} content - 文件内容
+ * @param {ParseTaskFileOptions} [options] - 解析选项
+ * @returns {TaskFileEntry[]} 解析出的任务列表
+ */
+export function parseTaskFile(content: string, options?: ParseTaskFileOptions): TaskFileEntry[] {
+  const branchRequired = options?.branchRequired ?? true;
+  const entries: TaskFileEntry[] = [];
+  let match: RegExpExecArray | null;
+  let blockIndex = 0;
+
+  // 重置正则 lastIndex，避免模块级 /g 正则跨调用残留状态
+  TASK_BLOCK_REGEX.lastIndex = 0;
+
+  while ((match = TASK_BLOCK_REGEX.exec(content)) !== null) {
+    blockIndex++;
+    const blockContent = match[1].trim();
+    const lines = blockContent.split('\n');
+
+    let branch: string | undefined;
+    const taskLines: string[] = [];
+
+    for (const line of lines) {
+      const branchMatch = line.trim().match(BRANCH_LINE_REGEX);
+      if (branchMatch) {
+        branch = branchMatch[1].trim();
+      } else {
+        taskLines.push(line);
+      }
+    }
+
+    if (branchRequired && !branch) {
+      throw new ClawtError(MESSAGES.TASK_FILE_MISSING_BRANCH(blockIndex));
+    }
+
+    const task = taskLines.join('\n').trim();
+    if (!task) {
+      throw new ClawtError(
+        branch
+          ? MESSAGES.TASK_FILE_MISSING_TASK(branch)
+          : MESSAGES.TASK_FILE_MISSING_TASK_BY_INDEX(blockIndex),
+      );
+    }
+
+    entries.push({ branch, task });
+  }
+
+  return entries;
+}
+
+/**
+ * 读取并解析任务文件
+ * 支持相对路径（基于 cwd）和绝对路径
+ * @param {string} filePath - 文件路径
+ * @param {ParseTaskFileOptions} [options] - 解析选项
+ * @returns {TaskFileEntry[]} 解析出的任务列表
+ */
+export function loadTaskFile(filePath: string, options?: ParseTaskFileOptions): TaskFileEntry[] {
+  const absolutePath = resolve(filePath);
+
+  if (!existsSync(absolutePath)) {
+    throw new ClawtError(MESSAGES.TASK_FILE_NOT_FOUND(absolutePath));
+  }
+
+  const content = readFileSync(absolutePath, 'utf-8');
+  const entries = parseTaskFile(content, options);
+
+  if (entries.length === 0) {
+    throw new ClawtError(MESSAGES.TASK_FILE_EMPTY);
+  }
+
+  return entries;
+}

package/src/utils/worktree-matcher.ts

@@ -38,6 +38,21 @@ export function findFuzzyMatches(worktrees: WorktreeInfo[], keyword: string): Wo
   return worktrees.filter((wt) => wt.branch.toLowerCase().includes(lowerKeyword));
 }
 
+/**
+ * 多选场景下的分支解析消息文案配置
+ * 与 WorktreeResolveMessages 类似，但用于需要多选的命令（如 remove）
+ */
+export interface WorktreeMultiResolveMessages {
+  /** 无可用 worktree 时的错误消息 */
+  noWorktrees: string;
+  /** 未传分支名时的多选交互提示 */
+  selectBranch: string;
+  /** 模糊匹配到多个结果时的多选交互提示 */
+  multipleMatches: (keyword: string) => string;
+  /** 无匹配结果时的错误消息 */
+  noMatch: (keyword: string, branches: string[]) => string;
+}
+
 /**
  * 通过交互式列表让用户从 worktree 列表中选择一个分支
  * @param {WorktreeInfo[]} worktrees - 可供选择的 worktree 列表
@@ -57,6 +72,83 @@ export async function promptSelectBranch(worktrees: WorktreeInfo[], message: str
   return worktrees.find((wt) => wt.branch === selectedBranch)!;
 }
 
+/**
+ * 通过交互式多选列表让用户从 worktree 列表中选择多个分支
+ * 用户可通过空格键选择/取消，回车键确认
+ * @param {WorktreeInfo[]} worktrees - 可供选择的 worktree 列表
+ * @param {string} message - 选择提示信息
+ * @returns {Promise<WorktreeInfo[]>} 用户选择的 worktree 列表
+ */
+export async function promptMultiSelectBranches(worktrees: WorktreeInfo[], message: string): Promise<WorktreeInfo[]> {
+  // @ts-expect-error enquirer 类型声明未导出 MultiSelect 类，但运行时存在
+  const selectedBranches: string[] = await new Enquirer.MultiSelect({
+    message,
+    choices: worktrees.map((wt) => ({
+      name: wt.branch,
+      message: wt.branch,
+    })),
+    // 使用空心圆/实心圆作为选中指示符
+    symbols: {
+      indicator: { on: '●', off: '○' },
+    },
+  }).run();
+
+  return worktrees.filter((wt) => selectedBranches.includes(wt.branch));
+}
+
+/**
+ * 根据用户输入解析目标 worktree（多选版本）
+ * 匹配策略：精确匹配 → 模糊匹配（唯一直接使用，多个交互多选） → 无匹配报错
+ * 不传分支名时列出所有可用分支供多选
+ * @param {WorktreeInfo[]} worktrees - 可用的 worktree 列表
+ * @param {WorktreeMultiResolveMessages} messages - 命令专属的消息文案
+ * @param {string} [branchName] - 用户输入的分支名（可选）
+ * @returns {Promise<WorktreeInfo[]>} 解析后的目标 worktree 列表
+ * @throws {ClawtError} 无可用 worktree 或无匹配结果时抛出
+ */
+export async function resolveTargetWorktrees(
+  worktrees: WorktreeInfo[],
+  messages: WorktreeMultiResolveMessages,
+  branchName?: string,
+): Promise<WorktreeInfo[]> {
+  // 无可用 worktree，直接报错
+  if (worktrees.length === 0) {
+    throw new ClawtError(messages.noWorktrees);
+  }
+
+  // 未传 -b 参数：列出所有分支供多选
+  if (!branchName) {
+    // 只有一个 worktree 时直接使用，无需选择
+    if (worktrees.length === 1) {
+      return [worktrees[0]];
+    }
+    return promptMultiSelectBranches(worktrees, messages.selectBranch);
+  }
+
+  // 1. 精确匹配优先
+  const exactMatch = findExactMatch(worktrees, branchName);
+  if (exactMatch) {
+    return [exactMatch];
+  }
+
+  // 2. 模糊匹配
+  const fuzzyMatches = findFuzzyMatches(worktrees, branchName);
+
+  // 2a. 唯一匹配，直接使用
+  if (fuzzyMatches.length === 1) {
+    return [fuzzyMatches[0]];
+  }
+
+  // 2b. 多个匹配，交互多选
+  if (fuzzyMatches.length > 1) {
+    return promptMultiSelectBranches(fuzzyMatches, messages.multipleMatches(branchName));
+  }
+
+  // 3. 无匹配，抛出错误并列出所有可用分支
+  const allBranches = worktrees.map((wt) => wt.branch);
+  throw new ClawtError(messages.noMatch(branchName, allBranches));
+}
+
 /**
  * 根据用户输入解析目标 worktree
  * 匹配策略：精确匹配 → 模糊匹配（唯一直接使用，多个交互选择） → 无匹配报错

package/src/utils/worktree.ts

@@ -49,6 +49,33 @@ export function createWorktrees(branchName: string, count: number): WorktreeInfo
   return results;
 }
 
+/**
+ * 根据独立分支名列表逐个创建 worktree（不自动编号）
+ * 与 createWorktrees 不同，不使用 generateBranchNames 自动编号
+ * 调用方负责分支名清理（sanitizeBranchName）
+ * @param {string[]} branchNames - 已清理的分支名列表
+ * @returns {WorktreeInfo[]} 创建的 worktree 信息列表
+ */
+export function createWorktreesByBranches(branchNames: string[]): WorktreeInfo[] {
+  // 1. 校验所有分支是否都不存在
+  validateBranchesNotExist(branchNames);
+
+  // 2. 确保项目 worktree 目录存在
+  const projectDir = getProjectWorktreeDir();
+  ensureDir(projectDir);
+
+  // 3. 串行创建 worktree
+  const results: WorktreeInfo[] = [];
+  for (const name of branchNames) {
+    const worktreePath = join(projectDir, name);
+    gitCreateWorktree(name, worktreePath);
+    results.push({ path: worktreePath, branch: name });
+    logger.info(`worktree 创建完成: ${worktreePath} (分支: ${name})`);
+  }
+
+  return results;
+}
+
 /**
  * 获取当前项目在 ~/.clawt/worktrees/<project>/ 下的所有 worktree
  * 通过与 git worktree list 交叉验证确认有效性

package/tests/unit/commands/config.test.ts

@@ -0,0 +1,110 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Command } from 'commander';
+
+// mock 依赖模块
+vi.mock('../../../src/logger/index.js', () => ({
+  logger: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+
+vi.mock('../../../src/utils/index.js', () => ({
+  loadConfig: vi.fn(),
+  writeDefaultConfig: vi.fn(),
+  printInfo: vi.fn(),
+  printSuccess: vi.fn(),
+  printSeparator: vi.fn(),
+  confirmDestructiveAction: vi.fn(),
+}));
+
+vi.mock('../../../src/constants/index.js', () => ({
+  CONFIG_PATH: '/mock/.clawt/config.json',
+  DEFAULT_CONFIG: {
+    claudeCodeCommand: 'claude',
+    autoDeleteBranch: false,
+    autoPullPush: false,
+    confirmDestructiveOps: true,
+  },
+  CONFIG_DESCRIPTIONS: {
+    claudeCodeCommand: 'Claude Code CLI 命令',
+    autoDeleteBranch: '自动删除分支',
+    autoPullPush: '自动 pull/push',
+    confirmDestructiveOps: '破坏性操作确认',
+  },
+  MESSAGES: {
+    CONFIG_RESET_SUCCESS: '配置已恢复为默认值',
+    DESTRUCTIVE_OP_CANCELLED: '已取消操作',
+  },
+}));
+
+import { registerConfigCommand } from '../../../src/commands/config.js';
+import { loadConfig, writeDefaultConfig, printInfo, printSuccess, confirmDestructiveAction } from '../../../src/utils/index.js';
+
+const mockedLoadConfig = vi.mocked(loadConfig);
+const mockedWriteDefaultConfig = vi.mocked(writeDefaultConfig);
+const mockedPrintInfo = vi.mocked(printInfo);
+const mockedPrintSuccess = vi.mocked(printSuccess);
+const mockedConfirmDestructiveAction = vi.mocked(confirmDestructiveAction);
+
+beforeEach(() => {
+  mockedLoadConfig.mockReset();
+  mockedWriteDefaultConfig.mockReset();
+  mockedPrintInfo.mockReset();
+  mockedPrintSuccess.mockReset();
+  mockedConfirmDestructiveAction.mockReset();
+});
+
+describe('registerConfigCommand', () => {
+  it('注册 config 命令和 config reset 子命令', () => {
+    const program = new Command();
+    registerConfigCommand(program);
+    const configCmd = program.commands.find((c) => c.name() === 'config');
+    expect(configCmd).toBeDefined();
+    const resetCmd = configCmd!.commands.find((c) => c.name() === 'reset');
+    expect(resetCmd).toBeDefined();
+  });
+});
+
+describe('handleConfig（通过 action 间接测试）', () => {
+  it('展示配置列表', () => {
+    mockedLoadConfig.mockReturnValue({
+      claudeCodeCommand: 'claude',
+      autoDeleteBranch: false,
+      autoPullPush: false,
+      confirmDestructiveOps: true,
+    });
+
+    const program = new Command();
+    program.exitOverride();
+    registerConfigCommand(program);
+    program.parse(['config'], { from: 'user' });
+
+    expect(mockedLoadConfig).toHaveBeenCalled();
+    // 应输出配置信息
+    expect(mockedPrintInfo).toHaveBeenCalled();
+  });
+});
+
+describe('handleConfigReset（通过 action 间接测试）', () => {
+  it('用户确认后恢复默认配置', async () => {
+    mockedConfirmDestructiveAction.mockResolvedValue(true);
+
+    const program = new Command();
+    program.exitOverride();
+    registerConfigCommand(program);
+    await program.parseAsync(['config', 'reset'], { from: 'user' });
+
+    expect(mockedWriteDefaultConfig).toHaveBeenCalled();
+    expect(mockedPrintSuccess).toHaveBeenCalled();
+  });
+
+  it('用户取消操作时不写入', async () => {
+    mockedConfirmDestructiveAction.mockResolvedValue(false);
+
+    const program = new Command();
+    program.exitOverride();
+    registerConfigCommand(program);
+    await program.parseAsync(['config', 'reset'], { from: 'user' });
+
+    expect(mockedWriteDefaultConfig).not.toHaveBeenCalled();
+    expect(mockedPrintInfo).toHaveBeenCalled();
+  });
+});