clawt 2.19.0 → 3.0.0

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

@@ -26,6 +26,10 @@ vi.mock('../../../src/constants/index.js', () => ({
 vi.mock('../../../src/utils/index.js', () => ({
   validateMainWorktree: vi.fn(),
   createWorktrees: vi.fn(),
+  getConfigValue: vi.fn().mockReturnValue(true),
+  requireProjectConfig: vi.fn().mockReturnValue({ clawtMainWorkBranch: 'main' }),
+  ensureOnMainWorkBranch: vi.fn().mockResolvedValue(undefined),
+  getValidateBranchName: vi.fn((name: string) => `clawt-validate-${name}`),
   printSuccess: vi.fn(),
   printInfo: vi.fn(),
   printSeparator: vi.fn(),
@@ -54,7 +58,7 @@ describe('registerCreateCommand', () => {
 });
 
 describe('handleCreate', () => {
-  it('成功创建 worktree', () => {
+  it('成功创建 worktree', async () => {
     mockedCreateWorktrees.mockReturnValue([
       { path: '/path/feature', branch: 'feature' },
     ]);
@@ -62,14 +66,14 @@ describe('handleCreate', () => {
     const program = new Command();
     program.exitOverride();
     registerCreateCommand(program);
-    program.parse(['create', '-b', 'feature'], { from: 'user' });
+    await program.parseAsync(['create', '-b', 'feature'], { from: 'user' });
 
     expect(mockedValidateMainWorktree).toHaveBeenCalled();
     expect(mockedCreateWorktrees).toHaveBeenCalledWith('feature', 1);
     expect(mockedPrintSuccess).toHaveBeenCalled();
   });
 
-  it('支持 -n 指定创建数量', () => {
+  it('支持 -n 指定创建数量', async () => {
     mockedCreateWorktrees.mockReturnValue([
       { path: '/path/feature-1', branch: 'feature-1' },
       { path: '/path/feature-2', branch: 'feature-2' },
@@ -78,38 +82,38 @@ describe('handleCreate', () => {
     const program = new Command();
     program.exitOverride();
     registerCreateCommand(program);
-    program.parse(['create', '-b', 'feature', '-n', '2'], { from: 'user' });
+    await program.parseAsync(['create', '-b', 'feature', '-n', '2'], { from: 'user' });
 
     expect(mockedCreateWorktrees).toHaveBeenCalledWith('feature', 2);
   });
 
-  it('无效数量抛出 ClawtError', () => {
+  it('无效数量抛出 ClawtError', async () => {
     const program = new Command();
     program.exitOverride();
     registerCreateCommand(program);
 
-    expect(() => {
-      program.parse(['create', '-b', 'feature', '-n', 'abc'], { from: 'user' });
-    }).toThrow();
+    await expect(
+      program.parseAsync(['create', '-b', 'feature', '-n', 'abc'], { from: 'user' }),
+    ).rejects.toThrow();
   });
 
-  it('数量为 0 时抛出 ClawtError', () => {
+  it('数量为 0 时抛出 ClawtError', async () => {
     const program = new Command();
     program.exitOverride();
     registerCreateCommand(program);
 
-    expect(() => {
-      program.parse(['create', '-b', 'feature', '-n', '0'], { from: 'user' });
-    }).toThrow();
+    await expect(
+      program.parseAsync(['create', '-b', 'feature', '-n', '0'], { from: 'user' }),
+    ).rejects.toThrow();
   });
 
-  it('负数数量抛出 ClawtError', () => {
+  it('负数数量抛出 ClawtError', async () => {
     const program = new Command();
     program.exitOverride();
     registerCreateCommand(program);
 
-    expect(() => {
-      program.parse(['create', '-b', 'feature', '-n', '-1'], { from: 'user' });
-    }).toThrow();
+    await expect(
+      program.parseAsync(['create', '-b', 'feature', '-n', '-1'], { from: 'user' }),
+    ).rejects.toThrow();
   });
 });

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

@@ -0,0 +1,146 @@
+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: {
+    INIT_SUCCESS: (branch: string) => `✓ 项目初始化成功，主工作分支设置为: ${branch}`,
+    INIT_UPDATED: (oldBranch: string, newBranch: string) => `✓ 已将主工作分支从 ${oldBranch} 更新为 ${newBranch}`,
+    INIT_SHOW: (configJson: string) => `当前项目配置:\n${configJson}`,
+    PROJECT_NOT_INITIALIZED: '项目尚未初始化，请先执行 clawt init 设置主工作分支',
+    PROJECT_CONFIG_MISSING_BRANCH: '项目配置缺少主工作分支信息，请重新执行 clawt init 设置主工作分支',
+  },
+}));
+
+vi.mock('../../../src/utils/index.js', () => ({
+  validateMainWorktree: vi.fn(),
+  getCurrentBranch: vi.fn().mockReturnValue('main'),
+  loadProjectConfig: vi.fn(),
+  saveProjectConfig: vi.fn(),
+  requireProjectConfig: vi.fn().mockReturnValue({ clawtMainWorkBranch: 'main' }),
+  printSuccess: vi.fn(),
+  printInfo: vi.fn(),
+  safeStringify: vi.fn((value: unknown, indent: number = 2) => JSON.stringify(value, null, indent)),
+}));
+
+import { registerInitCommand } from '../../../src/commands/init.js';
+import {
+  loadProjectConfig,
+  saveProjectConfig,
+  requireProjectConfig,
+  printSuccess,
+  printInfo,
+  getCurrentBranch,
+} from '../../../src/utils/index.js';
+
+const mockedLoadProjectConfig = vi.mocked(loadProjectConfig);
+const mockedSaveProjectConfig = vi.mocked(saveProjectConfig);
+const mockedRequireProjectConfig = vi.mocked(requireProjectConfig);
+const mockedPrintSuccess = vi.mocked(printSuccess);
+const mockedPrintInfo = vi.mocked(printInfo);
+const mockedGetCurrentBranch = vi.mocked(getCurrentBranch);
+
+beforeEach(() => {
+  mockedLoadProjectConfig.mockReset();
+  mockedSaveProjectConfig.mockReset();
+  mockedRequireProjectConfig.mockReset();
+  mockedRequireProjectConfig.mockReturnValue({ clawtMainWorkBranch: 'main' });
+  mockedPrintSuccess.mockReset();
+  mockedPrintInfo.mockReset();
+  mockedGetCurrentBranch.mockReturnValue('main');
+});
+
+describe('registerInitCommand', () => {
+  it('注册 init 命令', () => {
+    const program = new Command();
+    registerInitCommand(program);
+    const cmd = program.commands.find((c) => c.name() === 'init');
+    expect(cmd).toBeDefined();
+  });
+
+  it('注册 init show 子命令', () => {
+    const program = new Command();
+    registerInitCommand(program);
+    const initCmd = program.commands.find((c) => c.name() === 'init');
+    const showCmd = initCmd?.commands.find((c) => c.name() === 'show');
+    expect(showCmd).toBeDefined();
+  });
+});
+
+describe('handleInit', () => {
+  it('无参数且已初始化时使用当前分支切换主工作分支', async () => {
+    mockedLoadProjectConfig.mockReturnValue({ clawtMainWorkBranch: 'develop' });
+
+    const program = new Command();
+    program.exitOverride();
+    registerInitCommand(program);
+    await program.parseAsync(['init'], { from: 'user' });
+
+    expect(mockedSaveProjectConfig).toHaveBeenCalledWith({ clawtMainWorkBranch: 'main' });
+    expect(mockedPrintSuccess).toHaveBeenCalledWith(
+      expect.stringContaining('develop'),
+    );
+    expect(mockedPrintSuccess).toHaveBeenCalledWith(
+      expect.stringContaining('main'),
+    );
+  });
+
+  it('无参数且未初始化时使用当前分支初始化', async () => {
+    mockedLoadProjectConfig.mockReturnValue(null);
+
+    const program = new Command();
+    program.exitOverride();
+    registerInitCommand(program);
+    await program.parseAsync(['init'], { from: 'user' });
+
+    expect(mockedSaveProjectConfig).toHaveBeenCalledWith({ clawtMainWorkBranch: 'main' });
+    expect(mockedPrintSuccess).toHaveBeenCalled();
+  });
+
+  it('有 -b 参数时设置指定分支', async () => {
+    mockedLoadProjectConfig.mockReturnValue(null);
+
+    const program = new Command();
+    program.exitOverride();
+    registerInitCommand(program);
+    await program.parseAsync(['init', '-b', 'develop'], { from: 'user' });
+
+    expect(mockedSaveProjectConfig).toHaveBeenCalledWith({ clawtMainWorkBranch: 'develop' });
+    expect(mockedPrintSuccess).toHaveBeenCalled();
+  });
+
+  it('有 -b 参数且已初始化时更新配置', async () => {
+    mockedLoadProjectConfig.mockReturnValue({ clawtMainWorkBranch: 'main' });
+
+    const program = new Command();
+    program.exitOverride();
+    registerInitCommand(program);
+    await program.parseAsync(['init', '-b', 'develop'], { from: 'user' });
+
+    expect(mockedSaveProjectConfig).toHaveBeenCalledWith({ clawtMainWorkBranch: 'develop' });
+    // 验证 INIT_UPDATED 传入了旧分支名和新分支名
+    expect(mockedPrintSuccess).toHaveBeenCalledWith(
+      expect.stringContaining('main'),
+    );
+    expect(mockedPrintSuccess).toHaveBeenCalledWith(
+      expect.stringContaining('develop'),
+    );
+  });
+});
+
+describe('handleInitShow (show 子命令)', () => {
+  it('clawt init show 展示当前配置', async () => {
+    mockedRequireProjectConfig.mockReturnValue({ clawtMainWorkBranch: 'develop' });
+
+    const program = new Command();
+    program.exitOverride();
+    registerInitCommand(program);
+    await program.parseAsync(['init', 'show'], { from: 'user' });
+
+    expect(mockedPrintInfo).toHaveBeenCalled();
+    expect(mockedSaveProjectConfig).not.toHaveBeenCalled();
+  });
+});

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

@@ -64,7 +64,13 @@ vi.mock('../../../src/utils/index.js', () => ({
   gitMergeBase: vi.fn(),
   gitResetSoftTo: vi.fn(),
   getCurrentBranch: vi.fn(),
+  gitResetHard: vi.fn(),
+  gitCleanForce: vi.fn(),
+  gitCheckout: vi.fn(),
   resolveTargetWorktree: vi.fn(),
+  requireProjectConfig: vi.fn().mockReturnValue({ clawtMainWorkBranch: 'main' }),
+  getMainWorkBranch: vi.fn().mockReturnValue('main'),
+  ensureOnMainWorkBranch: vi.fn(),
 }));
 
 import { registerMergeCommand } from '../../../src/commands/merge.js';
@@ -175,7 +181,7 @@ describe('handleMerge', () => {
 
   it('目标 worktree 有未提交修改且提供 -m 时先提交再合并', async () => {
     mockedIsWorkingDirClean
-      .mockReturnValueOnce(true)   // 主 worktree 干净
+      .mockReturnValueOnce(true)   // 主 worktree 状态检测：干净
       .mockReturnValueOnce(false); // 目标 worktree 不干净
     mockedConfirmAction.mockResolvedValue(false); // 不清理
 

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

@@ -46,6 +46,10 @@ vi.mock('../../../src/utils/index.js', () => ({
   removeSnapshot: vi.fn(),
   removeProjectSnapshots: vi.fn(),
   resolveTargetWorktrees: vi.fn(),
+  requireProjectConfig: vi.fn().mockReturnValue({ clawtMainWorkBranch: 'main' }),
+  getValidateBranchName: vi.fn((name: string) => `clawt-validate-${name}`),
+  deleteValidateBranch: vi.fn(),
+  ensureOnMainWorkBranch: vi.fn(),
 }));
 
 import { registerRemoveCommand } from '../../../src/commands/remove.js';

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

@@ -23,6 +23,8 @@ vi.mock('../../../src/utils/index.js', () => ({
   confirmDestructiveAction: vi.fn(),
   printSuccess: vi.fn(),
   printInfo: vi.fn(),
+  requireProjectConfig: vi.fn().mockReturnValue({ clawtMainWorkBranch: 'main' }),
+  switchBackIfOnValidateBranch: vi.fn(),
 }));
 
 import { registerResetCommand } from '../../../src/commands/reset.js';

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

@@ -20,6 +20,7 @@ vi.mock('../../../src/utils/index.js', () => ({
   getProjectWorktrees: vi.fn(),
   launchInteractiveClaude: vi.fn(),
   resolveTargetWorktrees: vi.fn(),
+  promptGroupedMultiSelectBranches: vi.fn(),
 }));
 
 import { registerResumeCommand } from '../../../src/commands/resume.js';
@@ -29,6 +30,7 @@ import {
   getProjectWorktrees,
   launchInteractiveClaude,
   resolveTargetWorktrees,
+  promptGroupedMultiSelectBranches,
 } from '../../../src/utils/index.js';
 
 const mockedValidateMainWorktree = vi.mocked(validateMainWorktree);
@@ -36,6 +38,7 @@ const mockedValidateClaudeCodeInstalled = vi.mocked(validateClaudeCodeInstalled)
 const mockedGetProjectWorktrees = vi.mocked(getProjectWorktrees);
 const mockedLaunchInteractiveClaude = vi.mocked(launchInteractiveClaude);
 const mockedResolveTargetWorktrees = vi.mocked(resolveTargetWorktrees);
+const mockedPromptGroupedMultiSelectBranches = vi.mocked(promptGroupedMultiSelectBranches);
 
 beforeEach(() => {
   mockedValidateMainWorktree.mockReset();
@@ -43,6 +46,7 @@ beforeEach(() => {
   mockedGetProjectWorktrees.mockReset();
   mockedLaunchInteractiveClaude.mockReset();
   mockedResolveTargetWorktrees.mockReset();
+  mockedPromptGroupedMultiSelectBranches.mockReset();
 });
 
 describe('registerResumeCommand', () => {
@@ -55,7 +59,7 @@ describe('registerResumeCommand', () => {
 });
 
 describe('handleResume', () => {
-  it('成功恢复 Claude Code 会话', async () => {
+  it('传 -b 时走标准解析流程', async () => {
     const worktree = { path: '/path/feature', branch: 'feature' };
     mockedGetProjectWorktrees.mockReturnValue([worktree]);
     mockedResolveTargetWorktrees.mockResolvedValue([worktree]);
@@ -68,10 +72,31 @@ describe('handleResume', () => {
     expect(mockedValidateMainWorktree).toHaveBeenCalled();
     expect(mockedValidateClaudeCodeInstalled).toHaveBeenCalled();
     expect(mockedResolveTargetWorktrees).toHaveBeenCalled();
+    expect(mockedPromptGroupedMultiSelectBranches).not.toHaveBeenCalled();
     expect(mockedLaunchInteractiveClaude).toHaveBeenCalledWith(worktree, { autoContinue: true });
   });
 
-  it('不传 -b 时也能调用 resolveTargetWorktrees', async () => {
+  it('不传 -b 且多个 worktree 时默认使用分组多选', async () => {
+    const worktrees = [
+      { path: '/path/feature-a', branch: 'feature-a' },
+      { path: '/path/feature-b', branch: 'feature-b' },
+    ];
+    mockedGetProjectWorktrees.mockReturnValue(worktrees);
+    mockedPromptGroupedMultiSelectBranches.mockResolvedValue([worktrees[0]]);
+
+    const program = new Command();
+    program.exitOverride();
+    registerResumeCommand(program);
+    await program.parseAsync(['resume'], { from: 'user' });
+
+    expect(mockedPromptGroupedMultiSelectBranches).toHaveBeenCalledWith(
+      worktrees,
+      expect.any(String),
+    );
+    expect(mockedResolveTargetWorktrees).not.toHaveBeenCalled();
+  });
+
+  it('仅 1 个 worktree 时走标准流程', async () => {
     const worktree = { path: '/path/feature', branch: 'feature' };
     mockedGetProjectWorktrees.mockReturnValue([worktree]);
     mockedResolveTargetWorktrees.mockResolvedValue([worktree]);
@@ -81,11 +106,7 @@ describe('handleResume', () => {
     registerResumeCommand(program);
     await program.parseAsync(['resume'], { from: 'user' });
 
-    // branchName 参数为 undefined
-    expect(mockedResolveTargetWorktrees).toHaveBeenCalledWith(
-      expect.any(Array),
-      expect.any(Object),
-      undefined,
-    );
+    expect(mockedResolveTargetWorktrees).toHaveBeenCalled();
+    expect(mockedPromptGroupedMultiSelectBranches).not.toHaveBeenCalled();
   });
 });

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

@@ -71,6 +71,8 @@ vi.mock('../../../src/utils/index.js', async (importOriginal) => {
     parseTasksFromOptions: vi.fn(),
     createWorktreesByBranches: vi.fn(),
     printDryRunPreview: vi.fn(),
+    requireProjectConfig: vi.fn().mockReturnValue({ clawtMainWorkBranch: 'main' }),
+    ensureOnMainWorkBranch: vi.fn().mockResolvedValue(undefined),
   };
 });
 

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

@@ -25,6 +25,7 @@ vi.mock('../../../src/constants/index.js', () => ({
     SYNC_MERGING: (branch: string, mainBranch: string) => `正在将 ${mainBranch} 合并到 ${branch}...`,
     SYNC_CONFLICT: (path: string) => `合并冲突，请手动解决: ${path}`,
     SYNC_SUCCESS: (branch: string, mainBranch: string) => `✓ 已将 ${mainBranch} 同步到 ${branch}`,
+    SYNC_VALIDATE_BRANCH_REBUILT: (validateBranch: string) => `验证分支 ${validateBranch} 已重建`,
   },
   AUTO_SAVE_COMMIT_MESSAGE: 'clawt:auto-save',
 }));
@@ -46,6 +47,11 @@ vi.mock('../../../src/utils/index.js', () => ({
   printInfo: vi.fn(),
   printWarning: vi.fn(),
   resolveTargetWorktree: vi.fn(),
+  requireProjectConfig: vi.fn().mockReturnValue({ clawtMainWorkBranch: 'main' }),
+  getMainWorkBranch: vi.fn().mockReturnValue('main'),
+  rebuildValidateBranch: vi.fn(),
+  getValidateBranchName: vi.fn((name: string) => `clawt-validate-${name}`),
+  ensureOnMainWorkBranch: vi.fn(),
 }));
 
 import { registerSyncCommand } from '../../../src/commands/sync.js';

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

@@ -40,6 +40,11 @@ vi.mock('../../../src/constants/index.js', () => ({
     VALIDATE_PARALLEL_CMD_FAILED: (cmd: string, code: number) => `  ✗ ${cmd}（退出码: ${code}）`,
     VALIDATE_PARALLEL_CMD_ERROR: (cmd: string, msg: string) => `  ✗ ${cmd}（错误: ${msg}）`,
     SEPARATOR: '────',
+    VALIDATE_BRANCH_NOT_FOUND: (validateBranch: string, branch: string) => `验证分支 ${validateBranch} 不存在`,
+    VALIDATE_SUCCESS_WITH_BRANCH: (branch: string, validateBranch: string) => `✓ 已切换到验证分支 ${validateBranch} 并验证 ${branch}`,
+    VALIDATE_CONFIRM_AUTO_SYNC: (branch: string) => `是否自动 sync ${branch}`,
+    VALIDATE_AUTO_SYNC_DECLINED: (branch: string) => `已跳过 ${branch} 的自动 sync`,
+    VALIDATE_AUTO_SYNC_START: (branch: string) => `正在自动 sync ${branch}`,
   },
 }));
 
@@ -79,6 +84,7 @@ vi.mock('../../../src/utils/index.js', () => ({
   writeSnapshot: vi.fn(),
   removeSnapshot: vi.fn(),
   confirmDestructiveAction: vi.fn(),
+  confirmAction: vi.fn(),
   printSuccess: vi.fn(),
   printWarning: vi.fn(),
   printInfo: vi.fn(),
@@ -88,6 +94,13 @@ vi.mock('../../../src/utils/index.js', () => ({
   printSeparator: vi.fn(),
   parseParallelCommands: vi.fn(),
   runParallelCommands: vi.fn(),
+  requireProjectConfig: vi.fn().mockReturnValue({ clawtMainWorkBranch: 'main' }),
+  getValidateBranchName: vi.fn((name: string) => `clawt-validate-${name}`),
+  gitCheckout: vi.fn(),
+  ensureOnMainWorkBranch: vi.fn(),
+  handleDirtyWorkingDir: vi.fn(),
+  checkBranchExists: vi.fn().mockReturnValue(true),
+  getCurrentBranch: vi.fn().mockReturnValue('main'),
 }));
 
 import { registerValidateCommand } from '../../../src/commands/validate.js';

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

@@ -90,9 +90,9 @@ describe('writeConfig', () => {
 });
 
 describe('ensureClawtDirs', () => {
-  it('确保三个全局目录存在', () => {
+  it('确保四个全局目录存在', () => {
     ensureClawtDirs();
-    expect(mockedEnsureDir).toHaveBeenCalledTimes(3);
+    expect(mockedEnsureDir).toHaveBeenCalledTimes(4);
   });
 });
 

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

@@ -0,0 +1,136 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// mock node:fs
+vi.mock('node:fs', () => ({
+  existsSync: vi.fn(),
+  readFileSync: vi.fn(),
+  writeFileSync: vi.fn(),
+}));
+
+// mock logger
+vi.mock('../../../src/logger/index.js', () => ({
+  logger: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+
+// mock errors
+vi.mock('../../../src/errors/index.js', () => ({
+  ClawtError: class ClawtError extends Error {
+    exitCode: number;
+    constructor(message: string, exitCode = 1) {
+      super(message);
+      this.exitCode = exitCode;
+    }
+  },
+}));
+
+// mock constants
+vi.mock('../../../src/constants/index.js', () => ({
+  PROJECTS_CONFIG_DIR: '/mock/.clawt/projects',
+  MESSAGES: {
+    PROJECT_NOT_INITIALIZED: '项目尚未初始化，请先执行 clawt init 设置主工作分支',
+    PROJECT_CONFIG_MISSING_BRANCH: '项目配置缺少主工作分支信息，请重新执行 clawt init 设置主工作分支',
+  },
+}));
+
+// mock git
+vi.mock('../../../src/utils/git.js', () => ({
+  getProjectName: vi.fn().mockReturnValue('test-project'),
+}));
+
+// mock fs utils
+vi.mock('../../../src/utils/fs.js', () => ({
+  ensureDir: vi.fn(),
+}));
+
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import {
+  getProjectConfigPath,
+  loadProjectConfig,
+  saveProjectConfig,
+  requireProjectConfig,
+  getMainWorkBranch,
+} from '../../../src/utils/project-config.js';
+
+const mockedExistsSync = vi.mocked(existsSync);
+const mockedReadFileSync = vi.mocked(readFileSync);
+const mockedWriteFileSync = vi.mocked(writeFileSync);
+
+beforeEach(() => {
+  mockedExistsSync.mockReset();
+  mockedReadFileSync.mockReset();
+  mockedWriteFileSync.mockReset();
+});
+
+describe('getProjectConfigPath', () => {
+  it('返回正确的配置文件路径', () => {
+    const path = getProjectConfigPath('my-project');
+    // 路径格式：<PROJECTS_CONFIG_DIR>/<projectName>/config.json
+    expect(path).toContain('my-project');
+    expect(path).toContain('config.json');
+    expect(path).toContain('projects');
+  });
+});
+
+describe('loadProjectConfig', () => {
+  it('配置文件不存在时返回 null', () => {
+    mockedExistsSync.mockReturnValue(false);
+    expect(loadProjectConfig()).toBeNull();
+  });
+
+  it('配置文件存在时正确解析', () => {
+    mockedExistsSync.mockReturnValue(true);
+    mockedReadFileSync.mockReturnValue(JSON.stringify({ clawtMainWorkBranch: 'develop' }));
+    const config = loadProjectConfig();
+    expect(config).toEqual({ clawtMainWorkBranch: 'develop' });
+  });
+
+  it('配置文件损坏时返回 null', () => {
+    mockedExistsSync.mockReturnValue(true);
+    mockedReadFileSync.mockReturnValue('invalid json');
+    expect(loadProjectConfig()).toBeNull();
+  });
+});
+
+describe('saveProjectConfig', () => {
+  it('将配置写入文件', () => {
+    saveProjectConfig({ clawtMainWorkBranch: 'main' });
+    expect(mockedWriteFileSync).toHaveBeenCalledWith(
+      expect.stringContaining('config.json'),
+      JSON.stringify({ clawtMainWorkBranch: 'main' }, null, 2),
+      'utf-8',
+    );
+  });
+});
+
+describe('requireProjectConfig', () => {
+  it('配置存在且包含 clawtMainWorkBranch 时返回配置', () => {
+    mockedExistsSync.mockReturnValue(true);
+    mockedReadFileSync.mockReturnValue(JSON.stringify({ clawtMainWorkBranch: 'main' }));
+    expect(requireProjectConfig()).toEqual({ clawtMainWorkBranch: 'main' });
+  });
+
+  it('配置不存在时抛出错误', () => {
+    mockedExistsSync.mockReturnValue(false);
+    expect(() => requireProjectConfig()).toThrow();
+  });
+
+  it('配置存在但缺少 clawtMainWorkBranch 字段时抛出错误', () => {
+    mockedExistsSync.mockReturnValue(true);
+    mockedReadFileSync.mockReturnValue(JSON.stringify({}));
+    expect(() => requireProjectConfig()).toThrow('项目配置缺少主工作分支信息');
+  });
+
+  it('配置存在但 clawtMainWorkBranch 为空字符串时抛出错误', () => {
+    mockedExistsSync.mockReturnValue(true);
+    mockedReadFileSync.mockReturnValue(JSON.stringify({ clawtMainWorkBranch: '' }));
+    expect(() => requireProjectConfig()).toThrow('项目配置缺少主工作分支信息');
+  });
+});
+
+describe('getMainWorkBranch', () => {
+  it('返回主工作分支名', () => {
+    mockedExistsSync.mockReturnValue(true);
+    mockedReadFileSync.mockReturnValue(JSON.stringify({ clawtMainWorkBranch: 'develop' }));
+    expect(getMainWorkBranch()).toBe('develop');
+  });
+});

package/tests/unit/utils/update-checker.test.ts

@@ -19,13 +19,34 @@ vi.mock('node:https', () => ({
 }));
 
 // mock chalk（测试环境已通过 FORCE_COLOR=0 禁用颜色，但仍需确保不产生转义码）
-vi.mock('chalk', () => ({
-  default: {
-    red: (s: string) => s,
-    green: (s: string) => s,
-    cyan: (s: string) => s,
-  },
-}));
+// 使用 Proxy 实现链式调用，支持 chalk.bold.hex('#color')('text') 等任意嵌套
+vi.mock('chalk', () => {
+  /**
+   * 创建可链式调用的 chalk Proxy
+   * - 属性访问（如 .bold、.red）返回新 Proxy
+   * - 函数调用返回新 Proxy，但记录最后传入的字符串参数
+   * - toString / Symbol.toPrimitive 返回最后记录的字符串，支持模板字符串插值
+   * @param {string} [value] - 内部记录的字符串值
+   * @returns {unknown} 链式 Proxy 对象
+   */
+  const createChainProxy = (value = ''): unknown => {
+    const fn = (..._args: unknown[]) => {};
+    return new Proxy(fn, {
+      get: (_target, prop) => {
+        if (prop === '__esModule') return true;
+        if (prop === Symbol.toPrimitive || prop === 'toString') return () => value;
+        if (prop === 'length') return 0;
+        return createChainProxy(value);
+      },
+      apply: (_target, _thisArg, args) => {
+        // 记录最后传入的字符串参数作为输出值
+        const newValue = typeof args[0] === 'string' ? args[0] : value;
+        return createChainProxy(newValue);
+      },
+    });
+  };
+  return { default: createChainProxy(), __esModule: true };
+});
 
 // mock string-width（纯 ASCII 场景下直接返回字符串长度即可）
 vi.mock('string-width', () => ({