clawt 2.10.0 → 2.10.1

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

@@ -0,0 +1,382 @@
+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: {
+    VALIDATE_NO_WORKTREES: '没有可用的 worktree',
+    VALIDATE_SELECT_BRANCH: '选择要验证的分支',
+    VALIDATE_MULTIPLE_MATCHES: (keyword: string) => `找到多个匹配 "${keyword}" 的分支`,
+    VALIDATE_NO_MATCH: (keyword: string, branches: string[]) => `未找到匹配 "${keyword}" 的分支`,
+    TARGET_WORKTREE_CLEAN: '该 worktree 的分支上没有任何更改',
+    VALIDATE_SUCCESS: (branch: string) => `✓ 已验证 ${branch}`,
+    VALIDATE_CLEANED: (branch: string) => `✓ 已清理 ${branch} 的 validate 状态`,
+    VALIDATE_PATCH_APPLY_FAILED: (branch: string) => `patch 应用失败: ${branch}`,
+    INCREMENTAL_VALIDATE_SUCCESS: (branch: string) => `✓ 增量验证 ${branch}`,
+    INCREMENTAL_VALIDATE_FALLBACK: '降级为全量模式',
+    DESTRUCTIVE_OP_CANCELLED: '已取消操作',
+  },
+}));
+
+// mock enquirer
+vi.mock('enquirer', () => ({
+  default: {
+    Select: vi.fn(),
+  },
+}));
+
+vi.mock('../../../src/utils/index.js', () => ({
+  validateMainWorktree: vi.fn(),
+  getProjectName: vi.fn(),
+  getGitTopLevel: vi.fn(),
+  getProjectWorktrees: vi.fn(),
+  getConfigValue: vi.fn(),
+  isWorkingDirClean: vi.fn(),
+  gitAddAll: vi.fn(),
+  gitCommit: vi.fn(),
+  gitStashPush: vi.fn(),
+  gitRestoreStaged: vi.fn(),
+  gitResetHard: vi.fn(),
+  gitCleanForce: vi.fn(),
+  gitDiffBinaryAgainstBranch: vi.fn(),
+  gitApplyFromStdin: vi.fn(),
+  gitApplyCachedFromStdin: vi.fn(),
+  gitResetSoft: vi.fn(),
+  gitWriteTree: vi.fn(),
+  gitReadTree: vi.fn(),
+  getHeadCommitHash: vi.fn(),
+  getCommitTreeHash: vi.fn(),
+  gitDiffTree: vi.fn(),
+  gitApplyCachedCheck: vi.fn(),
+  hasLocalCommits: vi.fn(),
+  hasSnapshot: vi.fn(),
+  readSnapshot: vi.fn(),
+  writeSnapshot: vi.fn(),
+  removeSnapshot: vi.fn(),
+  confirmDestructiveAction: vi.fn(),
+  printSuccess: vi.fn(),
+  printWarning: vi.fn(),
+  printInfo: vi.fn(),
+  resolveTargetWorktree: vi.fn(),
+}));
+
+import { registerValidateCommand } from '../../../src/commands/validate.js';
+import {
+  getProjectName,
+  getGitTopLevel,
+  getProjectWorktrees,
+  getConfigValue,
+  isWorkingDirClean,
+  gitAddAll,
+  gitCommit,
+  gitDiffBinaryAgainstBranch,
+  gitApplyFromStdin,
+  gitResetSoft,
+  gitWriteTree,
+  gitRestoreStaged,
+  getHeadCommitHash,
+  gitReadTree,
+  hasLocalCommits,
+  hasSnapshot,
+  readSnapshot,
+  writeSnapshot,
+  removeSnapshot,
+  confirmDestructiveAction,
+  printSuccess,
+  printInfo,
+  resolveTargetWorktree,
+  gitResetHard,
+  gitCleanForce,
+  getCommitTreeHash,
+  gitDiffTree,
+  gitApplyCachedCheck,
+  gitApplyCachedFromStdin,
+  printWarning,
+} from '../../../src/utils/index.js';
+
+const mockedGetProjectName = vi.mocked(getProjectName);
+const mockedGetGitTopLevel = vi.mocked(getGitTopLevel);
+const mockedGetProjectWorktrees = vi.mocked(getProjectWorktrees);
+const mockedGetConfigValue = vi.mocked(getConfigValue);
+const mockedIsWorkingDirClean = vi.mocked(isWorkingDirClean);
+const mockedGitAddAll = vi.mocked(gitAddAll);
+const mockedGitCommit = vi.mocked(gitCommit);
+const mockedGitDiffBinaryAgainstBranch = vi.mocked(gitDiffBinaryAgainstBranch);
+const mockedGitApplyFromStdin = vi.mocked(gitApplyFromStdin);
+const mockedGitResetSoft = vi.mocked(gitResetSoft);
+const mockedGitWriteTree = vi.mocked(gitWriteTree);
+const mockedGitRestoreStaged = vi.mocked(gitRestoreStaged);
+const mockedGetHeadCommitHash = vi.mocked(getHeadCommitHash);
+const mockedGitReadTree = vi.mocked(gitReadTree);
+const mockedHasLocalCommits = vi.mocked(hasLocalCommits);
+const mockedHasSnapshot = vi.mocked(hasSnapshot);
+const mockedReadSnapshot = vi.mocked(readSnapshot);
+const mockedWriteSnapshot = vi.mocked(writeSnapshot);
+const mockedRemoveSnapshot = vi.mocked(removeSnapshot);
+const mockedConfirmDestructiveAction = vi.mocked(confirmDestructiveAction);
+const mockedPrintSuccess = vi.mocked(printSuccess);
+const mockedPrintInfo = vi.mocked(printInfo);
+const mockedResolveTargetWorktree = vi.mocked(resolveTargetWorktree);
+const mockedGitResetHard = vi.mocked(gitResetHard);
+const mockedGitCleanForce = vi.mocked(gitCleanForce);
+const mockedGetCommitTreeHash = vi.mocked(getCommitTreeHash);
+const mockedGitDiffTree = vi.mocked(gitDiffTree);
+const mockedGitApplyCachedCheck = vi.mocked(gitApplyCachedCheck);
+const mockedGitApplyCachedFromStdin = vi.mocked(gitApplyCachedFromStdin);
+const mockedPrintWarning = vi.mocked(printWarning);
+
+const worktree = { path: '/path/feature', branch: 'feature' };
+
+beforeEach(() => {
+  mockedGetGitTopLevel.mockReturnValue('/repo');
+  mockedGetProjectName.mockReturnValue('test-project');
+  mockedGetProjectWorktrees.mockReturnValue([worktree]);
+  mockedResolveTargetWorktree.mockResolvedValue(worktree);
+  mockedGetConfigValue.mockReturnValue(false);
+  mockedHasSnapshot.mockReturnValue(false);
+  mockedIsWorkingDirClean.mockReset();
+  mockedGitAddAll.mockReset();
+  mockedGitCommit.mockReset();
+  mockedGitDiffBinaryAgainstBranch.mockReset();
+  mockedGitApplyFromStdin.mockReset();
+  mockedGitResetSoft.mockReset();
+  mockedGitWriteTree.mockReset();
+  mockedGitRestoreStaged.mockReset();
+  mockedGetHeadCommitHash.mockReset();
+  mockedGitReadTree.mockReset();
+  mockedHasLocalCommits.mockReset();
+  mockedReadSnapshot.mockReset();
+  mockedWriteSnapshot.mockReset();
+  mockedRemoveSnapshot.mockReset();
+  mockedConfirmDestructiveAction.mockReset();
+  mockedPrintSuccess.mockReset();
+  mockedPrintInfo.mockReset();
+  mockedGitResetHard.mockReset();
+  mockedGitCleanForce.mockReset();
+  mockedGetCommitTreeHash.mockReset();
+  mockedGitDiffTree.mockReset();
+  mockedGitApplyCachedCheck.mockReset();
+  mockedGitApplyCachedFromStdin.mockReset();
+  mockedPrintWarning.mockReset();
+});
+
+describe('registerValidateCommand', () => {
+  it('注册 validate 命令', () => {
+    const program = new Command();
+    registerValidateCommand(program);
+    const cmd = program.commands.find((c) => c.name() === 'validate');
+    expect(cmd).toBeDefined();
+  });
+});
+
+describe('handleValidate', () => {
+  it('目标分支无变更时提示并返回', async () => {
+    mockedIsWorkingDirClean.mockReturnValue(true);
+    mockedHasLocalCommits.mockReturnValue(false);
+
+    const program = new Command();
+    program.exitOverride();
+    registerValidateCommand(program);
+    await program.parseAsync(['validate', '-b', 'feature'], { from: 'user' });
+
+    expect(mockedPrintInfo).toHaveBeenCalled();
+    expect(mockedGitDiffBinaryAgainstBranch).not.toHaveBeenCalled();
+  });
+
+  it('首次 validate：有已提交 commit 且主 worktree 干净', async () => {
+    // 目标 worktree 干净，但有已提交 commit
+    mockedIsWorkingDirClean.mockReturnValue(true); // 所有调用都返回 true
+    mockedHasLocalCommits.mockReturnValue(true);
+    mockedHasSnapshot.mockReturnValue(false);
+    mockedGitDiffBinaryAgainstBranch.mockReturnValue(Buffer.from('diff'));
+    mockedGitWriteTree.mockReturnValue('treehash123');
+    mockedGetHeadCommitHash.mockReturnValue('headhash456');
+
+    const program = new Command();
+    program.exitOverride();
+    registerValidateCommand(program);
+    await program.parseAsync(['validate', '-b', 'feature'], { from: 'user' });
+
+    expect(mockedGitDiffBinaryAgainstBranch).toHaveBeenCalledWith('feature', '/repo');
+    expect(mockedGitApplyFromStdin).toHaveBeenCalled();
+    expect(mockedWriteSnapshot).toHaveBeenCalledWith('test-project', 'feature', 'treehash123', 'headhash456');
+    expect(mockedPrintSuccess).toHaveBeenCalled();
+  });
+
+  it('首次 validate：有未提交修改时做临时 commit 后撤销', async () => {
+    // 主 worktree 干净，目标 worktree 有未提交修改
+    mockedIsWorkingDirClean
+      .mockReturnValueOnce(true)    // 主 worktree 调用（collectStatus 或 handleValidate 首次检查目标）
+      .mockReturnValueOnce(false);  // 目标 worktree 检查
+    mockedHasLocalCommits.mockReturnValue(false); // 无已提交 commit，但有未提交修改
+    mockedHasSnapshot.mockReturnValue(false);
+    mockedGitDiffBinaryAgainstBranch.mockReturnValue(Buffer.from('diff'));
+    mockedGitWriteTree.mockReturnValue('treehash');
+    mockedGetHeadCommitHash.mockReturnValue('headhash');
+
+    // 注意：hasUncommitted 来自 !isWorkingDirClean(targetWorktreePath)
+    // 这里的 mock 链：
+    // 第 1 次调用 isWorkingDirClean: 检查 targetWorktreePath => false（有未提交修改）
+    // 但是代码中先检查 isWorkingDirClean(mainWorktreePath)
+    // 需要更精确的 mock
+    mockedIsWorkingDirClean.mockReset();
+    mockedIsWorkingDirClean.mockImplementation((cwd?: string) => {
+      if (cwd === '/path/feature') return false;  // 目标 worktree 不干净
+      return true;  // 主 worktree 干净
+    });
+    // 因为 hasUncommitted 依赖 !isWorkingDirClean(targetWorktreePath)，
+    // 且 !hasUncommitted && !hasCommitted 需要检查 hasLocalCommits
+    mockedHasLocalCommits.mockReturnValue(true); // 让它不走"无变更"路径
+
+    const program = new Command();
+    program.exitOverride();
+    registerValidateCommand(program);
+    await program.parseAsync(['validate', '-b', 'feature'], { from: 'user' });
+
+    // 临时 commit
+    expect(mockedGitAddAll).toHaveBeenCalledWith('/path/feature');
+    expect(mockedGitCommit).toHaveBeenCalledWith('clawt:temp-commit-for-validate', '/path/feature');
+    // 撤销临时 commit
+    expect(mockedGitResetSoft).toHaveBeenCalledWith(1, '/path/feature');
+    expect(mockedGitRestoreStaged).toHaveBeenCalledWith('/path/feature');
+  });
+});
+
+describe('handleValidateClean', () => {
+  it('确认后清理 validate 状态', async () => {
+    mockedGetConfigValue.mockReturnValue(true); // confirmDestructiveOps
+    mockedConfirmDestructiveAction.mockResolvedValue(true);
+    mockedIsWorkingDirClean.mockReturnValue(false);
+
+    const program = new Command();
+    program.exitOverride();
+    registerValidateCommand(program);
+    await program.parseAsync(['validate', '--clean', '-b', 'feature'], { from: 'user' });
+
+    expect(mockedGitResetHard).toHaveBeenCalledWith('/repo');
+    expect(mockedGitCleanForce).toHaveBeenCalledWith('/repo');
+    expect(mockedRemoveSnapshot).toHaveBeenCalledWith('test-project', 'feature');
+    expect(mockedPrintSuccess).toHaveBeenCalled();
+  });
+
+  it('用户拒绝时取消操作', async () => {
+    mockedGetConfigValue.mockReturnValue(true);
+    mockedConfirmDestructiveAction.mockResolvedValue(false);
+
+    const program = new Command();
+    program.exitOverride();
+    registerValidateCommand(program);
+    await program.parseAsync(['validate', '--clean', '-b', 'feature'], { from: 'user' });
+
+    expect(mockedGitResetHard).not.toHaveBeenCalled();
+    expect(mockedRemoveSnapshot).not.toHaveBeenCalled();
+  });
+
+  it('confirmDestructiveOps=false 时跳过确认', async () => {
+    mockedGetConfigValue.mockReturnValue(false);
+    mockedIsWorkingDirClean.mockReturnValue(true);
+
+    const program = new Command();
+    program.exitOverride();
+    registerValidateCommand(program);
+    await program.parseAsync(['validate', '--clean', '-b', 'feature'], { from: 'user' });
+
+    expect(mockedConfirmDestructiveAction).not.toHaveBeenCalled();
+    expect(mockedRemoveSnapshot).toHaveBeenCalledWith('test-project', 'feature');
+  });
+});
+
+describe('增量 validate', () => {
+  it('HEAD 未变化时使用 read-tree 旧快照', async () => {
+    mockedIsWorkingDirClean.mockReturnValue(true);
+    mockedHasLocalCommits.mockReturnValue(true);
+    mockedHasSnapshot.mockReturnValue(true);
+    mockedReadSnapshot.mockReturnValue({ treeHash: 'oldtree', headCommitHash: 'headhash' });
+    mockedGetHeadCommitHash.mockReturnValue('headhash'); // HEAD 未变化
+    mockedGitDiffBinaryAgainstBranch.mockReturnValue(Buffer.from('diff'));
+    mockedGitWriteTree.mockReturnValue('newtree');
+
+    const program = new Command();
+    program.exitOverride();
+    registerValidateCommand(program);
+    await program.parseAsync(['validate', '-b', 'feature'], { from: 'user' });
+
+    expect(mockedGitReadTree).toHaveBeenCalledWith('oldtree', '/repo');
+    expect(mockedPrintSuccess).toHaveBeenCalled();
+  });
+
+  it('HEAD 变化时通过 patch 重放旧变更到暂存区', async () => {
+    mockedIsWorkingDirClean.mockReturnValue(true);
+    mockedHasLocalCommits.mockReturnValue(true);
+    mockedHasSnapshot.mockReturnValue(true);
+    mockedReadSnapshot.mockReturnValue({ treeHash: 'oldtree', headCommitHash: 'oldhead' });
+    mockedGetHeadCommitHash.mockReturnValue('newhead'); // HEAD 已变化
+    mockedGitDiffBinaryAgainstBranch.mockReturnValue(Buffer.from('diff'));
+    mockedGitWriteTree.mockReturnValue('newtree');
+    mockedGetCommitTreeHash.mockReturnValue('oldheadtree');
+    mockedGitDiffTree.mockReturnValue(Buffer.from('old change patch'));
+    mockedGitApplyCachedCheck.mockReturnValue(true);
+
+    const program = new Command();
+    program.exitOverride();
+    registerValidateCommand(program);
+    await program.parseAsync(['validate', '-b', 'feature'], { from: 'user' });
+
+    expect(mockedGetCommitTreeHash).toHaveBeenCalledWith('oldhead', '/repo');
+    expect(mockedGitDiffTree).toHaveBeenCalledWith('oldheadtree', 'oldtree', '/repo');
+    expect(mockedGitApplyCachedFromStdin).toHaveBeenCalled();
+  });
+
+  it('旧变更 patch 有冲突时降级为全量模式', async () => {
+    mockedIsWorkingDirClean.mockReturnValue(true);
+    mockedHasLocalCommits.mockReturnValue(true);
+    mockedHasSnapshot.mockReturnValue(true);
+    mockedReadSnapshot.mockReturnValue({ treeHash: 'oldtree', headCommitHash: 'oldhead' });
+    mockedGetHeadCommitHash.mockReturnValue('newhead');
+    mockedGitDiffBinaryAgainstBranch.mockReturnValue(Buffer.from('diff'));
+    mockedGitWriteTree.mockReturnValue('newtree');
+    mockedGetCommitTreeHash.mockReturnValue('oldheadtree');
+    mockedGitDiffTree.mockReturnValue(Buffer.from('conflicting patch'));
+    mockedGitApplyCachedCheck.mockReturnValue(false); // 有冲突
+
+    const program = new Command();
+    program.exitOverride();
+    registerValidateCommand(program);
+    await program.parseAsync(['validate', '-b', 'feature'], { from: 'user' });
+
+    expect(mockedPrintWarning).toHaveBeenCalled();
+    expect(mockedGitApplyCachedFromStdin).not.toHaveBeenCalled();
+  });
+
+  it('read-tree 失败时降级为全量模式', async () => {
+    mockedIsWorkingDirClean.mockReturnValue(true);
+    mockedHasLocalCommits.mockReturnValue(true);
+    mockedHasSnapshot.mockReturnValue(true);
+    mockedReadSnapshot.mockReturnValue({ treeHash: 'oldtree', headCommitHash: 'headhash' });
+    mockedGetHeadCommitHash.mockReturnValue('headhash');
+    mockedGitDiffBinaryAgainstBranch.mockReturnValue(Buffer.from('diff'));
+    mockedGitWriteTree.mockReturnValue('newtree');
+    mockedGitReadTree.mockImplementation(() => { throw new Error('gc reclaimed'); });
+
+    const program = new Command();
+    program.exitOverride();
+    registerValidateCommand(program);
+    await program.parseAsync(['validate', '-b', 'feature'], { from: 'user' });
+
+    expect(mockedPrintWarning).toHaveBeenCalled();
+    expect(mockedPrintSuccess).toHaveBeenCalled();
+  });
+});

package/tests/unit/constants/messages.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { MESSAGES } from '../../../src/constants/messages.js';
+import { MESSAGES } from '../../../src/constants/messages/index.js';
 
 describe('MESSAGES', () => {
   describe('纯字符串消息', () => {

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

@@ -18,12 +18,14 @@ vi.mock('../../../src/utils/fs.js', () => ({
 }));
 
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { loadConfig, getConfigValue } from '../../../src/utils/config.js';
+import { loadConfig, getConfigValue, writeDefaultConfig, ensureClawtDirs } from '../../../src/utils/config.js';
 import { DEFAULT_CONFIG } from '../../../src/constants/index.js';
+import { ensureDir } from '../../../src/utils/fs.js';
 
 const mockedExistsSync = vi.mocked(existsSync);
 const mockedReadFileSync = vi.mocked(readFileSync);
 const mockedWriteFileSync = vi.mocked(writeFileSync);
+const mockedEnsureDir = vi.mocked(ensureDir);
 
 describe('loadConfig', () => {
   it('配置文件不存在时返回默认配置', () => {
@@ -63,3 +65,21 @@ describe('getConfigValue', () => {
     expect(getConfigValue('confirmDestructiveOps')).toBe(true);
   });
 });
+
+describe('writeDefaultConfig', () => {
+  it('将默认配置写入配置文件', () => {
+    writeDefaultConfig();
+    expect(mockedWriteFileSync).toHaveBeenCalledWith(
+      expect.any(String),
+      JSON.stringify(DEFAULT_CONFIG, null, 2),
+      'utf-8',
+    );
+  });
+});
+
+describe('ensureClawtDirs', () => {
+  it('确保三个全局目录存在', () => {
+    ensureClawtDirs();
+    expect(mockedEnsureDir).toHaveBeenCalledTimes(3);
+  });
+});

package/tests/unit/utils/formatter.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi } from 'vitest';
-import { formatWorktreeStatus, printSuccess, printError, printWarning, printInfo } from '../../../src/utils/formatter.js';
+import { formatWorktreeStatus, printSuccess, printError, printWarning, printInfo, printSeparator, printDoubleSeparator, isWorktreeIdle } from '../../../src/utils/formatter.js';
 import { createWorktreeStatus } from '../../helpers/fixtures.js';
 
 describe('formatWorktreeStatus', () => {
@@ -38,6 +38,49 @@ describe('formatWorktreeStatus', () => {
   });
 });
 
+describe('isWorktreeIdle', () => {
+  it('全部为零且无未提交修改时返回 true', () => {
+    const status = createWorktreeStatus({ commitCount: 0, insertions: 0, deletions: 0, hasDirtyFiles: false });
+    expect(isWorktreeIdle(status)).toBe(true);
+  });
+
+  it('有提交时返回 false', () => {
+    const status = createWorktreeStatus({ commitCount: 1, insertions: 0, deletions: 0, hasDirtyFiles: false });
+    expect(isWorktreeIdle(status)).toBe(false);
+  });
+
+  it('有 insertions 时返回 false', () => {
+    const status = createWorktreeStatus({ commitCount: 0, insertions: 1, deletions: 0, hasDirtyFiles: false });
+    expect(isWorktreeIdle(status)).toBe(false);
+  });
+
+  it('有 deletions 时返回 false', () => {
+    const status = createWorktreeStatus({ commitCount: 0, insertions: 0, deletions: 1, hasDirtyFiles: false });
+    expect(isWorktreeIdle(status)).toBe(false);
+  });
+
+  it('有未提交修改时返回 false', () => {
+    const status = createWorktreeStatus({ commitCount: 0, insertions: 0, deletions: 0, hasDirtyFiles: true });
+    expect(isWorktreeIdle(status)).toBe(false);
+  });
+});
+
+describe('printSeparator', () => {
+  it('调用 console.log 输出分隔线', () => {
+    const spy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    printSeparator();
+    expect(spy).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('printDoubleSeparator', () => {
+  it('调用 console.log 输出粗分隔线', () => {
+    const spy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    printDoubleSeparator();
+    expect(spy).toHaveBeenCalledTimes(1);
+  });
+});
+
 describe('print 函数', () => {
   it('printSuccess 调用 console.log', () => {
     const spy = vi.spyOn(console, 'log').mockImplementation(() => {});

package/tests/unit/utils/git.test.ts

@@ -32,6 +32,8 @@ import {
   gitCommit,
   gitMerge,
   hasMergeConflict,
+  gitPull,
+  gitPush,
   gitResetHard,
   gitCleanForce,
   gitStashPush,
@@ -44,6 +46,7 @@ import {
   gitWorktreePrune,
   hasLocalCommits,
   getCommitCountAhead,
+  getCommitCountBehind,
   getDiffStat,
   gitDiffCachedBinary,
   gitApplyCachedFromStdin,
@@ -530,3 +533,44 @@ describe('gitApplyCachedCheck', () => {
     expect(gitApplyCachedCheck(patch, '/repo')).toBe(false);
   });
 });
+
+describe('gitPull', () => {
+  it('执行 git pull', () => {
+    gitPull('/repo');
+    expect(mockedExecCommand).toHaveBeenCalledWith('git pull', { cwd: '/repo' });
+  });
+
+  it('不传 cwd 时 cwd 为 undefined', () => {
+    gitPull();
+    expect(mockedExecCommand).toHaveBeenCalledWith('git pull', { cwd: undefined });
+  });
+});
+
+describe('gitPush', () => {
+  it('执行 git push', () => {
+    gitPush('/repo');
+    expect(mockedExecCommand).toHaveBeenCalledWith('git push', { cwd: '/repo' });
+  });
+
+  it('不传 cwd 时 cwd 为 undefined', () => {
+    gitPush();
+    expect(mockedExecCommand).toHaveBeenCalledWith('git push', { cwd: undefined });
+  });
+});
+
+describe('getCommitCountBehind', () => {
+  it('返回正确的落后提交数', () => {
+    mockedExecCommand.mockReturnValue('3');
+    expect(getCommitCountBehind('feature')).toBe(3);
+  });
+
+  it('返回 0 当输出无法解析', () => {
+    mockedExecCommand.mockReturnValue('');
+    expect(getCommitCountBehind('feature')).toBe(0);
+  });
+
+  it('命令失败时返回 0', () => {
+    mockedExecCommand.mockImplementation(() => { throw new Error('fail'); });
+    expect(getCommitCountBehind('feature')).toBe(0);
+  });
+});

package/tests/unit/utils/validate-snapshot.test.ts

@@ -39,6 +39,7 @@ import {
   writeSnapshot,
   removeSnapshot,
   removeProjectSnapshots,
+  getProjectSnapshotBranches,
 } from '../../../src/utils/validate-snapshot.js';
 
 const mockedExistsSync = vi.mocked(existsSync);
@@ -149,3 +150,27 @@ describe('removeProjectSnapshots', () => {
     expect(mockedUnlinkSync).not.toHaveBeenCalled();
   });
 });
+
+describe('getProjectSnapshotBranches', () => {
+  it('返回所有存在快照的分支名', () => {
+    mockedExistsSync.mockReturnValue(true);
+    // @ts-expect-error readdirSync 返回类型简化
+    mockedReaddirSync.mockReturnValue(['feat-a.tree', 'feat-a.head', 'feat-b.tree', 'feat-b.head']);
+    const result = getProjectSnapshotBranches('proj');
+    expect(result).toEqual(['feat-a', 'feat-b']);
+  });
+
+  it('没有 .tree 文件时返回空数组', () => {
+    mockedExistsSync.mockReturnValue(true);
+    // @ts-expect-error readdirSync 返回类型简化
+    mockedReaddirSync.mockReturnValue(['feat-a.head']);
+    const result = getProjectSnapshotBranches('proj');
+    expect(result).toEqual([]);
+  });
+
+  it('项目目录不存在时返回空数组', () => {
+    mockedExistsSync.mockReturnValue(false);
+    const result = getProjectSnapshotBranches('proj');
+    expect(result).toEqual([]);
+  });
+});

package/tests/unit/utils/worktree-matcher.test.ts

@@ -1,15 +1,18 @@
 import { describe, it, expect, vi } from 'vitest';
-import { findExactMatch, findFuzzyMatches, resolveTargetWorktree } from '../../../src/utils/worktree-matcher.js';
+import { findExactMatch, findFuzzyMatches, resolveTargetWorktree, resolveTargetWorktrees } from '../../../src/utils/worktree-matcher.js';
 import { createWorktreeInfo, createWorktreeList } from '../../helpers/fixtures.js';
 import { ClawtError } from '../../../src/errors/index.js';
-import type { WorktreeResolveMessages } from '../../../src/utils/worktree-matcher.js';
+import type { WorktreeResolveMessages, WorktreeMultiResolveMessages } from '../../../src/utils/worktree-matcher.js';
 
 // mock enquirer
 vi.mock('enquirer', () => ({
   default: {
-    Select: vi.fn().mockImplementation(({ choices }: { choices: Array<{ name: string }> }) => ({
-      run: vi.fn().mockResolvedValue(choices[0].name),
-    })),
+    Select: vi.fn().mockImplementation(function({ choices }: { choices: Array<{ name: string }> }) {
+      this.run = vi.fn().mockResolvedValue(choices[0].name);
+    }),
+    MultiSelect: vi.fn().mockImplementation(function({ choices }: { choices: Array<{ name: string }> }) {
+      this.run = vi.fn().mockResolvedValue(choices.map((c: { name: string }) => c.name));
+    }),
   },
 }));
 
@@ -114,3 +117,76 @@ describe('resolveTargetWorktree', () => {
     await expect(resolveTargetWorktree(worktrees, testMessages, 'xyz')).rejects.toThrow(ClawtError);
   });
 });
+
+/** 多选场景测试用消息配置 */
+const testMultiMessages: WorktreeMultiResolveMessages = {
+  noWorktrees: '无可用 worktree',
+  selectBranch: '请选择要移除的分支',
+  multipleMatches: (keyword: string) => `"${keyword}" 匹配到多个分支`,
+  noMatch: (keyword: string, branches: string[]) =>
+    `未找到匹配 "${keyword}"，可用：${branches.join(', ')}`,
+};
+
+describe('resolveTargetWorktrees', () => {
+  it('空列表抛出 ClawtError', async () => {
+    await expect(resolveTargetWorktrees([], testMultiMessages, 'any')).rejects.toThrow(ClawtError);
+    await expect(resolveTargetWorktrees([], testMultiMessages, 'any')).rejects.toThrow('无可用 worktree');
+  });
+
+  it('单个 worktree 且不传分支名时直接返回数组', async () => {
+    const worktrees = [createWorktreeInfo({ branch: 'only-one' })];
+    const result = await resolveTargetWorktrees(worktrees, testMultiMessages);
+    expect(result).toHaveLength(1);
+    expect(result[0].branch).toBe('only-one');
+  });
+
+  it('精确匹配优先，返回单元素数组', async () => {
+    const worktrees = [
+      createWorktreeInfo({ branch: 'feat' }),
+      createWorktreeInfo({ branch: 'feature' }),
+    ];
+    const result = await resolveTargetWorktrees(worktrees, testMultiMessages, 'feat');
+    expect(result).toHaveLength(1);
+    expect(result[0].branch).toBe('feat');
+  });
+
+  it('模糊匹配唯一结果直接返回单元素数组', async () => {
+    const worktrees = [
+      createWorktreeInfo({ branch: 'feature-login' }),
+      createWorktreeInfo({ branch: 'bugfix-auth' }),
+    ];
+    const result = await resolveTargetWorktrees(worktrees, testMultiMessages, 'login');
+    expect(result).toHaveLength(1);
+    expect(result[0].branch).toBe('feature-login');
+  });
+
+  it('模糊匹配多个结果时调用多选交互', async () => {
+    const worktrees = [
+      createWorktreeInfo({ branch: 'feature-login' }),
+      createWorktreeInfo({ branch: 'feature-logout' }),
+      createWorktreeInfo({ branch: 'bugfix-auth' }),
+    ];
+    const result = await resolveTargetWorktrees(worktrees, testMultiMessages, 'log');
+    // mock 的 MultiSelect 返回所有 choices，因此应返回匹配到的 2 个
+    expect(result).toHaveLength(2);
+    expect(result.map((w) => w.branch)).toEqual(['feature-login', 'feature-logout']);
+  });
+
+  it('不传分支名时多个 worktree 调用多选交互', async () => {
+    const worktrees = [
+      createWorktreeInfo({ branch: 'feature-a' }),
+      createWorktreeInfo({ branch: 'feature-b' }),
+    ];
+    const result = await resolveTargetWorktrees(worktrees, testMultiMessages);
+    // mock 的 MultiSelect 返回所有 choices
+    expect(result).toHaveLength(2);
+  });
+
+  it('无匹配抛出 ClawtError 并包含可用分支', async () => {
+    const worktrees = [
+      createWorktreeInfo({ branch: 'feature-a' }),
+      createWorktreeInfo({ branch: 'feature-b' }),
+    ];
+    await expect(resolveTargetWorktrees(worktrees, testMultiMessages, 'xyz')).rejects.toThrow(ClawtError);
+  });
+});