clawt 2.8.2 → 2.9.0

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

@@ -0,0 +1,151 @@
+import { describe, it, expect, vi } from 'vitest';
+
+// mock node:fs
+vi.mock('node:fs', () => ({
+  existsSync: vi.fn(),
+  readFileSync: vi.fn(),
+  writeFileSync: vi.fn(),
+  unlinkSync: vi.fn(),
+  readdirSync: vi.fn(),
+  rmdirSync: vi.fn(),
+}));
+
+// mock logger
+vi.mock('../../../src/logger/index.js', () => ({
+  logger: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+
+// mock fs 工具
+vi.mock('../../../src/utils/fs.js', () => ({
+  ensureDir: vi.fn(),
+}));
+
+// mock 常量路径
+vi.mock('../../../src/constants/index.js', async (importOriginal) => {
+  const original = await importOriginal<typeof import('../../../src/constants/index.js')>();
+  return {
+    ...original,
+    VALIDATE_SNAPSHOTS_DIR: '/tmp/test-snapshots',
+  };
+});
+
+import { existsSync, readFileSync, writeFileSync, unlinkSync, readdirSync, rmdirSync } from 'node:fs';
+import { ensureDir } from '../../../src/utils/fs.js';
+import {
+  getSnapshotPath,
+  hasSnapshot,
+  readSnapshot,
+  readSnapshotTreeHash,
+  writeSnapshot,
+  removeSnapshot,
+  removeProjectSnapshots,
+} from '../../../src/utils/validate-snapshot.js';
+
+const mockedExistsSync = vi.mocked(existsSync);
+const mockedReadFileSync = vi.mocked(readFileSync);
+const mockedWriteFileSync = vi.mocked(writeFileSync);
+const mockedUnlinkSync = vi.mocked(unlinkSync);
+const mockedReaddirSync = vi.mocked(readdirSync);
+const mockedRmdirSync = vi.mocked(rmdirSync);
+const mockedEnsureDir = vi.mocked(ensureDir);
+
+describe('getSnapshotPath', () => {
+  it('路径拼接正确', () => {
+    const path = getSnapshotPath('my-project', 'feature');
+    expect(path).toBe('/tmp/test-snapshots/my-project/feature.tree');
+  });
+});
+
+describe('hasSnapshot', () => {
+  it('快照存在时返回 true', () => {
+    mockedExistsSync.mockReturnValue(true);
+    expect(hasSnapshot('proj', 'branch')).toBe(true);
+  });
+
+  it('快照不存在时返回 false', () => {
+    mockedExistsSync.mockReturnValue(false);
+    expect(hasSnapshot('proj', 'branch')).toBe(false);
+  });
+});
+
+describe('readSnapshot', () => {
+  it('正常读取 treeHash 和 headCommitHash', () => {
+    mockedExistsSync.mockReturnValue(true);
+    mockedReadFileSync.mockImplementation((path: any) => {
+      if (String(path).endsWith('.tree')) return 'tree123\n';
+      if (String(path).endsWith('.head')) return 'head456\n';
+      return '';
+    });
+    const result = readSnapshot('proj', 'branch');
+    expect(result.treeHash).toBe('tree123');
+    expect(result.headCommitHash).toBe('head456');
+  });
+
+  it('文件不存在时返回空字符串', () => {
+    mockedExistsSync.mockReturnValue(false);
+    const result = readSnapshot('proj', 'branch');
+    expect(result.treeHash).toBe('');
+    expect(result.headCommitHash).toBe('');
+  });
+});
+
+describe('readSnapshotTreeHash', () => {
+  it('返回 treeHash', () => {
+    mockedExistsSync.mockReturnValue(true);
+    mockedReadFileSync.mockImplementation((path: any) => {
+      if (String(path).endsWith('.tree')) return 'tree789\n';
+      if (String(path).endsWith('.head')) return 'head000\n';
+      return '';
+    });
+    expect(readSnapshotTreeHash('proj', 'branch')).toBe('tree789');
+  });
+});
+
+describe('writeSnapshot', () => {
+  it('正确写入两个文件', () => {
+    writeSnapshot('proj', 'branch', 'tree123', 'head456');
+    expect(mockedEnsureDir).toHaveBeenCalledWith('/tmp/test-snapshots/proj');
+    expect(mockedWriteFileSync).toHaveBeenCalledTimes(2);
+    expect(mockedWriteFileSync).toHaveBeenCalledWith(
+      '/tmp/test-snapshots/proj/branch.tree',
+      'tree123',
+      'utf-8',
+    );
+    expect(mockedWriteFileSync).toHaveBeenCalledWith(
+      '/tmp/test-snapshots/proj/branch.head',
+      'head456',
+      'utf-8',
+    );
+  });
+});
+
+describe('removeSnapshot', () => {
+  it('删除存在的文件', () => {
+    mockedExistsSync.mockReturnValue(true);
+    removeSnapshot('proj', 'branch');
+    expect(mockedUnlinkSync).toHaveBeenCalledTimes(2);
+  });
+
+  it('文件不存在时不抛错', () => {
+    mockedExistsSync.mockReturnValue(false);
+    expect(() => removeSnapshot('proj', 'branch')).not.toThrow();
+    expect(mockedUnlinkSync).not.toHaveBeenCalled();
+  });
+});
+
+describe('removeProjectSnapshots', () => {
+  it('删除所有文件并删除空目录', () => {
+    mockedExistsSync.mockReturnValue(true);
+    // @ts-expect-error readdirSync 返回类型简化
+    mockedReaddirSync.mockReturnValue(['branch.tree', 'branch.head']);
+    removeProjectSnapshots('proj');
+    expect(mockedUnlinkSync).toHaveBeenCalledTimes(2);
+    expect(mockedRmdirSync).toHaveBeenCalledWith('/tmp/test-snapshots/proj');
+  });
+
+  it('项目目录不存在时不操作', () => {
+    mockedExistsSync.mockReturnValue(false);
+    removeProjectSnapshots('proj');
+    expect(mockedUnlinkSync).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,65 @@
+import { describe, it, expect, vi } from 'vitest';
+
+// mock shell
+vi.mock('../../../src/utils/shell.js', () => ({
+  execCommand: vi.fn(),
+}));
+
+// mock git（validateMainWorktree 依赖 getGitCommonDir）
+vi.mock('../../../src/utils/git.js', () => ({
+  getGitCommonDir: vi.fn(),
+}));
+
+// mock logger
+vi.mock('../../../src/logger/index.js', () => ({
+  logger: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+
+import { execCommand } from '../../../src/utils/shell.js';
+import { getGitCommonDir } from '../../../src/utils/git.js';
+import { validateMainWorktree, validateGitInstalled, validateClaudeCodeInstalled } from '../../../src/utils/validation.js';
+import { ClawtError } from '../../../src/errors/index.js';
+
+const mockedExecCommand = vi.mocked(execCommand);
+const mockedGetGitCommonDir = vi.mocked(getGitCommonDir);
+
+describe('validateMainWorktree', () => {
+  it('.git 返回时正常通过', () => {
+    mockedGetGitCommonDir.mockReturnValue('.git');
+    expect(() => validateMainWorktree()).not.toThrow();
+  });
+
+  it('非 .git 时抛出 ClawtError', () => {
+    mockedGetGitCommonDir.mockReturnValue('/path/to/.git');
+    expect(() => validateMainWorktree()).toThrow(ClawtError);
+  });
+
+  it('命令失败时抛出 ClawtError', () => {
+    mockedGetGitCommonDir.mockImplementation(() => { throw new Error('not a git repo'); });
+    expect(() => validateMainWorktree()).toThrow(ClawtError);
+  });
+});
+
+describe('validateGitInstalled', () => {
+  it('Git 已安装时正常通过', () => {
+    mockedExecCommand.mockReturnValue('git version 2.40.0');
+    expect(() => validateGitInstalled()).not.toThrow();
+  });
+
+  it('Git 未安装时抛出 ClawtError', () => {
+    mockedExecCommand.mockImplementation(() => { throw new Error('not found'); });
+    expect(() => validateGitInstalled()).toThrow(ClawtError);
+  });
+});
+
+describe('validateClaudeCodeInstalled', () => {
+  it('Claude Code 已安装时正常通过', () => {
+    mockedExecCommand.mockReturnValue('claude 1.0.0');
+    expect(() => validateClaudeCodeInstalled()).not.toThrow();
+  });
+
+  it('Claude Code 未安装时抛出 ClawtError', () => {
+    mockedExecCommand.mockImplementation(() => { throw new Error('not found'); });
+    expect(() => validateClaudeCodeInstalled()).toThrow(ClawtError);
+  });
+});

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

@@ -0,0 +1,116 @@
+import { describe, it, expect, vi } from 'vitest';
+import { findExactMatch, findFuzzyMatches, resolveTargetWorktree } 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';
+
+// mock enquirer
+vi.mock('enquirer', () => ({
+  default: {
+    Select: vi.fn().mockImplementation(({ choices }: { choices: Array<{ name: string }> }) => ({
+      run: vi.fn().mockResolvedValue(choices[0].name),
+    })),
+  },
+}));
+
+/** 测试用消息配置 */
+const testMessages: WorktreeResolveMessages = {
+  noWorktrees: '无可用 worktree',
+  selectBranch: '请选择分支',
+  multipleMatches: (keyword: string) => `"${keyword}" 匹配到多个分支`,
+  noMatch: (keyword: string, branches: string[]) =>
+    `未找到匹配 "${keyword}"，可用：${branches.join(', ')}`,
+};
+
+describe('findExactMatch', () => {
+  it('精确匹配返回正确的 WorktreeInfo', () => {
+    const worktrees = [
+      createWorktreeInfo({ branch: 'feature-a' }),
+      createWorktreeInfo({ branch: 'feature-b' }),
+    ];
+    const result = findExactMatch(worktrees, 'feature-b');
+    expect(result).toBeDefined();
+    expect(result!.branch).toBe('feature-b');
+  });
+
+  it('无匹配返回 undefined', () => {
+    const worktrees = [createWorktreeInfo({ branch: 'feature-a' })];
+    expect(findExactMatch(worktrees, 'feature-b')).toBeUndefined();
+  });
+
+  it('空列表返回 undefined', () => {
+    expect(findExactMatch([], 'any')).toBeUndefined();
+  });
+
+  it('大小写敏感（精确匹配）', () => {
+    const worktrees = [createWorktreeInfo({ branch: 'Feature-A' })];
+    expect(findExactMatch(worktrees, 'feature-a')).toBeUndefined();
+  });
+});
+
+describe('findFuzzyMatches', () => {
+  it('子串匹配（大小写不敏感）', () => {
+    const worktrees = [
+      createWorktreeInfo({ branch: 'feature-login' }),
+      createWorktreeInfo({ branch: 'feature-logout' }),
+      createWorktreeInfo({ branch: 'bugfix-auth' }),
+    ];
+    const result = findFuzzyMatches(worktrees, 'LOG');
+    expect(result).toHaveLength(2);
+    expect(result.map((w) => w.branch)).toEqual(['feature-login', 'feature-logout']);
+  });
+
+  it('空列表返回空数组', () => {
+    expect(findFuzzyMatches([], 'test')).toEqual([]);
+  });
+
+  it('无匹配返回空数组', () => {
+    const worktrees = [createWorktreeInfo({ branch: 'feature-a' })];
+    expect(findFuzzyMatches(worktrees, 'xyz')).toEqual([]);
+  });
+
+  it('全部匹配时返回全部', () => {
+    const worktrees = createWorktreeList(3);
+    const result = findFuzzyMatches(worktrees, 'branch');
+    expect(result).toHaveLength(3);
+  });
+});
+
+describe('resolveTargetWorktree', () => {
+  it('空列表抛出 ClawtError', async () => {
+    await expect(resolveTargetWorktree([], testMessages, 'any')).rejects.toThrow(ClawtError);
+    await expect(resolveTargetWorktree([], testMessages, 'any')).rejects.toThrow('无可用 worktree');
+  });
+
+  it('单个 worktree 且不传分支名时直接返回', async () => {
+    const worktrees = [createWorktreeInfo({ branch: 'only-one' })];
+    const result = await resolveTargetWorktree(worktrees, testMessages);
+    expect(result.branch).toBe('only-one');
+  });
+
+  it('精确匹配优先', async () => {
+    const worktrees = [
+      createWorktreeInfo({ branch: 'feat' }),
+      createWorktreeInfo({ branch: 'feature' }),
+    ];
+    const result = await resolveTargetWorktree(worktrees, testMessages, 'feat');
+    expect(result.branch).toBe('feat');
+  });
+
+  it('模糊匹配唯一结果直接返回', async () => {
+    const worktrees = [
+      createWorktreeInfo({ branch: 'feature-login' }),
+      createWorktreeInfo({ branch: 'bugfix-auth' }),
+    ];
+    const result = await resolveTargetWorktree(worktrees, testMessages, 'login');
+    expect(result.branch).toBe('feature-login');
+  });
+
+  it('无匹配抛出 ClawtError 并包含可用分支', async () => {
+    const worktrees = [
+      createWorktreeInfo({ branch: 'feature-a' }),
+      createWorktreeInfo({ branch: 'feature-b' }),
+    ];
+    await expect(resolveTargetWorktree(worktrees, testMessages, 'xyz')).rejects.toThrow(ClawtError);
+  });
+});

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

@@ -0,0 +1,181 @@
+import { describe, it, expect, vi } from 'vitest';
+
+// mock git 函数
+vi.mock('../../../src/utils/git.js', () => ({
+  getProjectName: vi.fn().mockReturnValue('my-project'),
+  gitWorktreeList: vi.fn().mockReturnValue(''),
+  createWorktree: vi.fn(),
+  removeWorktreeByPath: vi.fn(),
+  deleteBranch: vi.fn(),
+  gitWorktreePrune: vi.fn(),
+  getCommitCountAhead: vi.fn(),
+  getDiffStat: vi.fn(),
+  isWorkingDirClean: vi.fn(),
+}));
+
+// mock branch
+vi.mock('../../../src/utils/branch.js', () => ({
+  sanitizeBranchName: vi.fn((name: string) => name),
+  generateBranchNames: vi.fn((name: string, count: number) =>
+    count === 1 ? [name] : Array.from({ length: count }, (_, i) => `${name}-${i + 1}`),
+  ),
+  validateBranchesNotExist: vi.fn(),
+}));
+
+// mock fs
+vi.mock('../../../src/utils/fs.js', () => ({
+  ensureDir: vi.fn(),
+  removeEmptyDir: vi.fn(),
+}));
+
+// mock node:fs
+vi.mock('node:fs', () => ({
+  existsSync: vi.fn(),
+  readdirSync: vi.fn(),
+}));
+
+// mock constants
+vi.mock('../../../src/constants/index.js', async (importOriginal) => {
+  const original = await importOriginal<typeof import('../../../src/constants/index.js')>();
+  return {
+    ...original,
+    WORKTREES_DIR: '/tmp/test-worktrees',
+  };
+});
+
+// mock logger
+vi.mock('../../../src/logger/index.js', () => ({
+  logger: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+
+import { existsSync, readdirSync } from 'node:fs';
+import {
+  getProjectName,
+  gitWorktreeList,
+  createWorktree as gitCreateWorktree,
+  removeWorktreeByPath,
+  deleteBranch,
+  gitWorktreePrune,
+  getCommitCountAhead,
+  getDiffStat,
+  isWorkingDirClean,
+} from '../../../src/utils/git.js';
+import { sanitizeBranchName, validateBranchesNotExist } from '../../../src/utils/branch.js';
+import { ensureDir, removeEmptyDir } from '../../../src/utils/fs.js';
+import { createWorktrees, getProjectWorktrees, cleanupWorktrees, getWorktreeStatus } from '../../../src/utils/worktree.js';
+import { createWorktreeInfo } from '../../helpers/fixtures.js';
+
+const mockedExistsSync = vi.mocked(existsSync);
+const mockedReaddirSync = vi.mocked(readdirSync);
+const mockedGitWorktreeList = vi.mocked(gitWorktreeList);
+const mockedGitCreateWorktree = vi.mocked(gitCreateWorktree);
+const mockedRemoveWorktreeByPath = vi.mocked(removeWorktreeByPath);
+const mockedDeleteBranch = vi.mocked(deleteBranch);
+const mockedGetCommitCountAhead = vi.mocked(getCommitCountAhead);
+const mockedGetDiffStat = vi.mocked(getDiffStat);
+const mockedIsWorkingDirClean = vi.mocked(isWorkingDirClean);
+
+describe('createWorktrees', () => {
+  it('单个 worktree 创建', () => {
+    const result = createWorktrees('feature', 1);
+    expect(result).toHaveLength(1);
+    expect(result[0].branch).toBe('feature');
+    expect(result[0].path).toContain('feature');
+    expect(mockedGitCreateWorktree).toHaveBeenCalledTimes(1);
+  });
+
+  it('多个 worktree 创建', () => {
+    const result = createWorktrees('task', 3);
+    expect(result).toHaveLength(3);
+    expect(result[0].branch).toBe('task-1');
+    expect(result[1].branch).toBe('task-2');
+    expect(result[2].branch).toBe('task-3');
+    expect(mockedGitCreateWorktree).toHaveBeenCalledTimes(3);
+  });
+
+  it('调用分支名清理和存在性校验', () => {
+    createWorktrees('feature', 1);
+    expect(sanitizeBranchName).toHaveBeenCalledWith('feature');
+    expect(validateBranchesNotExist).toHaveBeenCalled();
+    expect(ensureDir).toHaveBeenCalled();
+  });
+});
+
+describe('getProjectWorktrees', () => {
+  it('项目目录不存在时返回空数组', () => {
+    mockedExistsSync.mockReturnValue(false);
+    expect(getProjectWorktrees()).toEqual([]);
+  });
+
+  it('正确解析和交叉验证', () => {
+    mockedExistsSync.mockReturnValue(true);
+    mockedGitWorktreeList.mockReturnValue(
+      '/repo  abc [main]\n/tmp/test-worktrees/my-project/feature  def [feature]',
+    );
+    mockedReaddirSync.mockReturnValue([
+      { name: 'feature', isDirectory: () => true },
+      { name: 'orphan', isDirectory: () => true },
+      { name: 'file.txt', isDirectory: () => false },
+    ] as any);
+    const result = getProjectWorktrees();
+    expect(result).toHaveLength(1);
+    expect(result[0].branch).toBe('feature');
+  });
+});
+
+describe('cleanupWorktrees', () => {
+  it('正确调用删除流程', () => {
+    const worktrees = [
+      createWorktreeInfo({ branch: 'a', path: '/path/a' }),
+      createWorktreeInfo({ branch: 'b', path: '/path/b' }),
+    ];
+    cleanupWorktrees(worktrees);
+    expect(mockedRemoveWorktreeByPath).toHaveBeenCalledTimes(2);
+    expect(mockedDeleteBranch).toHaveBeenCalledTimes(2);
+    expect(gitWorktreePrune).toHaveBeenCalled();
+    expect(removeEmptyDir).toHaveBeenCalled();
+  });
+
+  it('单个删除失败不影响后续', () => {
+    mockedRemoveWorktreeByPath.mockImplementationOnce(() => { throw new Error('fail'); });
+    const worktrees = [
+      createWorktreeInfo({ branch: 'a', path: '/path/a' }),
+      createWorktreeInfo({ branch: 'b', path: '/path/b' }),
+    ];
+    // 不应抛出异常
+    expect(() => cleanupWorktrees(worktrees)).not.toThrow();
+  });
+});
+
+describe('getWorktreeStatus', () => {
+  it('正确聚合状态信息', () => {
+    mockedGetCommitCountAhead.mockReturnValue(5);
+    mockedGetDiffStat.mockReturnValue({ insertions: 100, deletions: 20 });
+    mockedIsWorkingDirClean.mockReturnValue(false);
+    const worktree = createWorktreeInfo();
+    const result = getWorktreeStatus(worktree);
+    expect(result).toEqual({
+      commitCount: 5,
+      insertions: 100,
+      deletions: 20,
+      hasDirtyFiles: true,
+    });
+  });
+
+  it('工作区干净时 hasDirtyFiles 为 false', () => {
+    mockedGetCommitCountAhead.mockReturnValue(0);
+    mockedGetDiffStat.mockReturnValue({ insertions: 0, deletions: 0 });
+    mockedIsWorkingDirClean.mockReturnValue(true);
+    const worktree = createWorktreeInfo();
+    const result = getWorktreeStatus(worktree);
+    expect(result).not.toBeNull();
+    expect(result!.hasDirtyFiles).toBe(false);
+  });
+
+  it('获取失败时返回 null', () => {
+    mockedGetCommitCountAhead.mockImplementation(() => { throw new Error('fail'); });
+    const worktree = createWorktreeInfo();
+    const result = getWorktreeStatus(worktree);
+    expect(result).toBeNull();
+  });
+});

package/tsconfig.json

@@ -12,6 +12,6 @@
     "resolveJsonModule": true,
     "forceConsistentCasingInFileNames": true
   },
-  "include": ["src/**/*", "scripts/**/*"],
+  "include": ["src/**/*", "scripts/**/*", "tests/**/*"],
   "exclude": ["node_modules", "dist"]
 }

package/vitest.config.ts

@@ -0,0 +1,22 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    include: ['tests/**/*.test.ts'],
+    testTimeout: 10000,
+    environment: 'node',
+    setupFiles: ['tests/helpers/setup.ts'],
+    coverage: {
+      provider: 'v8',
+      include: ['src/**/*.ts'],
+      exclude: [
+        'src/index.ts',
+        'src/types/**',
+        'src/logger/**',
+      ],
+      reporter: ['text', 'lcov', 'html'],
+    },
+    restoreMocks: true,
+    clearMocks: true,
+  },
+});