clawt 2.20.0 → 3.1.0

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', () => ({

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

@@ -0,0 +1,272 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// 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', () => ({
+  VALIDATE_BRANCH_PREFIX: 'clawt-validate-',
+}));
+
+// mock enquirer（必须在所有 import 之前）
+const { mockSelectRun } = vi.hoisted(() => {
+  const mockSelectRun = vi.fn();
+  return { mockSelectRun };
+});
+
+vi.mock('enquirer', () => ({
+  default: {
+    Select: function MockSelect() { return { run: mockSelectRun }; },
+  },
+}));
+
+// mock git
+vi.mock('../../../src/utils/git.js', () => ({
+  checkBranchExists: vi.fn(),
+  createBranch: vi.fn(),
+  deleteBranch: vi.fn(),
+  getCurrentBranch: vi.fn(),
+  gitCheckout: vi.fn(),
+  gitResetHard: vi.fn(),
+  gitCleanForce: vi.fn(),
+  isWorkingDirClean: vi.fn().mockReturnValue(true),
+  gitAddAll: vi.fn(),
+  gitStashPush: vi.fn(),
+}));
+
+// mock project-config
+vi.mock('../../../src/utils/project-config.js', () => ({
+  getMainWorkBranch: vi.fn().mockReturnValue('main'),
+}));
+
+// mock formatter
+vi.mock('../../../src/utils/formatter.js', () => ({
+  printWarning: vi.fn(),
+}));
+
+import {
+  checkBranchExists,
+  createBranch,
+  deleteBranch,
+  getCurrentBranch,
+  gitCheckout,
+  gitResetHard,
+  gitCleanForce,
+  isWorkingDirClean,
+  gitAddAll,
+  gitStashPush,
+} from '../../../src/utils/git.js';
+import {
+  getValidateBranchName,
+  createValidateBranch,
+  deleteValidateBranch,
+  rebuildValidateBranch,
+  ensureOnMainWorkBranch,
+  handleDirtyWorkingDir,
+} from '../../../src/utils/validate-branch.js';
+const mockedCheckBranchExists = vi.mocked(checkBranchExists);
+const mockedCreateBranch = vi.mocked(createBranch);
+const mockedDeleteBranch = vi.mocked(deleteBranch);
+const mockedGetCurrentBranch = vi.mocked(getCurrentBranch);
+const mockedGitCheckout = vi.mocked(gitCheckout);
+const mockedGitResetHard = vi.mocked(gitResetHard);
+const mockedGitCleanForce = vi.mocked(gitCleanForce);
+const mockedIsWorkingDirClean = vi.mocked(isWorkingDirClean);
+const mockedGitAddAll = vi.mocked(gitAddAll);
+const mockedGitStashPush = vi.mocked(gitStashPush);
+
+beforeEach(() => {
+  mockedCheckBranchExists.mockReset();
+  mockedCreateBranch.mockReset();
+  mockedDeleteBranch.mockReset();
+  mockedGetCurrentBranch.mockReset();
+  mockedGitCheckout.mockReset();
+  mockedGitResetHard.mockReset();
+  mockedGitCleanForce.mockReset();
+  mockedIsWorkingDirClean.mockReset().mockReturnValue(true);
+  mockedGitAddAll.mockReset();
+  mockedGitStashPush.mockReset();
+  mockSelectRun.mockReset();
+});
+
+describe('getValidateBranchName', () => {
+  it('生成正确的验证分支名', () => {
+    expect(getValidateBranchName('feature')).toBe('clawt-validate-feature');
+  });
+
+  it('处理含连字符的分支名', () => {
+    expect(getValidateBranchName('my-feature-1')).toBe('clawt-validate-my-feature-1');
+  });
+});
+
+describe('createValidateBranch', () => {
+  it('分支不存在时创建', () => {
+    mockedCheckBranchExists.mockReturnValue(false);
+    createValidateBranch('feature');
+    expect(mockedCreateBranch).toHaveBeenCalledWith('clawt-validate-feature', undefined);
+  });
+
+  it('分支已存在时跳过', () => {
+    mockedCheckBranchExists.mockReturnValue(true);
+    createValidateBranch('feature');
+    expect(mockedCreateBranch).not.toHaveBeenCalled();
+  });
+});
+
+describe('deleteValidateBranch', () => {
+  it('分支存在时删除', () => {
+    mockedCheckBranchExists.mockReturnValue(true);
+    deleteValidateBranch('feature');
+    expect(mockedDeleteBranch).toHaveBeenCalledWith('clawt-validate-feature', undefined);
+  });
+
+  it('分支不存在时跳过', () => {
+    mockedCheckBranchExists.mockReturnValue(false);
+    deleteValidateBranch('feature');
+    expect(mockedDeleteBranch).not.toHaveBeenCalled();
+  });
+});
+
+describe('rebuildValidateBranch', () => {
+  it('重建时先删除再创建', async () => {
+    mockedGetCurrentBranch.mockReturnValue('main');
+    // 第一次调用 (deleteValidateBranch) 检查存在 → 删除
+    // 第二次调用 (createValidateBranch) 检查不存在 → 创建
+    mockedCheckBranchExists
+      .mockReturnValueOnce(true)   // deleteValidateBranch 检查
+      .mockReturnValueOnce(false); // createValidateBranch 检查
+    await rebuildValidateBranch('feature');
+    expect(mockedDeleteBranch).toHaveBeenCalled();
+    expect(mockedCreateBranch).toHaveBeenCalled();
+  });
+
+  it('当前在验证分支上时先执行 reset+clean 再切回', async () => {
+    // 第一次 getCurrentBranch（rebuildValidateBranch 内部检测）返回验证分支
+    // 第二次 getCurrentBranch（switchBackIfOnValidateBranch 内部）返回验证分支
+    mockedGetCurrentBranch.mockReturnValue('clawt-validate-feature');
+    mockedCheckBranchExists
+      .mockReturnValueOnce(true)   // deleteValidateBranch 检查
+      .mockReturnValueOnce(false); // createValidateBranch 检查
+    await rebuildValidateBranch('feature');
+    expect(mockedGitResetHard).toHaveBeenCalledWith(undefined);
+    expect(mockedGitCleanForce).toHaveBeenCalledWith(undefined);
+    expect(mockedGitCheckout).toHaveBeenCalledWith('main', undefined);
+  });
+
+  it('当前不在验证分支上时不执行 reset+clean', async () => {
+    mockedGetCurrentBranch.mockReturnValue('main');
+    mockedCheckBranchExists
+      .mockReturnValueOnce(true)
+      .mockReturnValueOnce(false);
+    await rebuildValidateBranch('feature');
+    expect(mockedGitResetHard).not.toHaveBeenCalled();
+    expect(mockedGitCleanForce).not.toHaveBeenCalled();
+  });
+});
+
+describe('handleDirtyWorkingDir', () => {
+  it('用户选择 reset 时执行 gitResetHard 和 gitCleanForce', async () => {
+    mockSelectRun.mockResolvedValue('reset');
+    // 第一次调用（handleDirtyWorkingDir 末尾检查）返回干净
+    mockedIsWorkingDirClean.mockReturnValue(true);
+    await handleDirtyWorkingDir();
+    expect(mockedGitResetHard).toHaveBeenCalledWith(undefined);
+    expect(mockedGitCleanForce).toHaveBeenCalledWith(undefined);
+  });
+
+  it('用户选择 stash 时执行 gitAddAll 和 gitStashPush', async () => {
+    mockSelectRun.mockResolvedValue('stash');
+    mockedIsWorkingDirClean.mockReturnValue(true);
+    await handleDirtyWorkingDir();
+    expect(mockedGitAddAll).toHaveBeenCalledWith(undefined);
+    expect(mockedGitStashPush).toHaveBeenCalledWith('clawt:auto-stash', undefined);
+  });
+
+  it('用户选择 exit 时抛出错误', async () => {
+    mockSelectRun.mockResolvedValue('exit');
+    await expect(handleDirtyWorkingDir()).rejects.toThrow('用户选择退出');
+  });
+
+  it('处理后工作区仍不干净时抛出错误', async () => {
+    mockSelectRun.mockResolvedValue('reset');
+    mockedIsWorkingDirClean.mockReturnValue(false);
+    await expect(handleDirtyWorkingDir()).rejects.toThrow('工作区仍然不干净');
+  });
+
+  it('传入 cwd 参数时透传给 git 操作', async () => {
+    mockSelectRun.mockResolvedValue('reset');
+    mockedIsWorkingDirClean.mockReturnValue(true);
+    await handleDirtyWorkingDir('/some/path');
+    expect(mockedGitResetHard).toHaveBeenCalledWith('/some/path');
+    expect(mockedGitCleanForce).toHaveBeenCalledWith('/some/path');
+  });
+});
+
+describe('ensureOnMainWorkBranch', () => {
+  it('当前在主工作分支上时直接返回', async () => {
+    mockedGetCurrentBranch.mockReturnValue('main');
+    await ensureOnMainWorkBranch();
+    expect(mockedGitCheckout).not.toHaveBeenCalled();
+  });
+
+  it('当前在验证分支上且工作区干净时自动切回主工作分支', async () => {
+    mockedGetCurrentBranch.mockReturnValue('clawt-validate-feature');
+    mockedIsWorkingDirClean.mockReturnValue(true);
+    await ensureOnMainWorkBranch();
+    expect(mockedGitCheckout).toHaveBeenCalledWith('main', undefined);
+    // 工作区干净时不应调用 resetHard/cleanForce
+    expect(mockedGitResetHard).not.toHaveBeenCalled();
+    expect(mockedGitCleanForce).not.toHaveBeenCalled();
+  });
+
+  it('当前在验证分支上且工作区脏时先清理再切回', async () => {
+    mockedGetCurrentBranch.mockReturnValue('clawt-validate-feature');
+    mockedIsWorkingDirClean.mockReturnValue(false);
+    await ensureOnMainWorkBranch();
+    // 验证分支上的修改直接丢弃
+    expect(mockedGitResetHard).toHaveBeenCalledWith(undefined);
+    expect(mockedGitCleanForce).toHaveBeenCalledWith(undefined);
+    expect(mockedGitCheckout).toHaveBeenCalledWith('main', undefined);
+  });
+
+  it('当前在其他分支上且工作区干净时直接切换到主工作分支', async () => {
+    mockedGetCurrentBranch.mockReturnValue('feature');
+    mockedIsWorkingDirClean.mockReturnValue(true);
+    await ensureOnMainWorkBranch();
+    expect(mockedGitCheckout).toHaveBeenCalledWith('main', undefined);
+  });
+
+  it('当前在其他分支上且工作区脏时先处理再切换', async () => {
+    mockedGetCurrentBranch.mockReturnValue('feature');
+    // 第一次调用（ensureOnMainWorkBranch 检测）返回脏
+    // 第二次调用（handleDirtyWorkingDir 末尾检查）返回干净
+    mockedIsWorkingDirClean.mockReturnValueOnce(false).mockReturnValueOnce(true);
+    mockSelectRun.mockResolvedValue('reset');
+    await ensureOnMainWorkBranch();
+    expect(mockedGitResetHard).toHaveBeenCalled();
+    expect(mockedGitCleanForce).toHaveBeenCalled();
+    expect(mockedGitCheckout).toHaveBeenCalledWith('main', undefined);
+  });
+
+  it('传入 cwd 参数时透传给 git 操作', async () => {
+    mockedGetCurrentBranch.mockReturnValue('clawt-validate-feature');
+    mockedIsWorkingDirClean.mockReturnValue(false);
+    await ensureOnMainWorkBranch('/some/path');
+    expect(mockedGitResetHard).toHaveBeenCalledWith('/some/path');
+    expect(mockedGitCleanForce).toHaveBeenCalledWith('/some/path');
+    expect(mockedGitCheckout).toHaveBeenCalledWith('main', '/some/path');
+  });
+});

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

@@ -48,6 +48,12 @@ vi.mock('../../../src/logger/index.js', () => ({
   logger: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
 }));
 
+// mock validate-branch
+vi.mock('../../../src/utils/validate-branch.js', () => ({
+  createValidateBranch: vi.fn(),
+  deleteValidateBranch: vi.fn(),
+}));
+
 import { existsSync, readdirSync } from 'node:fs';
 import {
   getProjectName,