clawt 2.9.1 → 2.10.1

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

@@ -0,0 +1,91 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Command } from 'commander';
+
+vi.mock('../../../src/logger/index.js', () => ({
+  logger: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+
+vi.mock('../../../src/constants/index.js', () => ({
+  MESSAGES: {
+    RESUME_NO_WORKTREES: '没有可用的 worktree',
+    RESUME_SELECT_BRANCH: '选择要恢复的分支',
+    RESUME_MULTIPLE_MATCHES: (keyword: string) => `找到多个匹配 "${keyword}" 的分支`,
+    RESUME_NO_MATCH: (keyword: string, branches: string[]) => `未找到匹配 "${keyword}" 的分支`,
+  },
+}));
+
+vi.mock('../../../src/utils/index.js', () => ({
+  validateMainWorktree: vi.fn(),
+  validateClaudeCodeInstalled: vi.fn(),
+  getProjectWorktrees: vi.fn(),
+  launchInteractiveClaude: vi.fn(),
+  resolveTargetWorktree: vi.fn(),
+}));
+
+import { registerResumeCommand } from '../../../src/commands/resume.js';
+import {
+  validateMainWorktree,
+  validateClaudeCodeInstalled,
+  getProjectWorktrees,
+  launchInteractiveClaude,
+  resolveTargetWorktree,
+} from '../../../src/utils/index.js';
+
+const mockedValidateMainWorktree = vi.mocked(validateMainWorktree);
+const mockedValidateClaudeCodeInstalled = vi.mocked(validateClaudeCodeInstalled);
+const mockedGetProjectWorktrees = vi.mocked(getProjectWorktrees);
+const mockedLaunchInteractiveClaude = vi.mocked(launchInteractiveClaude);
+const mockedResolveTargetWorktree = vi.mocked(resolveTargetWorktree);
+
+beforeEach(() => {
+  mockedValidateMainWorktree.mockReset();
+  mockedValidateClaudeCodeInstalled.mockReset();
+  mockedGetProjectWorktrees.mockReset();
+  mockedLaunchInteractiveClaude.mockReset();
+  mockedResolveTargetWorktree.mockReset();
+});
+
+describe('registerResumeCommand', () => {
+  it('注册 resume 命令', () => {
+    const program = new Command();
+    registerResumeCommand(program);
+    const cmd = program.commands.find((c) => c.name() === 'resume');
+    expect(cmd).toBeDefined();
+  });
+});
+
+describe('handleResume', () => {
+  it('成功恢复 Claude Code 会话', async () => {
+    const worktree = { path: '/path/feature', branch: 'feature' };
+    mockedGetProjectWorktrees.mockReturnValue([worktree]);
+    mockedResolveTargetWorktree.mockResolvedValue(worktree);
+
+    const program = new Command();
+    program.exitOverride();
+    registerResumeCommand(program);
+    await program.parseAsync(['resume', '-b', 'feature'], { from: 'user' });
+
+    expect(mockedValidateMainWorktree).toHaveBeenCalled();
+    expect(mockedValidateClaudeCodeInstalled).toHaveBeenCalled();
+    expect(mockedResolveTargetWorktree).toHaveBeenCalled();
+    expect(mockedLaunchInteractiveClaude).toHaveBeenCalledWith(worktree);
+  });
+
+  it('不传 -b 时也能调用 resolveTargetWorktree', async () => {
+    const worktree = { path: '/path/feature', branch: 'feature' };
+    mockedGetProjectWorktrees.mockReturnValue([worktree]);
+    mockedResolveTargetWorktree.mockResolvedValue(worktree);
+
+    const program = new Command();
+    program.exitOverride();
+    registerResumeCommand(program);
+    await program.parseAsync(['resume'], { from: 'user' });
+
+    // branchName 参数为 undefined
+    expect(mockedResolveTargetWorktree).toHaveBeenCalledWith(
+      expect.any(Array),
+      expect.any(Object),
+      undefined,
+    );
+  });
+});

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

@@ -0,0 +1,207 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Command } from 'commander';
+import { EventEmitter, Readable } from 'node:stream';
+
+vi.mock('../../../src/logger/index.js', () => ({
+  logger: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+
+vi.mock('../../../src/errors/index.js', () => ({
+  ClawtError: class ClawtError extends Error {
+    exitCode: number;
+    constructor(message: string, exitCode = 1) {
+      super(message);
+      this.exitCode = exitCode;
+    }
+  },
+}));
+
+vi.mock('../../../src/constants/index.js', () => ({
+  MESSAGES: {
+    BRANCH_EXISTS_USE_RESUME: (name: string) => `分支 ${name} 已存在，请使用 resume 恢复`,
+    WORKTREE_CREATED: (count: number) => `✓ 已创建 ${count} 个 worktree`,
+    INTERRUPTED: '已中断',
+    INTERRUPT_AUTO_CLEANED: (count: number) => `已清理 ${count} 个 worktree`,
+    INTERRUPT_CONFIRM_CLEANUP: '是否清理已创建的 worktree？',
+    INTERRUPT_CLEANED: (count: number) => `已清理 ${count} 个 worktree`,
+    INTERRUPT_KEPT: '已保留 worktree',
+  },
+}));
+
+vi.mock('../../../src/utils/index.js', () => ({
+  validateMainWorktree: vi.fn(),
+  validateClaudeCodeInstalled: vi.fn(),
+  createWorktrees: vi.fn(),
+  sanitizeBranchName: vi.fn(),
+  checkBranchExists: vi.fn(),
+  spawnProcess: vi.fn(),
+  killAllChildProcesses: vi.fn(),
+  cleanupWorktrees: vi.fn(),
+  getConfigValue: vi.fn(),
+  printSuccess: vi.fn(),
+  printError: vi.fn(),
+  printWarning: vi.fn(),
+  printInfo: vi.fn(),
+  printSeparator: vi.fn(),
+  printDoubleSeparator: vi.fn(),
+  confirmAction: vi.fn(),
+  launchInteractiveClaude: vi.fn(),
+}));
+
+import { registerRunCommand } from '../../../src/commands/run.js';
+import {
+  createWorktrees,
+  sanitizeBranchName,
+  checkBranchExists,
+  spawnProcess,
+  printSuccess,
+  launchInteractiveClaude,
+} from '../../../src/utils/index.js';
+
+const mockedCreateWorktrees = vi.mocked(createWorktrees);
+const mockedSanitizeBranchName = vi.mocked(sanitizeBranchName);
+const mockedCheckBranchExists = vi.mocked(checkBranchExists);
+const mockedSpawnProcess = vi.mocked(spawnProcess);
+const mockedPrintSuccess = vi.mocked(printSuccess);
+const mockedLaunchInteractiveClaude = vi.mocked(launchInteractiveClaude);
+
+/**
+ * 创建模拟子进程
+ * @param {string} stdout - 子进程标准输出内容
+ * @param {number} exitCode - 退出码
+ * @returns {object} 模拟的子进程对象
+ */
+function createMockChildProcess(stdout: string, exitCode: number) {
+  const child = new EventEmitter() as any;
+  const stdoutStream = new Readable({ read() {} });
+  const stderrStream = new Readable({ read() {} });
+  child.stdout = stdoutStream;
+  child.stderr = stderrStream;
+  child.pid = 12345;
+
+  // 延迟触发 close 事件
+  setTimeout(() => {
+    stdoutStream.push(stdout);
+    stdoutStream.push(null);
+    stderrStream.push(null);
+    child.emit('close', exitCode);
+  }, 10);
+
+  return child;
+}
+
+beforeEach(() => {
+  mockedCreateWorktrees.mockReset();
+  mockedSanitizeBranchName.mockReset();
+  mockedCheckBranchExists.mockReset();
+  mockedSpawnProcess.mockReset();
+  mockedPrintSuccess.mockReset();
+  mockedLaunchInteractiveClaude.mockReset();
+});
+
+describe('registerRunCommand', () => {
+  it('注册 run 命令', () => {
+    const program = new Command();
+    registerRunCommand(program);
+    const cmd = program.commands.find((c) => c.name() === 'run');
+    expect(cmd).toBeDefined();
+  });
+});
+
+describe('handleRun', () => {
+  it('未传 --tasks 时创建单个 worktree 并打开交互式界面', async () => {
+    mockedSanitizeBranchName.mockReturnValue('feature');
+    mockedCheckBranchExists.mockReturnValue(false);
+    const worktree = { path: '/path/feature', branch: 'feature' };
+    mockedCreateWorktrees.mockReturnValue([worktree]);
+
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+    await program.parseAsync(['run', '-b', 'feature'], { from: 'user' });
+
+    expect(mockedCreateWorktrees).toHaveBeenCalledWith('feature', 1);
+    expect(mockedLaunchInteractiveClaude).toHaveBeenCalledWith(worktree);
+  });
+
+  it('分支已存在时提示使用 resume', async () => {
+    mockedSanitizeBranchName.mockReturnValue('feature');
+    mockedCheckBranchExists.mockReturnValue(true);
+
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+
+    await expect(
+      program.parseAsync(['run', '-b', 'feature'], { from: 'user' }),
+    ).rejects.toThrow();
+  });
+
+  it('传 --tasks 时创建对应数量 worktree 并并行执行', async () => {
+    const worktrees = [
+      { path: '/path/feat-1', branch: 'feat-1' },
+      { path: '/path/feat-2', branch: 'feat-2' },
+    ];
+    mockedCreateWorktrees.mockReturnValue(worktrees);
+
+    const jsonOutput = JSON.stringify({
+      is_error: false,
+      duration_ms: 5000,
+      total_cost_usd: 0.05,
+    });
+    mockedSpawnProcess
+      .mockReturnValueOnce(createMockChildProcess(jsonOutput, 0))
+      .mockReturnValueOnce(createMockChildProcess(jsonOutput, 0));
+
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+    await program.parseAsync(['run', '-b', 'feat', '--tasks', 'task1', 'task2'], { from: 'user' });
+
+    expect(mockedCreateWorktrees).toHaveBeenCalledWith('feat', 2);
+    expect(mockedSpawnProcess).toHaveBeenCalledTimes(2);
+    expect(mockedPrintSuccess).toHaveBeenCalled();
+  });
+
+  it('任务执行失败时在通知中报告', async () => {
+    const worktrees = [{ path: '/path/feat-1', branch: 'feat-1' }];
+    mockedCreateWorktrees.mockReturnValue(worktrees);
+
+    const jsonOutput = JSON.stringify({
+      is_error: true,
+      duration_ms: 1000,
+      total_cost_usd: 0.01,
+    });
+    mockedSpawnProcess.mockReturnValueOnce(createMockChildProcess(jsonOutput, 1));
+
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+    await program.parseAsync(['run', '-b', 'feat', '--tasks', 'fail-task'], { from: 'user' });
+
+    // 应输出汇总（含失败信息）
+    expect(mockedSpawnProcess).toHaveBeenCalledTimes(1);
+  });
+
+  it('子进程发生错误时返回失败结果', async () => {
+    const worktrees = [{ path: '/path/feat-1', branch: 'feat-1' }];
+    mockedCreateWorktrees.mockReturnValue(worktrees);
+
+    // 创建会触发 error 事件的子进程
+    const child = new EventEmitter() as any;
+    child.stdout = new Readable({ read() {} });
+    child.stderr = new Readable({ read() {} });
+    child.pid = 12345;
+    setTimeout(() => {
+      child.emit('error', new Error('spawn error'));
+    }, 10);
+    mockedSpawnProcess.mockReturnValueOnce(child);
+
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+    await program.parseAsync(['run', '-b', 'feat', '--tasks', 'task1'], { from: 'user' });
+
+    expect(mockedSpawnProcess).toHaveBeenCalledTimes(1);
+  });
+});

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

@@ -0,0 +1,214 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Command } from 'commander';
+
+vi.mock('../../../src/logger/index.js', () => ({
+  logger: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+
+vi.mock('../../../src/constants/index.js', () => ({
+  MESSAGES: {
+    STATUS_TITLE: (name: string) => `项目 ${name} 状态`,
+    STATUS_MAIN_SECTION: '主 Worktree',
+    STATUS_WORKTREES_SECTION: 'Worktree 列表',
+    STATUS_SNAPSHOTS_SECTION: 'Validate 快照',
+    STATUS_NO_WORKTREES: '无 worktree',
+    STATUS_NO_SNAPSHOTS: '无快照',
+    STATUS_CHANGE_COMMITTED: '已提交',
+    STATUS_CHANGE_UNCOMMITTED: '未提交',
+    STATUS_CHANGE_CONFLICT: '冲突',
+    STATUS_CHANGE_CLEAN: '干净',
+    STATUS_SNAPSHOT_ORPHANED: '(孤立)',
+  },
+}));
+
+vi.mock('../../../src/utils/index.js', () => ({
+  validateMainWorktree: vi.fn(),
+  getProjectName: vi.fn(),
+  getCurrentBranch: vi.fn(),
+  isWorkingDirClean: vi.fn(),
+  getProjectWorktrees: vi.fn(),
+  getCommitCountAhead: vi.fn(),
+  getCommitCountBehind: vi.fn(),
+  getDiffStat: vi.fn(),
+  hasMergeConflict: vi.fn(),
+  hasLocalCommits: vi.fn(),
+  hasSnapshot: vi.fn(),
+  getProjectSnapshotBranches: vi.fn(),
+  printInfo: vi.fn(),
+  printDoubleSeparator: vi.fn(),
+  printSeparator: vi.fn(),
+}));
+
+import { registerStatusCommand } from '../../../src/commands/status.js';
+import {
+  getProjectName,
+  getCurrentBranch,
+  isWorkingDirClean,
+  getProjectWorktrees,
+  getCommitCountAhead,
+  getCommitCountBehind,
+  getDiffStat,
+  hasMergeConflict,
+  hasLocalCommits,
+  hasSnapshot,
+  getProjectSnapshotBranches,
+  printInfo,
+} from '../../../src/utils/index.js';
+
+const mockedGetProjectName = vi.mocked(getProjectName);
+const mockedGetCurrentBranch = vi.mocked(getCurrentBranch);
+const mockedIsWorkingDirClean = vi.mocked(isWorkingDirClean);
+const mockedGetProjectWorktrees = vi.mocked(getProjectWorktrees);
+const mockedGetCommitCountAhead = vi.mocked(getCommitCountAhead);
+const mockedGetCommitCountBehind = vi.mocked(getCommitCountBehind);
+const mockedGetDiffStat = vi.mocked(getDiffStat);
+const mockedHasMergeConflict = vi.mocked(hasMergeConflict);
+const mockedHasLocalCommits = vi.mocked(hasLocalCommits);
+const mockedHasSnapshot = vi.mocked(hasSnapshot);
+const mockedGetProjectSnapshotBranches = vi.mocked(getProjectSnapshotBranches);
+const mockedPrintInfo = vi.mocked(printInfo);
+
+beforeEach(() => {
+  mockedGetProjectName.mockReturnValue('test-project');
+  mockedGetCurrentBranch.mockReturnValue('main');
+  mockedIsWorkingDirClean.mockReturnValue(true);
+  mockedGetProjectWorktrees.mockReturnValue([]);
+  mockedGetProjectSnapshotBranches.mockReturnValue([]);
+  mockedGetCommitCountAhead.mockReturnValue(0);
+  mockedGetCommitCountBehind.mockReturnValue(0);
+  mockedGetDiffStat.mockReturnValue({ insertions: 0, deletions: 0 });
+  mockedHasMergeConflict.mockReturnValue(false);
+  mockedHasLocalCommits.mockReturnValue(false);
+  mockedHasSnapshot.mockReturnValue(false);
+  mockedPrintInfo.mockReset();
+});
+
+describe('registerStatusCommand', () => {
+  it('注册 status 命令', () => {
+    const program = new Command();
+    registerStatusCommand(program);
+    const cmd = program.commands.find((c) => c.name() === 'status');
+    expect(cmd).toBeDefined();
+  });
+});
+
+describe('handleStatus', () => {
+  it('无 worktree 时文本输出', () => {
+    const program = new Command();
+    program.exitOverride();
+    registerStatusCommand(program);
+    program.parse(['status'], { from: 'user' });
+
+    expect(mockedPrintInfo).toHaveBeenCalled();
+  });
+
+  it('--json 输出完整 JSON 结构', () => {
+    mockedGetProjectWorktrees.mockReturnValue([
+      { path: '/path/feature', branch: 'feature' },
+    ]);
+    mockedGetCommitCountAhead.mockReturnValue(2);
+    mockedGetDiffStat.mockReturnValue({ insertions: 10, deletions: 5 });
+    mockedHasLocalCommits.mockReturnValue(true);
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    const program = new Command();
+    program.exitOverride();
+    registerStatusCommand(program);
+    program.parse(['status', '--json'], { from: 'user' });
+
+    const jsonCall = consoleSpy.mock.calls.find((call) => {
+      try { JSON.parse(call[0]); return true; } catch { return false; }
+    });
+    expect(jsonCall).toBeDefined();
+    const parsed = JSON.parse(jsonCall![0]);
+    expect(parsed.main.projectName).toBe('test-project');
+    expect(parsed.main.branch).toBe('main');
+    expect(parsed.totalWorktrees).toBe(1);
+    expect(parsed.worktrees).toHaveLength(1);
+    expect(parsed.worktrees[0].branch).toBe('feature');
+  });
+
+  it('有 worktree 时收集正确的变更状态', () => {
+    mockedGetProjectWorktrees.mockReturnValue([
+      { path: '/path/feature', branch: 'feature' },
+    ]);
+    // 模拟冲突状态
+    mockedHasMergeConflict.mockReturnValue(true);
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    const program = new Command();
+    program.exitOverride();
+    registerStatusCommand(program);
+    program.parse(['status', '--json'], { from: 'user' });
+
+    const jsonCall = consoleSpy.mock.calls.find((call) => {
+      try { JSON.parse(call[0]); return true; } catch { return false; }
+    });
+    const parsed = JSON.parse(jsonCall![0]);
+    expect(parsed.worktrees[0].changeStatus).toBe('conflict');
+  });
+
+  it('主 worktree 不干净时 isClean=false', () => {
+    mockedIsWorkingDirClean.mockReturnValue(false);
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    const program = new Command();
+    program.exitOverride();
+    registerStatusCommand(program);
+    program.parse(['status', '--json'], { from: 'user' });
+
+    const jsonCall = consoleSpy.mock.calls.find((call) => {
+      try { JSON.parse(call[0]); return true; } catch { return false; }
+    });
+    const parsed = JSON.parse(jsonCall![0]);
+    expect(parsed.main.isClean).toBe(false);
+  });
+
+  it('存在快照时标识孤立快照', () => {
+    mockedGetProjectSnapshotBranches.mockReturnValue(['feature', 'deleted-branch']);
+    mockedGetProjectWorktrees.mockReturnValue([
+      { path: '/path/feature', branch: 'feature' },
+    ]);
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    const program = new Command();
+    program.exitOverride();
+    registerStatusCommand(program);
+    program.parse(['status', '--json'], { from: 'user' });
+
+    const jsonCall = consoleSpy.mock.calls.find((call) => {
+      try { JSON.parse(call[0]); return true; } catch { return false; }
+    });
+    const parsed = JSON.parse(jsonCall![0]);
+    expect(parsed.snapshots).toHaveLength(2);
+    expect(parsed.snapshots[0]).toEqual({ branch: 'feature', worktreeExists: true });
+    expect(parsed.snapshots[1]).toEqual({ branch: 'deleted-branch', worktreeExists: false });
+  });
+
+  it('uncommitted 变更状态正确检测', () => {
+    mockedGetProjectWorktrees.mockReturnValue([
+      { path: '/path/feature', branch: 'feature' },
+    ]);
+    mockedHasMergeConflict.mockReturnValue(false);
+    mockedIsWorkingDirClean
+      .mockReturnValueOnce(true)   // 主 worktree
+      .mockReturnValueOnce(false); // 目标 worktree 不干净
+
+    const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    const program = new Command();
+    program.exitOverride();
+    registerStatusCommand(program);
+    program.parse(['status', '--json'], { from: 'user' });
+
+    const jsonCall = consoleSpy.mock.calls.find((call) => {
+      try { JSON.parse(call[0]); return true; } catch { return false; }
+    });
+    const parsed = JSON.parse(jsonCall![0]);
+    expect(parsed.worktrees[0].changeStatus).toBe('uncommitted');
+  });
+});