clawt 1.0.0

package/dist/index.js

@@ -0,0 +1,923 @@
+#!/usr/bin/env node
+import { createRequire as __clawt_createRequire } from "module";
+const require = __clawt_createRequire(import.meta.url);
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/constants/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+var CLAWT_HOME = join(homedir(), ".clawt");
+var CONFIG_PATH = join(CLAWT_HOME, "config.json");
+var LOGS_DIR = join(CLAWT_HOME, "logs");
+var WORKTREES_DIR = join(CLAWT_HOME, "worktrees");
+
+// src/constants/branch.ts
+var INVALID_BRANCH_CHARS = /[\/\\.\s~:*?[\]^]+/g;
+
+// src/constants/messages.ts
+var MESSAGES = {
+  /** 不在主 worktree 根目录 */
+  NOT_MAIN_WORKTREE: "\u8BF7\u5728\u4E3B worktree \u7684\u6839\u76EE\u5F55\u4E0B\u6267\u884C clawt",
+  /** Git 未安装 */
+  GIT_NOT_INSTALLED: "Git \u672A\u5B89\u88C5\u6216\u4E0D\u5728 PATH \u4E2D\uFF0C\u8BF7\u5148\u5B89\u88C5 Git",
+  /** Claude Code CLI 未安装 */
+  CLAUDE_NOT_INSTALLED: "Claude Code CLI \u672A\u5B89\u88C5\uFF0C\u8BF7\u5148\u5B89\u88C5\uFF1Anpm install -g @anthropic-ai/claude-code",
+  /** 分支已存在 */
+  BRANCH_EXISTS: (name) => `\u5206\u652F ${name} \u5DF2\u5B58\u5728\uFF0C\u65E0\u6CD5\u521B\u5EFA`,
+  /** 分支名被转换 */
+  BRANCH_SANITIZED: (original, sanitized) => `\u5206\u652F\u540D\u5DF2\u8F6C\u6362: ${original} \u2192 ${sanitized}`,
+  /** worktree 创建成功 */
+  WORKTREE_CREATED: (count) => `\u2713 \u5DF2\u521B\u5EFA ${count} \u4E2A worktree`,
+  /** worktree 移除成功 */
+  WORKTREE_REMOVED: (path) => `\u2713 \u5DF2\u79FB\u9664 worktree: ${path}`,
+  /** 没有 worktree */
+  NO_WORKTREES: "(\u65E0 worktree)",
+  /** 目标 worktree 不存在 */
+  WORKTREE_NOT_FOUND: (name) => `worktree ${name} \u4E0D\u5B58\u5728`,
+  /** 主 worktree 有未提交更改 */
+  MAIN_WORKTREE_DIRTY: "\u4E3B worktree \u6709\u672A\u63D0\u4EA4\u7684\u66F4\u6539\uFF0C\u8BF7\u5148\u5904\u7406",
+  /** 目标 worktree 无更改 */
+  TARGET_WORKTREE_CLEAN: "\u8BE5 worktree \u7684\u5206\u652F\u4E0A\u6CA1\u6709\u4EFB\u4F55\u66F4\u6539\uFF0C\u65E0\u9700\u9A8C\u8BC1",
+  /** stash 已变更 */
+  STASH_CHANGED: "git stash list \u5DF2\u53D8\u66F4\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C",
+  /** validate 成功 */
+  VALIDATE_SUCCESS: (branch) => `\u2713 \u5DF2\u5C06\u5206\u652F ${branch} \u7684\u53D8\u66F4\u5E94\u7528\u5230\u4E3B worktree
+  \u53EF\u4EE5\u5F00\u59CB\u9A8C\u8BC1\u4E86`,
+  /** merge 成功 */
+  MERGE_SUCCESS: (branch, message) => `\u2713 \u5206\u652F ${branch} \u5DF2\u6210\u529F\u5408\u5E76\u5230\u5F53\u524D\u5206\u652F
+  \u63D0\u4EA4\u4FE1\u606F: ${message}
+  \u5DF2\u63A8\u9001\u5230\u8FDC\u7A0B\u4ED3\u5E93`,
+  /** merge 成功（无提交信息，目标 worktree 已提交过） */
+  MERGE_SUCCESS_NO_MESSAGE: (branch) => `\u2713 \u5206\u652F ${branch} \u5DF2\u6210\u529F\u5408\u5E76\u5230\u5F53\u524D\u5206\u652F
+  \u5DF2\u63A8\u9001\u5230\u8FDC\u7A0B\u4ED3\u5E93`,
+  /** merge 冲突 */
+  MERGE_CONFLICT: "\u5408\u5E76\u5B58\u5728\u51B2\u7A81\uFF0C\u8BF7\u624B\u52A8\u5904\u7406",
+  /** merge 后清理 worktree 和分支成功 */
+  WORKTREE_CLEANED: (branch) => `\u2713 \u5DF2\u6E05\u7406 worktree \u548C\u5206\u652F: ${branch}`,
+  /** 请提供提交信息 */
+  COMMIT_MESSAGE_REQUIRED: "\u8BF7\u63D0\u4F9B\u63D0\u4EA4\u4FE1\u606F\uFF08-m \u53C2\u6570\uFF09",
+  /** 目标 worktree 有未提交修改但未指定 -m */
+  TARGET_WORKTREE_DIRTY_NO_MESSAGE: "\u76EE\u6807 worktree \u6709\u672A\u63D0\u4EA4\u7684\u4FEE\u6539\uFF0C\u8BF7\u901A\u8FC7 -m \u53C2\u6570\u63D0\u4F9B\u63D0\u4EA4\u4FE1\u606F",
+  /** 目标 worktree 既干净又无本地提交 */
+  TARGET_WORKTREE_NO_CHANGES: "\u76EE\u6807 worktree \u6CA1\u6709\u4EFB\u4F55\u53EF\u5408\u5E76\u7684\u53D8\u66F4\uFF08\u5DE5\u4F5C\u533A\u5E72\u51C0\u4E14\u65E0\u672C\u5730\u63D0\u4EA4\uFF09",
+  /** 检测到用户中断 */
+  INTERRUPTED: "\u68C0\u6D4B\u5230\u9000\u51FA\u6307\u4EE4\uFF0C\u5DF2\u505C\u6B62 Claude Code \u4EFB\u52A1",
+  /** 中断后自动清理完成 */
+  INTERRUPT_AUTO_CLEANED: (count) => `\u2713 \u5DF2\u81EA\u52A8\u6E05\u7406 ${count} \u4E2A worktree \u548C\u5BF9\u5E94\u5206\u652F`,
+  /** 中断后手动确认清理 */
+  INTERRUPT_CONFIRM_CLEANUP: "\u662F\u5426\u79FB\u9664\u521A\u521A\u521B\u5EFA\u7684 worktree \u548C\u5BF9\u5E94\u5206\u652F\uFF1F",
+  /** 中断后清理完成 */
+  INTERRUPT_CLEANED: (count) => `\u2713 \u5DF2\u6E05\u7406 ${count} \u4E2A worktree \u548C\u5BF9\u5E94\u5206\u652F`,
+  /** 中断后保留 worktree */
+  INTERRUPT_KEPT: "\u5DF2\u4FDD\u7559 worktree\uFF0C\u53EF\u7A0D\u540E\u4F7F\u7528 clawt remove \u624B\u52A8\u6E05\u7406",
+  /** 分隔线 */
+  SEPARATOR: "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+  /** 粗分隔线 */
+  DOUBLE_SEPARATOR: "\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"
+};
+
+// src/constants/exitCodes.ts
+var EXIT_CODES = {
+  /** 成功 */
+  SUCCESS: 0,
+  /** 一般错误 */
+  ERROR: 1,
+  /** 参数错误 */
+  ARGUMENT_ERROR: 2
+};
+
+// src/constants/config.ts
+var DEFAULT_CONFIG = {
+  autoDeleteBranch: false,
+  /** 默认 Claude Code CLI 启动指令，用于不传 --tasks 时在 worktree 中打开交互式界面 */
+  claudeCodeCommand: "claude"
+};
+
+// src/errors/index.ts
+var ClawtError = class extends Error {
+  /** 退出码 */
+  exitCode;
+  /**
+   * @param {string} message - 错误消息
+   * @param {number} exitCode - 退出码，默认为 EXIT_CODES.ERROR (1)
+   */
+  constructor(message, exitCode = EXIT_CODES.ERROR) {
+    super(message);
+    this.name = "ClawtError";
+    this.exitCode = exitCode;
+  }
+};
+
+// src/logger/index.ts
+import winston from "winston";
+import DailyRotateFile from "winston-daily-rotate-file";
+import { existsSync, mkdirSync } from "fs";
+if (!existsSync(LOGS_DIR)) {
+  mkdirSync(LOGS_DIR, { recursive: true });
+}
+var logFormat = winston.format.printf(({ level, message, timestamp }) => {
+  const upperLevel = level.toUpperCase().padEnd(5);
+  return `[${timestamp}] [${upperLevel}] ${message}`;
+});
+var dailyRotateTransport = new DailyRotateFile({
+  dirname: LOGS_DIR,
+  filename: "clawt-%DATE%.log",
+  datePattern: "YYYY-MM-DD",
+  maxSize: "10m",
+  maxFiles: "30d"
+});
+var logger = winston.createLogger({
+  level: "debug",
+  format: winston.format.combine(
+    winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+    logFormat
+  ),
+  transports: [dailyRotateTransport]
+});
+
+// src/utils/shell.ts
+import { execSync, spawn } from "child_process";
+function execCommand(command, options) {
+  logger.debug(`\u6267\u884C\u547D\u4EE4: ${command}${options?.cwd ? ` (cwd: ${options.cwd})` : ""}`);
+  const result = execSync(command, {
+    cwd: options?.cwd,
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  return result.trim();
+}
+function spawnProcess(command, args, options) {
+  logger.debug(`\u542F\u52A8\u5B50\u8FDB\u7A0B: ${command} ${args.join(" ")}${options?.cwd ? ` (cwd: ${options.cwd})` : ""}`);
+  return spawn(command, args, {
+    cwd: options?.cwd,
+    stdio: options?.stdio ?? ["pipe", "pipe", "pipe"]
+  });
+}
+function killAllChildProcesses(children) {
+  for (const child of children) {
+    if (!child.killed) {
+      child.kill("SIGTERM");
+    }
+  }
+}
+
+// src/utils/git.ts
+import { basename } from "path";
+function getGitCommonDir(cwd) {
+  return execCommand("git rev-parse --git-common-dir", { cwd });
+}
+function getGitTopLevel(cwd) {
+  return execCommand("git rev-parse --show-toplevel", { cwd });
+}
+function getProjectName(cwd) {
+  const topLevel = getGitTopLevel(cwd);
+  return basename(topLevel);
+}
+function checkBranchExists(branchName, cwd) {
+  try {
+    execCommand(`git show-ref --verify refs/heads/${branchName}`, { cwd });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function createWorktree(branchName, worktreePath, cwd) {
+  logger.info(`\u521B\u5EFA worktree: ${worktreePath}`);
+  execCommand(`git worktree add -b ${branchName} "${worktreePath}"`, { cwd });
+}
+function removeWorktreeByPath(worktreePath, cwd) {
+  logger.info(`\u79FB\u9664 worktree: ${worktreePath}`);
+  execCommand(`git worktree remove -f "${worktreePath}"`, { cwd });
+}
+function deleteBranch(branchName, cwd) {
+  logger.info(`\u5220\u9664\u5206\u652F: ${branchName}`);
+  execCommand(`git branch -D ${branchName}`, { cwd });
+}
+function getStatusPorcelain(cwd) {
+  return execCommand("git status --porcelain", { cwd });
+}
+function isWorkingDirClean(cwd) {
+  return getStatusPorcelain(cwd) === "";
+}
+function gitAddAll(cwd) {
+  execCommand("git add .", { cwd });
+}
+function gitCommit(message, cwd) {
+  execCommand(`git commit -m '${message.replace(/'/g, "'\\''")}'`, { cwd });
+}
+function gitMerge(branchName, cwd) {
+  execCommand(`git merge ${branchName}`, { cwd });
+}
+function hasMergeConflict(cwd) {
+  const status = getStatusPorcelain(cwd);
+  return status.split("\n").some((line) => /^(UU|AA|DD|DU|UD|AU|UA)/.test(line));
+}
+function gitPull(cwd) {
+  execCommand("git pull", { cwd });
+}
+function gitPush(cwd) {
+  execCommand("git push", { cwd });
+}
+function gitResetHard(cwd) {
+  execCommand("git reset --hard HEAD", { cwd });
+}
+function gitCleanForce(cwd) {
+  execCommand("git clean -fd", { cwd });
+}
+function gitStashPush(message, cwd) {
+  execCommand(`git stash push -m "${message}"`, { cwd });
+}
+function gitStashApply(cwd) {
+  execCommand("git stash apply", { cwd });
+}
+function gitStashPop(index = 0, cwd) {
+  execCommand(`git stash pop stash@{${index}}`, { cwd });
+}
+function gitStashList(cwd) {
+  try {
+    return execCommand("git stash list", { cwd });
+  } catch {
+    return "";
+  }
+}
+function gitRestoreStaged(cwd) {
+  execCommand("git restore --staged .", { cwd });
+}
+function gitWorktreeList(cwd) {
+  return execCommand("git worktree list", { cwd });
+}
+function gitWorktreePrune(cwd) {
+  execCommand("git worktree prune", { cwd });
+}
+function hasLocalCommits(branchName, cwd) {
+  try {
+    const output = execCommand(`git log HEAD..${branchName} --oneline`, { cwd });
+    return output.trim() !== "";
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/formatter.ts
+import chalk from "chalk";
+import { createInterface } from "readline";
+function printSuccess(message) {
+  console.log(chalk.green(message));
+}
+function printError(message) {
+  console.error(chalk.red(`\u2717 ${message}`));
+}
+function printWarning(message) {
+  console.log(chalk.yellow(`\u26A0 ${message}`));
+}
+function printInfo(message) {
+  console.log(message);
+}
+function printSeparator() {
+  console.log(MESSAGES.SEPARATOR);
+}
+function printDoubleSeparator() {
+  console.log(MESSAGES.DOUBLE_SEPARATOR);
+}
+function confirmAction(question) {
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question(`${question} (y/N) `, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y");
+    });
+  });
+}
+
+// src/utils/branch.ts
+function sanitizeBranchName(branchName) {
+  const sanitized = branchName.replace(INVALID_BRANCH_CHARS, "-").replace(/-{2,}/g, "-").replace(/^-|-$/g, "");
+  if (sanitized !== branchName) {
+    logger.warn(MESSAGES.BRANCH_SANITIZED(branchName, sanitized));
+    printWarning(MESSAGES.BRANCH_SANITIZED(branchName, sanitized));
+  }
+  return sanitized;
+}
+function generateBranchNames(branchName, count) {
+  if (count === 1) {
+    return [branchName];
+  }
+  return Array.from({ length: count }, (_, i) => `${branchName}-${i + 1}`);
+}
+function validateBranchesNotExist(branchNames) {
+  for (const name of branchNames) {
+    if (checkBranchExists(name)) {
+      throw new ClawtError(MESSAGES.BRANCH_EXISTS(name));
+    }
+  }
+}
+
+// src/utils/validation.ts
+function validateMainWorktree() {
+  try {
+    const gitCommonDir = getGitCommonDir();
+    if (gitCommonDir !== ".git") {
+      throw new ClawtError(MESSAGES.NOT_MAIN_WORKTREE);
+    }
+  } catch (error) {
+    if (error instanceof ClawtError) {
+      throw error;
+    }
+    throw new ClawtError(MESSAGES.NOT_MAIN_WORKTREE);
+  }
+}
+function validateClaudeCodeInstalled() {
+  try {
+    execCommand("claude --version");
+  } catch {
+    throw new ClawtError(MESSAGES.CLAUDE_NOT_INSTALLED);
+  }
+}
+
+// src/utils/worktree.ts
+import { join as join2 } from "path";
+import { existsSync as existsSync3, readdirSync as readdirSync2 } from "fs";
+
+// src/utils/fs.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync, rmdirSync } from "fs";
+function ensureDir(dirPath) {
+  if (!existsSync2(dirPath)) {
+    mkdirSync2(dirPath, { recursive: true });
+  }
+}
+function removeEmptyDir(dirPath) {
+  if (!existsSync2(dirPath)) {
+    return false;
+  }
+  const entries = readdirSync(dirPath);
+  if (entries.length === 0) {
+    rmdirSync(dirPath);
+    return true;
+  }
+  return false;
+}
+
+// src/utils/worktree.ts
+function getProjectWorktreeDir() {
+  const projectName = getProjectName();
+  return join2(WORKTREES_DIR, projectName);
+}
+function createWorktrees(branchName, count) {
+  const sanitized = sanitizeBranchName(branchName);
+  const branchNames = generateBranchNames(sanitized, count);
+  validateBranchesNotExist(branchNames);
+  const projectDir = getProjectWorktreeDir();
+  ensureDir(projectDir);
+  const results = [];
+  for (const name of branchNames) {
+    const worktreePath = join2(projectDir, name);
+    createWorktree(name, worktreePath);
+    results.push({ path: worktreePath, branch: name });
+    logger.info(`worktree \u521B\u5EFA\u5B8C\u6210: ${worktreePath} (\u5206\u652F: ${name})`);
+  }
+  return results;
+}
+function getProjectWorktrees() {
+  const projectDir = getProjectWorktreeDir();
+  if (!existsSync3(projectDir)) {
+    return [];
+  }
+  const worktreeListOutput = gitWorktreeList();
+  const registeredPaths = new Set(
+    worktreeListOutput.split("\n").map((line) => line.split(/\s+/)[0])
+  );
+  const entries = readdirSync2(projectDir, { withFileTypes: true });
+  const worktrees = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const fullPath = join2(projectDir, entry.name);
+    if (registeredPaths.has(fullPath)) {
+      worktrees.push({
+        path: fullPath,
+        branch: entry.name
+      });
+    }
+  }
+  return worktrees;
+}
+function cleanupWorktrees(worktrees) {
+  for (const wt of worktrees) {
+    try {
+      removeWorktreeByPath(wt.path);
+      deleteBranch(wt.branch);
+      logger.info(`\u5DF2\u6E05\u7406 worktree \u548C\u5206\u652F: ${wt.branch}`);
+    } catch (error) {
+      logger.error(`\u6E05\u7406 worktree \u5931\u8D25: ${wt.path} - ${error}`);
+    }
+  }
+  gitWorktreePrune();
+  const projectDir = getProjectWorktreeDir();
+  removeEmptyDir(projectDir);
+}
+
+// src/utils/config.ts
+import { existsSync as existsSync4, readFileSync } from "fs";
+function loadConfig() {
+  if (!existsSync4(CONFIG_PATH)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  const raw = readFileSync(CONFIG_PATH, "utf-8");
+  return { ...DEFAULT_CONFIG, ...JSON.parse(raw) };
+}
+function getConfigValue(key) {
+  const config = loadConfig();
+  return config[key];
+}
+function ensureClawtDirs() {
+  ensureDir(CLAWT_HOME);
+  ensureDir(LOGS_DIR);
+  ensureDir(WORKTREES_DIR);
+}
+
+// src/utils/prompt.ts
+import Enquirer from "enquirer";
+
+// src/commands/list.ts
+function registerListCommand(program2) {
+  program2.command("list").description("\u5217\u51FA\u5F53\u524D\u9879\u76EE\u6240\u6709 worktree").action(() => {
+    handleList();
+  });
+}
+function handleList() {
+  validateMainWorktree();
+  const projectName = getProjectName();
+  const worktrees = getProjectWorktrees();
+  logger.info(`list \u547D\u4EE4\u6267\u884C\uFF0C\u9879\u76EE: ${projectName}\uFF0C\u5171 ${worktrees.length} \u4E2A worktree`);
+  printInfo(`\u5F53\u524D\u9879\u76EE: ${projectName}
+`);
+  if (worktrees.length === 0) {
+    printInfo(`  ${MESSAGES.NO_WORKTREES}`);
+  } else {
+    for (const wt of worktrees) {
+      printInfo(`  ${wt.path}   [${wt.branch}]`);
+    }
+    printInfo(`
+\u5171 ${worktrees.length} \u4E2A worktree`);
+  }
+}
+
+// src/commands/create.ts
+function registerCreateCommand(program2) {
+  program2.command("create").description("\u6279\u91CF\u521B\u5EFA worktree \u53CA\u5BF9\u5E94\u5206\u652F").requiredOption("-b, --branch <branchName>", "\u5206\u652F\u540D").option("-n, --number <count>", "\u521B\u5EFA\u6570\u91CF", "1").action((options) => {
+    handleCreate(options);
+  });
+}
+function handleCreate(options) {
+  validateMainWorktree();
+  const count = Number(options.number);
+  logger.info(`create \u547D\u4EE4\u6267\u884C\uFF0C\u5206\u652F: ${options.branch}\uFF0C\u6570\u91CF: ${count}`);
+  const worktrees = createWorktrees(options.branch, count);
+  printSuccess(MESSAGES.WORKTREE_CREATED(worktrees.length));
+  printInfo("");
+  worktrees.forEach((wt, index) => {
+    printInfo(`\u76EE\u5F55\u8DEF\u5F84${index + 1}\uFF1A`);
+    printInfo(`  ${wt.path}`);
+    printInfo(`  \u5206\u652F\u540D: ${wt.branch}`);
+    printSeparator();
+  });
+}
+
+// src/commands/remove.ts
+import { join as join3 } from "path";
+function registerRemoveCommand(program2) {
+  program2.command("remove").description("\u79FB\u9664 worktree\uFF08\u652F\u6301\u5355\u4E2A/\u6279\u91CF/\u5168\u90E8\uFF09").option("--all", "\u79FB\u9664\u5F53\u524D\u9879\u76EE\u4E0B\u6240\u6709 worktree").option("-b, --branch <branchName>", "\u6307\u5B9A\u5206\u652F\u540D").option("-i, --index <index>", "\u6307\u5B9A\u7D22\u5F15\uFF08\u914D\u5408 -b \u4F7F\u7528\uFF09").action(async (options) => {
+    await handleRemove(options);
+  });
+}
+function resolveWorktreesToRemove(options) {
+  const projectDir = getProjectWorktreeDir();
+  const allWorktrees = getProjectWorktrees();
+  if (options.all) {
+    return allWorktrees;
+  }
+  if (!options.branch) {
+    throw new ClawtError("\u8BF7\u6307\u5B9A --all \u6216 -b <branchName> \u53C2\u6570");
+  }
+  if (options.index !== void 0) {
+    const targetName = `${options.branch}-${options.index}`;
+    const targetPath = join3(projectDir, targetName);
+    const found = allWorktrees.find((wt) => wt.path === targetPath);
+    if (!found) {
+      throw new ClawtError(MESSAGES.WORKTREE_NOT_FOUND(targetName));
+    }
+    return [found];
+  }
+  const matched = allWorktrees.filter(
+    (wt) => wt.branch === options.branch || wt.branch.startsWith(`${options.branch}-`)
+  );
+  if (matched.length === 0) {
+    throw new ClawtError(MESSAGES.WORKTREE_NOT_FOUND(options.branch));
+  }
+  return matched;
+}
+async function handleRemove(options) {
+  validateMainWorktree();
+  const projectName = getProjectName();
+  logger.info(`remove \u547D\u4EE4\u6267\u884C\uFF0C\u9879\u76EE: ${projectName}`);
+  const worktreesToRemove = resolveWorktreesToRemove(options);
+  if (worktreesToRemove.length === 0) {
+    printInfo(MESSAGES.NO_WORKTREES);
+    return;
+  }
+  printInfo("\u5373\u5C06\u79FB\u9664\u4EE5\u4E0B worktree \u53CA\u672C\u5730\u5206\u652F\uFF1A\n");
+  worktreesToRemove.forEach((wt, index) => {
+    printInfo(`  ${index + 1}. ${wt.path}  \u2192  \u5206\u652F: ${wt.branch}`);
+  });
+  printInfo("");
+  const autoDelete = getConfigValue("autoDeleteBranch");
+  let shouldDeleteBranch = autoDelete;
+  if (!autoDelete) {
+    shouldDeleteBranch = await confirmAction("\u662F\u5426\u540C\u65F6\u5220\u9664\u5BF9\u5E94\u7684\u672C\u5730\u5206\u652F\uFF1F");
+  }
+  for (const wt of worktreesToRemove) {
+    try {
+      removeWorktreeByPath(wt.path);
+      if (shouldDeleteBranch) {
+        deleteBranch(wt.branch);
+      }
+      printSuccess(MESSAGES.WORKTREE_REMOVED(wt.path));
+    } catch (error) {
+      logger.error(`\u79FB\u9664 worktree \u5931\u8D25: ${wt.path} - ${error}`);
+      throw error;
+    }
+  }
+  gitWorktreePrune();
+  const projectDir = getProjectWorktreeDir();
+  removeEmptyDir(projectDir);
+}
+
+// src/commands/run.ts
+import { spawnSync } from "child_process";
+function registerRunCommand(program2) {
+  program2.command("run").description("\u6279\u91CF\u521B\u5EFA worktree \u5E76\u542F\u52A8 Claude Code \u6267\u884C\u4EFB\u52A1").requiredOption("-b, --branch <branchName>", "\u5206\u652F\u540D").option("--tasks <task...>", "\u4EFB\u52A1\u5217\u8868\uFF08\u53EF\u591A\u6B21\u6307\u5B9A\uFF09\uFF0C\u4E0D\u4F20\u5219\u5728 worktree \u4E2D\u6253\u5F00 Claude Code \u4EA4\u4E92\u5F0F\u754C\u9762").action(async (options) => {
+    await handleRun(options);
+  });
+}
+function launchInteractiveClaude(worktree) {
+  const commandStr = getConfigValue("claudeCodeCommand");
+  const parts = commandStr.split(/\s+/).filter(Boolean);
+  const cmd = parts[0];
+  const args = parts.slice(1);
+  printInfo(`\u6B63\u5728 worktree \u4E2D\u542F\u52A8 Claude Code \u4EA4\u4E92\u5F0F\u754C\u9762...`);
+  printInfo(`  \u5206\u652F: ${worktree.branch}`);
+  printInfo(`  \u8DEF\u5F84: ${worktree.path}`);
+  printInfo(`  \u6307\u4EE4: ${commandStr}`);
+  printInfo("");
+  const result = spawnSync(cmd, args, {
+    cwd: worktree.path,
+    stdio: "inherit"
+  });
+  if (result.error) {
+    throw new ClawtError(`\u542F\u52A8 Claude Code \u5931\u8D25: ${result.error.message}`);
+  }
+  if (result.status !== null && result.status !== 0) {
+    printWarning(`Claude Code \u9000\u51FA\u7801: ${result.status}`);
+  }
+}
+function executeClaudeTask(worktree, task) {
+  const child = spawnProcess(
+    "claude",
+    ["-p", task, "--output-format", "json", "--permission-mode", "bypassPermissions"],
+    {
+      cwd: worktree.path,
+      // stdin 必须设置为 'ignore'，不能用 'pipe'
+      // 原因：claude -p 是非交互模式，不需要 stdin 输入。如果 stdin 为 'pipe'，
+      // 父进程会创建一个可写流连接到子进程但从不写入也不关闭，
+      // claude 检测到 stdin 是管道后会尝试读取输入，导致进程永远卡住
+      stdio: ["ignore", "pipe", "pipe"]
+    }
+  );
+  const promise = new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("close", (code) => {
+      let result = null;
+      let success = code === 0;
+      try {
+        if (stdout.trim()) {
+          result = JSON.parse(stdout.trim());
+          success = !result.is_error;
+        }
+      } catch {
+        logger.warn(`\u89E3\u6790 Claude Code \u8F93\u51FA\u5931\u8D25: ${stdout.substring(0, 200)}`);
+      }
+      resolve({
+        task,
+        branch: worktree.branch,
+        worktreePath: worktree.path,
+        success,
+        result,
+        error: success ? void 0 : stderr || "\u4EFB\u52A1\u6267\u884C\u5931\u8D25"
+      });
+    });
+    child.on("error", (err) => {
+      resolve({
+        task,
+        branch: worktree.branch,
+        worktreePath: worktree.path,
+        success: false,
+        result: null,
+        error: err.message
+      });
+    });
+  });
+  return { child, promise };
+}
+function printTaskNotification(taskResult) {
+  const { success, worktreePath, branch, result } = taskResult;
+  const status = success ? "\u5B8C\u6210" : "\u5931\u8D25";
+  const icon = success ? "\u2713" : "\u2717";
+  const durationStr = result ? `${(result.duration_ms / 1e3).toFixed(1)}s` : "N/A";
+  const costStr = result ? `$${result.total_cost_usd.toFixed(2)}` : "N/A";
+  const resultStr = success ? "success" : "failed";
+  if (success) {
+    printSuccess(`${icon} [${status}] worktree: ${worktreePath}`);
+  } else {
+    printError(`${icon} [${status}] worktree: ${worktreePath}`);
+  }
+  printInfo(`  \u5206\u652F: ${branch}`);
+  printInfo(`  \u8017\u65F6: ${durationStr}`);
+  printInfo(`  \u82B1\u8D39: ${costStr}`);
+  printInfo(`  \u7ED3\u679C: ${resultStr}`);
+  printSeparator();
+}
+function printTaskSummary(summary) {
+  printDoubleSeparator();
+  printInfo(`\u5168\u90E8\u4EFB\u52A1\u5DF2\u5B8C\u6210 (${summary.total}/${summary.total})`);
+  printInfo(`  \u6210\u529F: ${summary.succeeded}`);
+  printInfo(`  \u5931\u8D25: ${summary.failed}`);
+  printInfo(`  \u603B\u8017\u65F6: ${(summary.totalDurationMs / 1e3).toFixed(1)}s`);
+  printInfo(`  \u603B\u82B1\u8D39: $${summary.totalCostUsd.toFixed(2)}`);
+  printDoubleSeparator();
+}
+async function handleInterruptCleanup(worktrees) {
+  const autoDelete = getConfigValue("autoDeleteBranch");
+  if (autoDelete) {
+    cleanupWorktrees(worktrees);
+    printSuccess(MESSAGES.INTERRUPT_AUTO_CLEANED(worktrees.length));
+    return;
+  }
+  const shouldClean = await confirmAction(MESSAGES.INTERRUPT_CONFIRM_CLEANUP);
+  if (shouldClean) {
+    cleanupWorktrees(worktrees);
+    printSuccess(MESSAGES.INTERRUPT_CLEANED(worktrees.length));
+  } else {
+    printInfo(MESSAGES.INTERRUPT_KEPT);
+  }
+}
+async function handleRun(options) {
+  validateMainWorktree();
+  validateClaudeCodeInstalled();
+  if (!options.tasks || options.tasks.length === 0) {
+    const worktrees2 = createWorktrees(options.branch, 1);
+    const worktree = worktrees2[0];
+    printSuccess(MESSAGES.WORKTREE_CREATED(1));
+    launchInteractiveClaude(worktree);
+    return;
+  }
+  const tasks = options.tasks.map((t) => t.trim()).filter(Boolean);
+  if (tasks.length === 0) {
+    throw new ClawtError("\u4EFB\u52A1\u5217\u8868\u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  const count = tasks.length;
+  logger.info(`run \u547D\u4EE4\u6267\u884C\uFF0C\u5206\u652F: ${options.branch}\uFF0C\u4EFB\u52A1\u6570: ${count}`);
+  const worktrees = createWorktrees(options.branch, count);
+  printSuccess(MESSAGES.WORKTREE_CREATED(worktrees.length));
+  for (const wt of worktrees) {
+    printInfo(`  \u5206\u652F: ${wt.branch}  \u8DEF\u5F84: ${wt.path}`);
+  }
+  printInfo("");
+  const startTime = Date.now();
+  const handles = worktrees.map((wt, index) => {
+    const task = tasks[index];
+    logger.info(`\u542F\u52A8\u4EFB\u52A1 ${index + 1}: ${task} (worktree: ${wt.path})`);
+    return executeClaudeTask(wt, task);
+  });
+  const childProcesses = handles.map((h) => h.child);
+  let interrupted = false;
+  const sigintHandler = async () => {
+    if (interrupted) return;
+    interrupted = true;
+    printInfo("");
+    printWarning(MESSAGES.INTERRUPTED);
+    killAllChildProcesses(childProcesses);
+    await Promise.allSettled(handles.map((h) => h.promise));
+    await handleInterruptCleanup(worktrees);
+    process.exit(1);
+  };
+  process.on("SIGINT", sigintHandler);
+  const taskPromises = handles.map(
+    (handle) => handle.promise.then((result) => {
+      if (!interrupted) {
+        printTaskNotification(result);
+      }
+      return result;
+    })
+  );
+  const results = await Promise.all(taskPromises);
+  process.removeListener("SIGINT", sigintHandler);
+  if (interrupted) return;
+  const totalDurationMs = Date.now() - startTime;
+  const summary = {
+    total: results.length,
+    succeeded: results.filter((r) => r.success).length,
+    failed: results.filter((r) => !r.success).length,
+    totalDurationMs,
+    totalCostUsd: results.reduce((sum, r) => sum + (r.result?.total_cost_usd ?? 0), 0)
+  };
+  printTaskSummary(summary);
+}
+
+// src/commands/validate.ts
+import { join as join4 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import Enquirer2 from "enquirer";
+function registerValidateCommand(program2) {
+  program2.command("validate").description("\u5728\u4E3B worktree \u9A8C\u8BC1\u67D0\u4E2A worktree \u5206\u652F\u7684\u53D8\u66F4").requiredOption("-b, --branch <branchName>", "\u8981\u9A8C\u8BC1\u7684\u5206\u652F\u540D").action(async (options) => {
+    await handleValidate(options);
+  });
+}
+async function handleDirtyMainWorktree(mainWorktreePath) {
+  printWarning("\u4E3B worktree \u5F53\u524D\u5206\u652F\u6709\u672A\u63D0\u4EA4\u7684\u66F4\u6539\uFF0C\u8BF7\u9009\u62E9\u5904\u7406\u65B9\u5F0F\uFF1A\n");
+  const choice = await new Enquirer2.Select({
+    message: "\u9009\u62E9\u5904\u7406\u65B9\u5F0F",
+    choices: [
+      {
+        name: "reset",
+        message: "reset (\u63A8\u8350) - \u4E22\u5F03\u6240\u6709\u66F4\u6539 (git reset --hard HEAD && git clean -fd)"
+      },
+      {
+        name: "stash",
+        message: "stash        - \u6682\u5B58\u66F4\u6539 (git add . && git stash)"
+      },
+      {
+        name: "exit",
+        message: "exit         - \u9000\u51FA\uFF0C\u624B\u52A8\u5904\u7406"
+      }
+    ],
+    initial: 0
+  }).run();
+  if (choice === "exit") {
+    throw new ClawtError("\u7528\u6237\u9009\u62E9\u9000\u51FA");
+  }
+  if (choice === "reset") {
+    gitResetHard(mainWorktreePath);
+    gitCleanForce(mainWorktreePath);
+  } else if (choice === "stash") {
+    gitAddAll(mainWorktreePath);
+    gitStashPush("clawt:auto-stash", mainWorktreePath);
+  }
+  if (!isWorkingDirClean(mainWorktreePath)) {
+    throw new ClawtError("\u5DE5\u4F5C\u533A\u4ECD\u7136\u4E0D\u5E72\u51C0\uFF0C\u8BF7\u624B\u52A8\u5904\u7406");
+  }
+}
+async function handleValidate(options) {
+  validateMainWorktree();
+  const projectName = getProjectName();
+  const mainWorktreePath = getGitTopLevel();
+  const projectDir = getProjectWorktreeDir();
+  const targetWorktreePath = join4(projectDir, options.branch);
+  logger.info(`validate \u547D\u4EE4\u6267\u884C\uFF0C\u5206\u652F: ${options.branch}`);
+  if (!existsSync5(targetWorktreePath)) {
+    throw new ClawtError(MESSAGES.WORKTREE_NOT_FOUND(options.branch));
+  }
+  if (!isWorkingDirClean(mainWorktreePath)) {
+    await handleDirtyMainWorktree(mainWorktreePath);
+  }
+  if (isWorkingDirClean(targetWorktreePath)) {
+    printInfo(MESSAGES.TARGET_WORKTREE_CLEAN);
+    return;
+  }
+  const stashMessage = `clawt:validate:${options.branch}`;
+  gitAddAll(targetWorktreePath);
+  gitStashPush(stashMessage, targetWorktreePath);
+  gitStashApply(targetWorktreePath);
+  gitRestoreStaged(targetWorktreePath);
+  const stashList = gitStashList(mainWorktreePath);
+  const firstLine = stashList.split("\n")[0] || "";
+  if (!firstLine.includes(stashMessage)) {
+    throw new ClawtError(MESSAGES.STASH_CHANGED);
+  }
+  gitStashPop(0, mainWorktreePath);
+  printSuccess(MESSAGES.VALIDATE_SUCCESS(options.branch));
+}
+
+// src/commands/merge.ts
+import { join as join5 } from "path";
+import { existsSync as existsSync6 } from "fs";
+function registerMergeCommand(program2) {
+  program2.command("merge").description("\u5408\u5E76\u67D0\u4E2A\u5DF2\u9A8C\u8BC1\u7684 worktree \u5206\u652F\u5230\u4E3B worktree").requiredOption("-b, --branch <branchName>", "\u8981\u5408\u5E76\u7684\u5206\u652F\u540D").option("-m, --message <message>", "\u63D0\u4EA4\u4FE1\u606F\uFF08\u5DE5\u4F5C\u533A\u6709\u4FEE\u6539\u65F6\u5FC5\u586B\uFF09").action(async (options) => {
+    await handleMerge(options);
+  });
+}
+async function shouldCleanupAfterMerge(branchName) {
+  const autoDelete = getConfigValue("autoDeleteBranch");
+  if (autoDelete) {
+    printInfo(`\u5DF2\u914D\u7F6E\u81EA\u52A8\u5220\u9664\uFF0Cmerge \u6210\u529F\u540E\u5C06\u81EA\u52A8\u6E05\u7406 worktree \u548C\u5206\u652F: ${branchName}`);
+    return true;
+  }
+  return confirmAction(`merge \u6210\u529F\u540E\u662F\u5426\u5220\u9664\u5BF9\u5E94\u7684 worktree \u548C\u5206\u652F (${branchName})\uFF1F`);
+}
+function cleanupWorktreeAndBranch(worktreePath, branchName) {
+  cleanupWorktrees([{ path: worktreePath, branch: branchName }]);
+  printSuccess(MESSAGES.WORKTREE_CLEANED(branchName));
+}
+async function handleMerge(options) {
+  validateMainWorktree();
+  const mainWorktreePath = getGitTopLevel();
+  const projectDir = getProjectWorktreeDir();
+  const targetWorktreePath = join5(projectDir, options.branch);
+  logger.info(`merge \u547D\u4EE4\u6267\u884C\uFF0C\u5206\u652F: ${options.branch}\uFF0C\u63D0\u4EA4\u4FE1\u606F: ${options.message ?? "(\u672A\u63D0\u4F9B)"}`);
+  if (!existsSync6(targetWorktreePath)) {
+    throw new ClawtError(MESSAGES.WORKTREE_NOT_FOUND(options.branch));
+  }
+  if (!isWorkingDirClean(mainWorktreePath)) {
+    throw new ClawtError(MESSAGES.MAIN_WORKTREE_DIRTY);
+  }
+  const shouldCleanup = await shouldCleanupAfterMerge(options.branch);
+  const targetClean = isWorkingDirClean(targetWorktreePath);
+  if (!targetClean) {
+    if (!options.message) {
+      throw new ClawtError(MESSAGES.TARGET_WORKTREE_DIRTY_NO_MESSAGE);
+    }
+    gitAddAll(targetWorktreePath);
+    gitCommit(options.message, targetWorktreePath);
+  } else {
+    if (!hasLocalCommits(options.branch, mainWorktreePath)) {
+      throw new ClawtError(MESSAGES.TARGET_WORKTREE_NO_CHANGES);
+    }
+  }
+  try {
+    gitMerge(options.branch, mainWorktreePath);
+  } catch (error) {
+    if (hasMergeConflict(mainWorktreePath)) {
+      throw new ClawtError(MESSAGES.MERGE_CONFLICT);
+    }
+    throw error;
+  }
+  if (hasMergeConflict(mainWorktreePath)) {
+    throw new ClawtError(MESSAGES.MERGE_CONFLICT);
+  }
+  gitPull(mainWorktreePath);
+  gitPush(mainWorktreePath);
+  if (options.message) {
+    printSuccess(MESSAGES.MERGE_SUCCESS(options.branch, options.message));
+  } else {
+    printSuccess(MESSAGES.MERGE_SUCCESS_NO_MESSAGE(options.branch));
+  }
+  if (shouldCleanup) {
+    cleanupWorktreeAndBranch(targetWorktreePath, options.branch);
+  }
+}
+
+// src/index.ts
+ensureClawtDirs();
+var program = new Command();
+program.name("clawt").description("\u672C\u5730\u5E76\u884C\u6267\u884C\u591A\u4E2AClaude Code Agent\u4EFB\u52A1\uFF0C\u878D\u5408 Git Worktree \u4E0E Claude Code CLI \u7684\u547D\u4EE4\u884C\u5DE5\u5177").version("1.0.0");
+registerListCommand(program);
+registerCreateCommand(program);
+registerRemoveCommand(program);
+registerRunCommand(program);
+registerValidateCommand(program);
+registerMergeCommand(program);
+process.on("uncaughtException", (error) => {
+  if (error instanceof ClawtError) {
+    printError(error.message);
+    logger.error(error.message);
+    process.exit(error.exitCode);
+  }
+  printError(error.message || "\u672A\u77E5\u9519\u8BEF");
+  logger.error(`\u672A\u6355\u83B7\u5F02\u5E38: ${error.message}
+${error.stack}`);
+  process.exit(EXIT_CODES.ERROR);
+});
+process.on("unhandledRejection", (reason) => {
+  const error = reason instanceof Error ? reason : new Error(String(reason));
+  if (error instanceof ClawtError) {
+    printError(error.message);
+    logger.error(error.message);
+    process.exit(error.exitCode);
+  }
+  printError(error.message || "\u672A\u77E5\u9519\u8BEF");
+  logger.error(`\u672A\u5904\u7406\u7684 Promise \u62D2\u7EDD: ${error.message}`);
+  process.exit(EXIT_CODES.ERROR);
+});
+program.parse(process.argv);