clawt 2.10.0 → 2.11.0

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

@@ -0,0 +1,240 @@
+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/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: {
+    NO_WORKTREES: '(无 worktree)',
+    WORKTREE_REMOVED: (path: string) => `✓ 已移除 worktree: ${path}`,
+    REMOVE_PARTIAL_FAILURE: (failures: Array<{ path: string; error: string }>) => `${failures.length} 个移除失败`,
+    REMOVE_NO_WORKTREES: '当前项目没有可用的 worktree，无需移除',
+    REMOVE_SELECT_BRANCH: '请选择要移除的分支（空格选择，回车确认）',
+    REMOVE_MULTIPLE_MATCHES: (name: string) => `"${name}" 匹配到多个分支`,
+    REMOVE_NO_MATCH: (name: string, branches: string[]) => `未找到与 "${name}" 匹配的分支，可用：${branches.join(', ')}`,
+  },
+}));
+
+vi.mock('../../../src/utils/index.js', () => ({
+  validateMainWorktree: vi.fn(),
+  getProjectName: vi.fn(),
+  getProjectWorktreeDir: vi.fn(),
+  getProjectWorktrees: vi.fn(),
+  removeWorktreeByPath: vi.fn(),
+  deleteBranch: vi.fn(),
+  getConfigValue: vi.fn(),
+  gitWorktreePrune: vi.fn(),
+  removeEmptyDir: vi.fn(),
+  printInfo: vi.fn(),
+  printSuccess: vi.fn(),
+  printError: vi.fn(),
+  confirmAction: vi.fn(),
+  removeSnapshot: vi.fn(),
+  removeProjectSnapshots: vi.fn(),
+  resolveTargetWorktrees: vi.fn(),
+}));
+
+import { registerRemoveCommand } from '../../../src/commands/remove.js';
+import {
+  validateMainWorktree,
+  getProjectName,
+  getProjectWorktrees,
+  removeWorktreeByPath,
+  deleteBranch,
+  getConfigValue,
+  confirmAction,
+  removeSnapshot,
+  removeProjectSnapshots,
+  printSuccess,
+  printError,
+  resolveTargetWorktrees,
+} from '../../../src/utils/index.js';
+
+const mockedGetProjectName = vi.mocked(getProjectName);
+const mockedGetProjectWorktrees = vi.mocked(getProjectWorktrees);
+const mockedRemoveWorktreeByPath = vi.mocked(removeWorktreeByPath);
+const mockedDeleteBranch = vi.mocked(deleteBranch);
+const mockedGetConfigValue = vi.mocked(getConfigValue);
+const mockedConfirmAction = vi.mocked(confirmAction);
+const mockedRemoveSnapshot = vi.mocked(removeSnapshot);
+const mockedRemoveProjectSnapshots = vi.mocked(removeProjectSnapshots);
+const mockedPrintSuccess = vi.mocked(printSuccess);
+const mockedPrintError = vi.mocked(printError);
+const mockedResolveTargetWorktrees = vi.mocked(resolveTargetWorktrees);
+
+beforeEach(() => {
+  vi.mocked(validateMainWorktree).mockReset();
+  mockedGetProjectName.mockReturnValue('test-project');
+  mockedGetProjectWorktrees.mockReset();
+  mockedRemoveWorktreeByPath.mockReset();
+  mockedDeleteBranch.mockReset();
+  mockedGetConfigValue.mockReset();
+  mockedConfirmAction.mockReset();
+  mockedRemoveSnapshot.mockReset();
+  mockedRemoveProjectSnapshots.mockReset();
+  mockedPrintSuccess.mockReset();
+  mockedPrintError.mockReset();
+  mockedResolveTargetWorktrees.mockReset();
+});
+
+describe('registerRemoveCommand', () => {
+  it('注册 remove 命令', () => {
+    const program = new Command();
+    registerRemoveCommand(program);
+    const cmd = program.commands.find((c) => c.name() === 'remove');
+    expect(cmd).toBeDefined();
+  });
+});
+
+describe('handleRemove', () => {
+  it('--all 移除所有 worktree（autoDeleteBranch=true）', async () => {
+    mockedGetProjectWorktrees.mockReturnValue([
+      { path: '/path/feature-1', branch: 'feature-1' },
+      { path: '/path/feature-2', branch: 'feature-2' },
+    ]);
+    mockedGetConfigValue.mockReturnValue(true);
+
+    const program = new Command();
+    program.exitOverride();
+    registerRemoveCommand(program);
+    await program.parseAsync(['remove', '--all'], { from: 'user' });
+
+    expect(mockedRemoveWorktreeByPath).toHaveBeenCalledTimes(2);
+    expect(mockedDeleteBranch).toHaveBeenCalledTimes(2);
+    expect(mockedRemoveProjectSnapshots).toHaveBeenCalledWith('test-project');
+  });
+
+  it('-b 精确匹配时通过 resolveTargetWorktrees 解析并移除', async () => {
+    mockedGetProjectWorktrees.mockReturnValue([
+      { path: '/path/feature', branch: 'feature' },
+      { path: '/path/other', branch: 'other' },
+    ]);
+    mockedResolveTargetWorktrees.mockResolvedValue([
+      { path: '/path/feature', branch: 'feature' },
+    ]);
+    mockedGetConfigValue.mockReturnValue(true);
+
+    const program = new Command();
+    program.exitOverride();
+    registerRemoveCommand(program);
+    await program.parseAsync(['remove', '-b', 'feature'], { from: 'user' });
+
+    expect(mockedResolveTargetWorktrees).toHaveBeenCalled();
+    expect(mockedRemoveWorktreeByPath).toHaveBeenCalledTimes(1);
+    expect(mockedRemoveWorktreeByPath).toHaveBeenCalledWith('/path/feature');
+  });
+
+  it('-b 模糊匹配多个时通过 resolveTargetWorktrees 解析并批量移除', async () => {
+    mockedGetProjectWorktrees.mockReturnValue([
+      { path: '/path/feature-1', branch: 'feature-1' },
+      { path: '/path/feature-2', branch: 'feature-2' },
+      { path: '/path/other', branch: 'other' },
+    ]);
+    // 模拟用户多选了两个
+    mockedResolveTargetWorktrees.mockResolvedValue([
+      { path: '/path/feature-1', branch: 'feature-1' },
+      { path: '/path/feature-2', branch: 'feature-2' },
+    ]);
+    mockedGetConfigValue.mockReturnValue(true);
+
+    const program = new Command();
+    program.exitOverride();
+    registerRemoveCommand(program);
+    await program.parseAsync(['remove', '-b', 'feature'], { from: 'user' });
+
+    expect(mockedRemoveWorktreeByPath).toHaveBeenCalledTimes(2);
+  });
+
+  it('未指定 --all 或 -b 时通过 resolveTargetWorktrees 展示多选列表', async () => {
+    mockedGetProjectWorktrees.mockReturnValue([
+      { path: '/path/feature-1', branch: 'feature-1' },
+      { path: '/path/feature-2', branch: 'feature-2' },
+    ]);
+    mockedResolveTargetWorktrees.mockResolvedValue([
+      { path: '/path/feature-1', branch: 'feature-1' },
+    ]);
+    mockedGetConfigValue.mockReturnValue(true);
+
+    const program = new Command();
+    program.exitOverride();
+    registerRemoveCommand(program);
+    await program.parseAsync(['remove'], { from: 'user' });
+
+    // 未传 branch 参数，resolveTargetWorktrees 的第三个参数应为 undefined
+    expect(mockedResolveTargetWorktrees).toHaveBeenCalledWith(
+      expect.any(Array),
+      expect.any(Object),
+      undefined,
+    );
+    expect(mockedRemoveWorktreeByPath).toHaveBeenCalledTimes(1);
+  });
+
+  it('autoDeleteBranch=false 时询问用户是否删除分支', async () => {
+    mockedGetProjectWorktrees.mockReturnValue([
+      { path: '/path/feature', branch: 'feature' },
+    ]);
+    mockedResolveTargetWorktrees.mockResolvedValue([
+      { path: '/path/feature', branch: 'feature' },
+    ]);
+    mockedGetConfigValue.mockReturnValue(false);
+    mockedConfirmAction.mockResolvedValue(false);
+
+    const program = new Command();
+    program.exitOverride();
+    registerRemoveCommand(program);
+    await program.parseAsync(['remove', '-b', 'feature'], { from: 'user' });
+
+    expect(mockedConfirmAction).toHaveBeenCalled();
+    // 用户拒绝删除分支
+    expect(mockedDeleteBranch).not.toHaveBeenCalled();
+  });
+
+  it('-b 指定不存在的分支时 resolveTargetWorktrees 抛出错误', async () => {
+    mockedGetProjectWorktrees.mockReturnValue([
+      { path: '/path/other', branch: 'other' },
+    ]);
+    mockedResolveTargetWorktrees.mockRejectedValue(new Error('未找到与 "nonexistent" 匹配的分支'));
+
+    const program = new Command();
+    program.exitOverride();
+    registerRemoveCommand(program);
+
+    await expect(
+      program.parseAsync(['remove', '-b', 'nonexistent'], { from: 'user' }),
+    ).rejects.toThrow();
+  });
+
+  it('移除过程中部分失败时汇报并抛出错误', async () => {
+    mockedGetProjectWorktrees.mockReturnValue([
+      { path: '/path/feature-1', branch: 'feature-1' },
+      { path: '/path/feature-2', branch: 'feature-2' },
+    ]);
+    mockedGetConfigValue.mockReturnValue(true);
+    // 第一个成功，第二个失败
+    mockedRemoveWorktreeByPath
+      .mockImplementationOnce(() => {})
+      .mockImplementationOnce(() => { throw new Error('remove failed'); });
+
+    const program = new Command();
+    program.exitOverride();
+    registerRemoveCommand(program);
+
+    await expect(
+      program.parseAsync(['remove', '--all'], { from: 'user' }),
+    ).rejects.toThrow();
+
+    expect(mockedPrintError).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,124 @@
+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: {
+    RESET_SUCCESS: '✓ 已重置主 worktree',
+    RESET_ALREADY_CLEAN: '主 worktree 已经是干净状态',
+    DESTRUCTIVE_OP_CANCELLED: '已取消操作',
+  },
+}));
+
+vi.mock('../../../src/utils/index.js', () => ({
+  validateMainWorktree: vi.fn(),
+  getGitTopLevel: vi.fn(),
+  getConfigValue: vi.fn(),
+  isWorkingDirClean: vi.fn(),
+  gitResetHard: vi.fn(),
+  gitCleanForce: vi.fn(),
+  confirmDestructiveAction: vi.fn(),
+  printSuccess: vi.fn(),
+  printInfo: vi.fn(),
+}));
+
+import { registerResetCommand } from '../../../src/commands/reset.js';
+import {
+  getGitTopLevel,
+  getConfigValue,
+  isWorkingDirClean,
+  gitResetHard,
+  gitCleanForce,
+  confirmDestructiveAction,
+  printSuccess,
+  printInfo,
+} from '../../../src/utils/index.js';
+
+const mockedGetGitTopLevel = vi.mocked(getGitTopLevel);
+const mockedGetConfigValue = vi.mocked(getConfigValue);
+const mockedIsWorkingDirClean = vi.mocked(isWorkingDirClean);
+const mockedGitResetHard = vi.mocked(gitResetHard);
+const mockedGitCleanForce = vi.mocked(gitCleanForce);
+const mockedConfirmDestructiveAction = vi.mocked(confirmDestructiveAction);
+const mockedPrintSuccess = vi.mocked(printSuccess);
+const mockedPrintInfo = vi.mocked(printInfo);
+
+beforeEach(() => {
+  mockedGetGitTopLevel.mockReturnValue('/repo');
+  mockedGetConfigValue.mockReset();
+  mockedIsWorkingDirClean.mockReset();
+  mockedGitResetHard.mockReset();
+  mockedGitCleanForce.mockReset();
+  mockedConfirmDestructiveAction.mockReset();
+  mockedPrintSuccess.mockReset();
+  mockedPrintInfo.mockReset();
+});
+
+describe('registerResetCommand', () => {
+  it('注册 reset 命令', () => {
+    const program = new Command();
+    registerResetCommand(program);
+    const cmd = program.commands.find((c) => c.name() === 'reset');
+    expect(cmd).toBeDefined();
+  });
+});
+
+describe('handleReset', () => {
+  it('工作区已干净时提示', async () => {
+    mockedIsWorkingDirClean.mockReturnValue(true);
+
+    const program = new Command();
+    program.exitOverride();
+    registerResetCommand(program);
+    await program.parseAsync(['reset'], { from: 'user' });
+
+    expect(mockedGitResetHard).not.toHaveBeenCalled();
+    expect(mockedPrintInfo).toHaveBeenCalled();
+  });
+
+  it('工作区不干净且确认后执行重置', async () => {
+    mockedIsWorkingDirClean.mockReturnValue(false);
+    mockedGetConfigValue.mockReturnValue(true); // confirmDestructiveOps = true
+    mockedConfirmDestructiveAction.mockResolvedValue(true);
+
+    const program = new Command();
+    program.exitOverride();
+    registerResetCommand(program);
+    await program.parseAsync(['reset'], { from: 'user' });
+
+    expect(mockedGitResetHard).toHaveBeenCalledWith('/repo');
+    expect(mockedGitCleanForce).toHaveBeenCalledWith('/repo');
+    expect(mockedPrintSuccess).toHaveBeenCalled();
+  });
+
+  it('用户拒绝确认时不执行重置', async () => {
+    mockedIsWorkingDirClean.mockReturnValue(false);
+    mockedGetConfigValue.mockReturnValue(true);
+    mockedConfirmDestructiveAction.mockResolvedValue(false);
+
+    const program = new Command();
+    program.exitOverride();
+    registerResetCommand(program);
+    await program.parseAsync(['reset'], { from: 'user' });
+
+    expect(mockedGitResetHard).not.toHaveBeenCalled();
+    expect(mockedPrintInfo).toHaveBeenCalled();
+  });
+
+  it('confirmDestructiveOps=false 时跳过确认直接重置', async () => {
+    mockedIsWorkingDirClean.mockReturnValue(false);
+    mockedGetConfigValue.mockReturnValue(false);
+
+    const program = new Command();
+    program.exitOverride();
+    registerResetCommand(program);
+    await program.parseAsync(['reset'], { from: 'user' });
+
+    expect(mockedConfirmDestructiveAction).not.toHaveBeenCalled();
+    expect(mockedGitResetHard).toHaveBeenCalledWith('/repo');
+    expect(mockedGitCleanForce).toHaveBeenCalledWith('/repo');
+  });
+});

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,
+    );
+  });
+});