clawt 2.19.0 → 3.0.0

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-matcher.test.ts

@@ -1,7 +1,8 @@
 import { describe, it, expect, vi } from 'vitest';
-import { findExactMatch, findFuzzyMatches, resolveTargetWorktree, resolveTargetWorktrees } from '../../../src/utils/worktree-matcher.js';
+import { findExactMatch, findFuzzyMatches, resolveTargetWorktree, resolveTargetWorktrees, groupWorktreesByDate, buildGroupedChoices, buildGroupMembershipMap } from '../../../src/utils/worktree-matcher.js';
 import { createWorktreeInfo, createWorktreeList } from '../../helpers/fixtures.js';
 import { ClawtError } from '../../../src/errors/index.js';
+import { SELECT_ALL_NAME, GROUP_SELECT_ALL_PREFIX, UNKNOWN_DATE_GROUP } from '../../../src/constants/index.js';
 import type { WorktreeResolveMessages, WorktreeMultiResolveMessages } from '../../../src/utils/worktree-matcher.js';
 
 // mock enquirer
@@ -16,6 +17,19 @@ vi.mock('enquirer', () => ({
   },
 }));
 
+// mock getBranchCreatedAt，分组测试中按需控制返回值
+vi.mock('../../../src/utils/git.js', () => ({
+  getBranchCreatedAt: vi.fn().mockReturnValue(null),
+}));
+
+// mock node:fs 的 statSync，分组测试中按需控制返回值
+vi.mock('node:fs', () => ({
+  statSync: vi.fn().mockReturnValue({ birthtime: new Date('2026-02-27T10:00:00') }),
+}));
+
+import { statSync } from 'node:fs';
+const mockedStatSync = vi.mocked(statSync);
+
 /** 测试用消息配置 */
 const testMessages: WorktreeResolveMessages = {
   noWorktrees: '无可用 worktree',
@@ -190,3 +204,130 @@ describe('resolveTargetWorktrees', () => {
     await expect(resolveTargetWorktrees(worktrees, testMultiMessages, 'xyz')).rejects.toThrow(ClawtError);
   });
 });
+
+describe('groupWorktreesByDate', () => {
+  it('多日期分组：不同日期的分支被正确分组，最新日期在前', () => {
+    const worktrees = [
+      createWorktreeInfo({ path: '/worktrees/feature-auth', branch: 'feature-auth' }),
+      createWorktreeInfo({ path: '/worktrees/feature-login', branch: 'feature-login' }),
+      createWorktreeInfo({ path: '/worktrees/bugfix-nav', branch: 'bugfix-nav' }),
+    ];
+
+    mockedStatSync
+      .mockReturnValueOnce({ birthtime: new Date('2026-02-26T10:00:00') } as any)
+      .mockReturnValueOnce({ birthtime: new Date('2026-02-26T14:00:00') } as any)
+      .mockReturnValueOnce({ birthtime: new Date('2026-02-25T09:00:00') } as any);
+
+    const groups = groupWorktreesByDate(worktrees);
+    const keys = [...groups.keys()];
+
+    // 最新日期在前
+    expect(keys).toEqual(['2026-02-26', '2026-02-25']);
+    // 2026-02-26 组有 2 个分支
+    expect(groups.get('2026-02-26')).toHaveLength(2);
+    expect(groups.get('2026-02-26')!.map((wt) => wt.branch)).toEqual(['feature-auth', 'feature-login']);
+    // 2026-02-25 组有 1 个分支
+    expect(groups.get('2026-02-25')).toHaveLength(1);
+    expect(groups.get('2026-02-25')![0].branch).toBe('bugfix-nav');
+  });
+
+  it('statSync 异常时归入"未知日期"组', () => {
+    const worktrees = [
+      createWorktreeInfo({ path: '/worktrees/feature-auth', branch: 'feature-auth' }),
+      createWorktreeInfo({ path: '/worktrees/old-branch', branch: 'old-branch' }),
+    ];
+
+    mockedStatSync
+      .mockReturnValueOnce({ birthtime: new Date('2026-02-26T10:00:00') } as any)
+      .mockImplementationOnce(() => { throw new Error('ENOENT'); });
+
+    const groups = groupWorktreesByDate(worktrees);
+    const keys = [...groups.keys()];
+
+    // 未知日期在最后
+    expect(keys).toEqual(['2026-02-26', UNKNOWN_DATE_GROUP]);
+    expect(groups.get(UNKNOWN_DATE_GROUP)).toHaveLength(1);
+    expect(groups.get(UNKNOWN_DATE_GROUP)![0].branch).toBe('old-branch');
+  });
+
+  it('单日期分组：所有分支同一天', () => {
+    const worktrees = [
+      createWorktreeInfo({ path: '/worktrees/feature-a', branch: 'feature-a' }),
+      createWorktreeInfo({ path: '/worktrees/feature-b', branch: 'feature-b' }),
+    ];
+
+    mockedStatSync
+      .mockReturnValueOnce({ birthtime: new Date('2026-02-26T10:00:00') } as any)
+      .mockReturnValueOnce({ birthtime: new Date('2026-02-26T15:00:00') } as any);
+
+    const groups = groupWorktreesByDate(worktrees);
+    const keys = [...groups.keys()];
+
+    expect(keys).toEqual(['2026-02-26']);
+    expect(groups.get('2026-02-26')).toHaveLength(2);
+  });
+});
+
+describe('buildGroupedChoices', () => {
+  it('构建的 choices 包含全局全选、分隔线、组全选和分支', () => {
+    const groups = new Map<string, Array<{ path: string; branch: string }>>([
+      ['2026-02-26', [
+        createWorktreeInfo({ branch: 'feature-auth' }),
+        createWorktreeInfo({ branch: 'feature-login' }),
+      ]],
+      [UNKNOWN_DATE_GROUP, [
+        createWorktreeInfo({ branch: 'old-branch' }),
+      ]],
+    ]);
+
+    const choices = buildGroupedChoices(groups);
+
+    // 全局全选在顶部
+    expect(choices[0]).toEqual({ name: SELECT_ALL_NAME, message: '[select-all]' });
+
+    // 第一组分隔线
+    expect(choices[1]).toHaveProperty('role', 'separator');
+
+    // 第一组组全选
+    expect(choices[2]).toEqual({
+      name: `${GROUP_SELECT_ALL_PREFIX}2026-02-26`,
+      message: '[select-all: 2026-02-26]',
+    });
+
+    // 第一组分支
+    expect(choices[3]).toEqual({ name: 'feature-auth', message: 'feature-auth' });
+    expect(choices[4]).toEqual({ name: 'feature-login', message: 'feature-login' });
+
+    // 未知日期组分隔线（含 chalk 高亮，使用 stringContaining 匹配）
+    expect(choices[5]).toHaveProperty('role', 'separator');
+    expect((choices[5] as { message: string }).message).toContain('未知日期');
+
+    // 未知日期组全选
+    expect(choices[6]).toEqual({
+      name: `${GROUP_SELECT_ALL_PREFIX}${UNKNOWN_DATE_GROUP}`,
+      message: `[select-all: ${UNKNOWN_DATE_GROUP}]`,
+    });
+
+    // 未知日期组分支
+    expect(choices[7]).toEqual({ name: 'old-branch', message: 'old-branch' });
+  });
+});
+
+describe('buildGroupMembershipMap', () => {
+  it('构建组全选 name 到分支 name 列表的正确映射', () => {
+    const groups = new Map<string, Array<{ path: string; branch: string }>>([
+      ['2026-02-26', [
+        createWorktreeInfo({ branch: 'feature-auth' }),
+        createWorktreeInfo({ branch: 'feature-login' }),
+      ]],
+      ['2026-02-25', [
+        createWorktreeInfo({ branch: 'bugfix-nav' }),
+      ]],
+    ]);
+
+    const membershipMap = buildGroupMembershipMap(groups);
+
+    expect(membershipMap.get(`${GROUP_SELECT_ALL_PREFIX}2026-02-26`)).toEqual(['feature-auth', 'feature-login']);
+    expect(membershipMap.get(`${GROUP_SELECT_ALL_PREFIX}2026-02-25`)).toEqual(['bugfix-nav']);
+  });
+});

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,