clawt 3.1.2 → 3.2.0

package/dist/index.js

@@ -180,6 +180,8 @@ var VALIDATE_MESSAGES = {
   \u6682\u5B58\u533A = \u4E0A\u6B21\u5FEB\u7167\uFF0C\u5DE5\u4F5C\u76EE\u5F55 = \u6700\u65B0\u53D8\u66F4`,
   /** 增量 validate 降级为全量模式提示 */
   INCREMENTAL_VALIDATE_FALLBACK: "\u589E\u91CF\u5BF9\u6BD4\u5931\u8D25\uFF0C\u5DF2\u964D\u7EA7\u4E3A\u5168\u91CF\u6A21\u5F0F",
+  /** 增量 validate 检测到目标 worktree 无新变更 */
+  INCREMENTAL_VALIDATE_NO_CHANGES: (branch) => `\u5206\u652F ${branch} \u81EA\u4E0A\u6B21 validate \u4EE5\u6765\u6CA1\u6709\u65B0\u7684\u53D8\u66F4\uFF0C\u5DF2\u6062\u590D\u5230\u4E0A\u6B21\u9A8C\u8BC1\u72B6\u6001`,
   /** validate 状态已清理 */
   VALIDATE_CLEANED: (branch) => `\u2713 \u5206\u652F ${branch} \u7684 validate \u72B6\u6001\u5DF2\u6E05\u7406`,
   /** validate patch apply 失败，提示用户同步主分支 */
@@ -460,7 +462,11 @@ var INIT_MESSAGES = {
   /** 项目未初始化（requireProjectConfig 使用） */
   PROJECT_NOT_INITIALIZED: "\u9879\u76EE\u5C1A\u672A\u521D\u59CB\u5316\uFF0C\u8BF7\u5148\u6267\u884C clawt init \u8BBE\u7F6E\u4E3B\u5DE5\u4F5C\u5206\u652F",
   /** 项目配置缺少 clawtMainWorkBranch 字段 */
-  PROJECT_CONFIG_MISSING_BRANCH: "\u9879\u76EE\u914D\u7F6E\u7F3A\u5C11\u4E3B\u5DE5\u4F5C\u5206\u652F\u4FE1\u606F\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C clawt init \u8BBE\u7F6E\u4E3B\u5DE5\u4F5C\u5206\u652F"
+  PROJECT_CONFIG_MISSING_BRANCH: "\u9879\u76EE\u914D\u7F6E\u7F3A\u5C11\u4E3B\u5DE5\u4F5C\u5206\u652F\u4FE1\u606F\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C clawt init \u8BBE\u7F6E\u4E3B\u5DE5\u4F5C\u5206\u652F",
+  /** init show 交互式面板选择配置项提示 */
+  INIT_SELECT_PROMPT: "\u9009\u62E9\u8981\u4FEE\u6539\u7684\u9879\u76EE\u914D\u7F6E\u9879",
+  /** init show 交互式面板配置项修改成功 */
+  INIT_SET_SUCCESS: (key, value) => `\u2713 \u9879\u76EE\u914D\u7F6E ${key} \u5DF2\u8BBE\u7F6E\u4E3A ${value}`
 };
 
 // src/constants/messages/interactive-panel.ts
@@ -608,6 +614,32 @@ function deriveConfigDescriptions(definitions) {
 var DEFAULT_CONFIG = deriveDefaultConfig(CONFIG_DEFINITIONS);
 var CONFIG_DESCRIPTIONS = deriveConfigDescriptions(CONFIG_DEFINITIONS);
 
+// src/constants/project-config.ts
+var PROJECT_CONFIG_DEFINITIONS = {
+  clawtMainWorkBranch: {
+    defaultValue: "",
+    description: "\u4E3B worktree \u7684\u5DE5\u4F5C\u5206\u652F\u540D"
+  },
+  validateRunCommand: {
+    defaultValue: void 0,
+    description: "validate \u6210\u529F\u540E\u81EA\u52A8\u6267\u884C\u7684\u547D\u4EE4\uFF08-r \u7684\u9ED8\u8BA4\u503C\uFF09"
+  }
+};
+function deriveDefaultConfig2(definitions) {
+  const entries = Object.entries(definitions).map(
+    ([key, def]) => [key, def.defaultValue]
+  );
+  return Object.fromEntries(entries);
+}
+function deriveConfigDescriptions2(definitions) {
+  const entries = Object.entries(definitions).map(
+    ([key, def]) => [key, def.description]
+  );
+  return Object.fromEntries(entries);
+}
+var PROJECT_DEFAULT_CONFIG = deriveDefaultConfig2(PROJECT_CONFIG_DEFINITIONS);
+var PROJECT_CONFIG_DESCRIPTIONS = deriveConfigDescriptions2(PROJECT_CONFIG_DEFINITIONS);
+
 // src/constants/git.ts
 var AUTO_SAVE_COMMIT_MESSAGE = "chore: auto-save before sync";
 
@@ -1259,6 +1291,10 @@ function getMainWorkBranch() {
   const config2 = requireProjectConfig();
   return config2.clawtMainWorkBranch;
 }
+function getValidateRunCommand() {
+  const config2 = loadProjectConfig();
+  return config2?.validateRunCommand || void 0;
+}
 
 // src/utils/validate-branch.ts
 function getValidateBranchName(branchName) {
@@ -1638,6 +1674,9 @@ function getSnapshotPath(projectName, branchName) {
 function getSnapshotHeadPath(projectName, branchName) {
   return join6(VALIDATE_SNAPSHOTS_DIR, projectName, `${branchName}.head`);
 }
+function getSnapshotStagedPath(projectName, branchName) {
+  return join6(VALIDATE_SNAPSHOTS_DIR, projectName, `${branchName}.staged`);
+}
 function hasSnapshot(projectName, branchName) {
   return existsSync8(getSnapshotPath(projectName, branchName));
 }
@@ -1650,23 +1689,28 @@ function getSnapshotModifiedTime(projectName, branchName) {
 function readSnapshot(projectName, branchName) {
   const snapshotPath = getSnapshotPath(projectName, branchName);
   const headPath = getSnapshotHeadPath(projectName, branchName);
+  const stagedPath = getSnapshotStagedPath(projectName, branchName);
   logger.debug(`\u8BFB\u53D6 validate \u5FEB\u7167: ${snapshotPath}`);
   const treeHash = existsSync8(snapshotPath) ? readFileSync3(snapshotPath, "utf-8").trim() : "";
   const headCommitHash = existsSync8(headPath) ? readFileSync3(headPath, "utf-8").trim() : "";
-  return { treeHash, headCommitHash };
+  const stagedTreeHash = existsSync8(stagedPath) ? readFileSync3(stagedPath, "utf-8").trim() : "";
+  return { treeHash, headCommitHash, stagedTreeHash };
 }
-function writeSnapshot(projectName, branchName, treeHash, headCommitHash) {
+function writeSnapshot(projectName, branchName, treeHash, headCommitHash, stagedTreeHash = "") {
   const snapshotPath = getSnapshotPath(projectName, branchName);
   const headPath = getSnapshotHeadPath(projectName, branchName);
+  const stagedPath = getSnapshotStagedPath(projectName, branchName);
   const snapshotDir = join6(VALIDATE_SNAPSHOTS_DIR, projectName);
   ensureDir(snapshotDir);
   writeFileSync3(snapshotPath, treeHash, "utf-8");
   writeFileSync3(headPath, headCommitHash, "utf-8");
-  logger.info(`\u5DF2\u4FDD\u5B58 validate \u5FEB\u7167: ${snapshotPath}, ${headPath}`);
+  writeFileSync3(stagedPath, stagedTreeHash, "utf-8");
+  logger.info(`\u5DF2\u4FDD\u5B58 validate \u5FEB\u7167: ${snapshotPath}, ${headPath}, ${stagedPath}`);
 }
 function removeSnapshot(projectName, branchName) {
   const snapshotPath = getSnapshotPath(projectName, branchName);
   const headPath = getSnapshotHeadPath(projectName, branchName);
+  const stagedPath = getSnapshotStagedPath(projectName, branchName);
   if (existsSync8(snapshotPath)) {
     unlinkSync(snapshotPath);
     logger.info(`\u5DF2\u5220\u9664 validate \u5FEB\u7167: ${snapshotPath}`);
@@ -1675,6 +1719,10 @@ function removeSnapshot(projectName, branchName) {
     unlinkSync(headPath);
     logger.info(`\u5DF2\u5220\u9664 validate \u5FEB\u7167: ${headPath}`);
   }
+  if (existsSync8(stagedPath)) {
+    unlinkSync(stagedPath);
+    logger.info(`\u5DF2\u5220\u9664 validate \u5FEB\u7167: ${stagedPath}`);
+  }
 }
 function getProjectSnapshotBranches(projectName) {
   const projectDir = join6(VALIDATE_SNAPSHOTS_DIR, projectName);
@@ -2717,7 +2765,7 @@ function parseConfigValue(key, rawValue) {
   }
   return { success: true, value: rawValue };
 }
-async function promptConfigValue(key, currentValue) {
+async function promptConfigValue(key, currentValue, allowedValues) {
   const expectedType = typeof currentValue;
   if (expectedType === "boolean") {
     return promptBooleanValue(key, currentValue);
@@ -2725,18 +2773,43 @@ async function promptConfigValue(key, currentValue) {
   if (expectedType === "number") {
     return promptNumberValue(key, currentValue);
   }
-  const definition = CONFIG_DEFINITIONS[key];
-  if (definition.allowedValues) {
-    return promptEnumValue(key, currentValue, definition.allowedValues);
+  if (allowedValues) {
+    return promptEnumValue(key, currentValue, allowedValues);
   }
   return promptStringValue(key, currentValue);
 }
 function formatConfigValue(value) {
+  if (value === void 0 || value === null) {
+    return chalk7.dim("(\u672A\u8BBE\u7F6E)");
+  }
   if (typeof value === "boolean") {
     return value ? chalk7.green("true") : chalk7.yellow("false");
   }
   return chalk7.cyan(String(value));
 }
+async function interactiveConfigEditor(config2, definitions, options) {
+  const keys = Object.keys(definitions);
+  const disabledKeys = options?.disabledKeys ?? {};
+  const configRecord = config2;
+  const choices = keys.map((k) => {
+    const isDisabled = k in disabledKeys;
+    const value = configRecord[k];
+    const isObject = typeof value === "object" && value !== null;
+    return {
+      name: k,
+      message: `${k}: ${isObject || isDisabled ? chalk7.dim(isObject ? JSON.stringify(value) : String(value ?? "")) : formatConfigValue(value)}  ${chalk7.dim(`\u2014 ${definitions[k].description}`)}`,
+      ...isDisabled && { disabled: disabledKeys[k] }
+    };
+  });
+  const selectedKey = await new Enquirer4.Select({
+    message: options?.selectPrompt ?? MESSAGES.CONFIG_SELECT_PROMPT,
+    choices
+  }).run();
+  const currentValue = configRecord[selectedKey];
+  const definition = definitions[selectedKey];
+  const newValue = await promptConfigValue(selectedKey, currentValue, definition.allowedValues);
+  return { key: selectedKey, newValue };
+}
 async function promptBooleanValue(key, currentValue) {
   const choices = [
     { name: "true", message: "true" },
@@ -2774,7 +2847,7 @@ async function promptEnumValue(key, currentValue, allowedValues) {
 async function promptStringValue(key, currentValue) {
   return await new Enquirer4.Input({
     message: MESSAGES.CONFIG_INPUT_PROMPT(key),
-    initial: currentValue
+    initial: currentValue || ""
   }).run();
 }
 
@@ -2909,55 +2982,144 @@ async function checkForUpdates(currentVersion) {
   }
 }
 
-// src/utils/json.ts
-function primitiveToString(value) {
-  if (value === void 0) {
-    return "undefined";
+// src/utils/validate-runner.ts
+function executeSingleCommand(command, mainWorktreePath) {
+  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;
   }
-  if (value === null) {
-    return "null";
+  const exitCode = result.status ?? 1;
+  if (exitCode === 0) {
+    printSuccess(MESSAGES.VALIDATE_RUN_SUCCESS(command));
+  } else {
+    printError(MESSAGES.VALIDATE_RUN_FAILED(command, exitCode));
   }
-  if (typeof value === "symbol") {
-    return value.toString();
+}
+function reportParallelResults(results) {
+  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 (typeof value === "function") {
-    return `[Function: ${value.name || "anonymous"}]`;
+  if (failedCount === 0) {
+    printSuccess(MESSAGES.VALIDATE_PARALLEL_RUN_ALL_SUCCESS(results.length));
+  } else {
+    printError(MESSAGES.VALIDATE_PARALLEL_RUN_SUMMARY(successCount, failedCount));
   }
-  return String(value);
 }
-function safeStringify(value, indent = 2) {
-  if (value === null || typeof value !== "object") {
-    return primitiveToString(value);
+async function executeParallelCommands(commands, mainWorktreePath) {
+  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);
+}
+async function executeRunCommand(command, mainWorktreePath) {
+  printInfo("");
+  const commands = parseParallelCommands(command);
+  if (commands.length <= 1) {
+    executeSingleCommand(commands[0] || command, mainWorktreePath);
+  } else {
+    await executeParallelCommands(commands, mainWorktreePath);
+  }
+}
+
+// src/utils/validate-core.ts
+function migrateChangesViaPatch(targetWorktreePath, mainWorktreePath, branchName, hasUncommitted) {
+  let didTempCommit = false;
   try {
-    const seen = /* @__PURE__ */ new WeakSet();
-    return JSON.stringify(
-      value,
-      (_key, val) => {
-        if (typeof val === "bigint") {
-          return val.toString();
-        }
-        if (typeof val === "undefined" || typeof val === "function" || typeof val === "symbol") {
-          return primitiveToString(val);
-        }
-        if (typeof val === "object" && val !== null) {
-          if (seen.has(val)) {
-            return "[Circular]";
-          }
-          seen.add(val);
-        }
-        return val;
-      },
-      indent
-    );
-  } catch {
-    try {
-      return JSON.stringify(String(value), null, indent);
-    } catch {
-      return "[Unserializable]";
+    if (hasUncommitted) {
+      gitAddAll(targetWorktreePath);
+      gitCommit("clawt:temp-commit-for-validate", targetWorktreePath);
+      didTempCommit = true;
+    }
+    const patch = gitDiffBinaryAgainstBranch(branchName, mainWorktreePath);
+    if (patch.length > 0) {
+      try {
+        gitApplyFromStdin(patch, mainWorktreePath);
+      } catch (error) {
+        logger.warn(`patch apply \u5931\u8D25: ${error}`);
+        printWarning(MESSAGES.VALIDATE_PATCH_APPLY_FAILED(branchName));
+        return { success: false };
+      }
+    }
+    return { success: true };
+  } finally {
+    if (didTempCommit) {
+      try {
+        gitResetSoft(1, targetWorktreePath);
+      } catch (error) {
+        logger.error(`\u64A4\u9500\u4E34\u65F6 commit \u5931\u8D25: ${error}`);
+      }
+      try {
+        gitRestoreStaged(targetWorktreePath);
+      } catch (error) {
+        logger.error(`\u6062\u590D\u6682\u5B58\u533A\u5931\u8D25: ${error}`);
+      }
+    }
+  }
+}
+function computeCurrentTreeHash(mainWorktreePath) {
+  gitAddAll(mainWorktreePath);
+  const treeHash = gitWriteTree(mainWorktreePath);
+  gitRestoreStaged(mainWorktreePath);
+  return treeHash;
+}
+function saveCurrentSnapshotTree(mainWorktreePath, projectName, branchName, stagedTreeHash = "") {
+  gitAddAll(mainWorktreePath);
+  const treeHash = gitWriteTree(mainWorktreePath);
+  gitRestoreStaged(mainWorktreePath);
+  const headCommitHash = getHeadCommitHash(mainWorktreePath);
+  writeSnapshot(projectName, branchName, treeHash, headCommitHash, stagedTreeHash);
+  return treeHash;
+}
+function loadOldSnapshotToStage(oldTreeHash, oldHeadCommitHash, currentHeadCommitHash, mainWorktreePath) {
+  try {
+    if (oldHeadCommitHash && oldHeadCommitHash !== currentHeadCommitHash) {
+      const oldHeadTreeHash = getCommitTreeHash(oldHeadCommitHash, mainWorktreePath);
+      const oldChangePatch = gitDiffTree(oldHeadTreeHash, oldTreeHash, mainWorktreePath);
+      if (oldChangePatch.length > 0 && gitApplyCachedCheck(oldChangePatch, mainWorktreePath)) {
+        gitApplyCachedFromStdin(oldChangePatch, mainWorktreePath);
+        const stagedTreeHash = gitWriteTree(mainWorktreePath);
+        return { success: true, stagedTreeHash };
+      } else if (oldChangePatch.length > 0) {
+        logger.warn("\u65E7\u53D8\u66F4 patch \u4E0E\u5F53\u524D HEAD \u51B2\u7A81\uFF0C\u964D\u7EA7\u4E3A\u5168\u91CF\u6A21\u5F0F");
+        return { success: false, stagedTreeHash: "" };
+      }
+      return { success: true, stagedTreeHash: "" };
+    } else {
+      gitReadTree(oldTreeHash, mainWorktreePath);
+      return { success: true, stagedTreeHash: oldTreeHash };
     }
+  } catch (error) {
+    logger.warn(`\u589E\u91CF read-tree \u5931\u8D25: ${error}`);
+    return { success: false, stagedTreeHash: "" };
   }
 }
+function switchToValidateBranch(branchName, mainWorktreePath) {
+  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;
+}
 
 // src/utils/interactive-panel.ts
 import { createInterface as createInterface2 } from "readline";
@@ -3925,40 +4087,6 @@ function registerValidateCommand(program2) {
 async function handleDirtyMainWorktree(mainWorktreePath) {
   await handleDirtyWorkingDir(mainWorktreePath);
 }
-function migrateChangesViaPatch(targetWorktreePath, mainWorktreePath, branchName, hasUncommitted) {
-  let didTempCommit = false;
-  try {
-    if (hasUncommitted) {
-      gitAddAll(targetWorktreePath);
-      gitCommit("clawt:temp-commit-for-validate", targetWorktreePath);
-      didTempCommit = true;
-    }
-    const patch = gitDiffBinaryAgainstBranch(branchName, mainWorktreePath);
-    if (patch.length > 0) {
-      try {
-        gitApplyFromStdin(patch, mainWorktreePath);
-      } catch (error) {
-        logger.warn(`patch apply \u5931\u8D25: ${error}`);
-        printWarning(MESSAGES.VALIDATE_PATCH_APPLY_FAILED(branchName));
-        return { success: false };
-      }
-    }
-    return { success: true };
-  } finally {
-    if (didTempCommit) {
-      try {
-        gitResetSoft(1, targetWorktreePath);
-      } catch (error) {
-        logger.error(`\u64A4\u9500\u4E34\u65F6 commit \u5931\u8D25: ${error}`);
-      }
-      try {
-        gitRestoreStaged(targetWorktreePath);
-      } catch (error) {
-        logger.error(`\u6062\u590D\u6682\u5B58\u533A\u5931\u8D25: ${error}`);
-      }
-    }
-  }
-}
 async function handlePatchApplyFailure(targetWorktreePath, branchName) {
   const confirmed = await confirmAction(MESSAGES.VALIDATE_CONFIRM_AUTO_SYNC(branchName));
   if (!confirmed) {
@@ -3968,14 +4096,6 @@ async function handlePatchApplyFailure(targetWorktreePath, branchName) {
   printInfo(MESSAGES.VALIDATE_AUTO_SYNC_START(branchName));
   const syncResult = await executeSyncForBranch(targetWorktreePath, branchName);
 }
-function saveCurrentSnapshotTree(mainWorktreePath, projectName, branchName) {
-  gitAddAll(mainWorktreePath);
-  const treeHash = gitWriteTree(mainWorktreePath);
-  gitRestoreStaged(mainWorktreePath);
-  const headCommitHash = getHeadCommitHash(mainWorktreePath);
-  writeSnapshot(projectName, branchName, treeHash, headCommitHash);
-  return treeHash;
-}
 async function handleValidateClean(options) {
   validateMainWorktree();
   requireProjectConfig();
@@ -4004,11 +4124,7 @@ async function handleValidateClean(options) {
   printSuccess(MESSAGES.VALIDATE_CLEANED(branchName));
 }
 async function handleFirstValidate(targetWorktreePath, mainWorktreePath, projectName, branchName, hasUncommitted) {
-  const validateBranchName = getValidateBranchName(branchName);
-  if (!checkBranchExists(validateBranchName)) {
-    throw new ClawtError(MESSAGES.VALIDATE_BRANCH_NOT_FOUND(validateBranchName, branchName));
-  }
-  gitCheckout(validateBranchName, mainWorktreePath);
+  const validateBranchName = switchToValidateBranch(branchName, mainWorktreePath);
   const result = migrateChangesViaPatch(targetWorktreePath, mainWorktreePath, branchName, hasUncommitted);
   if (!result.success) {
     await ensureOnMainWorkBranch(mainWorktreePath);
@@ -4019,102 +4135,48 @@ async function handleFirstValidate(targetWorktreePath, mainWorktreePath, project
   printSuccess(MESSAGES.VALIDATE_SUCCESS_WITH_BRANCH(branchName, validateBranchName));
 }
 async function handleIncrementalValidate(targetWorktreePath, mainWorktreePath, projectName, branchName, hasUncommitted) {
-  const { treeHash: oldTreeHash, headCommitHash: oldHeadCommitHash } = readSnapshot(projectName, branchName);
+  const { treeHash: oldTreeHash, headCommitHash: oldHeadCommitHash, stagedTreeHash: oldStagedTreeHash } = readSnapshot(projectName, branchName);
   if (!isWorkingDirClean(mainWorktreePath)) {
     gitResetHard(mainWorktreePath);
     gitCleanForce(mainWorktreePath);
   }
-  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);
-  }
+  const validateBranchName = switchToValidateBranch(branchName, mainWorktreePath);
   const result = migrateChangesViaPatch(targetWorktreePath, mainWorktreePath, branchName, hasUncommitted);
   if (!result.success) {
     await ensureOnMainWorkBranch(mainWorktreePath);
     await handlePatchApplyFailure(targetWorktreePath, branchName);
     return;
   }
-  saveCurrentSnapshotTree(mainWorktreePath, projectName, branchName);
-  try {
-    const currentHeadCommitHash = getHeadCommitHash(mainWorktreePath);
-    if (oldHeadCommitHash && oldHeadCommitHash !== currentHeadCommitHash) {
-      const oldHeadTreeHash = getCommitTreeHash(oldHeadCommitHash, mainWorktreePath);
-      const oldChangePatch = gitDiffTree(oldHeadTreeHash, oldTreeHash, mainWorktreePath);
-      if (oldChangePatch.length > 0 && gitApplyCachedCheck(oldChangePatch, mainWorktreePath)) {
-        gitApplyCachedFromStdin(oldChangePatch, mainWorktreePath);
-      } else if (oldChangePatch.length > 0) {
-        logger.warn("\u65E7\u53D8\u66F4 patch \u4E0E\u5F53\u524D HEAD \u51B2\u7A81\uFF0C\u964D\u7EA7\u4E3A\u5168\u91CF\u6A21\u5F0F");
-        printWarning(MESSAGES.INCREMENTAL_VALIDATE_FALLBACK);
-        printSuccess(MESSAGES.VALIDATE_SUCCESS_WITH_BRANCH(branchName, validateBranchName));
-        return;
+  const newTreeHash = computeCurrentTreeHash(mainWorktreePath);
+  const currentHeadCommitHash = getHeadCommitHash(mainWorktreePath);
+  const hasNewChanges = newTreeHash !== oldTreeHash || oldHeadCommitHash && oldHeadCommitHash !== currentHeadCommitHash;
+  if (!hasNewChanges) {
+    if (oldStagedTreeHash) {
+      try {
+        gitReadTree(oldStagedTreeHash, mainWorktreePath);
+      } catch (error) {
+        logger.warn(`\u6062\u590D\u6682\u5B58\u533A\u5931\u8D25: ${error}`);
       }
-    } else {
-      gitReadTree(oldTreeHash, mainWorktreePath);
     }
-  } catch (error) {
-    logger.warn(`\u589E\u91CF read-tree \u5931\u8D25: ${error}`);
-    printWarning(MESSAGES.INCREMENTAL_VALIDATE_FALLBACK);
+    printInfo(MESSAGES.INCREMENTAL_VALIDATE_NO_CHANGES(branchName));
     printSuccess(MESSAGES.VALIDATE_SUCCESS_WITH_BRANCH(branchName, validateBranchName));
     return;
   }
-  printSuccess(MESSAGES.INCREMENTAL_VALIDATE_SUCCESS(branchName));
-}
-function executeSingleCommand(command, mainWorktreePath) {
-  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));
+  const stageResult = loadOldSnapshotToStage(oldTreeHash, oldHeadCommitHash, currentHeadCommitHash, mainWorktreePath);
+  if (!stageResult.success) {
+    printWarning(MESSAGES.INCREMENTAL_VALIDATE_FALLBACK);
+    writeSnapshot(projectName, branchName, newTreeHash, currentHeadCommitHash, "");
+    printSuccess(MESSAGES.VALIDATE_SUCCESS_WITH_BRANCH(branchName, validateBranchName));
     return;
   }
-  const exitCode = result.status ?? 1;
-  if (exitCode === 0) {
-    printSuccess(MESSAGES.VALIDATE_RUN_SUCCESS(command));
-  } else {
-    printError(MESSAGES.VALIDATE_RUN_FAILED(command, exitCode));
-  }
-}
-function reportParallelResults(results) {
-  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));
-  }
-}
-async function executeParallelCommands(commands, mainWorktreePath) {
-  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);
+  writeSnapshot(projectName, branchName, newTreeHash, currentHeadCommitHash, stageResult.stagedTreeHash);
+  printSuccess(MESSAGES.INCREMENTAL_VALIDATE_SUCCESS(branchName));
 }
-async function executeRunCommand(command, mainWorktreePath) {
-  printInfo("");
-  const commands = parseParallelCommands(command);
-  if (commands.length <= 1) {
-    executeSingleCommand(commands[0] || command, mainWorktreePath);
-  } else {
-    await executeParallelCommands(commands, mainWorktreePath);
+function resolveRunCommand(optionRun) {
+  if (optionRun) {
+    return optionRun;
   }
+  return getValidateRunCommand();
 }
 async function handleValidate(options) {
   if (options.clean) {
@@ -4148,8 +4210,9 @@ async function handleValidate(options) {
     }
     await handleFirstValidate(targetWorktreePath, mainWorktreePath, projectName, branchName, hasUncommitted);
   }
-  if (options.run) {
-    await executeRunCommand(options.run, mainWorktreePath);
+  const runCommand = resolveRunCommand(options.run);
+  if (runCommand) {
+    await executeRunCommand(runCommand, mainWorktreePath);
   }
 }
 
@@ -4274,8 +4337,6 @@ async function handleMerge(options) {
 }
 
 // src/commands/config.ts
-import chalk11 from "chalk";
-import Enquirer5 from "enquirer";
 function registerConfigCommand(program2) {
   const configCmd = program2.command("config").description("\u4EA4\u4E92\u5F0F\u67E5\u770B\u548C\u4FEE\u6539\u5168\u5C40\u914D\u7F6E").action(async () => {
     await handleConfigSet();
@@ -4329,25 +4390,19 @@ async function handleConfigSet(key, value) {
 }
 async function handleInteractiveConfigSet() {
   const config2 = loadConfig();
-  const keys = Object.keys(DEFAULT_CONFIG);
   logger.info("config set \u547D\u4EE4\u6267\u884C\uFF0C\u8FDB\u5165\u4EA4\u4E92\u5F0F\u914D\u7F6E");
-  const choices = keys.map((k) => {
-    const isObject = typeof DEFAULT_CONFIG[k] === "object";
-    return {
-      name: k,
-      message: `${k}: ${isObject ? chalk11.dim(JSON.stringify(config2[k])) : formatConfigValue(config2[k])}  ${chalk11.dim(`\u2014 ${CONFIG_DESCRIPTIONS[k]}`)}`,
-      ...isObject && { disabled: CONFIG_ALIAS_DISABLED_HINT }
-    };
+  const disabledKeys = {};
+  for (const k of Object.keys(DEFAULT_CONFIG)) {
+    if (typeof DEFAULT_CONFIG[k] === "object") {
+      disabledKeys[k] = CONFIG_ALIAS_DISABLED_HINT;
+    }
+  }
+  const { key, newValue } = await interactiveConfigEditor(config2, CONFIG_DEFINITIONS, {
+    disabledKeys
   });
-  const selectedKey = await new Enquirer5.Select({
-    message: MESSAGES.CONFIG_SELECT_PROMPT,
-    choices
-  }).run();
-  const currentValue = config2[selectedKey];
-  const newValue = await promptConfigValue(selectedKey, currentValue);
-  config2[selectedKey] = newValue;
+  config2[key] = newValue;
   saveConfig(config2);
-  printSuccess(MESSAGES.CONFIG_SET_SUCCESS(selectedKey, String(newValue)));
+  printSuccess(MESSAGES.CONFIG_SET_SUCCESS(key, String(newValue)));
 }
 function handleConfigGet(key) {
   if (!isValidConfigKey(key)) {
@@ -4391,7 +4446,7 @@ async function handleReset() {
 }
 
 // src/commands/status.ts
-import chalk12 from "chalk";
+import chalk11 from "chalk";
 function registerStatusCommand(program2) {
   program2.command("status").description("\u663E\u793A\u9879\u76EE\u5168\u5C40\u72B6\u6001\u603B\u89C8\uFF08\u652F\u6301 --json \u683C\u5F0F\u8F93\u51FA\uFF09").option("--json", "\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA").option("-i, --interactive", "\u4EA4\u4E92\u5F0F\u9762\u677F\u6A21\u5F0F").action(async (options) => {
     await handleStatus(options);
@@ -4509,7 +4564,7 @@ function printStatusAsJson(result) {
 }
 function printStatusAsText(result) {
   printDoubleSeparator();
-  printInfo(`  ${chalk12.bold.cyan(MESSAGES.STATUS_TITLE(result.main.projectName))}`);
+  printInfo(`  ${chalk11.bold.cyan(MESSAGES.STATUS_TITLE(result.main.projectName))}`);
   printDoubleSeparator();
   printInfo("");
   printMainSection(result.main);
@@ -4522,17 +4577,17 @@ function printStatusAsText(result) {
   printDoubleSeparator();
 }
 function printMainSection(main2) {
-  printInfo(`  ${chalk12.bold("\u25C6")} ${chalk12.bold(MESSAGES.STATUS_MAIN_SECTION)}`);
-  printInfo(`    \u5206\u652F: ${chalk12.bold(main2.branch)}`);
+  printInfo(`  ${chalk11.bold("\u25C6")} ${chalk11.bold(MESSAGES.STATUS_MAIN_SECTION)}`);
+  printInfo(`    \u5206\u652F: ${chalk11.bold(main2.branch)}`);
   if (main2.isClean) {
-    printInfo(`    \u72B6\u6001: ${chalk12.green("\u2713 \u5E72\u51C0")}`);
+    printInfo(`    \u72B6\u6001: ${chalk11.green("\u2713 \u5E72\u51C0")}`);
   } else {
-    printInfo(`    \u72B6\u6001: ${chalk12.yellow("\u2717 \u6709\u672A\u63D0\u4EA4\u4FEE\u6539")}`);
+    printInfo(`    \u72B6\u6001: ${chalk11.yellow("\u2717 \u6709\u672A\u63D0\u4EA4\u4FEE\u6539")}`);
   }
   printInfo("");
 }
 function printWorktreesSection(worktrees, total) {
-  printInfo(`  ${chalk12.bold("\u25C6")} ${chalk12.bold(MESSAGES.STATUS_WORKTREES_SECTION)} (${total} \u4E2A)`);
+  printInfo(`  ${chalk11.bold("\u25C6")} ${chalk11.bold(MESSAGES.STATUS_WORKTREES_SECTION)} (${total} \u4E2A)`);
   printInfo("");
   if (worktrees.length === 0) {
     printInfo(`    ${MESSAGES.STATUS_NO_WORKTREES}`);
@@ -4544,56 +4599,56 @@ function printWorktreesSection(worktrees, total) {
 }
 function printWorktreeItem(wt) {
   const statusLabel = formatChangeStatusLabel2(wt.changeStatus);
-  printInfo(`  ${chalk12.bold("\u25CF")} ${chalk12.bold(wt.branch)}   [${statusLabel}]`);
+  printInfo(`  ${chalk11.bold("\u25CF")} ${chalk11.bold(wt.branch)}   [${statusLabel}]`);
   if (wt.insertions > 0 || wt.deletions > 0) {
-    printInfo(`    ${chalk12.green(`+${wt.insertions}`)} ${chalk12.red(`-${wt.deletions}`)}`);
+    printInfo(`    ${chalk11.green(`+${wt.insertions}`)} ${chalk11.red(`-${wt.deletions}`)}`);
   }
   if (wt.commitsAhead > 0) {
-    printInfo(`    ${chalk12.yellow(`${wt.commitsAhead} \u4E2A\u672C\u5730\u63D0\u4EA4`)}`);
+    printInfo(`    ${chalk11.yellow(`${wt.commitsAhead} \u4E2A\u672C\u5730\u63D0\u4EA4`)}`);
   }
   if (wt.commitsBehind > 0) {
-    printInfo(`    ${chalk12.yellow(`\u843D\u540E\u4E3B\u5206\u652F ${wt.commitsBehind} \u4E2A\u63D0\u4EA4`)}`);
+    printInfo(`    ${chalk11.yellow(`\u843D\u540E\u4E3B\u5206\u652F ${wt.commitsBehind} \u4E2A\u63D0\u4EA4`)}`);
   } else {
-    printInfo(`    ${chalk12.green("\u4E0E\u4E3B\u5206\u652F\u540C\u6B65")}`);
+    printInfo(`    ${chalk11.green("\u4E0E\u4E3B\u5206\u652F\u540C\u6B65")}`);
   }
   if (wt.createdAt) {
     const relativeTime = formatRelativeTime(wt.createdAt);
     if (relativeTime) {
-      printInfo(`    ${chalk12.gray(MESSAGES.STATUS_CREATED_AT(relativeTime))}`);
+      printInfo(`    ${chalk11.gray(MESSAGES.STATUS_CREATED_AT(relativeTime))}`);
     }
   }
   if (wt.snapshotTime) {
     const relativeTime = formatRelativeTime(wt.snapshotTime);
     if (relativeTime) {
-      printInfo(`    ${chalk12.green(MESSAGES.STATUS_LAST_VALIDATED(relativeTime))}`);
+      printInfo(`    ${chalk11.green(MESSAGES.STATUS_LAST_VALIDATED(relativeTime))}`);
     }
   } else {
-    printInfo(`    ${chalk12.red(MESSAGES.STATUS_NOT_VALIDATED)}`);
+    printInfo(`    ${chalk11.red(MESSAGES.STATUS_NOT_VALIDATED)}`);
   }
   printInfo("");
 }
 function formatChangeStatusLabel2(status) {
   switch (status) {
     case "committed":
-      return chalk12.green(MESSAGES.STATUS_CHANGE_COMMITTED);
+      return chalk11.green(MESSAGES.STATUS_CHANGE_COMMITTED);
     case "uncommitted":
-      return chalk12.yellow(MESSAGES.STATUS_CHANGE_UNCOMMITTED);
+      return chalk11.yellow(MESSAGES.STATUS_CHANGE_UNCOMMITTED);
     case "conflict":
-      return chalk12.red(MESSAGES.STATUS_CHANGE_CONFLICT);
+      return chalk11.red(MESSAGES.STATUS_CHANGE_CONFLICT);
     case "clean":
-      return chalk12.gray(MESSAGES.STATUS_CHANGE_CLEAN);
+      return chalk11.gray(MESSAGES.STATUS_CHANGE_CLEAN);
   }
 }
 function printSnapshotsSection(snapshots) {
-  printInfo(`  ${chalk12.bold("\u25C6")} ${chalk12.bold(MESSAGES.STATUS_SNAPSHOTS_SECTION)} (${snapshots.total} \u4E2A)`);
+  printInfo(`  ${chalk11.bold("\u25C6")} ${chalk11.bold(MESSAGES.STATUS_SNAPSHOTS_SECTION)} (${snapshots.total} \u4E2A)`);
   if (snapshots.orphaned > 0) {
-    printInfo(`    ${chalk12.yellow(MESSAGES.STATUS_SNAPSHOT_ORPHANED(snapshots.orphaned))}`);
+    printInfo(`    ${chalk11.yellow(MESSAGES.STATUS_SNAPSHOT_ORPHANED(snapshots.orphaned))}`);
   }
   printInfo("");
 }
 
 // src/commands/alias.ts
-import chalk13 from "chalk";
+import chalk12 from "chalk";
 function getRegisteredCommandNames(program2) {
   return program2.commands.map((cmd) => cmd.name());
 }
@@ -4614,7 +4669,7 @@ ${MESSAGES.ALIAS_LIST_TITLE}
 `);
   printSeparator();
   for (const [alias, command] of entries) {
-    printInfo(`  ${chalk13.bold(alias)} \u2192 ${chalk13.cyan(command)}`);
+    printInfo(`  ${chalk12.bold(alias)} \u2192 ${chalk12.cyan(command)}`);
   }
   printInfo("");
   printSeparator();
@@ -4663,7 +4718,7 @@ function registerAliasCommand(program2) {
 // src/commands/projects.ts
 import { existsSync as existsSync10, readdirSync as readdirSync5, statSync as statSync4 } from "fs";
 import { join as join8 } from "path";
-import chalk14 from "chalk";
+import chalk13 from "chalk";
 function registerProjectsCommand(program2) {
   program2.command("projects [name]").description("\u5C55\u793A\u6240\u6709\u9879\u76EE\u7684 worktree \u6982\u89C8\uFF0C\u6216\u67E5\u770B\u6307\u5B9A\u9879\u76EE\u7684 worktree \u8BE6\u60C5").option("--json", "\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA").action((name, options) => {
     handleProjects({ name, json: options.json });
@@ -4782,7 +4837,7 @@ function sortByLastActiveTimeDesc(projects) {
 }
 function printProjectsOverviewAsText(result) {
   printDoubleSeparator();
-  printInfo(`  ${chalk14.bold.cyan(MESSAGES.PROJECTS_OVERVIEW_TITLE)}`);
+  printInfo(`  ${chalk13.bold.cyan(MESSAGES.PROJECTS_OVERVIEW_TITLE)}`);
   printDoubleSeparator();
   printInfo("");
   if (result.projects.length === 0) {
@@ -4796,7 +4851,7 @@ function printProjectsOverviewAsText(result) {
   }
   printSeparator();
   printInfo("");
-  printInfo(`  \u5171 ${chalk14.bold(String(result.totalProjects))} \u4E2A\u9879\u76EE   ${chalk14.gray(MESSAGES.PROJECTS_TOTAL_DISK_USAGE(formatDiskSize(result.totalDiskUsage)))}`);
+  printInfo(`  \u5171 ${chalk13.bold(String(result.totalProjects))} \u4E2A\u9879\u76EE   ${chalk13.gray(MESSAGES.PROJECTS_TOTAL_DISK_USAGE(formatDiskSize(result.totalDiskUsage)))}`);
   printInfo("");
   printDoubleSeparator();
 }
@@ -4804,16 +4859,16 @@ function printProjectOverviewItem(project) {
   const relativeTime = formatRelativeTime(project.lastActiveTime);
   const activeLabel = relativeTime ? MESSAGES.PROJECTS_LAST_ACTIVE(relativeTime) : "";
   const diskLabel = MESSAGES.PROJECTS_DISK_USAGE(formatDiskSize(project.diskUsage));
-  printInfo(`  ${chalk14.bold("\u25CF")} ${chalk14.bold(project.name)}`);
-  printInfo(`    ${MESSAGES.PROJECTS_WORKTREE_COUNT(project.worktreeCount)}   ${chalk14.gray(activeLabel)}   ${chalk14.gray(diskLabel)}`);
+  printInfo(`  ${chalk13.bold("\u25CF")} ${chalk13.bold(project.name)}`);
+  printInfo(`    ${MESSAGES.PROJECTS_WORKTREE_COUNT(project.worktreeCount)}   ${chalk13.gray(activeLabel)}   ${chalk13.gray(diskLabel)}`);
   printInfo("");
 }
 function printProjectDetailAsText(result) {
   printDoubleSeparator();
-  printInfo(`  ${chalk14.bold.cyan(MESSAGES.PROJECTS_DETAIL_TITLE(result.name))}`);
+  printInfo(`  ${chalk13.bold.cyan(MESSAGES.PROJECTS_DETAIL_TITLE(result.name))}`);
   printDoubleSeparator();
   printInfo("");
-  printInfo(`  ${chalk14.bold("\u25C6")} ${chalk14.bold(MESSAGES.PROJECTS_PATH(result.projectDir))}`);
+  printInfo(`  ${chalk13.bold("\u25C6")} ${chalk13.bold(MESSAGES.PROJECTS_PATH(result.projectDir))}`);
   printInfo(`    ${MESSAGES.PROJECTS_TOTAL_DISK_USAGE(formatDiskSize(result.totalDiskUsage))}`);
   printInfo("");
   printSeparator();
@@ -4833,9 +4888,9 @@ function printWorktreeDetailItem(wt) {
   const relativeTime = formatRelativeTime(wt.lastModifiedTime);
   const modifiedLabel = relativeTime ? MESSAGES.PROJECTS_LAST_MODIFIED(relativeTime) : "";
   const diskLabel = MESSAGES.PROJECTS_DISK_USAGE(formatDiskSize(wt.diskUsage));
-  printInfo(`  ${chalk14.bold("\u25CF")} ${chalk14.bold(wt.branch)}`);
+  printInfo(`  ${chalk13.bold("\u25CF")} ${chalk13.bold(wt.branch)}`);
   printInfo(`    ${wt.path}`);
-  printInfo(`    ${chalk14.gray(modifiedLabel)}   ${chalk14.gray(diskLabel)}`);
+  printInfo(`    ${chalk13.gray(modifiedLabel)}   ${chalk13.gray(diskLabel)}`);
   printInfo("");
 }
 
@@ -5058,16 +5113,23 @@ function registerInitCommand(program2) {
     await handleInit(options);
   });
   initCmd.addCommand(
-    new Cmd("show").description("\u5C55\u793A\u5F53\u524D\u9879\u76EE\u7684 init \u914D\u7F6E").action(() => {
-      handleInitShow();
+    new Cmd("show").description("\u4EA4\u4E92\u5F0F\u67E5\u770B\u548C\u4FEE\u6539\u9879\u76EE\u914D\u7F6E").action(async () => {
+      await handleInitShow();
     })
   );
 }
-function handleInitShow() {
+async function handleInitShow() {
   validateMainWorktree();
   const config2 = requireProjectConfig();
-  const configJson = safeStringify(config2);
-  printInfo(MESSAGES.INIT_SHOW(configJson));
+  logger.info("init show \u547D\u4EE4\u6267\u884C\uFF0C\u8FDB\u5165\u4EA4\u4E92\u5F0F\u9879\u76EE\u914D\u7F6E");
+  const { key, newValue } = await interactiveConfigEditor(
+    config2,
+    PROJECT_CONFIG_DEFINITIONS,
+    { selectPrompt: MESSAGES.INIT_SELECT_PROMPT }
+  );
+  const updatedConfig = { ...config2, [key]: newValue };
+  saveProjectConfig(updatedConfig);
+  printSuccess(MESSAGES.INIT_SET_SUCCESS(key, String(newValue)));
 }
 async function handleInit(options) {
   validateMainWorktree();