clawt 3.1.2 → 3.2.0

package/src/utils/validate-core.ts

@@ -0,0 +1,174 @@
+import { logger } from '../logger/index.js';
+import { ClawtError } from '../errors/index.js';
+import { MESSAGES } from '../constants/index.js';
+import {
+  gitAddAll,
+  gitCommit,
+  gitRestoreStaged,
+  gitDiffBinaryAgainstBranch,
+  gitApplyFromStdin,
+  gitApplyCachedFromStdin,
+  gitResetSoft,
+  gitWriteTree,
+  gitReadTree,
+  getCommitTreeHash,
+  gitDiffTree,
+  gitApplyCachedCheck,
+  getValidateBranchName,
+  checkBranchExists,
+  gitCheckout,
+  getCurrentBranch,
+  getHeadCommitHash,
+  writeSnapshot,
+  printWarning,
+} from './index.js';
+
+/**
+ * 通过 patch 将目标分支的全量变更（已提交 + 未提交）迁移到主 worktree
+ * 使用 git diff HEAD...branch --binary 获取变更，避免 stash 方式无法检测已提交 commit 的问题
+ * @param {string} targetWorktreePath - 目标 worktree 路径
+ * @param {string} mainWorktreePath - 主 worktree 路径
+ * @param {string} branchName - 分支名
+ * @param {boolean} hasUncommitted - 目标 worktree 是否有未提交修改
+ * @returns {{ success: boolean }} patch 迁移结果
+ */
+export function migrateChangesViaPatch(targetWorktreePath: string, mainWorktreePath: string, branchName: string, hasUncommitted: boolean): { success: boolean } {
+  let didTempCommit = false;
+
+  try {
+    // 如果有未提交修改，先做临时 commit 以便 diff 能捕获全部变更
+    if (hasUncommitted) {
+      gitAddAll(targetWorktreePath);
+      gitCommit('clawt:temp-commit-for-validate', targetWorktreePath);
+      didTempCommit = true;
+    }
+
+    // 在主 worktree 执行三点 diff，获取目标分支自分叉点以来的全量变更
+    const patch = gitDiffBinaryAgainstBranch(branchName, mainWorktreePath);
+
+    // 应用 patch 到主 worktree 工作目录
+    if (patch.length > 0) {
+      try {
+        gitApplyFromStdin(patch, mainWorktreePath);
+      } catch (error) {
+        logger.warn(`patch apply 失败: ${error}`);
+        printWarning(MESSAGES.VALIDATE_PATCH_APPLY_FAILED(branchName));
+        return { success: false };
+      }
+    }
+
+    return { success: true };
+  } finally {
+    // 确保临时 commit 一定会被撤销，恢复目标 worktree 原状
+    // 每个操作独立 try-catch，避免前一个失败导致后续操作不执行
+    if (didTempCommit) {
+      try {
+        gitResetSoft(1, targetWorktreePath);
+      } catch (error) {
+        logger.error(`撤销临时 commit 失败: ${error}`);
+      }
+      try {
+        gitRestoreStaged(targetWorktreePath);
+      } catch (error) {
+        logger.error(`恢复暂存区失败: ${error}`);
+      }
+    }
+  }
+}
+
+/**
+ * 计算当前主 worktree 工作目录变更的 git tree hash
+ * 操作序列：git add . → git write-tree → git restore --staged .
+ * 仅计算 tree hash，不写入快照文件
+ * @param {string} mainWorktreePath - 主 worktree 路径
+ * @returns {string} 当前工作目录变更对应的 tree hash
+ */
+export function computeCurrentTreeHash(mainWorktreePath: string): string {
+  gitAddAll(mainWorktreePath);
+  const treeHash = gitWriteTree(mainWorktreePath);
+  gitRestoreStaged(mainWorktreePath);
+  return treeHash;
+}
+
+/**
+ * 保存当前主 worktree 工作目录变更为 git tree 对象快照
+ * 操作序列：git add . → git write-tree → git restore --staged .
+ * 同时保存当前 HEAD commit hash，用于增量 validate 时对齐基准
+ * @param {string} mainWorktreePath - 主 worktree 路径
+ * @param {string} projectName - 项目名
+ * @param {string} branchName - 分支名
+ * @param {string} [stagedTreeHash=''] - validate 结束时暂存区对应的 tree hash
+ * @returns {string} 生成的 tree hash
+ */
+export function saveCurrentSnapshotTree(mainWorktreePath: string, projectName: string, branchName: string, stagedTreeHash = ''): string {
+  gitAddAll(mainWorktreePath);
+  const treeHash = gitWriteTree(mainWorktreePath);
+  gitRestoreStaged(mainWorktreePath);
+  const headCommitHash = getHeadCommitHash(mainWorktreePath);
+  writeSnapshot(projectName, branchName, treeHash, headCommitHash, stagedTreeHash);
+  return treeHash;
+}
+
+/**
+ * 将旧快照载入暂存区（从 handleIncrementalValidate 步骤 6 提取）
+ * 根据 HEAD 是否变化，选择不同的载入策略：
+ * - HEAD 变化：将旧变更 patch 重放到当前 HEAD 暂存区上
+ * - HEAD 未变化：直接 read-tree 旧快照
+ * @param {string} oldTreeHash - 旧快照的 tree hash
+ * @param {string} oldHeadCommitHash - 旧快照时的 HEAD commit hash
+ * @param {string} currentHeadCommitHash - 当前的 HEAD commit hash
+ * @param {string} mainWorktreePath - 主 worktree 路径
+ * @returns {{ success: boolean; stagedTreeHash: string }} 载入结果
+ */
+export function loadOldSnapshotToStage(oldTreeHash: string, oldHeadCommitHash: string, currentHeadCommitHash: string, mainWorktreePath: string): { success: boolean; stagedTreeHash: string } {
+  try {
+    if (oldHeadCommitHash && oldHeadCommitHash !== currentHeadCommitHash) {
+      // HEAD 发生了变化：
+      // 将旧变更 patch（旧 tree 相对于旧 HEAD 的差异）重放到当前 HEAD 暂存区上，
+      // 避免新旧 tree 基准不同导致 diff 混入 HEAD 变化的内容
+      const oldHeadTreeHash = getCommitTreeHash(oldHeadCommitHash, mainWorktreePath);
+      const oldChangePatch = gitDiffTree(oldHeadTreeHash, oldTreeHash, mainWorktreePath);
+
+      if (oldChangePatch.length > 0 && gitApplyCachedCheck(oldChangePatch, mainWorktreePath)) {
+        // 无冲突：apply --cached 到当前 HEAD 暂存区
+        gitApplyCachedFromStdin(oldChangePatch, mainWorktreePath);
+        // 记录暂存区的 tree hash（gitWriteTree 不修改暂存区内容，仅生成 tree 对象）
+        const stagedTreeHash = gitWriteTree(mainWorktreePath);
+        return { success: true, stagedTreeHash };
+      } else if (oldChangePatch.length > 0) {
+        // 有冲突：降级为全量模式（暂存区保持为空）
+        logger.warn('旧变更 patch 与当前 HEAD 冲突，降级为全量模式');
+        return { success: false, stagedTreeHash: '' };
+      }
+      // oldChangePatch 为空表示旧变更为空，暂存区保持干净即可
+      return { success: true, stagedTreeHash: '' };
+    } else {
+      // HEAD 未变化（或旧版快照无 HEAD 信息）：直接 read-tree 旧快照
+      gitReadTree(oldTreeHash, mainWorktreePath);
+      return { success: true, stagedTreeHash: oldTreeHash };
+    }
+  } catch (error) {
+    // 旧 tree 对象无法读取（可能被 git gc 回收），降级为全量模式
+    logger.warn(`增量 read-tree 失败: ${error}`);
+    return { success: false, stagedTreeHash: '' };
+  }
+}
+
+/**
+ * 切换到验证分支（首次/增量 validate 共享逻辑）
+ * 校验验证分支是否存在，若当前不在该分支则执行 checkout
+ * @param {string} branchName - 原始分支名
+ * @param {string} mainWorktreePath - 主 worktree 路径
+ * @returns {string} 验证分支名
+ */
+export function switchToValidateBranch(branchName: string, mainWorktreePath: string): string {
+  const validateBranchName = getValidateBranchName(branchName);
+  if (!checkBranchExists(validateBranchName)) {
+    throw new ClawtError(MESSAGES.VALIDATE_BRANCH_NOT_FOUND(validateBranchName, branchName));
+  }
+  const currentBranch = getCurrentBranch(mainWorktreePath);
+  if (currentBranch !== validateBranchName) {
+    gitCheckout(validateBranchName, mainWorktreePath);
+  }
+  return validateBranchName;
+}

package/src/utils/validate-runner.ts

@@ -0,0 +1,105 @@
+import { MESSAGES } from '../constants/index.js';
+import {
+  printInfo,
+  printSuccess,
+  printError,
+  printSeparator,
+  runCommandInherited,
+  parseParallelCommands,
+  runParallelCommands,
+} from './index.js';
+import type { ParallelCommandResult } from './index.js';
+
+/**
+ * 执行单个命令（同步方式，保持原有行为不变）
+ * @param {string} command - 要执行的命令字符串
+ * @param {string} mainWorktreePath - 主 worktree 路径
+ */
+function executeSingleCommand(command: string, mainWorktreePath: string): void {
+  printInfo(MESSAGES.VALIDATE_RUN_START(command));
+  printSeparator();
+
+  const result = runCommandInherited(command, { cwd: mainWorktreePath });
+
+  printSeparator();
+
+  if (result.error) {
+    // 进程启动失败（如命令不存在）
+    printError(MESSAGES.VALIDATE_RUN_ERROR(command, result.error.message));
+    return;
+  }
+
+  const exitCode = result.status ?? 1;
+  if (exitCode === 0) {
+    printSuccess(MESSAGES.VALIDATE_RUN_SUCCESS(command));
+  } else {
+    printError(MESSAGES.VALIDATE_RUN_FAILED(command, exitCode));
+  }
+}
+
+/**
+ * 汇总输出并行命令的执行结果
+ * @param {ParallelCommandResult[]} results - 各命令的执行结果数组
+ */
+function reportParallelResults(results: ParallelCommandResult[]): void {
+  printSeparator();
+
+  const successCount = results.filter((r) => r.exitCode === 0 && !r.error).length;
+  const failedCount = results.length - successCount;
+
+  for (const result of results) {
+    if (result.error) {
+      printError(MESSAGES.VALIDATE_PARALLEL_CMD_ERROR(result.command, result.error));
+    } else if (result.exitCode === 0) {
+      printSuccess(MESSAGES.VALIDATE_PARALLEL_CMD_SUCCESS(result.command));
+    } else {
+      printError(MESSAGES.VALIDATE_PARALLEL_CMD_FAILED(result.command, result.exitCode));
+    }
+  }
+
+  if (failedCount === 0) {
+    printSuccess(MESSAGES.VALIDATE_PARALLEL_RUN_ALL_SUCCESS(results.length));
+  } else {
+    printError(MESSAGES.VALIDATE_PARALLEL_RUN_SUMMARY(successCount, failedCount));
+  }
+}
+
+/**
+ * 并行执行多个命令并汇总结果
+ * @param {string[]} commands - 要并行执行的命令数组
+ * @param {string} mainWorktreePath - 主 worktree 路径
+ */
+async function executeParallelCommands(commands: string[], mainWorktreePath: string): Promise<void> {
+  printInfo(MESSAGES.VALIDATE_PARALLEL_RUN_START(commands.length));
+
+  for (let i = 0; i < commands.length; i++) {
+    printInfo(MESSAGES.VALIDATE_PARALLEL_CMD_START(i + 1, commands.length, commands[i]));
+  }
+
+  printSeparator();
+
+  const results = await runParallelCommands(commands, { cwd: mainWorktreePath });
+
+  reportParallelResults(results);
+}
+
+/**
+ * 在主 worktree 中执行用户指定的命令
+ * 根据命令字符串中的 & 分隔符决定是单命令执行还是并行执行
+ * 命令执行失败不影响 validate 本身的结果，仅输出提示
+ * @param {string} command - 要执行的命令字符串
+ * @param {string} mainWorktreePath - 主 worktree 路径
+ */
+export async function executeRunCommand(command: string, mainWorktreePath: string): Promise<void> {
+  printInfo('');
+
+  const commands = parseParallelCommands(command);
+
+  if (commands.length <= 1) {
+    // 单命令（包括含 && 的串行命令），走原有同步路径
+    executeSingleCommand(commands[0] || command, mainWorktreePath);
+  } else {
+    // 多命令，并行执行
+    await executeParallelCommands(commands, mainWorktreePath);
+  }
+}

package/src/utils/validate-snapshot.ts

@@ -24,6 +24,16 @@ function getSnapshotHeadPath(projectName: string, branchName: string): string {
   return join(VALIDATE_SNAPSHOTS_DIR, projectName, `${branchName}.head`);
 }
 
+/**
+ * 获取指定项目和分支的 validate 快照 staged tree 文件路径
+ * @param {string} projectName - 项目名
+ * @param {string} branchName - 分支名
+ * @returns {string} staged tree hash 文件的绝对路径
+ */
+function getSnapshotStagedPath(projectName: string, branchName: string): string {
+  return join(VALIDATE_SNAPSHOTS_DIR, projectName, `${branchName}.staged`);
+}
+
 /**
  * 判断指定项目和分支是否存在 validate 快照
  * @param {string} projectName - 项目名
@@ -58,49 +68,55 @@ export function readSnapshotTreeHash(projectName: string, branchName: string): s
 }
 
 /**
- * 读取指定项目和分支的 validate 快照（tree hash + HEAD commit hash）
- * tree hash 从 .tree 文件读取，HEAD commit hash 从 .head 文件读取
+ * 读取指定项目和分支的 validate 快照（tree hash + HEAD commit hash + staged tree hash）
+ * tree hash 从 .tree 文件读取，HEAD commit hash 从 .head 文件读取，staged tree hash 从 .staged 文件读取
  * @param {string} projectName - 项目名
  * @param {string} branchName - 分支名
- * @returns {{ treeHash: string; headCommitHash: string }} 快照数据
+ * @returns {{ treeHash: string; headCommitHash: string; stagedTreeHash: string }} 快照数据
  */
-export function readSnapshot(projectName: string, branchName: string): { treeHash: string; headCommitHash: string } {
+export function readSnapshot(projectName: string, branchName: string): { treeHash: string; headCommitHash: string; stagedTreeHash: string } {
   const snapshotPath = getSnapshotPath(projectName, branchName);
   const headPath = getSnapshotHeadPath(projectName, branchName);
+  const stagedPath = getSnapshotStagedPath(projectName, branchName);
   logger.debug(`读取 validate 快照: ${snapshotPath}`);
 
   const treeHash = existsSync(snapshotPath) ? readFileSync(snapshotPath, 'utf-8').trim() : '';
   const headCommitHash = existsSync(headPath) ? readFileSync(headPath, 'utf-8').trim() : '';
+  const stagedTreeHash = existsSync(stagedPath) ? readFileSync(stagedPath, 'utf-8').trim() : '';
 
-  return { treeHash, headCommitHash };
+  return { treeHash, headCommitHash, stagedTreeHash };
 }
 
 /**
  * 写入 validate 快照内容（自动创建目录）
- * tree hash 写入 .tree 文件，HEAD commit hash 写入 .head 文件
+ * tree hash 写入 .tree 文件，HEAD commit hash 写入 .head 文件，staged tree hash 写入 .staged 文件
  * @param {string} projectName - 项目名
  * @param {string} branchName - 分支名
  * @param {string} treeHash - git tree 对象的 hash
  * @param {string} headCommitHash - 快照时主 worktree 的 HEAD commit hash
+ * @param {string} [stagedTreeHash=''] - validate 结束时暂存区对应的 tree hash
  */
-export function writeSnapshot(projectName: string, branchName: string, treeHash: string, headCommitHash: string): void {
+export function writeSnapshot(projectName: string, branchName: string, treeHash: string, headCommitHash: string, stagedTreeHash = ''): void {
   const snapshotPath = getSnapshotPath(projectName, branchName);
   const headPath = getSnapshotHeadPath(projectName, branchName);
+  const stagedPath = getSnapshotStagedPath(projectName, branchName);
   const snapshotDir = join(VALIDATE_SNAPSHOTS_DIR, projectName);
   ensureDir(snapshotDir);
   writeFileSync(snapshotPath, treeHash, 'utf-8');
   writeFileSync(headPath, headCommitHash, 'utf-8');
-  logger.info(`已保存 validate 快照: ${snapshotPath}, ${headPath}`);
+  writeFileSync(stagedPath, stagedTreeHash, 'utf-8');
+  logger.info(`已保存 validate 快照: ${snapshotPath}, ${headPath}, ${stagedPath}`);
 }
 
 /**
- * 删除指定项目和分支的 validate 快照（.tree + .head）
+ * 删除指定项目和分支的 validate 快照（.tree + .head + .staged）
  * @param {string} projectName - 项目名
  * @param {string} branchName - 分支名
  */
 export function removeSnapshot(projectName: string, branchName: string): void {
   const snapshotPath = getSnapshotPath(projectName, branchName);
   const headPath = getSnapshotHeadPath(projectName, branchName);
+  const stagedPath = getSnapshotStagedPath(projectName, branchName);
   if (existsSync(snapshotPath)) {
     unlinkSync(snapshotPath);
     logger.info(`已删除 validate 快照: ${snapshotPath}`);
@@ -109,6 +125,10 @@ export function removeSnapshot(projectName: string, branchName: string): void {
     unlinkSync(headPath);
     logger.info(`已删除 validate 快照: ${headPath}`);
   }
+  if (existsSync(stagedPath)) {
+    unlinkSync(stagedPath);
+    logger.info(`已删除 validate 快照: ${stagedPath}`);
+  }
 }
 
 /**

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

@@ -38,6 +38,7 @@ vi.mock('../../../src/utils/index.js', async (importOriginal) => {
     parseConfigValue: original.parseConfigValue,
     promptConfigValue: original.promptConfigValue,
     formatConfigValue: original.formatConfigValue,
+    interactiveConfigEditor: original.interactiveConfigEditor,
   };
 });
 

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

@@ -12,6 +12,12 @@ vi.mock('../../../src/constants/index.js', () => ({
     INIT_SHOW: (configJson: string) => `当前项目配置:\n${configJson}`,
     PROJECT_NOT_INITIALIZED: '项目尚未初始化，请先执行 clawt init 设置主工作分支',
     PROJECT_CONFIG_MISSING_BRANCH: '项目配置缺少主工作分支信息，请重新执行 clawt init 设置主工作分支',
+    INIT_SELECT_PROMPT: '选择要修改的项目配置项',
+    INIT_SET_SUCCESS: (key: string, value: string) => `✓ 项目配置 ${key} 已设置为 ${value}`,
+  },
+  PROJECT_CONFIG_DEFINITIONS: {
+    clawtMainWorkBranch: { defaultValue: '', description: '主 worktree 的工作分支名' },
+    validateRunCommand: { defaultValue: undefined, description: 'validate 成功后自动执行的命令' },
   },
 }));
 
@@ -24,6 +30,7 @@ vi.mock('../../../src/utils/index.js', () => ({
   printSuccess: vi.fn(),
   printInfo: vi.fn(),
   safeStringify: vi.fn((value: unknown, indent: number = 2) => JSON.stringify(value, null, indent)),
+  interactiveConfigEditor: vi.fn(),
 }));
 
 import { registerInitCommand } from '../../../src/commands/init.js';
@@ -32,16 +39,16 @@ import {
   saveProjectConfig,
   requireProjectConfig,
   printSuccess,
-  printInfo,
   getCurrentBranch,
+  interactiveConfigEditor,
 } 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);
+const mockedInteractiveConfigEditor = vi.mocked(interactiveConfigEditor);
 
 beforeEach(() => {
   mockedLoadProjectConfig.mockReset();
@@ -49,8 +56,8 @@ beforeEach(() => {
   mockedRequireProjectConfig.mockReset();
   mockedRequireProjectConfig.mockReturnValue({ clawtMainWorkBranch: 'main' });
   mockedPrintSuccess.mockReset();
-  mockedPrintInfo.mockReset();
   mockedGetCurrentBranch.mockReturnValue('main');
+  mockedInteractiveConfigEditor.mockReset();
 });
 
 describe('registerInitCommand', () => {
@@ -132,15 +139,43 @@ describe('handleInit', () => {
 });
 
 describe('handleInitShow (show 子命令)', () => {
-  it('clawt init show 展示当前配置', async () => {
+  it('clawt init show 进入交互式面板并保存修改', async () => {
     mockedRequireProjectConfig.mockReturnValue({ clawtMainWorkBranch: 'develop' });
+    mockedInteractiveConfigEditor.mockResolvedValue({ key: 'validateRunCommand', newValue: 'npm test' });
+
+    const program = new Command();
+    program.exitOverride();
+    registerInitCommand(program);
+    await program.parseAsync(['init', 'show'], { from: 'user' });
+
+    // 验证调用了交互式配置编辑器
+    expect(mockedInteractiveConfigEditor).toHaveBeenCalled();
+    // 验证保存了合并后的配置
+    expect(mockedSaveProjectConfig).toHaveBeenCalledWith({
+      clawtMainWorkBranch: 'develop',
+      validateRunCommand: 'npm test',
+    });
+    // 验证输出了成功消息
+    expect(mockedPrintSuccess).toHaveBeenCalledWith(
+      expect.stringContaining('validateRunCommand'),
+    );
+  });
+
+  it('clawt init show 修改已有配置项', async () => {
+    mockedRequireProjectConfig.mockReturnValue({
+      clawtMainWorkBranch: 'main',
+      validateRunCommand: 'npm test',
+    });
+    mockedInteractiveConfigEditor.mockResolvedValue({ key: 'clawtMainWorkBranch', newValue: 'develop' });
 
     const program = new Command();
     program.exitOverride();
     registerInitCommand(program);
     await program.parseAsync(['init', 'show'], { from: 'user' });
 
-    expect(mockedPrintInfo).toHaveBeenCalled();
-    expect(mockedSaveProjectConfig).not.toHaveBeenCalled();
+    expect(mockedSaveProjectConfig).toHaveBeenCalledWith({
+      clawtMainWorkBranch: 'develop',
+      validateRunCommand: 'npm test',
+    });
   });
 });