clawt 2.8.2 → 2.9.1

package/README.md

@@ -331,3 +331,21 @@ feature/a.b  →  feature-a-b
 ## 日志
 
 日志保存在 `~/.clawt/logs/` 目录，按日期滚动，保留 30 天。使用 `--debug` 全局选项可在终端实时查看调试日志。
+
+## 开发
+
+### 测试
+
+项目使用 [Vitest](https://vitest.dev/) 作为测试框架，搭配 `@vitest/coverage-v8` 生成覆盖率报告。
+
+```bash
+# 执行全部测试
+npm test
+
+# 监听模式（文件变更后自动重新运行）
+npm run test:watch
+
+# 执行测试并生成覆盖率报告
+npm run test:coverage
+```
+

package/docs/spec.md

@@ -27,6 +27,10 @@
   - [5.13 重置主 Worktree 工作区和暂存区](#513-重置主-worktree-工作区和暂存区)
 - [6. 错误处理规范](#6-错误处理规范)
 - [7. 非功能性需求](#7-非功能性需求)
+  - [7.1 性能](#71-性能)
+  - [7.2 兼容性](#72-兼容性)
+  - [7.3 测试](#73-测试)
+  - [7.4 安全性](#74-安全性)
 
 ---
 
@@ -40,6 +44,7 @@
 | CLI 框架 | Commander.js                  |
 | 日志库   | winston (按日期滚动文件)       |
 | 交互式   | enquirer (选项选择/确认对话)   |
+| 测试     | Vitest + @vitest/coverage-v8               |
 | 构建     | tsup / tsc                    |
 | 分发     | pnpm 全局安装 (`pnpm add -g clawt`) |
 
@@ -1155,7 +1160,27 @@ clawt reset
 - Node.js >= 18
 - Git >= 2.15（worktree 功能稳定版本）
 
-### 7.3 安全性
+### 7.3 测试
+
+- 测试框架：Vitest，配置文件为 `vitest.config.ts`
+- 覆盖率工具：@vitest/coverage-v8，覆盖率报告格式为 text、lcov、html
+- 测试目录结构：`tests/unit/` 下按模块分组（`constants/`、`errors/`、`utils/`）
+- 测试辅助文件：
+  - `tests/helpers/setup.ts`：全局 setup，禁用 chalk 颜色输出避免 ANSI 转义码干扰断言
+  - `tests/helpers/fixtures.ts`：测试数据工厂，提供 `createWorktreeInfo()`、`createWorktreeStatus()`、`createWorktreeList()` 等工厂函数
+- 覆盖范围：`src/` 下的 `utils/`、`errors/`、`constants/` 全部关键模块，共 12 个测试文件、163 个测试用例
+- 覆盖率统计排除项：`src/index.ts`（入口文件）、`src/types/**`（类型定义）、`src/logger/**`（日志模块）
+- npm 脚本：
+  - `npm test`：执行全部测试（`vitest run`）
+  - `npm run test:watch`：监听模式（`vitest`）
+  - `npm run test:coverage`：执行测试并生成覆盖率报告（`vitest run --coverage`）
+- 测试配置特性：
+  - `restoreMocks: true`：每个测试后自动恢复 mock
+  - `clearMocks: true`：每个测试后自动清除 mock 调用记录
+  - `testTimeout: 10000`：单个测试超时 10 秒
+  - `environment: 'node'`：使用 Node.js 测试环境
+
+### 7.4 安全性
 
 - 不在日志中记录 Claude Code API 密钥等敏感信息
 - `--permission-mode bypassPermissions` 仅在 worktree 隔离环境中使用

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawt",
-  "version": "2.8.2",
+  "version": "2.9.1",
   "description": "本地并行执行多个Claude Code Agent任务，融合 Git Worktree 与 Claude Code CLI 的命令行工具",
   "type": "module",
   "main": "dist/index.js",
@@ -24,8 +24,10 @@
   },
   "devDependencies": {
     "@types/node": "^22.13.1",
+    "@vitest/coverage-v8": "^4.0.18",
     "tsup": "^8.3.6",
-    "typescript": "^5.7.3"
+    "typescript": "^5.7.3",
+    "vitest": "^4.0.18"
   },
   "engines": {
     "node": ">=18"
@@ -33,6 +35,9 @@
   "scripts": {
     "build": "tsup",
     "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
     "postinstall": "node dist/postinstall.js",
     "release": "bash scripts/release.sh"
   }

package/tests/helpers/fixtures.ts

@@ -0,0 +1,41 @@
+import type { WorktreeInfo, WorktreeStatus } from '../../src/types/index.js';
+
+/**
+ * 创建测试用 WorktreeInfo
+ * @param {Partial<WorktreeInfo>} overrides - 覆盖字段
+ * @returns {WorktreeInfo} 测试数据
+ */
+export function createWorktreeInfo(overrides: Partial<WorktreeInfo> = {}): WorktreeInfo {
+  return {
+    path: '/Users/test/.clawt/worktrees/my-project/feature-branch',
+    branch: 'feature-branch',
+    ...overrides,
+  };
+}
+
+/**
+ * 创建测试用 WorktreeStatus
+ * @param {Partial<WorktreeStatus>} overrides - 覆盖字段
+ * @returns {WorktreeStatus} 测试数据
+ */
+export function createWorktreeStatus(overrides: Partial<WorktreeStatus> = {}): WorktreeStatus {
+  return {
+    commitCount: 3,
+    insertions: 42,
+    deletions: 10,
+    hasDirtyFiles: false,
+    ...overrides,
+  };
+}
+
+/**
+ * 创建多个测试用 WorktreeInfo
+ * @param {number} count - 数量
+ * @returns {WorktreeInfo[]} 测试数据数组
+ */
+export function createWorktreeList(count: number): WorktreeInfo[] {
+  return Array.from({ length: count }, (_, i) => createWorktreeInfo({
+    path: `/Users/test/.clawt/worktrees/my-project/branch-${i + 1}`,
+    branch: `branch-${i + 1}`,
+  }));
+}

package/tests/helpers/setup.ts

@@ -0,0 +1,2 @@
+// 禁用 chalk 颜色输出，避免 ANSI 转义码干扰断言
+process.env.FORCE_COLOR = '0';

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

@@ -0,0 +1,58 @@
+import { describe, it, expect } from 'vitest';
+import { INVALID_BRANCH_CHARS } from '../../../src/constants/branch.js';
+
+describe('INVALID_BRANCH_CHARS', () => {
+  it('是一个全局正则表达式', () => {
+    expect(INVALID_BRANCH_CHARS).toBeInstanceOf(RegExp);
+    expect(INVALID_BRANCH_CHARS.global).toBe(true);
+  });
+
+  it('匹配斜杠 /', () => {
+    expect('feature/test'.replace(new RegExp(INVALID_BRANCH_CHARS.source, 'g'), '-')).toBe('feature-test');
+  });
+
+  it('匹配反斜杠 \\', () => {
+    expect('feature\\test'.replace(new RegExp(INVALID_BRANCH_CHARS.source, 'g'), '-')).toBe('feature-test');
+  });
+
+  it('匹配点号 .', () => {
+    expect('feature.test'.replace(new RegExp(INVALID_BRANCH_CHARS.source, 'g'), '-')).toBe('feature-test');
+  });
+
+  it('匹配空格', () => {
+    expect('feature test'.replace(new RegExp(INVALID_BRANCH_CHARS.source, 'g'), '-')).toBe('feature-test');
+  });
+
+  it('匹配波浪号 ~', () => {
+    expect('feature~test'.replace(new RegExp(INVALID_BRANCH_CHARS.source, 'g'), '-')).toBe('feature-test');
+  });
+
+  it('匹配冒号 :', () => {
+    expect('feature:test'.replace(new RegExp(INVALID_BRANCH_CHARS.source, 'g'), '-')).toBe('feature-test');
+  });
+
+  it('匹配星号 *', () => {
+    expect('feature*test'.replace(new RegExp(INVALID_BRANCH_CHARS.source, 'g'), '-')).toBe('feature-test');
+  });
+
+  it('匹配问号 ?', () => {
+    expect('feature?test'.replace(new RegExp(INVALID_BRANCH_CHARS.source, 'g'), '-')).toBe('feature-test');
+  });
+
+  it('匹配方括号 []', () => {
+    expect('feature[test]'.replace(new RegExp(INVALID_BRANCH_CHARS.source, 'g'), '-')).toBe('feature-test-');
+  });
+
+  it('匹配 ^', () => {
+    expect('feature^test'.replace(new RegExp(INVALID_BRANCH_CHARS.source, 'g'), '-')).toBe('feature-test');
+  });
+
+  it('连续非法字符合并为一次匹配', () => {
+    expect('feature...test'.replace(new RegExp(INVALID_BRANCH_CHARS.source, 'g'), '-')).toBe('feature-test');
+  });
+
+  it('不匹配合法字符（字母、数字、-）', () => {
+    const legal = 'feature-add-login-123';
+    expect(legal.replace(new RegExp(INVALID_BRANCH_CHARS.source, 'g'), '-')).toBe(legal);
+  });
+});

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

@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest';
+import { CONFIG_DEFINITIONS, DEFAULT_CONFIG, CONFIG_DESCRIPTIONS } from '../../../src/constants/config.js';
+
+describe('CONFIG_DEFINITIONS', () => {
+  it('所有配置项都有 defaultValue 和 description', () => {
+    for (const [key, def] of Object.entries(CONFIG_DEFINITIONS)) {
+      expect(def).toHaveProperty('defaultValue');
+      expect(def).toHaveProperty('description');
+      expect(typeof def.description).toBe('string');
+      expect(def.description.length).toBeGreaterThan(0);
+    }
+  });
+});
+
+describe('DEFAULT_CONFIG', () => {
+  it('与 CONFIG_DEFINITIONS 的 key 一致', () => {
+    const definitionKeys = Object.keys(CONFIG_DEFINITIONS).sort();
+    const configKeys = Object.keys(DEFAULT_CONFIG).sort();
+    expect(configKeys).toEqual(definitionKeys);
+  });
+
+  it('每个 key 的值等于对应 CONFIG_DEFINITIONS 的 defaultValue', () => {
+    for (const [key, def] of Object.entries(CONFIG_DEFINITIONS)) {
+      expect((DEFAULT_CONFIG as Record<string, unknown>)[key]).toBe(def.defaultValue);
+    }
+  });
+
+  it('包含预期的配置项和默认值', () => {
+    expect(DEFAULT_CONFIG.autoDeleteBranch).toBe(false);
+    expect(DEFAULT_CONFIG.claudeCodeCommand).toBe('claude');
+    expect(DEFAULT_CONFIG.autoPullPush).toBe(false);
+    expect(DEFAULT_CONFIG.confirmDestructiveOps).toBe(true);
+  });
+});
+
+describe('CONFIG_DESCRIPTIONS', () => {
+  it('与 CONFIG_DEFINITIONS 的 key 一致', () => {
+    const definitionKeys = Object.keys(CONFIG_DEFINITIONS).sort();
+    const descriptionKeys = Object.keys(CONFIG_DESCRIPTIONS).sort();
+    expect(descriptionKeys).toEqual(definitionKeys);
+  });
+
+  it('每个 key 的值等于对应 CONFIG_DEFINITIONS 的 description', () => {
+    for (const [key, def] of Object.entries(CONFIG_DEFINITIONS)) {
+      expect((CONFIG_DESCRIPTIONS as Record<string, string>)[key]).toBe(def.description);
+    }
+  });
+
+  it('所有描述值都是非空字符串', () => {
+    for (const desc of Object.values(CONFIG_DESCRIPTIONS)) {
+      expect(typeof desc).toBe('string');
+      expect(desc.length).toBeGreaterThan(0);
+    }
+  });
+});

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

@@ -0,0 +1,27 @@
+import { describe, it, expect } from 'vitest';
+import { EXIT_CODES } from '../../../src/constants/exitCodes.js';
+
+describe('EXIT_CODES', () => {
+  it('SUCCESS 为 0', () => {
+    expect(EXIT_CODES.SUCCESS).toBe(0);
+  });
+
+  it('ERROR 为 1', () => {
+    expect(EXIT_CODES.ERROR).toBe(1);
+  });
+
+  it('ARGUMENT_ERROR 为 2', () => {
+    expect(EXIT_CODES.ARGUMENT_ERROR).toBe(2);
+  });
+
+  it('包含且仅包含三个退出码', () => {
+    expect(Object.keys(EXIT_CODES)).toHaveLength(3);
+    expect(Object.keys(EXIT_CODES).sort()).toEqual(['ARGUMENT_ERROR', 'ERROR', 'SUCCESS']);
+  });
+
+  it('所有值都是数字', () => {
+    for (const value of Object.values(EXIT_CODES)) {
+      expect(typeof value).toBe('number');
+    }
+  });
+});

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

@@ -0,0 +1,17 @@
+import { describe, it, expect } from 'vitest';
+import { AUTO_SAVE_COMMIT_MESSAGE } from '../../../src/constants/git.js';
+
+describe('AUTO_SAVE_COMMIT_MESSAGE', () => {
+  it('值为预期的 commit message', () => {
+    expect(AUTO_SAVE_COMMIT_MESSAGE).toBe('chore: auto-save before sync');
+  });
+
+  it('是非空字符串', () => {
+    expect(typeof AUTO_SAVE_COMMIT_MESSAGE).toBe('string');
+    expect(AUTO_SAVE_COMMIT_MESSAGE.length).toBeGreaterThan(0);
+  });
+
+  it('符合 conventional commit 格式', () => {
+    expect(AUTO_SAVE_COMMIT_MESSAGE).toMatch(/^[a-z]+:\s.+$/);
+  });
+});

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

@@ -0,0 +1,25 @@
+import { describe, it, expect } from 'vitest';
+import { DEBUG_LOG_PREFIX, DEBUG_TIMESTAMP_FORMAT } from '../../../src/constants/logger.js';
+
+describe('DEBUG_LOG_PREFIX', () => {
+  it('值为 [DEBUG]', () => {
+    expect(DEBUG_LOG_PREFIX).toBe('[DEBUG]');
+  });
+
+  it('包含方括号包裹的标识', () => {
+    expect(DEBUG_LOG_PREFIX).toMatch(/^\[.+\]$/);
+  });
+});
+
+describe('DEBUG_TIMESTAMP_FORMAT', () => {
+  it('值为 HH:mm:ss.SSS', () => {
+    expect(DEBUG_TIMESTAMP_FORMAT).toBe('HH:mm:ss.SSS');
+  });
+
+  it('包含时分秒和毫秒', () => {
+    expect(DEBUG_TIMESTAMP_FORMAT).toContain('HH');
+    expect(DEBUG_TIMESTAMP_FORMAT).toContain('mm');
+    expect(DEBUG_TIMESTAMP_FORMAT).toContain('ss');
+    expect(DEBUG_TIMESTAMP_FORMAT).toContain('SSS');
+  });
+});

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

@@ -0,0 +1,240 @@
+import { describe, it, expect } from 'vitest';
+import { MESSAGES } from '../../../src/constants/messages.js';
+
+describe('MESSAGES', () => {
+  describe('纯字符串消息', () => {
+    const stringKeys = [
+      'NOT_MAIN_WORKTREE',
+      'GIT_NOT_INSTALLED',
+      'CLAUDE_NOT_INSTALLED',
+      'NO_WORKTREES',
+      'MAIN_WORKTREE_DIRTY',
+      'TARGET_WORKTREE_CLEAN',
+      'MERGE_CONFLICT',
+      'COMMIT_MESSAGE_REQUIRED',
+      'TARGET_WORKTREE_DIRTY_NO_MESSAGE',
+      'TARGET_WORKTREE_NO_CHANGES',
+      'INTERRUPTED',
+      'INTERRUPT_CONFIRM_CLEANUP',
+      'INTERRUPT_KEPT',
+      'CONFIG_CORRUPTED',
+      'CONFIG_RESET_SUCCESS',
+      'SEPARATOR',
+      'DOUBLE_SEPARATOR',
+      'WORKTREE_STATUS_UNAVAILABLE',
+      'INCREMENTAL_VALIDATE_FALLBACK',
+      'MERGE_SQUASH_PROMPT',
+      'DESTRUCTIVE_OP_CANCELLED',
+      'RESET_SUCCESS',
+      'RESET_ALREADY_CLEAN',
+      'RESUME_NO_WORKTREES',
+      'RESUME_SELECT_BRANCH',
+      'VALIDATE_NO_WORKTREES',
+      'VALIDATE_SELECT_BRANCH',
+      'MERGE_NO_WORKTREES',
+      'MERGE_SELECT_BRANCH',
+      'SYNC_NO_WORKTREES',
+      'SYNC_SELECT_BRANCH',
+      'PULL_CONFLICT',
+      'PUSH_FAILED',
+    ] as const;
+
+    it.each(stringKeys)('%s 是非空字符串', (key) => {
+      const value = MESSAGES[key];
+      expect(typeof value).toBe('string');
+      expect((value as string).length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('模板函数消息', () => {
+    it('BRANCH_EXISTS 包含分支名', () => {
+      const result = MESSAGES.BRANCH_EXISTS('feature-a');
+      expect(result).toContain('feature-a');
+    });
+
+    it('BRANCH_EXISTS_USE_RESUME 包含分支名和 resume 提示', () => {
+      const result = MESSAGES.BRANCH_EXISTS_USE_RESUME('feature-a');
+      expect(result).toContain('feature-a');
+      expect(result).toContain('resume');
+    });
+
+    it('BRANCH_NAME_EMPTY 包含原始分支名', () => {
+      const result = MESSAGES.BRANCH_NAME_EMPTY('...');
+      expect(result).toContain('...');
+    });
+
+    it('BRANCH_SANITIZED 包含原始名和转换后的名称', () => {
+      const result = MESSAGES.BRANCH_SANITIZED('feat/test', 'feat-test');
+      expect(result).toContain('feat/test');
+      expect(result).toContain('feat-test');
+    });
+
+    it('WORKTREE_CREATED 包含数量', () => {
+      const result = MESSAGES.WORKTREE_CREATED(3);
+      expect(result).toContain('3');
+    });
+
+    it('WORKTREE_REMOVED 包含路径', () => {
+      const result = MESSAGES.WORKTREE_REMOVED('/path/to/wt');
+      expect(result).toContain('/path/to/wt');
+    });
+
+    it('WORKTREE_NOT_FOUND 包含名称', () => {
+      const result = MESSAGES.WORKTREE_NOT_FOUND('test-branch');
+      expect(result).toContain('test-branch');
+    });
+
+    it('VALIDATE_SUCCESS 包含分支名', () => {
+      const result = MESSAGES.VALIDATE_SUCCESS('feature-x');
+      expect(result).toContain('feature-x');
+    });
+
+    it('MERGE_SUCCESS 包含分支名和提交信息', () => {
+      const result = MESSAGES.MERGE_SUCCESS('feat-a', 'fix bug', true);
+      expect(result).toContain('feat-a');
+      expect(result).toContain('fix bug');
+      expect(result).toContain('已推送');
+    });
+
+    it('MERGE_SUCCESS 未推送时不包含推送提示', () => {
+      const result = MESSAGES.MERGE_SUCCESS('feat-a', 'fix bug', false);
+      expect(result).not.toContain('已推送');
+    });
+
+    it('MERGE_SUCCESS_NO_MESSAGE 包含分支名', () => {
+      const result = MESSAGES.MERGE_SUCCESS_NO_MESSAGE('feat-a', false);
+      expect(result).toContain('feat-a');
+    });
+
+    it('WORKTREE_CLEANED 包含分支名', () => {
+      const result = MESSAGES.WORKTREE_CLEANED('feature-clean');
+      expect(result).toContain('feature-clean');
+    });
+
+    it('INTERRUPT_AUTO_CLEANED 包含数量', () => {
+      const result = MESSAGES.INTERRUPT_AUTO_CLEANED(2);
+      expect(result).toContain('2');
+    });
+
+    it('INTERRUPT_CLEANED 包含数量', () => {
+      const result = MESSAGES.INTERRUPT_CLEANED(5);
+      expect(result).toContain('5');
+    });
+
+    it('INVALID_COUNT 包含无效值', () => {
+      const result = MESSAGES.INVALID_COUNT('abc');
+      expect(result).toContain('abc');
+    });
+
+    it('INCREMENTAL_VALIDATE_SUCCESS 包含分支名', () => {
+      const result = MESSAGES.INCREMENTAL_VALIDATE_SUCCESS('dev');
+      expect(result).toContain('dev');
+    });
+
+    it('VALIDATE_CLEANED 包含分支名', () => {
+      const result = MESSAGES.VALIDATE_CLEANED('test');
+      expect(result).toContain('test');
+    });
+
+    it('MERGE_VALIDATE_STATE_HINT 包含分支名', () => {
+      const result = MESSAGES.MERGE_VALIDATE_STATE_HINT('feat');
+      expect(result).toContain('feat');
+    });
+
+    it('SYNC_AUTO_COMMITTED 包含分支名', () => {
+      const result = MESSAGES.SYNC_AUTO_COMMITTED('sync-branch');
+      expect(result).toContain('sync-branch');
+    });
+
+    it('SYNC_MERGING 包含目标分支和主分支', () => {
+      const result = MESSAGES.SYNC_MERGING('feature', 'main');
+      expect(result).toContain('feature');
+      expect(result).toContain('main');
+    });
+
+    it('SYNC_SUCCESS 包含目标分支和主分支', () => {
+      const result = MESSAGES.SYNC_SUCCESS('feature', 'main');
+      expect(result).toContain('feature');
+      expect(result).toContain('main');
+    });
+
+    it('SYNC_CONFLICT 包含 worktree 路径', () => {
+      const result = MESSAGES.SYNC_CONFLICT('/path/to/wt');
+      expect(result).toContain('/path/to/wt');
+    });
+
+    it('VALIDATE_PATCH_APPLY_FAILED 包含分支名', () => {
+      const result = MESSAGES.VALIDATE_PATCH_APPLY_FAILED('feat');
+      expect(result).toContain('feat');
+      expect(result).toContain('sync');
+    });
+
+    it('MERGE_SQUASH_COMMITTED 包含分支名', () => {
+      const result = MESSAGES.MERGE_SQUASH_COMMITTED('feat');
+      expect(result).toContain('feat');
+    });
+
+    it('MERGE_SQUASH_PENDING 包含路径和分支名', () => {
+      const result = MESSAGES.MERGE_SQUASH_PENDING('/path/wt', 'feat');
+      expect(result).toContain('/path/wt');
+      expect(result).toContain('feat');
+    });
+
+    it('REMOVE_PARTIAL_FAILURE 包含失败信息', () => {
+      const failures = [
+        { path: '/path/a', error: '权限不足' },
+        { path: '/path/b', error: '不存在' },
+      ];
+      const result = MESSAGES.REMOVE_PARTIAL_FAILURE(failures);
+      expect(result).toContain('/path/a');
+      expect(result).toContain('权限不足');
+      expect(result).toContain('/path/b');
+      expect(result).toContain('不存在');
+    });
+
+    it('RESUME_NO_MATCH 包含名称和分支列表', () => {
+      const result = MESSAGES.RESUME_NO_MATCH('test', ['branch-1', 'branch-2']);
+      expect(result).toContain('test');
+      expect(result).toContain('branch-1');
+      expect(result).toContain('branch-2');
+    });
+
+    it('RESUME_MULTIPLE_MATCHES 包含名称', () => {
+      const result = MESSAGES.RESUME_MULTIPLE_MATCHES('feat');
+      expect(result).toContain('feat');
+    });
+
+    it('VALIDATE_NO_MATCH 包含名称和分支列表', () => {
+      const result = MESSAGES.VALIDATE_NO_MATCH('test', ['b1']);
+      expect(result).toContain('test');
+      expect(result).toContain('b1');
+    });
+
+    it('VALIDATE_MULTIPLE_MATCHES 包含名称', () => {
+      const result = MESSAGES.VALIDATE_MULTIPLE_MATCHES('feat');
+      expect(result).toContain('feat');
+    });
+
+    it('MERGE_NO_MATCH 包含名称和分支列表', () => {
+      const result = MESSAGES.MERGE_NO_MATCH('test', ['b1']);
+      expect(result).toContain('test');
+      expect(result).toContain('b1');
+    });
+
+    it('MERGE_MULTIPLE_MATCHES 包含名称', () => {
+      const result = MESSAGES.MERGE_MULTIPLE_MATCHES('feat');
+      expect(result).toContain('feat');
+    });
+
+    it('SYNC_NO_MATCH 包含名称和分支列表', () => {
+      const result = MESSAGES.SYNC_NO_MATCH('test', ['b1']);
+      expect(result).toContain('test');
+      expect(result).toContain('b1');
+    });
+
+    it('SYNC_MULTIPLE_MATCHES 包含名称', () => {
+      const result = MESSAGES.SYNC_MULTIPLE_MATCHES('feat');
+      expect(result).toContain('feat');
+    });
+  });
+});

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

@@ -0,0 +1,51 @@
+import { describe, it, expect } from 'vitest';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { CLAWT_HOME, CONFIG_PATH, LOGS_DIR, WORKTREES_DIR, VALIDATE_SNAPSHOTS_DIR } from '../../../src/constants/paths.js';
+
+describe('CLAWT_HOME', () => {
+  it('位于用户主目录下的 .clawt', () => {
+    expect(CLAWT_HOME).toBe(join(homedir(), '.clawt'));
+  });
+
+  it('包含 .clawt', () => {
+    expect(CLAWT_HOME).toContain('.clawt');
+  });
+});
+
+describe('CONFIG_PATH', () => {
+  it('位于 CLAWT_HOME 下的 config.json', () => {
+    expect(CONFIG_PATH).toBe(join(CLAWT_HOME, 'config.json'));
+  });
+
+  it('以 .json 结尾', () => {
+    expect(CONFIG_PATH).toMatch(/\.json$/);
+  });
+});
+
+describe('LOGS_DIR', () => {
+  it('位于 CLAWT_HOME 下的 logs', () => {
+    expect(LOGS_DIR).toBe(join(CLAWT_HOME, 'logs'));
+  });
+});
+
+describe('WORKTREES_DIR', () => {
+  it('位于 CLAWT_HOME 下的 worktrees', () => {
+    expect(WORKTREES_DIR).toBe(join(CLAWT_HOME, 'worktrees'));
+  });
+});
+
+describe('VALIDATE_SNAPSHOTS_DIR', () => {
+  it('位于 CLAWT_HOME 下的 validate-snapshots', () => {
+    expect(VALIDATE_SNAPSHOTS_DIR).toBe(join(CLAWT_HOME, 'validate-snapshots'));
+  });
+});
+
+describe('路径层级关系', () => {
+  it('CONFIG_PATH、LOGS_DIR、WORKTREES_DIR、VALIDATE_SNAPSHOTS_DIR 都在 CLAWT_HOME 下', () => {
+    expect(CONFIG_PATH.startsWith(CLAWT_HOME)).toBe(true);
+    expect(LOGS_DIR.startsWith(CLAWT_HOME)).toBe(true);
+    expect(WORKTREES_DIR.startsWith(CLAWT_HOME)).toBe(true);
+    expect(VALIDATE_SNAPSHOTS_DIR.startsWith(CLAWT_HOME)).toBe(true);
+  });
+});

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

@@ -0,0 +1,41 @@
+import { describe, it, expect } from 'vitest';
+import { ENABLE_BRACKETED_PASTE, DISABLE_BRACKETED_PASTE, PASTE_THRESHOLD_MS } from '../../../src/constants/terminal.js';
+
+describe('ENABLE_BRACKETED_PASTE', () => {
+  it('值为启用 Bracketed Paste Mode 的 ANSI 转义序列', () => {
+    expect(ENABLE_BRACKETED_PASTE).toBe('\x1b[?2004h');
+  });
+
+  it('以 ESC[ 开头', () => {
+    expect(ENABLE_BRACKETED_PASTE.startsWith('\x1b[')).toBe(true);
+  });
+});
+
+describe('DISABLE_BRACKETED_PASTE', () => {
+  it('值为禁用 Bracketed Paste Mode 的 ANSI 转义序列', () => {
+    expect(DISABLE_BRACKETED_PASTE).toBe('\x1b[?2004l');
+  });
+
+  it('以 ESC[ 开头', () => {
+    expect(DISABLE_BRACKETED_PASTE.startsWith('\x1b[')).toBe(true);
+  });
+});
+
+describe('ENABLE_BRACKETED_PASTE 与 DISABLE_BRACKETED_PASTE', () => {
+  it('仅末尾字符不同（h vs l）', () => {
+    expect(ENABLE_BRACKETED_PASTE.slice(0, -1)).toBe(DISABLE_BRACKETED_PASTE.slice(0, -1));
+    expect(ENABLE_BRACKETED_PASTE.at(-1)).toBe('h');
+    expect(DISABLE_BRACKETED_PASTE.at(-1)).toBe('l');
+  });
+});
+
+describe('PASTE_THRESHOLD_MS', () => {
+  it('值为 10', () => {
+    expect(PASTE_THRESHOLD_MS).toBe(10);
+  });
+
+  it('是正整数', () => {
+    expect(Number.isInteger(PASTE_THRESHOLD_MS)).toBe(true);
+    expect(PASTE_THRESHOLD_MS).toBeGreaterThan(0);
+  });
+});