clawt 2.9.1 → 2.10.1

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

@@ -0,0 +1,323 @@
+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: {
+    MERGE_NO_WORKTREES: '没有可用的 worktree',
+    MERGE_SELECT_BRANCH: '选择要合并的分支',
+    MERGE_MULTIPLE_MATCHES: (keyword: string) => `找到多个匹配 "${keyword}" 的分支`,
+    MERGE_NO_MATCH: (keyword: string, branches: string[]) => `未找到匹配 "${keyword}" 的分支`,
+    MERGE_SQUASH_PROMPT: '是否压缩提交？',
+    MERGE_SQUASH_COMMITTED: (branch: string) => `已压缩提交: ${branch}`,
+    MERGE_SQUASH_PENDING: (path: string, branch: string) => `请手动提交: ${path}`,
+    MERGE_VALIDATE_STATE_HINT: (branch: string) => `分支 ${branch} 存在 validate 状态`,
+    MAIN_WORKTREE_DIRTY: '主 worktree 有未提交的更改',
+    TARGET_WORKTREE_DIRTY_NO_MESSAGE: '目标 worktree 有未提交修改，请提供 -m 参数',
+    TARGET_WORKTREE_NO_CHANGES: '没有可合并的变更',
+    MERGE_CONFLICT: '合并冲突',
+    PULL_CONFLICT: 'pull 冲突',
+    PUSH_FAILED: 'push 失败',
+    MERGE_SUCCESS: (branch: string, message: string, autoPullPush: boolean) => `合并成功: ${branch}`,
+    MERGE_SUCCESS_NO_MESSAGE: (branch: string, autoPullPush: boolean) => `合并成功: ${branch}`,
+    WORKTREE_CLEANED: (branch: string) => `已清理: ${branch}`,
+  },
+  AUTO_SAVE_COMMIT_MESSAGE: 'clawt:auto-save',
+}));
+
+vi.mock('../../../src/utils/index.js', () => ({
+  validateMainWorktree: vi.fn(),
+  getProjectName: vi.fn(),
+  getGitTopLevel: vi.fn(),
+  getProjectWorktrees: vi.fn(),
+  isWorkingDirClean: vi.fn(),
+  gitAddAll: vi.fn(),
+  gitCommit: vi.fn(),
+  gitMerge: vi.fn(),
+  hasMergeConflict: vi.fn(),
+  gitPull: vi.fn(),
+  gitPush: vi.fn(),
+  hasLocalCommits: vi.fn(),
+  hasSnapshot: vi.fn(),
+  removeSnapshot: vi.fn(),
+  printSuccess: vi.fn(),
+  printInfo: vi.fn(),
+  printWarning: vi.fn(),
+  getConfigValue: vi.fn(),
+  confirmAction: vi.fn(),
+  cleanupWorktrees: vi.fn(),
+  hasCommitWithMessage: vi.fn(),
+  gitMergeBase: vi.fn(),
+  gitResetSoftTo: vi.fn(),
+  getCurrentBranch: vi.fn(),
+  resolveTargetWorktree: vi.fn(),
+}));
+
+import { registerMergeCommand } from '../../../src/commands/merge.js';
+import {
+  getProjectName,
+  getGitTopLevel,
+  getProjectWorktrees,
+  isWorkingDirClean,
+  gitAddAll,
+  gitCommit,
+  gitMerge,
+  hasMergeConflict,
+  gitPull,
+  gitPush,
+  hasLocalCommits,
+  hasSnapshot,
+  removeSnapshot,
+  printSuccess,
+  printWarning,
+  getConfigValue,
+  confirmAction,
+  cleanupWorktrees,
+  hasCommitWithMessage,
+  resolveTargetWorktree,
+} from '../../../src/utils/index.js';
+
+const mockedGetProjectName = vi.mocked(getProjectName);
+const mockedGetGitTopLevel = vi.mocked(getGitTopLevel);
+const mockedGetProjectWorktrees = vi.mocked(getProjectWorktrees);
+const mockedIsWorkingDirClean = vi.mocked(isWorkingDirClean);
+const mockedGitAddAll = vi.mocked(gitAddAll);
+const mockedGitCommit = vi.mocked(gitCommit);
+const mockedGitMerge = vi.mocked(gitMerge);
+const mockedHasMergeConflict = vi.mocked(hasMergeConflict);
+const mockedGitPull = vi.mocked(gitPull);
+const mockedGitPush = vi.mocked(gitPush);
+const mockedHasLocalCommits = vi.mocked(hasLocalCommits);
+const mockedHasSnapshot = vi.mocked(hasSnapshot);
+const mockedRemoveSnapshot = vi.mocked(removeSnapshot);
+const mockedPrintSuccess = vi.mocked(printSuccess);
+const mockedPrintWarning = vi.mocked(printWarning);
+const mockedGetConfigValue = vi.mocked(getConfigValue);
+const mockedConfirmAction = vi.mocked(confirmAction);
+const mockedCleanupWorktrees = vi.mocked(cleanupWorktrees);
+const mockedHasCommitWithMessage = vi.mocked(hasCommitWithMessage);
+const mockedResolveTargetWorktree = vi.mocked(resolveTargetWorktree);
+
+const worktree = { path: '/path/feature', branch: 'feature' };
+
+beforeEach(() => {
+  mockedGetGitTopLevel.mockReturnValue('/repo');
+  mockedGetProjectName.mockReturnValue('test-project');
+  mockedGetProjectWorktrees.mockReturnValue([worktree]);
+  mockedResolveTargetWorktree.mockResolvedValue(worktree);
+  mockedHasCommitWithMessage.mockReturnValue(false);
+  // 显式重置所有可能泄漏的 mock
+  mockedHasMergeConflict.mockReset();
+  mockedHasMergeConflict.mockReturnValue(false);
+  mockedHasSnapshot.mockReturnValue(false);
+  mockedGetConfigValue.mockReturnValue(false); // autoPullPush, autoDeleteBranch
+  mockedConfirmAction.mockResolvedValue(false);
+  mockedGitMerge.mockReset();
+  mockedGitPull.mockReset();
+  mockedGitPush.mockReset();
+  mockedIsWorkingDirClean.mockReset();
+  mockedHasLocalCommits.mockReset();
+  mockedPrintSuccess.mockReset();
+  mockedPrintWarning.mockReset();
+  mockedRemoveSnapshot.mockReset();
+  mockedCleanupWorktrees.mockReset();
+});
+
+describe('registerMergeCommand', () => {
+  it('注册 merge 命令', () => {
+    const program = new Command();
+    registerMergeCommand(program);
+    const cmd = program.commands.find((c) => c.name() === 'merge');
+    expect(cmd).toBeDefined();
+  });
+});
+
+describe('handleMerge', () => {
+  it('主 worktree 不干净时抛出错误', async () => {
+    mockedIsWorkingDirClean.mockReturnValue(false);
+
+    const program = new Command();
+    program.exitOverride();
+    registerMergeCommand(program);
+
+    await expect(
+      program.parseAsync(['merge', '-b', 'feature'], { from: 'user' }),
+    ).rejects.toThrow();
+  });
+
+  it('目标 worktree 有未提交修改但未提供 -m 时抛出', async () => {
+    mockedIsWorkingDirClean
+      .mockReturnValueOnce(true) // 主 worktree 干净
+      .mockReturnValueOnce(false); // 目标 worktree 不干净
+
+    const program = new Command();
+    program.exitOverride();
+    registerMergeCommand(program);
+
+    await expect(
+      program.parseAsync(['merge', '-b', 'feature'], { from: 'user' }),
+    ).rejects.toThrow();
+  });
+
+  it('目标 worktree 有未提交修改且提供 -m 时先提交再合并', async () => {
+    mockedIsWorkingDirClean
+      .mockReturnValueOnce(true)   // 主 worktree 干净
+      .mockReturnValueOnce(false); // 目标 worktree 不干净
+    mockedConfirmAction.mockResolvedValue(false); // 不清理
+
+    const program = new Command();
+    program.exitOverride();
+    registerMergeCommand(program);
+    await program.parseAsync(['merge', '-b', 'feature', '-m', 'test commit'], { from: 'user' });
+
+    expect(mockedGitAddAll).toHaveBeenCalledWith('/path/feature');
+    expect(mockedGitCommit).toHaveBeenCalledWith('test commit', '/path/feature');
+    expect(mockedGitMerge).toHaveBeenCalledWith('feature', '/repo');
+    expect(mockedPrintSuccess).toHaveBeenCalled();
+  });
+
+  it('目标 worktree 干净但无本地提交时抛出', async () => {
+    mockedIsWorkingDirClean.mockReturnValue(true);
+    mockedHasLocalCommits.mockReturnValue(false);
+
+    const program = new Command();
+    program.exitOverride();
+    registerMergeCommand(program);
+
+    await expect(
+      program.parseAsync(['merge', '-b', 'feature'], { from: 'user' }),
+    ).rejects.toThrow();
+  });
+
+  it('目标 worktree 干净且有本地提交时直接合并', async () => {
+    mockedIsWorkingDirClean.mockReturnValue(true);
+    mockedHasLocalCommits.mockReturnValue(true);
+    mockedConfirmAction.mockResolvedValue(false);
+
+    const program = new Command();
+    program.exitOverride();
+    registerMergeCommand(program);
+    await program.parseAsync(['merge', '-b', 'feature'], { from: 'user' });
+
+    expect(mockedGitMerge).toHaveBeenCalledWith('feature', '/repo');
+    expect(mockedPrintSuccess).toHaveBeenCalled();
+  });
+
+  it('合并冲突时抛出错误', async () => {
+    mockedIsWorkingDirClean.mockReturnValue(true);
+    mockedHasLocalCommits.mockReturnValue(true);
+    mockedGitMerge.mockImplementation(() => { throw new Error('merge conflict'); });
+    mockedHasMergeConflict.mockReturnValue(true);
+
+    const program = new Command();
+    program.exitOverride();
+    registerMergeCommand(program);
+
+    await expect(
+      program.parseAsync(['merge', '-b', 'feature'], { from: 'user' }),
+    ).rejects.toThrow();
+  });
+
+  it('autoPullPush=true 时执行 pull 和 push', async () => {
+    mockedIsWorkingDirClean.mockReturnValue(true);
+    mockedHasLocalCommits.mockReturnValue(true);
+    mockedGetConfigValue.mockImplementation((key: string) => {
+      if (key === 'autoPullPush') return true;
+      if (key === 'autoDeleteBranch') return false;
+      return false;
+    });
+    mockedConfirmAction.mockResolvedValue(false);
+
+    const program = new Command();
+    program.exitOverride();
+    registerMergeCommand(program);
+    await program.parseAsync(['merge', '-b', 'feature'], { from: 'user' });
+
+    expect(mockedGitPull).toHaveBeenCalledWith('/repo');
+    expect(mockedGitPush).toHaveBeenCalledWith('/repo');
+  });
+
+  it('autoDeleteBranch=true 时自动清理', async () => {
+    mockedIsWorkingDirClean.mockReturnValue(true);
+    mockedHasLocalCommits.mockReturnValue(true);
+    mockedGetConfigValue.mockImplementation((key: string) => {
+      if (key === 'autoPullPush') return false;
+      if (key === 'autoDeleteBranch') return true;
+      return false;
+    });
+
+    const program = new Command();
+    program.exitOverride();
+    registerMergeCommand(program);
+    await program.parseAsync(['merge', '-b', 'feature'], { from: 'user' });
+
+    expect(mockedCleanupWorktrees).toHaveBeenCalled();
+  });
+
+  it('merge 成功后清理 validate 快照', async () => {
+    mockedIsWorkingDirClean.mockReturnValue(true);
+    mockedHasLocalCommits.mockReturnValue(true);
+    mockedHasSnapshot.mockReturnValue(true);
+    mockedConfirmAction.mockResolvedValue(false);
+
+    const program = new Command();
+    program.exitOverride();
+    registerMergeCommand(program);
+    await program.parseAsync(['merge', '-b', 'feature'], { from: 'user' });
+
+    expect(mockedRemoveSnapshot).toHaveBeenCalledWith('test-project', 'feature');
+  });
+
+  it('pull 冲突时输出警告', async () => {
+    mockedIsWorkingDirClean.mockReturnValue(true);
+    mockedHasLocalCommits.mockReturnValue(true);
+    mockedGetConfigValue.mockImplementation((key: string) => {
+      if (key === 'autoPullPush') return true;
+      return false;
+    });
+    mockedGitPull.mockImplementation(() => { throw new Error('pull failed'); });
+    // merge 成功后的调用顺序：
+    // 1. 步骤 6 二次确认 hasMergeConflict → false
+    // 2. pull catch 中 hasMergeConflict → true（触发 printWarning 并 return）
+    mockedHasMergeConflict.mockReturnValueOnce(false)
+      .mockReturnValueOnce(true);
+
+    const program = new Command();
+    program.exitOverride();
+    registerMergeCommand(program);
+    await program.parseAsync(['merge', '-b', 'feature'], { from: 'user' });
+
+    expect(mockedPrintWarning).toHaveBeenCalled();
+  });
+
+  it('push 失败时输出警告', async () => {
+    mockedIsWorkingDirClean.mockReturnValue(true);
+    mockedHasLocalCommits.mockReturnValue(true);
+    mockedGetConfigValue.mockImplementation((key: string) => {
+      if (key === 'autoPullPush') return true;
+      return false;
+    });
+    mockedGitPush.mockImplementation(() => { throw new Error('push failed'); });
+    mockedConfirmAction.mockResolvedValue(false);
+
+    const program = new Command();
+    program.exitOverride();
+    registerMergeCommand(program);
+    await program.parseAsync(['merge', '-b', 'feature'], { from: 'user' });
+
+    expect(mockedPrintWarning).toHaveBeenCalled();
+  });
+});

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