clawt 2.14.0 → 2.15.0

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

@@ -2,15 +2,17 @@ import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { Command } from 'commander';
 
 // mock enquirer（必须在所有 import 之前）
-const { mockSelectRun, mockInputRun } = vi.hoisted(() => {
+const { mockSelectRun, mockInputRun, mockSelectConstructorArgs } = vi.hoisted(() => {
   const mockSelectRun = vi.fn();
   const mockInputRun = vi.fn();
-  return { mockSelectRun, mockInputRun };
+  /** 用于捕获 Select 构造时传入的参数 */
+  const mockSelectConstructorArgs: unknown[] = [];
+  return { mockSelectRun, mockInputRun, mockSelectConstructorArgs };
 });
 
 vi.mock('enquirer', () => ({
   default: {
-    Select: function MockSelect() { return { run: mockSelectRun }; },
+    Select: function MockSelect(opts: unknown) { mockSelectConstructorArgs.push(opts); return { run: mockSelectRun }; },
     Input: function MockInput() { return { run: mockInputRun }; },
   },
 }));
@@ -48,6 +50,7 @@ vi.mock('../../../src/constants/index.js', () => ({
     confirmDestructiveOps: true,
     maxConcurrency: 0,
     terminalApp: 'auto',
+    aliases: {},
   },
   CONFIG_DESCRIPTIONS: {
     autoDeleteBranch: '自动删除分支',
@@ -56,6 +59,7 @@ vi.mock('../../../src/constants/index.js', () => ({
     confirmDestructiveOps: '破坏性操作确认',
     maxConcurrency: '最大并发数',
     terminalApp: '终端应用',
+    aliases: '命令别名映射',
   },
   CONFIG_DEFINITIONS: {
     autoDeleteBranch: { defaultValue: false, description: '自动删除分支' },
@@ -64,7 +68,9 @@ vi.mock('../../../src/constants/index.js', () => ({
     confirmDestructiveOps: { defaultValue: true, description: '破坏性操作确认' },
     maxConcurrency: { defaultValue: 0, description: '最大并发数' },
     terminalApp: { defaultValue: 'auto', description: '终端应用', allowedValues: ['auto', 'iterm2', 'terminal'] },
+    aliases: { defaultValue: {}, description: '命令别名映射' },
   },
+  CONFIG_ALIAS_DISABLED_HINT: '(通过 clawt alias 命令管理)',
   MESSAGES: {
     CONFIG_RESET_SUCCESS: '配置已恢复为默认值',
     DESTRUCTIVE_OP_CANCELLED: '已取消操作',
@@ -104,6 +110,7 @@ function createMockConfig() {
     confirmDestructiveOps: true,
     maxConcurrency: 0,
     terminalApp: 'auto',
+    aliases: {},
   };
 }
 
@@ -117,6 +124,7 @@ beforeEach(() => {
   mockedConfirmDestructiveAction.mockReset();
   mockSelectRun.mockReset();
   mockInputRun.mockReset();
+  mockSelectConstructorArgs.length = 0;
 });
 
 describe('registerConfigCommand', () => {
@@ -374,6 +382,29 @@ describe('handleConfigSet — 交互模式', () => {
     );
     expect(mockedPrintSuccess).toHaveBeenCalled();
   });
+
+  it('aliases 选项带 disabled 属性且不可选', async () => {
+    mockedLoadConfig.mockReturnValue(createMockConfig());
+    // 选择一个普通配置项完成交互流程
+    mockSelectRun.mockResolvedValueOnce('autoDeleteBranch');
+    mockSelectRun.mockResolvedValueOnce('true');
+
+    const program = new Command();
+    program.exitOverride();
+    registerConfigCommand(program);
+    await program.parseAsync(['config', 'set'], { from: 'user' });
+
+    // 捕获第一次 Select 构造参数（配置项选择列表）
+    const selectOpts = mockSelectConstructorArgs[0] as { choices: Array<{ name: string; disabled?: string }> };
+    const aliasesChoice = selectOpts.choices.find((c) => c.name === 'aliases');
+    expect(aliasesChoice).toBeDefined();
+    expect(aliasesChoice!.disabled).toBe('(通过 clawt alias 命令管理)');
+
+    // 普通配置项不应有 disabled 属性
+    const normalChoice = selectOpts.choices.find((c) => c.name === 'autoDeleteBranch');
+    expect(normalChoice).toBeDefined();
+    expect(normalChoice!.disabled).toBeUndefined();
+  });
 });
 
 describe('handleConfigGet', () => {

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

@@ -19,7 +19,7 @@ vi.mock('../../../src/utils/index.js', () => ({
   validateClaudeCodeInstalled: vi.fn(),
   getProjectWorktrees: vi.fn(),
   launchInteractiveClaude: vi.fn(),
-  resolveTargetWorktree: vi.fn(),
+  resolveTargetWorktrees: vi.fn(),
 }));
 
 import { registerResumeCommand } from '../../../src/commands/resume.js';
@@ -28,21 +28,21 @@ import {
   validateClaudeCodeInstalled,
   getProjectWorktrees,
   launchInteractiveClaude,
-  resolveTargetWorktree,
+  resolveTargetWorktrees,
 } 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);
+const mockedResolveTargetWorktrees = vi.mocked(resolveTargetWorktrees);
 
 beforeEach(() => {
   mockedValidateMainWorktree.mockReset();
   mockedValidateClaudeCodeInstalled.mockReset();
   mockedGetProjectWorktrees.mockReset();
   mockedLaunchInteractiveClaude.mockReset();
-  mockedResolveTargetWorktree.mockReset();
+  mockedResolveTargetWorktrees.mockReset();
 });
 
 describe('registerResumeCommand', () => {
@@ -58,7 +58,7 @@ describe('handleResume', () => {
   it('成功恢复 Claude Code 会话', async () => {
     const worktree = { path: '/path/feature', branch: 'feature' };
     mockedGetProjectWorktrees.mockReturnValue([worktree]);
-    mockedResolveTargetWorktree.mockResolvedValue(worktree);
+    mockedResolveTargetWorktrees.mockResolvedValue([worktree]);
 
     const program = new Command();
     program.exitOverride();
@@ -67,14 +67,14 @@ describe('handleResume', () => {
 
     expect(mockedValidateMainWorktree).toHaveBeenCalled();
     expect(mockedValidateClaudeCodeInstalled).toHaveBeenCalled();
-    expect(mockedResolveTargetWorktree).toHaveBeenCalled();
+    expect(mockedResolveTargetWorktrees).toHaveBeenCalled();
     expect(mockedLaunchInteractiveClaude).toHaveBeenCalledWith(worktree, { autoContinue: true });
   });
 
-  it('不传 -b 时也能调用 resolveTargetWorktree', async () => {
+  it('不传 -b 时也能调用 resolveTargetWorktrees', async () => {
     const worktree = { path: '/path/feature', branch: 'feature' };
     mockedGetProjectWorktrees.mockReturnValue([worktree]);
-    mockedResolveTargetWorktree.mockResolvedValue(worktree);
+    mockedResolveTargetWorktrees.mockResolvedValue([worktree]);
 
     const program = new Command();
     program.exitOverride();
@@ -82,7 +82,7 @@ describe('handleResume', () => {
     await program.parseAsync(['resume'], { from: 'user' });
 
     // branchName 参数为 undefined
-    expect(mockedResolveTargetWorktree).toHaveBeenCalledWith(
+    expect(mockedResolveTargetWorktrees).toHaveBeenCalledWith(
       expect.any(Array),
       expect.any(Object),
       undefined,

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

@@ -31,6 +31,14 @@ vi.mock('../../../src/constants/index.js', () => ({
     BRANCH_OR_FILE_REQUIRED: '请指定 -b 或 -f',
     TASK_FILE_LOADED: (count: number, path: string) => `✓ 从 ${path} 加载了 ${count} 个任务`,
     TASK_FILE_MISSING_TASK_BY_INDEX: (blockIndex: number) => `第 ${blockIndex} 个任务块缺少任务描述`,
+    DRY_RUN_TITLE: 'Dry Run 预览',
+    DRY_RUN_TASK_COUNT: (count: number) => `任务数: ${count}`,
+    DRY_RUN_CONCURRENCY: (concurrency: number) => `并发数: ${concurrency === 0 ? '不限制' : concurrency}`,
+    DRY_RUN_WORKTREE_DIR: (dir: string) => `Worktree 目录: ${dir}`,
+    DRY_RUN_BRANCH_EXISTS_WARNING: (name: string) => `分支 ${name} 已存在`,
+    DRY_RUN_INTERACTIVE_MODE: '模式: 交互式（无预设任务）',
+    DRY_RUN_READY: '预览完成，无冲突。移除 --dry-run 即可正式执行。',
+    DRY_RUN_HAS_CONFLICT: '存在分支冲突，实际执行时将会报错。请先处理冲突的分支。',
   },
 }));
 
@@ -46,8 +54,11 @@ vi.mock('../../../src/utils/index.js', async (importOriginal) => {
     validateClaudeCodeInstalled: vi.fn(),
     createWorktrees: vi.fn(),
     sanitizeBranchName: vi.fn(),
+    generateBranchNames: vi.fn(),
     checkBranchExists: vi.fn(),
     getConfigValue: vi.fn().mockReturnValue(0),
+    parseConcurrency: vi.fn().mockReturnValue(0),
+    getProjectWorktreeDir: vi.fn().mockReturnValue('/mock/.clawt/worktrees/test-project'),
     printSuccess: vi.fn(),
     printError: vi.fn(),
     printWarning: vi.fn(),
@@ -57,7 +68,9 @@ vi.mock('../../../src/utils/index.js', async (importOriginal) => {
     confirmAction: vi.fn(),
     launchInteractiveClaude: vi.fn(),
     loadTaskFile: vi.fn(),
+    parseTasksFromOptions: vi.fn(),
     createWorktreesByBranches: vi.fn(),
+    printDryRunPreview: vi.fn(),
   };
 });
 
@@ -80,6 +93,7 @@ vi.mock('../../../src/utils/worktree.js', () => ({
 
 vi.mock('../../../src/utils/config.js', () => ({
   getConfigValue: vi.fn().mockReturnValue(0),
+  parseConcurrency: vi.fn().mockReturnValue(0),
   loadConfig: vi.fn(),
   writeDefaultConfig: vi.fn(),
   ensureClawtDirs: vi.fn(),
@@ -110,30 +124,45 @@ vi.mock('../../../src/utils/progress.js', () => ({
   },
 }));
 
+vi.mock('../../../src/utils/dry-run.js', () => ({
+  truncateTaskDesc: vi.fn(),
+  printDryRunPreview: vi.fn(),
+}));
+
 import { registerRunCommand } from '../../../src/commands/run.js';
 import {
   createWorktrees,
   createWorktreesByBranches,
   sanitizeBranchName,
+  generateBranchNames,
   checkBranchExists,
+  parseConcurrency,
   printSuccess,
+  printDryRunPreview,
   launchInteractiveClaude,
   getConfigValue,
   loadTaskFile,
+  parseTasksFromOptions,
+  validateClaudeCodeInstalled,
 } from '../../../src/utils/index.js';
 import { spawnProcess } from '../../../src/utils/shell.js';
-import { printInfo } from '../../../src/utils/formatter.js';
+import { printInfo as formatterPrintInfo } from '../../../src/utils/formatter.js';
 
 const mockedCreateWorktrees = vi.mocked(createWorktrees);
 const mockedCreateWorktreesByBranches = vi.mocked(createWorktreesByBranches);
 const mockedSanitizeBranchName = vi.mocked(sanitizeBranchName);
+const mockedGenerateBranchNames = vi.mocked(generateBranchNames);
 const mockedCheckBranchExists = vi.mocked(checkBranchExists);
+const mockedParseConcurrency = vi.mocked(parseConcurrency);
 const mockedSpawnProcess = vi.mocked(spawnProcess);
 const mockedPrintSuccess = vi.mocked(printSuccess);
-const mockedPrintInfo = vi.mocked(printInfo);
+const mockedPrintDryRunPreview = vi.mocked(printDryRunPreview);
+const mockedFormatterPrintInfo = vi.mocked(formatterPrintInfo);
 const mockedLaunchInteractiveClaude = vi.mocked(launchInteractiveClaude);
 const mockedGetConfigValue = vi.mocked(getConfigValue);
 const mockedLoadTaskFile = vi.mocked(loadTaskFile);
+const mockedParseTasksFromOptions = vi.mocked(parseTasksFromOptions);
+const mockedValidateClaudeCodeInstalled = vi.mocked(validateClaudeCodeInstalled);
 
 /**
  * 创建模拟子进程
@@ -166,16 +195,33 @@ beforeEach(() => {
   mockedCreateWorktrees.mockReset();
   mockedCreateWorktreesByBranches.mockReset();
   mockedSanitizeBranchName.mockReset();
+  mockedGenerateBranchNames.mockReset();
   mockedCheckBranchExists.mockReset();
+  mockedParseConcurrency.mockReset();
+  mockedParseConcurrency.mockReturnValue(0);
   mockedSpawnProcess.mockReset();
   mockedPrintSuccess.mockReset();
-  mockedPrintInfo.mockReset();
+  mockedPrintDryRunPreview.mockReset();
+  mockedFormatterPrintInfo.mockReset();
   mockedLaunchInteractiveClaude.mockReset();
   mockedGetConfigValue.mockReset();
   mockedGetConfigValue.mockReturnValue(0 as any);
   mockedLoadTaskFile.mockReset();
+  mockedParseTasksFromOptions.mockReset();
+  mockedValidateClaudeCodeInstalled.mockReset();
   // sanitizeBranchName 默认返回输入值
   mockedSanitizeBranchName.mockImplementation((name: string) => name);
+  // generateBranchNames 默认使用真实逻辑
+  mockedGenerateBranchNames.mockImplementation((name: string, count: number) => {
+    if (count === 1) return [name];
+    return Array.from({ length: count }, (_, i) => `${name}-${i + 1}`);
+  });
+  // parseTasksFromOptions 默认使用真实逻辑
+  mockedParseTasksFromOptions.mockImplementation((rawTasks: string[]) => {
+    const tasks = rawTasks.map((t) => t.trim()).filter(Boolean);
+    if (tasks.length === 0) throw new Error('任务列表不能为空');
+    return tasks;
+  });
 });
 
 describe('registerRunCommand', () => {
@@ -285,6 +331,7 @@ describe('handleRun', () => {
   });
 
   it('传 --concurrency 限制并发数', async () => {
+    mockedParseConcurrency.mockReturnValue(1);
     const worktrees = [
       { path: '/path/feat-1', branch: 'feat-1' },
       { path: '/path/feat-2', branch: 'feat-2' },
@@ -311,7 +358,7 @@ describe('handleRun', () => {
     // 所有任务都应执行完毕
     expect(mockedSpawnProcess).toHaveBeenCalledTimes(3);
     // 应输出并发限制提示
-    expect(mockedPrintInfo).toHaveBeenCalledWith(expect.stringContaining('并发限制'));
+    expect(mockedFormatterPrintInfo).toHaveBeenCalledWith(expect.stringContaining('并发限制'));
   });
 
   it('--concurrency 为 0 时不限制并发', async () => {
@@ -336,12 +383,13 @@ describe('handleRun', () => {
     await program.parseAsync(['run', '-b', 'feat', '--tasks', 'task1', 'task2', '-c', '0'], { from: 'user' });
 
     // 不限制并发时不输出并发限制提示
-    expect(mockedPrintInfo).not.toHaveBeenCalledWith(expect.stringContaining('并发限制'));
+    expect(mockedFormatterPrintInfo).not.toHaveBeenCalledWith(expect.stringContaining('并发限制'));
     expect(mockedSpawnProcess).toHaveBeenCalledTimes(2);
   });
 
   it('未传 -c 时使用全局配置的 maxConcurrency', async () => {
     mockedGetConfigValue.mockReturnValue(2 as any);
+    mockedParseConcurrency.mockReturnValue(2);
 
     const worktrees = [
       { path: '/path/feat-1', branch: 'feat-1' },
@@ -366,7 +414,7 @@ describe('handleRun', () => {
     await program.parseAsync(['run', '-b', 'feat', '--tasks', 'task1', 'task2', 'task3'], { from: 'user' });
 
     // 应输出并发限制提示（使用配置值 2）
-    expect(mockedPrintInfo).toHaveBeenCalledWith(expect.stringContaining('并发限制'));
+    expect(mockedFormatterPrintInfo).toHaveBeenCalledWith(expect.stringContaining('并发限制'));
     expect(mockedSpawnProcess).toHaveBeenCalledTimes(3);
   });
 
@@ -454,3 +502,109 @@ describe('handleRun', () => {
     ).rejects.toThrow();
   });
 });
+
+describe('handleRun --dry-run', () => {
+  it('--dry-run + --tasks 展示任务预览，不创建 worktree 也不启动 Claude Code', async () => {
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+    await program.parseAsync(['run', '-b', 'feat', '--tasks', '实现登录功能', '修复首页bug', '--dry-run'], { from: 'user' });
+
+    // 不创建 worktree
+    expect(mockedCreateWorktrees).not.toHaveBeenCalled();
+    expect(mockedCreateWorktreesByBranches).not.toHaveBeenCalled();
+    // 不启动 Claude Code
+    expect(mockedLaunchInteractiveClaude).not.toHaveBeenCalled();
+    expect(mockedSpawnProcess).not.toHaveBeenCalled();
+    // 应调用 generateBranchNames 生成分支名
+    expect(mockedGenerateBranchNames).toHaveBeenCalledWith('feat', 2);
+    // 应调用 printDryRunPreview 输出预览
+    expect(mockedPrintDryRunPreview).toHaveBeenCalledWith(['feat-1', 'feat-2'], ['实现登录功能', '修复首页bug'], 0);
+  });
+
+  it('--dry-run 不调用 validateClaudeCodeInstalled', async () => {
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+    await program.parseAsync(['run', '-b', 'feat', '--tasks', 'task1', '--dry-run'], { from: 'user' });
+
+    expect(mockedValidateClaudeCodeInstalled).not.toHaveBeenCalled();
+  });
+
+  it('--dry-run 交互式模式展示单个 worktree 信息', async () => {
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+    await program.parseAsync(['run', '-b', 'feat', '--dry-run'], { from: 'user' });
+
+    // 不创建 worktree
+    expect(mockedCreateWorktrees).not.toHaveBeenCalled();
+    // 不启动 Claude Code
+    expect(mockedLaunchInteractiveClaude).not.toHaveBeenCalled();
+    // 交互式模式：分支名列表为单个，任务为空数组
+    expect(mockedPrintDryRunPreview).toHaveBeenCalledWith(['feat'], [], 0);
+  });
+
+  it('--dry-run + -f 从任务文件展示预览', async () => {
+    mockedLoadTaskFile.mockReturnValue([
+      { branch: 'feat-login', task: '实现登录功能' },
+      { branch: 'fix-bug', task: '修复问题' },
+    ]);
+
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+    await program.parseAsync(['run', '-f', 'tasks.md', '--dry-run'], { from: 'user' });
+
+    // 应加载任务文件
+    expect(mockedLoadTaskFile).toHaveBeenCalledWith('tasks.md', { branchRequired: true });
+    // 不创建 worktree
+    expect(mockedCreateWorktrees).not.toHaveBeenCalled();
+    expect(mockedCreateWorktreesByBranches).not.toHaveBeenCalled();
+    // 不启动 Claude Code
+    expect(mockedSpawnProcess).not.toHaveBeenCalled();
+    // 应调用 printDryRunPreview
+    expect(mockedPrintDryRunPreview).toHaveBeenCalledWith(
+      ['feat-login', 'fix-bug'],
+      ['实现登录功能', '修复问题'],
+      0,
+    );
+  });
+
+  it('--dry-run + -f + -b 模式使用 -b 自动编号', async () => {
+    mockedLoadTaskFile.mockReturnValue([
+      { task: '任务1' },
+      { task: '任务2' },
+    ]);
+
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+    await program.parseAsync(['run', '-b', 'feat', '-f', 'tasks.md', '--dry-run'], { from: 'user' });
+
+    // 应使用 generateBranchNames 自动编号
+    expect(mockedGenerateBranchNames).toHaveBeenCalledWith('feat', 2);
+    // 不实际创建 worktree
+    expect(mockedCreateWorktrees).not.toHaveBeenCalled();
+    // 应调用 printDryRunPreview
+    expect(mockedPrintDryRunPreview).toHaveBeenCalled();
+  });
+
+  it('--dry-run 传递并发配置给 printDryRunPreview', async () => {
+    mockedParseConcurrency.mockReturnValue(3);
+
+    const program = new Command();
+    program.exitOverride();
+    registerRunCommand(program);
+    await program.parseAsync(['run', '-b', 'feat', '--tasks', 'task1', 'task2', '-c', '3', '--dry-run'], { from: 'user' });
+
+    // 不创建 worktree
+    expect(mockedCreateWorktrees).not.toHaveBeenCalled();
+    // 应将并发数传递给 printDryRunPreview
+    expect(mockedPrintDryRunPreview).toHaveBeenCalledWith(
+      expect.any(Array),
+      expect.any(Array),
+      3,
+    );
+  });
+});

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

@@ -12,7 +12,6 @@ describe('MESSAGES', () => {
       'TARGET_WORKTREE_CLEAN',
       'MERGE_CONFLICT',
       'COMMIT_MESSAGE_REQUIRED',
-      'TARGET_WORKTREE_DIRTY_NO_MESSAGE',
       'TARGET_WORKTREE_NO_CHANGES',
       'INTERRUPTED',
       'INTERRUPT_CONFIRM_CLEANUP',
@@ -49,6 +48,11 @@ describe('MESSAGES', () => {
   });
 
   describe('模板函数消息', () => {
+    it('TARGET_WORKTREE_DIRTY_NO_MESSAGE 包含 worktree 路径', () => {
+      const result = MESSAGES.TARGET_WORKTREE_DIRTY_NO_MESSAGE('/path/to/wt');
+      expect(result).toContain('/path/to/wt');
+    });
+
     it('BRANCH_EXISTS 包含分支名', () => {
       const result = MESSAGES.BRANCH_EXISTS('feature-a');
       expect(result).toContain('feature-a');

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

@@ -18,7 +18,7 @@ vi.mock('../../../src/utils/fs.js', () => ({
 }));
 
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { loadConfig, getConfigValue, writeDefaultConfig, writeConfig, saveConfig, ensureClawtDirs } from '../../../src/utils/config.js';
+import { loadConfig, getConfigValue, writeDefaultConfig, writeConfig, saveConfig, ensureClawtDirs, parseConcurrency } from '../../../src/utils/config.js';
 import { DEFAULT_CONFIG } from '../../../src/constants/index.js';
 import { ensureDir } from '../../../src/utils/fs.js';
 
@@ -96,6 +96,28 @@ describe('ensureClawtDirs', () => {
   });
 });
 
+describe('parseConcurrency', () => {
+  it('命令行参数 undefined 时返回配置值', () => {
+    expect(parseConcurrency(undefined, 5)).toBe(5);
+  });
+
+  it('命令行参数为有效正整数时返回解析值', () => {
+    expect(parseConcurrency('3', 0)).toBe(3);
+  });
+
+  it('命令行参数为 0 时返回 0（不限制）', () => {
+    expect(parseConcurrency('0', 5)).toBe(0);
+  });
+
+  it('命令行参数为负数时抛出错误', () => {
+    expect(() => parseConcurrency('-1', 0)).toThrow();
+  });
+
+  it('命令行参数为非数字时抛出错误', () => {
+    expect(() => parseConcurrency('abc', 0)).toThrow();
+  });
+});
+
 describe('saveConfig', () => {
   it('将配置对象写入配置文件', () => {
     const customConfig = { ...DEFAULT_CONFIG, autoDeleteBranch: true };

package/tests/unit/utils/dry-run.test.ts

@@ -0,0 +1,124 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('../../../src/constants/index.js', () => ({
+  MESSAGES: {
+    DRY_RUN_TITLE: 'Dry Run 预览',
+    DRY_RUN_TASK_COUNT: (count: number) => `任务数: ${count}`,
+    DRY_RUN_CONCURRENCY: (concurrency: number) => `并发数: ${concurrency === 0 ? '不限制' : concurrency}`,
+    DRY_RUN_WORKTREE_DIR: (dir: string) => `Worktree: ${dir}`,
+    DRY_RUN_BRANCH_EXISTS_WARNING: (name: string) => `分支 ${name} 已存在`,
+    DRY_RUN_INTERACTIVE_MODE: '模式: 交互式（无预设任务）',
+    DRY_RUN_READY: '预览完成，无冲突。移除 --dry-run 即可正式执行。',
+    DRY_RUN_HAS_CONFLICT: '存在分支冲突，实际执行时将会报错。请先处理冲突的分支。',
+  },
+}));
+
+vi.mock('../../../src/utils/git.js', () => ({
+  checkBranchExists: vi.fn(),
+}));
+
+vi.mock('../../../src/utils/worktree.js', () => ({
+  getProjectWorktreeDir: vi.fn().mockReturnValue('/mock/.clawt/worktrees/test-project'),
+}));
+
+vi.mock('../../../src/utils/formatter.js', () => ({
+  printInfo: vi.fn(),
+  printDoubleSeparator: vi.fn(),
+  printSeparator: vi.fn(),
+}));
+
+import { truncateTaskDesc, printDryRunPreview } from '../../../src/utils/dry-run.js';
+import { checkBranchExists } from '../../../src/utils/git.js';
+import { printInfo } from '../../../src/utils/formatter.js';
+
+const mockedCheckBranchExists = vi.mocked(checkBranchExists);
+const mockedPrintInfo = vi.mocked(printInfo);
+
+beforeEach(() => {
+  mockedCheckBranchExists.mockReset();
+  mockedPrintInfo.mockReset();
+});
+
+describe('truncateTaskDesc', () => {
+  it('短文本原样返回', () => {
+    expect(truncateTaskDesc('实现登录功能')).toBe('实现登录功能');
+  });
+
+  it('超过80字符时截断并加省略号', () => {
+    const longTask = 'a'.repeat(100);
+    const result = truncateTaskDesc(longTask);
+    expect(result.length).toBe(83); // 80 + '...'
+    expect(result.endsWith('...')).toBe(true);
+  });
+
+  it('恰好80字符时不截断', () => {
+    const task = 'a'.repeat(80);
+    expect(truncateTaskDesc(task)).toBe(task);
+  });
+
+  it('多行文本合并为单行', () => {
+    const multiLine = '第一行\n第二行\n第三行';
+    expect(truncateTaskDesc(multiLine)).toBe('第一行 第二行 第三行');
+  });
+
+  it('首尾空白被去除', () => {
+    expect(truncateTaskDesc('  hello  ')).toBe('hello');
+  });
+});
+
+describe('printDryRunPreview', () => {
+  it('无冲突时输出预览完成结论', () => {
+    mockedCheckBranchExists.mockReturnValue(false);
+
+    printDryRunPreview(['feat-1', 'feat-2'], ['任务1', '任务2'], 0);
+
+    // 正常分支应包含 ✓ 标识
+    expect(mockedPrintInfo).toHaveBeenCalledWith(expect.stringContaining('✓'));
+    // 应输出预览完成结论
+    expect(mockedPrintInfo).toHaveBeenCalledWith(expect.stringContaining('预览完成'));
+  });
+
+  it('有分支冲突时输出冲突警告', () => {
+    mockedCheckBranchExists
+      .mockReturnValueOnce(false)
+      .mockReturnValueOnce(true);
+
+    printDryRunPreview(['feat-1', 'feat-2'], ['任务1', '任务2'], 0);
+
+    // 冲突分支的序号行应同时包含分支名和"已存在"警告
+    expect(mockedPrintInfo).toHaveBeenCalledWith(expect.stringContaining('已存在'));
+    // 冲突分支应包含 ⚠ 标识
+    expect(mockedPrintInfo).toHaveBeenCalledWith(expect.stringContaining('⚠'));
+    // 应输出冲突结论
+    expect(mockedPrintInfo).toHaveBeenCalledWith(expect.stringContaining('分支冲突'));
+  });
+
+  it('交互式模式显示交互提示', () => {
+    mockedCheckBranchExists.mockReturnValue(false);
+
+    printDryRunPreview(['feat'], [], 0);
+
+    // 交互式模式下应显示交互模式提示
+    expect(mockedPrintInfo).toHaveBeenCalledWith(expect.stringContaining('交互式'));
+  });
+
+  it('非交互式模式显示任务描述', () => {
+    mockedCheckBranchExists.mockReturnValue(false);
+
+    printDryRunPreview(['feat-1'], ['实现登录功能'], 2);
+
+    // 应包含任务描述
+    expect(mockedPrintInfo).toHaveBeenCalledWith(expect.stringContaining('实现登录功能'));
+  });
+
+  it('摘要行合并为一行并包含关键信息', () => {
+    mockedCheckBranchExists.mockReturnValue(false);
+
+    printDryRunPreview(['feat-1', 'feat-2'], ['任务1', '任务2'], 5);
+
+    // 摘要行应同时包含任务数、并发数和 Worktree 路径
+    expect(mockedPrintInfo).toHaveBeenCalledWith(expect.stringContaining('任务数: 2'));
+    expect(mockedPrintInfo).toHaveBeenCalledWith(expect.stringContaining('并发数: 5'));
+    expect(mockedPrintInfo).toHaveBeenCalledWith(expect.stringContaining('Worktree:'));
+  });
+});

package/tests/unit/utils/task-file.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { parseTaskFile, loadTaskFile } from '../../../src/utils/task-file.js';
+import { parseTaskFile, loadTaskFile, parseTasksFromOptions } from '../../../src/utils/task-file.js';
 import { existsSync, readFileSync } from 'node:fs';
 
 vi.mock('node:fs', () => ({
@@ -234,3 +234,28 @@ describe('loadTaskFile', () => {
     expect(entries[0].task).toBe('实现登录功能');
   });
 });
+
+describe('parseTasksFromOptions', () => {
+  it('正常解析任务列表', () => {
+    const tasks = parseTasksFromOptions(['task1', 'task2', 'task3']);
+    expect(tasks).toEqual(['task1', 'task2', 'task3']);
+  });
+
+  it('去除首尾空白', () => {
+    const tasks = parseTasksFromOptions(['  task1  ', '  task2  ']);
+    expect(tasks).toEqual(['task1', 'task2']);
+  });
+
+  it('过滤空字符串', () => {
+    const tasks = parseTasksFromOptions(['task1', '', '  ', 'task2']);
+    expect(tasks).toEqual(['task1', 'task2']);
+  });
+
+  it('全部为空时抛出错误', () => {
+    expect(() => parseTasksFromOptions(['', '  '])).toThrow('任务列表不能为空');
+  });
+
+  it('空数组时抛出错误', () => {
+    expect(() => parseTasksFromOptions([])).toThrow('任务列表不能为空');
+  });
+});