hamster-wheel-cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,2678 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  runCli: () => runCli
+});
+module.exports = __toCommonJS(cli_exports);
+var import_node_child_process = require("child_process");
+var import_commander = require("commander");
+
+// src/config.ts
+var import_node_path2 = __toESM(require("path"));
+
+// src/utils.ts
+var import_node_path = __toESM(require("path"));
+var import_fs_extra = __toESM(require("fs-extra"));
+var importExeca = async () => {
+  const importer = new Function("specifier", "return import(specifier)");
+  return importer("execa");
+};
+async function runCommand(command, args, options = {}) {
+  const label = options.verboseLabel ?? "cmd";
+  const displayCmd = options.verboseCommand ?? [command, ...args].join(" ");
+  const cwd = options.cwd ?? process.cwd();
+  options.logger?.debug(`[${label}] ${displayCmd} (cwd: ${cwd})`);
+  const logger = options.logger;
+  const streamEnabled = Boolean(options.stream?.enabled && logger);
+  const stdoutPrefix = options.stream?.stdoutPrefix ?? `[${label}] `;
+  const stderrPrefix = options.stream?.stderrPrefix ?? `[${label} stderr] `;
+  const createLineStreamer = (prefix) => {
+    let buffer = "";
+    const emit = (line) => {
+      logger?.info(`${prefix}${line}`);
+    };
+    const push = (chunk) => {
+      const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      buffer += text.replace(/\r/g, "\n");
+      const parts = buffer.split("\n");
+      buffer = parts.pop() ?? "";
+      parts.forEach(emit);
+    };
+    const flush = () => {
+      if (buffer.length === 0) return;
+      emit(buffer);
+      buffer = "";
+    };
+    return { push, flush };
+  };
+  const attachStream = (stream, streamer) => {
+    if (!stream) return;
+    if (typeof stream.setEncoding === "function") {
+      stream.setEncoding("utf8");
+    }
+    stream.on("data", streamer.push);
+    stream.on("end", streamer.flush);
+  };
+  const stdoutStreamer = streamEnabled ? createLineStreamer(stdoutPrefix) : null;
+  const stderrStreamer = streamEnabled ? createLineStreamer(stderrPrefix) : null;
+  try {
+    const { execa } = await importExeca();
+    const subprocess = execa(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      input: options.input,
+      all: false
+    });
+    if (stdoutStreamer) {
+      attachStream(subprocess.stdout, stdoutStreamer);
+    }
+    if (stderrStreamer) {
+      attachStream(subprocess.stderr, stderrStreamer);
+    }
+    const result = await subprocess;
+    stdoutStreamer?.flush();
+    stderrStreamer?.flush();
+    const commandResult = {
+      stdout: String(result.stdout ?? ""),
+      stderr: String(result.stderr ?? ""),
+      exitCode: result.exitCode ?? 0
+    };
+    if (logger) {
+      const stdout = commandResult.stdout.trim();
+      const stderr = commandResult.stderr.trim();
+      if (stdout.length > 0) {
+        logger.debug(`[${label}] stdout: ${stdout}`);
+      }
+      if (stderr.length > 0) {
+        logger.debug(`[${label}] stderr: ${stderr}`);
+      }
+      logger.debug(`[${label}] exit ${commandResult.exitCode}`);
+    }
+    return commandResult;
+  } catch (error) {
+    const execaError = error;
+    stdoutStreamer?.flush();
+    stderrStreamer?.flush();
+    const commandResult = {
+      stdout: String(execaError.stdout ?? ""),
+      stderr: String(execaError.stderr ?? String(error)),
+      exitCode: execaError.exitCode ?? 1
+    };
+    if (logger) {
+      const stdout = commandResult.stdout.trim();
+      const stderr = commandResult.stderr.trim();
+      if (stdout.length > 0) {
+        logger.debug(`[${label}] stdout: ${stdout}`);
+      }
+      if (stderr.length > 0) {
+        logger.debug(`[${label}] stderr: ${stderr}`);
+      }
+      logger.debug(`[${label}] exit ${commandResult.exitCode}`);
+    }
+    return commandResult;
+  }
+}
+function isoNow() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function resolvePath(cwd, target) {
+  return import_node_path.default.isAbsolute(target) ? target : import_node_path.default.join(cwd, target);
+}
+async function ensureDir(dirPath) {
+  await import_fs_extra.default.mkdirp(dirPath);
+}
+async function ensureFile(filePath, initialContent = "") {
+  await ensureDir(import_node_path.default.dirname(filePath));
+  const exists = await import_fs_extra.default.pathExists(filePath);
+  if (!exists) {
+    await import_fs_extra.default.writeFile(filePath, initialContent, "utf8");
+  }
+}
+async function appendSection(filePath, content) {
+  await ensureDir(import_node_path.default.dirname(filePath));
+  await import_fs_extra.default.appendFile(filePath, `
+${content}
+`, "utf8");
+}
+async function readFileSafe(filePath) {
+  const exists = await import_fs_extra.default.pathExists(filePath);
+  if (!exists) return "";
+  return import_fs_extra.default.readFile(filePath, "utf8");
+}
+function pad2(value) {
+  return String(value).padStart(2, "0");
+}
+
+// src/config.ts
+function buildAiConfig(options) {
+  return {
+    command: options.aiCli,
+    args: options.aiArgs,
+    promptArg: options.aiPromptArg
+  };
+}
+function buildWorktreeConfig(options) {
+  return {
+    useWorktree: options.useWorktree,
+    branchName: options.branch,
+    worktreePath: options.worktreePath,
+    baseBranch: options.baseBranch
+  };
+}
+function buildTestConfig(options) {
+  return {
+    unitCommand: options.unitCommand,
+    e2eCommand: options.e2eCommand
+  };
+}
+function buildPrConfig(options) {
+  return {
+    enable: options.pr,
+    title: options.prTitle,
+    bodyPath: options.prBody,
+    draft: options.draft,
+    reviewers: options.reviewers
+  };
+}
+function buildWebhookConfig(options) {
+  if (!options.webhookUrls || options.webhookUrls.length === 0) return void 0;
+  return {
+    urls: options.webhookUrls,
+    timeoutMs: options.webhookTimeout
+  };
+}
+function buildWorkflowFiles(options, cwd) {
+  return {
+    workflowDoc: resolvePath(cwd, options.workflowDoc),
+    notesFile: resolvePath(cwd, options.notesFile),
+    planFile: resolvePath(cwd, options.planFile)
+  };
+}
+function buildLoopConfig(options, cwd) {
+  return {
+    task: options.task,
+    iterations: options.iterations,
+    stopSignal: options.stopSignal,
+    ai: buildAiConfig(options),
+    workflowFiles: buildWorkflowFiles(options, cwd),
+    git: buildWorktreeConfig(options),
+    tests: buildTestConfig(options),
+    pr: buildPrConfig(options),
+    webhooks: buildWebhookConfig(options),
+    cwd,
+    logFile: options.logFile ? resolvePath(cwd, options.logFile) : void 0,
+    verbose: options.verbose,
+    runTests: options.runTests,
+    runE2e: options.runE2e,
+    autoCommit: options.autoCommit,
+    autoPush: options.autoPush,
+    skipInstall: options.skipInstall
+  };
+}
+function defaultNotesPath() {
+  return import_node_path2.default.join("memory", "notes.md");
+}
+function defaultPlanPath() {
+  return import_node_path2.default.join("memory", "plan.md");
+}
+function defaultWorkflowDoc() {
+  return import_node_path2.default.join("docs", "ai-workflow.md");
+}
+
+// src/global-config.ts
+var import_node_os = __toESM(require("os"));
+var import_node_path3 = __toESM(require("path"));
+var import_fs_extra2 = __toESM(require("fs-extra"));
+function getGlobalConfigPath() {
+  return import_node_path3.default.join(import_node_os.default.homedir(), ".wheel-ai", "config.toml");
+}
+function stripTomlComment(line) {
+  let quote = null;
+  let escaped = false;
+  for (let i = 0; i < line.length; i += 1) {
+    const char = line[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (quote) {
+      if (quote === '"' && char === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (char === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (char === "#" || char === ";") {
+      return line.slice(0, i);
+    }
+  }
+  return line;
+}
+function findUnquotedIndex(text, target) {
+  let quote = null;
+  let escaped = false;
+  for (let i = 0; i < text.length; i += 1) {
+    const char = text[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (quote) {
+      if (quote === '"' && char === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (char === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (char === target) {
+      return i;
+    }
+  }
+  return -1;
+}
+function parseTomlString(raw) {
+  const value = raw.trim();
+  if (value.length < 2) return null;
+  const quote = value[0];
+  if (quote !== '"' && quote !== "'") return null;
+  let result = "";
+  let escaped = false;
+  for (let i = 1; i < value.length; i += 1) {
+    const char = value[i];
+    if (quote === '"') {
+      if (escaped) {
+        switch (char) {
+          case "n":
+            result += "\n";
+            break;
+          case "t":
+            result += "	";
+            break;
+          case "r":
+            result += "\r";
+            break;
+          case '"':
+          case "\\":
+            result += char;
+            break;
+          default:
+            result += char;
+            break;
+        }
+        escaped = false;
+        continue;
+      }
+      if (char === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (char === quote) {
+        const rest = value.slice(i + 1).trim();
+        if (rest.length > 0) return null;
+        return result;
+      }
+      result += char;
+      continue;
+    }
+    if (char === quote) {
+      const rest = value.slice(i + 1).trim();
+      if (rest.length > 0) return null;
+      return result;
+    }
+    result += char;
+  }
+  return null;
+}
+function normalizeShortcutName(name) {
+  const trimmed = name.trim();
+  if (!trimmed) return null;
+  if (/\s/.test(trimmed)) return null;
+  return trimmed;
+}
+function parseGlobalConfig(content) {
+  const lines = content.split(/\r?\n/);
+  let currentSection = null;
+  const shortcut = {};
+  for (const rawLine of lines) {
+    const line = stripTomlComment(rawLine).trim();
+    if (!line) continue;
+    const sectionMatch = /^\[(.+)\]$/.exec(line);
+    if (sectionMatch) {
+      currentSection = sectionMatch[1].trim();
+      continue;
+    }
+    if (currentSection !== "shortcut") continue;
+    const equalIndex = findUnquotedIndex(line, "=");
+    if (equalIndex <= 0) continue;
+    const key = line.slice(0, equalIndex).trim();
+    const valuePart = line.slice(equalIndex + 1).trim();
+    if (!key || !valuePart) continue;
+    const parsedValue = parseTomlString(valuePart);
+    if (parsedValue === null) continue;
+    shortcut[key] = parsedValue;
+  }
+  const name = normalizeShortcutName(shortcut.name ?? "");
+  const command = (shortcut.command ?? "").trim();
+  if (!name || !command) {
+    return {};
+  }
+  return {
+    shortcut: {
+      name,
+      command
+    }
+  };
+}
+async function loadGlobalConfig(logger) {
+  const filePath = getGlobalConfigPath();
+  const exists = await import_fs_extra2.default.pathExists(filePath);
+  if (!exists) return null;
+  try {
+    const content = await import_fs_extra2.default.readFile(filePath, "utf8");
+    return parseGlobalConfig(content);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger?.warn(`\u8BFB\u53D6\u5168\u5C40\u914D\u7F6E\u5931\u8D25\uFF0C\u5DF2\u5FFD\u7565\uFF1A${message}`);
+    return null;
+  }
+}
+function splitCommandArgs(command) {
+  const args = [];
+  let current = "";
+  let quote = null;
+  let escaped = false;
+  for (let i = 0; i < command.length; i += 1) {
+    const char = command[i];
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+    if (quote) {
+      if (quote === '"' && char === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (char === quote) {
+        quote = null;
+        continue;
+      }
+      current += char;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      if (current.length > 0) {
+        args.push(current);
+        current = "";
+      }
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    current += char;
+  }
+  if (current.length > 0) {
+    args.push(current);
+  }
+  return args;
+}
+function normalizeShortcutArgs(args) {
+  if (args.length > 0 && args[0] === "run") {
+    return args.slice(1);
+  }
+  return args;
+}
+function applyShortcutArgv(argv, config) {
+  if (!config?.shortcut) return argv;
+  if (argv.length < 3) return argv;
+  const commandIndex = 2;
+  if (argv[commandIndex] !== config.shortcut.name) return argv;
+  const shortcutArgs = normalizeShortcutArgs(splitCommandArgs(config.shortcut.command));
+  return [
+    ...argv.slice(0, commandIndex),
+    "run",
+    ...shortcutArgs,
+    ...argv.slice(commandIndex + 1)
+  ];
+}
+
+// src/git.ts
+var import_node_path4 = __toESM(require("path"));
+async function branchExists(branch, cwd, logger) {
+  const result = await runCommand("git", ["rev-parse", "--verify", branch], {
+    cwd,
+    logger,
+    verboseLabel: "git",
+    verboseCommand: `git rev-parse --verify ${branch}`
+  });
+  return result.exitCode === 0;
+}
+async function resolveBaseBranch(baseBranch, repoRoot, logger) {
+  const baseExists = await branchExists(baseBranch, repoRoot, logger);
+  if (baseExists) return baseBranch;
+  const current = await getCurrentBranch(repoRoot, logger);
+  const currentExists = await branchExists(current, repoRoot, logger);
+  if (currentExists) {
+    logger.warn(`\u57FA\u7EBF\u5206\u652F ${baseBranch} \u4E0D\u5B58\u5728\uFF0C\u6539\u7528\u5F53\u524D\u5206\u652F ${current} \u4F5C\u4E3A\u57FA\u7EBF`);
+    return current;
+  }
+  throw new Error(`\u57FA\u7EBF\u5206\u652F ${baseBranch} \u4E0D\u5B58\u5728\uFF0C\u4E14\u65E0\u6CD5\u786E\u5B9A\u53EF\u7528\u7684\u5F53\u524D\u5206\u652F`);
+}
+async function getRepoRoot(cwd, logger) {
+  const result = await runCommand("git", ["rev-parse", "--show-toplevel"], {
+    cwd,
+    logger,
+    verboseLabel: "git",
+    verboseCommand: "git rev-parse --show-toplevel"
+  });
+  if (result.exitCode !== 0) {
+    throw new Error("\u5F53\u524D\u76EE\u5F55\u4E0D\u662F git \u4ED3\u5E93\uFF0C\u65E0\u6CD5\u7EE7\u7EED");
+  }
+  return result.stdout.trim();
+}
+async function getCurrentBranch(cwd, logger) {
+  const result = await runCommand("git", ["branch", "--show-current"], {
+    cwd,
+    logger,
+    verboseLabel: "git",
+    verboseCommand: "git branch --show-current"
+  });
+  if (result.exitCode !== 0) {
+    throw new Error(`\u65E0\u6CD5\u83B7\u53D6\u5F53\u524D\u5206\u652F: ${result.stderr}`);
+  }
+  return result.stdout.trim();
+}
+async function getUpstreamBranch(branchName, cwd, logger) {
+  const result = await runCommand("git", ["rev-parse", "--abbrev-ref", "--symbolic-full-name", `${branchName}@{u}`], {
+    cwd,
+    logger,
+    verboseLabel: "git",
+    verboseCommand: `git rev-parse --abbrev-ref --symbolic-full-name ${branchName}@{u}`
+  });
+  if (result.exitCode !== 0) {
+    logger?.warn(`\u5206\u652F ${branchName} \u6CA1\u6709\u5173\u8054\u7684 upstream: ${result.stderr || result.stdout}`);
+    return null;
+  }
+  return result.stdout.trim();
+}
+function defaultWorktreePath(repoRoot, branchName) {
+  return import_node_path4.default.join(repoRoot, "..", "worktrees", branchName);
+}
+async function ensureBranchExists(branchName, baseBranch, repoRoot, logger) {
+  const exists = await branchExists(branchName, repoRoot, logger);
+  if (exists) return;
+  const create = await runCommand("git", ["branch", branchName, baseBranch], {
+    cwd: repoRoot,
+    logger,
+    verboseLabel: "git",
+    verboseCommand: `git branch ${branchName} ${baseBranch}`
+  });
+  if (create.exitCode !== 0) {
+    throw new Error(`\u521B\u5EFA\u5206\u652F\u5931\u8D25: ${create.stderr}`);
+  }
+  logger.info(`\u5DF2\u57FA\u4E8E ${baseBranch} \u521B\u5EFA\u5206\u652F ${branchName}`);
+}
+async function ensureWorktree(config, repoRoot, logger) {
+  if (!config.useWorktree) {
+    return { path: repoRoot, created: false };
+  }
+  const branchName = config.branchName ?? generateBranchName();
+  const baseBranch = await resolveBaseBranch(config.baseBranch, repoRoot, logger);
+  const worktreePath = resolvePath(repoRoot, config.worktreePath ?? defaultWorktreePath(repoRoot, branchName));
+  await ensureBranchExists(branchName, baseBranch, repoRoot, logger);
+  const addResult = await runCommand("git", ["worktree", "add", worktreePath, branchName], {
+    cwd: repoRoot,
+    logger,
+    verboseLabel: "git",
+    verboseCommand: `git worktree add ${worktreePath} ${branchName}`
+  });
+  if (addResult.exitCode !== 0) {
+    const alreadyExists = addResult.stderr.includes("already exists") || addResult.stdout.includes("already exists");
+    if (alreadyExists) {
+      logger.warn(`worktree \u8DEF\u5F84\u5DF2\u5B58\u5728\uFF0C\u8DF3\u8FC7\u521B\u5EFA: ${worktreePath}`);
+      return { path: worktreePath, created: false };
+    }
+    throw new Error(`\u521B\u5EFA worktree \u5931\u8D25: ${addResult.stderr || addResult.stdout}`);
+  }
+  logger.success(`\u5DF2\u5728 ${worktreePath} \u521B\u5EFA\u5E76\u6302\u8F7D worktree (${branchName})`);
+  return { path: worktreePath, created: true };
+}
+async function isWorktreeClean(cwd, logger) {
+  const status = await runCommand("git", ["status", "--porcelain"], {
+    cwd,
+    logger,
+    verboseLabel: "git",
+    verboseCommand: "git status --porcelain"
+  });
+  if (status.exitCode !== 0) {
+    logger?.warn(`\u65E0\u6CD5\u83B7\u53D6 git \u72B6\u6001: ${status.stderr || status.stdout}`);
+    return false;
+  }
+  return status.stdout.trim().length === 0;
+}
+async function isBranchPushed(branchName, cwd, logger) {
+  const upstream = await getUpstreamBranch(branchName, cwd, logger);
+  if (!upstream) return false;
+  const countResult = await runCommand("git", ["rev-list", "--left-right", "--count", `${upstream}...${branchName}`], {
+    cwd,
+    logger,
+    verboseLabel: "git",
+    verboseCommand: `git rev-list --left-right --count ${upstream}...${branchName}`
+  });
+  if (countResult.exitCode !== 0) {
+    logger.warn(`\u65E0\u6CD5\u6BD4\u8F83\u5206\u652F ${branchName} \u4E0E ${upstream}: ${countResult.stderr || countResult.stdout}`);
+    return false;
+  }
+  const [behindStr, aheadStr] = countResult.stdout.trim().split(/\s+/);
+  const ahead = Number.parseInt(aheadStr ?? "0", 10);
+  if (Number.isNaN(ahead)) {
+    logger.warn(`\u65E0\u6CD5\u89E3\u6790\u5206\u652F\u63A8\u9001\u72B6\u6001: ${countResult.stdout}`);
+    return false;
+  }
+  if (ahead > 0) {
+    logger.warn(`\u5206\u652F ${branchName} \u4ECD\u6709 ${ahead} \u4E2A\u672C\u5730\u63D0\u4EA4\u672A\u63A8\u9001`);
+    return false;
+  }
+  return true;
+}
+function normalizeCommitTitle(title) {
+  return title.replace(/\s+/g, " ").trim();
+}
+function normalizeCommitBody(body) {
+  if (!body) return void 0;
+  const normalized = body.replace(/\r\n?/g, "\n").trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function formatCommitCommand(message) {
+  const title = normalizeCommitTitle(message.title) || "chore: \u66F4\u65B0\u8FED\u4EE3\u4EA7\u51FA";
+  const parts = ["git commit -m", JSON.stringify(title)];
+  const body = normalizeCommitBody(message.body);
+  if (body) {
+    parts.push("-m", JSON.stringify(body));
+  }
+  return parts.join(" ");
+}
+function buildCommitArgs(message) {
+  const title = normalizeCommitTitle(message.title) || "chore: \u66F4\u65B0\u8FED\u4EE3\u4EA7\u51FA";
+  const args = ["commit", "-m", title];
+  const body = normalizeCommitBody(message.body);
+  if (body) {
+    args.push("-m", body);
+  }
+  return args;
+}
+async function commitAll(message, cwd, logger) {
+  const add = await runCommand("git", ["add", "-A"], {
+    cwd,
+    logger,
+    verboseLabel: "git",
+    verboseCommand: "git add -A"
+  });
+  if (add.exitCode !== 0) {
+    throw new Error(`git add \u5931\u8D25: ${add.stderr}`);
+  }
+  const commit = await runCommand("git", buildCommitArgs(message), {
+    cwd,
+    logger,
+    verboseLabel: "git",
+    verboseCommand: formatCommitCommand(message)
+  });
+  if (commit.exitCode !== 0) {
+    logger.warn(`git commit \u8DF3\u8FC7\u6216\u5931\u8D25: ${commit.stderr}`);
+    return;
+  }
+  logger.success("\u5DF2\u63D0\u4EA4\u5F53\u524D\u53D8\u66F4");
+}
+async function pushBranch(branchName, cwd, logger) {
+  const push = await runCommand("git", ["push", "-u", "origin", branchName], {
+    cwd,
+    logger,
+    verboseLabel: "git",
+    verboseCommand: `git push -u origin ${branchName}`
+  });
+  if (push.exitCode !== 0) {
+    throw new Error(`git push \u5931\u8D25: ${push.stderr}`);
+  }
+  logger.success(`\u5DF2\u63A8\u9001\u5206\u652F ${branchName}`);
+}
+async function removeWorktree(worktreePath, repoRoot, logger) {
+  const remove = await runCommand("git", ["worktree", "remove", "--force", worktreePath], {
+    cwd: repoRoot,
+    logger,
+    verboseLabel: "git",
+    verboseCommand: `git worktree remove --force ${worktreePath}`
+  });
+  if (remove.exitCode !== 0) {
+    throw new Error(`\u5220\u9664 worktree \u5931\u8D25: ${remove.stderr || remove.stdout}`);
+  }
+  const prune = await runCommand("git", ["worktree", "prune"], {
+    cwd: repoRoot,
+    logger,
+    verboseLabel: "git",
+    verboseCommand: "git worktree prune"
+  });
+  if (prune.exitCode !== 0) {
+    logger.warn(`worktree prune \u5931\u8D25: ${prune.stderr || prune.stdout}`);
+  }
+  logger.success(`\u5DF2\u5220\u9664 worktree: ${worktreePath}`);
+}
+function generateBranchName() {
+  const now = /* @__PURE__ */ new Date();
+  const stamp = `${now.getFullYear()}${(now.getMonth() + 1).toString().padStart(2, "0")}${now.getDate().toString().padStart(2, "0")}-${now.getHours().toString().padStart(2, "0")}${now.getMinutes().toString().padStart(2, "0")}`;
+  return `wheel-aii/${stamp}`;
+}
+
+// src/logs.ts
+var import_node_os2 = __toESM(require("os"));
+var import_node_path5 = __toESM(require("path"));
+var import_fs_extra3 = __toESM(require("fs-extra"));
+var LOGS_DIR = import_node_path5.default.join(import_node_os2.default.homedir(), ".wheel-ai", "logs");
+function getLogsDir() {
+  return LOGS_DIR;
+}
+function getCurrentRegistryPath() {
+  return import_node_path5.default.join(LOGS_DIR, "current.json");
+}
+async function ensureLogsDir() {
+  await import_fs_extra3.default.mkdirp(LOGS_DIR);
+}
+function formatTimeString(date = /* @__PURE__ */ new Date()) {
+  const year = date.getFullYear();
+  const month = pad2(date.getMonth() + 1);
+  const day = pad2(date.getDate());
+  const hours = pad2(date.getHours());
+  const minutes = pad2(date.getMinutes());
+  const seconds = pad2(date.getSeconds());
+  return `${year}${month}${day}${hours}${minutes}${seconds}`;
+}
+function sanitizeBranchName(branchName) {
+  const normalized = branchName.trim();
+  if (!normalized) return "";
+  const replaced = normalized.replace(/[\\/:*?"<>|\s]+/g, "-");
+  return replaced.replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+}
+function buildAutoLogFilePath(branchName, date = /* @__PURE__ */ new Date()) {
+  const safeBranch = sanitizeBranchName(branchName) || "unknown";
+  return import_node_path5.default.join(LOGS_DIR, `wheel-ai-auto-log-${formatTimeString(date)}-${safeBranch}.log`);
+}
+function getLogMetaPath(logFile) {
+  const baseName = import_node_path5.default.basename(logFile, import_node_path5.default.extname(logFile));
+  return import_node_path5.default.join(LOGS_DIR, `${baseName}.json`);
+}
+function buildLogKey(logFile) {
+  return import_node_path5.default.basename(logFile);
+}
+function formatCommandLine(argv) {
+  const quote = (value) => {
+    if (/[\s"'\\]/.test(value)) {
+      return JSON.stringify(value);
+    }
+    return value;
+  };
+  return argv.map(quote).join(" ").trim();
+}
+async function writeJsonFile(filePath, data) {
+  await ensureLogsDir();
+  await import_fs_extra3.default.writeFile(filePath, `${JSON.stringify(data, null, 2)}
+`, "utf8");
+}
+async function writeRunMetadata(logFile, metadata) {
+  const metaPath = getLogMetaPath(logFile);
+  await writeJsonFile(metaPath, metadata);
+}
+async function readCurrentRegistry() {
+  const filePath = getCurrentRegistryPath();
+  const exists = await import_fs_extra3.default.pathExists(filePath);
+  if (!exists) return {};
+  try {
+    const content = await import_fs_extra3.default.readFile(filePath, "utf8");
+    const parsed = JSON.parse(content);
+    if (!parsed || typeof parsed !== "object") return {};
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+async function upsertCurrentRegistry(logFile, metadata) {
+  const registry = await readCurrentRegistry();
+  const key = buildLogKey(logFile);
+  registry[key] = { ...metadata, logFile };
+  await writeJsonFile(getCurrentRegistryPath(), registry);
+}
+async function removeCurrentRegistry(logFile) {
+  const registry = await readCurrentRegistry();
+  const key = buildLogKey(logFile);
+  if (!(key in registry)) return;
+  delete registry[key];
+  await writeJsonFile(getCurrentRegistryPath(), registry);
+}
+
+// src/logs-viewer.ts
+var import_fs_extra4 = __toESM(require("fs-extra"));
+var import_node_path6 = __toESM(require("path"));
+function isRunMetadata(value) {
+  if (!value || typeof value !== "object") return false;
+  const record = value;
+  return typeof record.command === "string" && typeof record.round === "number" && typeof record.tokenUsed === "number" && typeof record.path === "string";
+}
+function buildLogMetaPath(logsDir, logFile) {
+  const baseName = import_node_path6.default.basename(logFile, import_node_path6.default.extname(logFile));
+  return import_node_path6.default.join(logsDir, `${baseName}.json`);
+}
+async function readLogMetadata(logsDir, logFile) {
+  const metaPath = buildLogMetaPath(logsDir, logFile);
+  const exists = await import_fs_extra4.default.pathExists(metaPath);
+  if (!exists) return void 0;
+  try {
+    const content = await import_fs_extra4.default.readFile(metaPath, "utf8");
+    const parsed = JSON.parse(content);
+    return isRunMetadata(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function buildRunningLogKeys(registry) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const [key, entry] of Object.entries(registry)) {
+    keys.add(key);
+    if (entry.logFile) {
+      keys.add(import_node_path6.default.basename(entry.logFile));
+    }
+  }
+  return keys;
+}
+async function loadLogEntries(logsDir, registry) {
+  const exists = await import_fs_extra4.default.pathExists(logsDir);
+  if (!exists) return [];
+  const running = buildRunningLogKeys(registry);
+  const names = await import_fs_extra4.default.readdir(logsDir);
+  const entries = [];
+  for (const name of names) {
+    if (import_node_path6.default.extname(name).toLowerCase() !== ".log") continue;
+    if (running.has(name)) continue;
+    const filePath = import_node_path6.default.join(logsDir, name);
+    let stat;
+    try {
+      stat = await import_fs_extra4.default.stat(filePath);
+    } catch {
+      continue;
+    }
+    if (!stat.isFile()) continue;
+    const meta = await readLogMetadata(logsDir, filePath);
+    entries.push({
+      fileName: name,
+      filePath,
+      size: stat.size,
+      mtimeMs: stat.mtimeMs,
+      meta
+    });
+  }
+  return entries.sort((a, b) => b.mtimeMs - a.mtimeMs);
+}
+function getTerminalSize() {
+  const rows = process.stdout.rows ?? 24;
+  const columns = process.stdout.columns ?? 80;
+  return { rows, columns };
+}
+function truncateLine(line, width) {
+  if (width <= 0) return "";
+  if (line.length <= width) return line;
+  return line.slice(0, width);
+}
+function formatTimestamp(ms) {
+  const date = new Date(ms);
+  const year = date.getFullYear();
+  const month = pad2(date.getMonth() + 1);
+  const day = pad2(date.getDate());
+  const hours = pad2(date.getHours());
+  const minutes = pad2(date.getMinutes());
+  const seconds = pad2(date.getSeconds());
+  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+}
+function formatBytes(size) {
+  if (size < 1024) return `${size}B`;
+  const kb = size / 1024;
+  if (kb < 1024) return `${kb.toFixed(1)}KB`;
+  const mb = kb / 1024;
+  return `${mb.toFixed(1)}MB`;
+}
+function getPageSize(rows) {
+  return Math.max(1, rows - 2);
+}
+async function readLogLines(logFile) {
+  try {
+    const content = await import_fs_extra4.default.readFile(logFile, "utf8");
+    const normalized = content.replace(/\r\n?/g, "\n");
+    const lines = normalized.split("\n");
+    return lines.length > 0 ? lines : [""];
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return [`\uFF08\u65E0\u6CD5\u8BFB\u53D6\u65E5\u5FD7\u6587\u4EF6\uFF1A${message}\uFF09`];
+  }
+}
+function buildListHeader(state, columns) {
+  const total = state.logs.length;
+  const title = `\u65E5\u5FD7\u5217\u8868\uFF08${total} \u6761\uFF09\uFF5C\u2191/\u2193 \u9009\u62E9  Enter \u67E5\u770B  q \u9000\u51FA`;
+  return truncateLine(title, columns);
+}
+function buildListStatus(state, columns) {
+  if (state.logs.length === 0) {
+    const text = state.lastError ? `\u52A0\u8F7D\u5931\u8D25\uFF1A${state.lastError}` : "\u6682\u65E0\u53EF\u67E5\u770B\u7684\u65E5\u5FD7";
+    return truncateLine(text, columns);
+  }
+  const entry = state.logs[state.selectedIndex];
+  const meta = entry.meta;
+  const detail = meta ? `\u9879\u76EE ${meta.path}` : `\u6587\u4EF6 ${entry.fileName}`;
+  const suffix = state.lastError ? ` \uFF5C \u52A0\u8F7D\u5931\u8D25\uFF1A${state.lastError}` : "";
+  return truncateLine(`${detail}${suffix}`, columns);
+}
+function buildListLine(entry, selected, columns) {
+  const marker = selected ? ">" : " ";
+  const time = formatTimestamp(entry.mtimeMs);
+  const metaInfo = entry.meta ? `\u8F6E\u6B21 ${entry.meta.round} \uFF5C Token ${entry.meta.tokenUsed}` : `\u5927\u5C0F ${formatBytes(entry.size)}`;
+  return truncateLine(`${marker} ${entry.fileName} \uFF5C ${time} \uFF5C ${metaInfo}`, columns);
+}
+function buildViewHeader(entry, columns) {
+  const title = `\u65E5\u5FD7\u67E5\u770B\uFF5C${entry.fileName}\uFF5C\u2191/\u2193 \u7FFB\u9875  b \u8FD4\u56DE  q \u9000\u51FA`;
+  return truncateLine(title, columns);
+}
+function buildViewStatus(entry, page, columns) {
+  const meta = entry.meta;
+  const metaInfo = meta ? `\u8F6E\u6B21 ${meta.round} \uFF5C Token ${meta.tokenUsed} \uFF5C \u9879\u76EE ${meta.path}` : `\u6587\u4EF6 ${entry.fileName}`;
+  const status = `\u9875 ${page.current}/${page.total} \uFF5C ${metaInfo}`;
+  return truncateLine(status, columns);
+}
+function ensureListOffset(state, pageSize) {
+  const total = state.logs.length;
+  if (total === 0) {
+    state.listOffset = 0;
+    state.selectedIndex = 0;
+    return;
+  }
+  const maxOffset = Math.max(0, total - pageSize);
+  if (state.selectedIndex < state.listOffset) {
+    state.listOffset = state.selectedIndex;
+  }
+  if (state.selectedIndex >= state.listOffset + pageSize) {
+    state.listOffset = state.selectedIndex - pageSize + 1;
+  }
+  state.listOffset = Math.min(Math.max(state.listOffset, 0), maxOffset);
+}
+function renderList(state) {
+  const { rows, columns } = getTerminalSize();
+  const pageSize = getPageSize(rows);
+  const header = buildListHeader(state, columns);
+  ensureListOffset(state, pageSize);
+  if (state.logs.length === 0) {
+    const filler = Array.from({ length: pageSize }, () => "");
+    const status2 = buildListStatus(state, columns);
+    const content2 = [header, ...filler, status2].join("\n");
+    process.stdout.write(`\x1B[2J\x1B[H${content2}`);
+    return;
+  }
+  const start = state.listOffset;
+  const slice = state.logs.slice(start, start + pageSize);
+  const lines = slice.map((entry, index) => {
+    const selected = start + index === state.selectedIndex;
+    return buildListLine(entry, selected, columns);
+  });
+  while (lines.length < pageSize) {
+    lines.push("");
+  }
+  const status = buildListStatus(state, columns);
+  const content = [header, ...lines, status].join("\n");
+  process.stdout.write(`\x1B[2J\x1B[H${content}`);
+}
+function renderView(view) {
+  const { rows, columns } = getTerminalSize();
+  const pageSize = getPageSize(rows);
+  const header = buildViewHeader(view.entry, columns);
+  const maxOffset = Math.max(0, Math.ceil(view.lines.length / pageSize) - 1);
+  view.pageOffset = Math.min(Math.max(view.pageOffset, 0), maxOffset);
+  const start = view.pageOffset * pageSize;
+  const pageLines = view.lines.slice(start, start + pageSize).map((line) => truncateLine(line, columns));
+  while (pageLines.length < pageSize) {
+    pageLines.push("");
+  }
+  const status = buildViewStatus(view.entry, { current: view.pageOffset + 1, total: Math.max(1, maxOffset + 1) }, columns);
+  const content = [header, ...pageLines, status].join("\n");
+  process.stdout.write(`\x1B[2J\x1B[H${content}`);
+}
+function render(state) {
+  if (state.mode === "view" && state.view) {
+    renderView(state.view);
+    return;
+  }
+  renderList(state);
+}
+function shouldExit(input) {
+  if (input === "") return true;
+  if (input.toLowerCase() === "q") return true;
+  return false;
+}
+function isEnter(input) {
+  return input.includes("\r") || input.includes("\n");
+}
+function isArrowUp(input) {
+  return input.includes("\x1B[A");
+}
+function isArrowDown(input) {
+  return input.includes("\x1B[B");
+}
+function isEscape(input) {
+  return input === "\x1B";
+}
+function setupCleanup(cleanup) {
+  const exitHandler = () => {
+    cleanup();
+  };
+  const signalHandler = () => {
+    cleanup();
+    process.exit(0);
+  };
+  process.on("SIGINT", signalHandler);
+  process.on("SIGTERM", signalHandler);
+  process.on("exit", exitHandler);
+}
+function clampIndex(value, total) {
+  if (total <= 0) return 0;
+  return Math.min(Math.max(value, 0), total - 1);
+}
+async function runLogsViewer() {
+  if (!process.stdout.isTTY || !process.stdin.isTTY) {
+    console.log("\u5F53\u524D\u7EC8\u7AEF\u4E0D\u652F\u6301\u4EA4\u4E92\u5F0F logs\u3002");
+    return;
+  }
+  const logsDir = getLogsDir();
+  const state = {
+    mode: "list",
+    logs: [],
+    selectedIndex: 0,
+    listOffset: 0
+  };
+  let cleaned = false;
+  const cleanup = () => {
+    if (cleaned) return;
+    cleaned = true;
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+    }
+    process.stdout.write("\x1B[?25h");
+  };
+  setupCleanup(cleanup);
+  process.stdout.write("\x1B[?25l");
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  let loading = false;
+  const loadLogs = async () => {
+    try {
+      const registry = await readCurrentRegistry();
+      state.logs = await loadLogEntries(logsDir, registry);
+      state.selectedIndex = clampIndex(state.selectedIndex, state.logs.length);
+      state.lastError = void 0;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      state.lastError = message;
+      state.logs = [];
+      state.selectedIndex = 0;
+    }
+  };
+  const openView = async () => {
+    if (loading || state.logs.length === 0) return;
+    loading = true;
+    const entry = state.logs[state.selectedIndex];
+    state.mode = "view";
+    state.view = {
+      entry,
+      lines: ["\u52A0\u8F7D\u4E2D\u2026"],
+      pageOffset: 0
+    };
+    render(state);
+    const lines = await readLogLines(entry.filePath);
+    const pageSize = getPageSize(getTerminalSize().rows);
+    const maxOffset = Math.max(0, Math.ceil(lines.length / pageSize) - 1);
+    state.view = {
+      entry,
+      lines,
+      pageOffset: maxOffset
+    };
+    loading = false;
+    render(state);
+  };
+  await loadLogs();
+  render(state);
+  process.stdin.on("data", (data) => {
+    const input = data.toString("utf8");
+    if (shouldExit(input)) {
+      cleanup();
+      process.exit(0);
+    }
+    if (state.mode === "list") {
+      if (isArrowUp(input)) {
+        state.selectedIndex = clampIndex(state.selectedIndex - 1, state.logs.length);
+        render(state);
+        return;
+      }
+      if (isArrowDown(input)) {
+        state.selectedIndex = clampIndex(state.selectedIndex + 1, state.logs.length);
+        render(state);
+        return;
+      }
+      if (isEnter(input)) {
+        void openView();
+        return;
+      }
+      return;
+    }
+    if (state.mode === "view" && state.view) {
+      if (isArrowUp(input)) {
+        state.view.pageOffset -= 1;
+        render(state);
+        return;
+      }
+      if (isArrowDown(input)) {
+        state.view.pageOffset += 1;
+        render(state);
+        return;
+      }
+      if (input.toLowerCase() === "b" || isEscape(input)) {
+        state.mode = "list";
+        state.view = void 0;
+        render(state);
+        return;
+      }
+    }
+  });
+  process.stdout.on("resize", () => {
+    render(state);
+  });
+}
+
+// src/loop.ts
+var import_fs_extra7 = __toESM(require("fs-extra"));
+var import_node_path8 = __toESM(require("path"));
+
+// src/ai.ts
+function buildPrompt(input) {
+  const sections = [
+    "# \u80CC\u666F\u4EFB\u52A1",
+    input.task,
+    "# \u5DE5\u4F5C\u6D41\u7A0B\u57FA\u7EBF\uFF08\u4F9B AI \u81EA\u4E3B\u6267\u884C\uFF09",
+    input.workflowGuide,
+    "# \u5F53\u524D\u6301\u4E45\u5316\u8BA1\u5212",
+    input.plan || "\uFF08\u6682\u65E0\u8BA1\u5212\uFF0C\u9996\u8F6E\u8BF7\u751F\u6210\u53EF\u6267\u884C\u8BA1\u5212\u5E76\u5199\u5165 plan \u6587\u4EF6\uFF09",
+    "# \u5386\u53F2\u8FED\u4EE3\u4E0E\u8BB0\u5FC6",
+    input.notes || "\uFF08\u9996\u6B21\u6267\u884C\uFF0C\u6682\u65E0\u5386\u53F2\uFF09",
+    "# \u672C\u8F6E\u6267\u884C\u8981\u6C42",
+    [
+      "1. \u81EA\u6211\u68C0\u67E5\u5E76\u8865\u5168\u9700\u6C42\uFF1B\u660E\u786E\u4EA4\u4ED8\u7269\u4E0E\u9A8C\u6536\u6807\u51C6\u3002",
+      "2. \u66F4\u65B0/\u7EC6\u5316\u8BA1\u5212\uFF0C\u5FC5\u8981\u65F6\u5728 plan \u6587\u4EF6\u4E2D\u91CD\u5199\u4EFB\u52A1\u6811\u4E0E\u4F18\u5148\u7EA7\u3002",
+      "3. \u8BBE\u8BA1\u5F00\u53D1\u6B65\u9AA4\u5E76\u76F4\u63A5\u751F\u6210\u4EE3\u7801\uFF08\u65E0\u9700\u518D\u6B21\u8BF7\u6C42\u786E\u8BA4\uFF09\u3002",
+      "4. \u8FDB\u884C\u4EE3\u7801\u81EA\u5BA1\uFF0C\u7ED9\u51FA\u98CE\u9669\u4E0E\u6539\u8FDB\u6E05\u5355\u3002",
+      "5. \u751F\u6210\u5355\u5143\u6D4B\u8BD5\u4E0E e2e \u6D4B\u8BD5\u4EE3\u7801\u5E76\u7ED9\u51FA\u8FD0\u884C\u547D\u4EE4\uFF1B\u5982\u679C\u73AF\u5883\u5141\u8BB8\u53EF\u76F4\u63A5\u8FD0\u884C\u547D\u4EE4\u3002",
+      "6. \u7EF4\u62A4\u6301\u4E45\u5316\u8BB0\u5FC6\u6587\u4EF6\uFF1A\u6458\u8981\u672C\u8F6E\u5173\u952E\u7ED3\u8BBA\u3001\u9057\u7559\u95EE\u9898\u3001\u4E0B\u4E00\u6B65\u5EFA\u8BAE\u3002",
+      "7. \u51C6\u5907\u63D0\u4EA4 PR \u6240\u9700\u7684\u6807\u9898\u4E0E\u63CF\u8FF0\uFF08\u542B\u53D8\u66F4\u6458\u8981\u3001\u6D4B\u8BD5\u7ED3\u679C\u3001\u98CE\u9669\uFF09\u3002",
+      "8. \u5F53\u6240\u6709\u76EE\u6807\u5B8C\u6210\u65F6\uFF0C\u5728\u8F93\u51FA\u4E2D\u52A0\u5165\u6807\u8BB0 <<DONE>> \u4EE5\u4FBF\u5916\u5C42\u505C\u6B62\u5FAA\u73AF\u3002"
+    ].join("\n")
+  ];
+  return sections.join("\n\n");
+}
+function pickNumber(pattern, text) {
+  const match = pattern.exec(text);
+  if (!match || match.length < 2) return void 0;
+  const value = Number.parseInt(match[match.length - 1], 10);
+  return Number.isNaN(value) ? void 0 : value;
+}
+function parseTokenUsage(logs) {
+  const total = pickNumber(/total[_\s]tokens:\s*(\d+)/i, logs);
+  const input = pickNumber(/(input|prompt)[_\s]tokens:\s*(\d+)/i, logs);
+  const output = pickNumber(/(output|completion)[_\s]tokens:\s*(\d+)/i, logs);
+  const consumed = pickNumber(/tokens?\s+used:\s*(\d+)/i, logs) ?? pickNumber(/consumed\s+(\d+)\s+tokens?/i, logs);
+  const totalTokens = total ?? (input !== void 0 || output !== void 0 ? (input ?? 0) + (output ?? 0) : consumed);
+  if (totalTokens === void 0) return null;
+  return {
+    inputTokens: input,
+    outputTokens: output,
+    totalTokens
+  };
+}
+function addOptional(a, b) {
+  if (typeof a !== "number" && typeof b !== "number") return void 0;
+  return (a ?? 0) + (b ?? 0);
+}
+function mergeTokenUsage(previous, current) {
+  if (!current) return previous;
+  if (!previous) return { ...current };
+  return {
+    inputTokens: addOptional(previous.inputTokens, current.inputTokens),
+    outputTokens: addOptional(previous.outputTokens, current.outputTokens),
+    totalTokens: previous.totalTokens + current.totalTokens
+  };
+}
+async function runAi(prompt, ai, logger, cwd) {
+  const args = [...ai.args];
+  const verboseCommand = ai.promptArg ? [ai.command, ...ai.args, ai.promptArg, "<prompt>"].join(" ") : [ai.command, ...ai.args, "<stdin>"].join(" ");
+  const streamPrefix = `[${ai.command}] `;
+  const streamErrorPrefix = `[${ai.command} stderr] `;
+  let result;
+  if (ai.promptArg) {
+    args.push(ai.promptArg, prompt);
+    result = await runCommand(ai.command, args, {
+      cwd,
+      logger,
+      verboseLabel: "ai",
+      verboseCommand,
+      stream: {
+        enabled: true,
+        stdoutPrefix: streamPrefix,
+        stderrPrefix: streamErrorPrefix
+      }
+    });
+  } else {
+    result = await runCommand(ai.command, args, {
+      cwd,
+      input: prompt,
+      logger,
+      verboseLabel: "ai",
+      verboseCommand,
+      stream: {
+        enabled: true,
+        stdoutPrefix: streamPrefix,
+        stderrPrefix: streamErrorPrefix
+      }
+    });
+  }
+  if (result.exitCode !== 0) {
+    throw new Error(`AI CLI \u6267\u884C\u5931\u8D25: ${result.stderr || result.stdout}`);
+  }
+  logger.success("AI \u8F93\u51FA\u5B8C\u6210");
+  const usage = parseTokenUsage([result.stdout, result.stderr].filter(Boolean).join("\n"));
+  return {
+    output: result.stdout.trim(),
+    usage
+  };
+}
+function formatIterationRecord(record) {
+  const lines = [
+    `### \u8FED\u4EE3 ${record.iteration} \uFF5C ${record.timestamp}`,
+    "",
+    "#### \u63D0\u793A\u4E0A\u4E0B\u6587",
+    "```",
+    record.prompt,
+    "```",
+    "",
+    "#### AI \u8F93\u51FA",
+    "```",
+    record.aiOutput,
+    "```",
+    ""
+  ];
+  if (record.testResults && record.testResults.length > 0) {
+    lines.push("#### \u6D4B\u8BD5\u7ED3\u679C");
+    record.testResults.forEach((result) => {
+      const label = result.kind === "unit" ? "\u5355\u5143\u6D4B\u8BD5" : "e2e \u6D4B\u8BD5";
+      const status = result.success ? "\u2705 \u901A\u8FC7" : "\u274C \u5931\u8D25";
+      lines.push(`${status} \uFF5C ${label} \uFF5C \u547D\u4EE4: ${result.command} \uFF5C \u9000\u51FA\u7801: ${result.exitCode}`);
+      if (!result.success) {
+        lines.push("```");
+        lines.push(result.stderr || result.stdout || "\uFF08\u65E0\u8F93\u51FA\uFF09");
+        lines.push("```");
+        lines.push("");
+      }
+    });
+  }
+  return lines.join("\n");
+}
+
+// src/deps.ts
+var import_node_path7 = __toESM(require("path"));
+var import_fs_extra5 = __toESM(require("fs-extra"));
+function parsePackageManagerField(value) {
+  if (!value) return null;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "yarn" || normalized.startsWith("yarn@")) return "yarn";
+  if (normalized === "pnpm" || normalized.startsWith("pnpm@")) return "pnpm";
+  if (normalized === "npm" || normalized.startsWith("npm@")) return "npm";
+  return null;
+}
+function hasLockForManager(manager, hints) {
+  if (manager === "yarn") return hints.hasYarnLock;
+  if (manager === "pnpm") return hints.hasPnpmLock;
+  return hints.hasNpmLock || hints.hasNpmShrinkwrap;
+}
+function resolvePackageManager(hints) {
+  const fromField = parsePackageManagerField(hints.packageManagerField);
+  if (fromField) {
+    return {
+      manager: fromField,
+      source: "packageManager",
+      hasLock: hasLockForManager(fromField, hints)
+    };
+  }
+  if (hints.hasYarnLock) {
+    return {
+      manager: "yarn",
+      source: "lockfile",
+      hasLock: true
+    };
+  }
+  if (hints.hasPnpmLock) {
+    return {
+      manager: "pnpm",
+      source: "lockfile",
+      hasLock: true
+    };
+  }
+  if (hints.hasNpmLock || hints.hasNpmShrinkwrap) {
+    return {
+      manager: "npm",
+      source: "lockfile",
+      hasLock: true
+    };
+  }
+  return {
+    manager: "yarn",
+    source: "default",
+    hasLock: false
+  };
+}
+function buildInstallCommand(resolution) {
+  switch (resolution.manager) {
+    case "yarn": {
+      const args = ["yarn", "install"];
+      if (resolution.hasLock) {
+        args.push("--frozen-lockfile");
+      } else {
+        args.push("--no-lockfile");
+      }
+      return args.join(" ");
+    }
+    case "pnpm": {
+      const args = ["pnpm", "install"];
+      if (resolution.hasLock) {
+        args.push("--frozen-lockfile");
+      }
+      return args.join(" ");
+    }
+    case "npm": {
+      const args = resolution.hasLock ? ["npm", "ci"] : ["npm", "install"];
+      args.push("--no-audit", "--no-fund");
+      return args.join(" ");
+    }
+    default: {
+      return "yarn install";
+    }
+  }
+}
+function resolveSourceLabel(source) {
+  switch (source) {
+    case "packageManager":
+      return "packageManager \u5B57\u6BB5";
+    case "lockfile":
+      return "\u9501\u6587\u4EF6";
+    case "default":
+      return "\u9ED8\u8BA4\u7B56\u7565";
+    default:
+      return "\u672A\u77E5\u6765\u6E90";
+  }
+}
+function extractPackageManagerField(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const candidate = value;
+  const field = candidate.packageManager;
+  return typeof field === "string" ? field : void 0;
+}
+async function readPackageManagerHints(cwd, logger) {
+  const packageJsonPath = import_node_path7.default.join(cwd, "package.json");
+  const hasPackageJson = await import_fs_extra5.default.pathExists(packageJsonPath);
+  if (!hasPackageJson) return null;
+  let packageManagerField;
+  try {
+    const packageJson = await import_fs_extra5.default.readJson(packageJsonPath);
+    packageManagerField = extractPackageManagerField(packageJson);
+  } catch (error) {
+    logger.warn(`\u8BFB\u53D6 package.json \u5931\u8D25\uFF0C\u5C06\u6539\u7528\u9501\u6587\u4EF6\u5224\u65AD\u5305\u7BA1\u7406\u5668: ${String(error)}`);
+  }
+  const [hasYarnLock, hasPnpmLock, hasNpmLock, hasNpmShrinkwrap] = await Promise.all([
+    import_fs_extra5.default.pathExists(import_node_path7.default.join(cwd, "yarn.lock")),
+    import_fs_extra5.default.pathExists(import_node_path7.default.join(cwd, "pnpm-lock.yaml")),
+    import_fs_extra5.default.pathExists(import_node_path7.default.join(cwd, "package-lock.json")),
+    import_fs_extra5.default.pathExists(import_node_path7.default.join(cwd, "npm-shrinkwrap.json"))
+  ]);
+  return {
+    packageManagerField,
+    hasYarnLock,
+    hasPnpmLock,
+    hasNpmLock,
+    hasNpmShrinkwrap
+  };
+}
+async function ensureDependencies(cwd, logger) {
+  const hints = await readPackageManagerHints(cwd, logger);
+  if (!hints) {
+    logger.info("\u672A\u68C0\u6D4B\u5230 package.json\uFF0C\u8DF3\u8FC7\u4F9D\u8D56\u68C0\u67E5");
+    return;
+  }
+  const resolution = resolvePackageManager(hints);
+  const sourceLabel = resolveSourceLabel(resolution.source);
+  logger.info(`\u4F9D\u8D56\u68C0\u67E5\uFF1A\u4F7F\u7528 ${resolution.manager}\uFF08\u6765\u6E90\uFF1A${sourceLabel}\uFF09`);
+  if (resolution.source === "default") {
+    logger.warn("\u672A\u68C0\u6D4B\u5230 packageManager \u914D\u7F6E\u6216\u9501\u6587\u4EF6\uFF0C\u5C06\u6309\u9ED8\u8BA4\u7B56\u7565\u5B89\u88C5\u4F9D\u8D56");
+  }
+  const command = buildInstallCommand(resolution);
+  logger.info(`\u5F00\u59CB\u5B89\u88C5\u4F9D\u8D56: ${command}`);
+  const result = await runCommand("bash", ["-lc", command], {
+    cwd,
+    logger,
+    verboseLabel: "deps",
+    verboseCommand: `bash -lc "${command}"`,
+    stream: {
+      enabled: true,
+      stdoutPrefix: "[deps] ",
+      stderrPrefix: "[deps err] "
+    }
+  });
+  if (result.exitCode !== 0) {
+    const details = result.stderr || result.stdout || "\u65E0\u8F93\u51FA";
+    throw new Error(`\u4F9D\u8D56\u5B89\u88C5\u5931\u8D25: ${details}`);
+  }
+  logger.success("\u4F9D\u8D56\u68C0\u67E5\u5B8C\u6210");
+}
+
+// src/gh.ts
+function isGhPrInfo(input) {
+  if (typeof input !== "object" || input === null) return false;
+  const candidate = input;
+  return typeof candidate.number === "number" && typeof candidate.url === "string" && typeof candidate.title === "string" && typeof candidate.state === "string" && typeof candidate.headRefName === "string";
+}
+function resolveRunDatabaseId(candidate) {
+  const databaseId = candidate.databaseId;
+  if (typeof databaseId === "number" && Number.isFinite(databaseId)) return databaseId;
+  const id = candidate.id;
+  if (typeof id === "number" && Number.isFinite(id)) return id;
+  if (typeof id === "string") {
+    const parsed = Number(id);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return null;
+}
+function parseGhRunInfo(input) {
+  if (typeof input !== "object" || input === null) return null;
+  const candidate = input;
+  const databaseId = resolveRunDatabaseId(candidate);
+  if (databaseId === null) return null;
+  if (typeof candidate.name !== "string") return null;
+  if (typeof candidate.status !== "string") return null;
+  if (typeof candidate.url !== "string") return null;
+  const conclusion = candidate.conclusion;
+  const hasValidConclusion = conclusion === void 0 || conclusion === null || typeof conclusion === "string";
+  if (!hasValidConclusion) return null;
+  return {
+    databaseId,
+    name: candidate.name,
+    status: candidate.status,
+    conclusion: conclusion ?? null,
+    url: candidate.url
+  };
+}
+function parseGhRunList(output) {
+  try {
+    const parsed = JSON.parse(output);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.map(parseGhRunInfo).filter((run) => run !== null);
+  } catch {
+    return [];
+  }
+}
+function resolvePrTitle(branch, title) {
+  const trimmed = title?.trim();
+  if (trimmed) return trimmed;
+  return `chore: \u81EA\u52A8 PR (${branch})`;
+}
+function buildPrCreateArgs(branch, config) {
+  const args = ["pr", "create", "--head", branch, "--title", resolvePrTitle(branch, config.title)];
+  if (config.bodyPath) {
+    args.push("--body-file", config.bodyPath);
+  } else {
+    args.push("--body", "\u81EA\u52A8\u751F\u6210 PR\uFF08\u672A\u63D0\u4F9B body \u6587\u4EF6\uFF09");
+  }
+  if (config.draft) {
+    args.push("--draft");
+  }
+  if (config.reviewers && config.reviewers.length > 0) {
+    args.push("--reviewer", config.reviewers.join(","));
+  }
+  return args;
+}
+function isPrAlreadyExistsMessage(output) {
+  const trimmed = output.trim();
+  if (!trimmed) return false;
+  const ghPattern = /a pull request for branch ["']?[^"']+["']? into branch ["']?[^"']+["']? already exists/i;
+  if (ghPattern.test(trimmed)) return true;
+  const hasAlreadyExists = /already exists/i.test(trimmed);
+  const hasPrKeyword = /\b(pull request|pr)\b/i.test(trimmed);
+  const hasBranch = /\bbranch\b/i.test(trimmed);
+  if (hasAlreadyExists && hasPrKeyword && hasBranch) return true;
+  const hasChineseExists = trimmed.includes("\u5DF2\u5B58\u5728");
+  const hasChinesePr = trimmed.includes("\u62C9\u53D6\u8BF7\u6C42") || trimmed.includes("\u5408\u5E76\u8BF7\u6C42") || /\bPR\b/i.test(trimmed);
+  const hasChineseBranch = trimmed.includes("\u5206\u652F");
+  if (hasChineseExists && hasChinesePr && hasChineseBranch) return true;
+  return false;
+}
+function extractPrUrl(output) {
+  const match = output.match(/https?:\/\/\S+/);
+  if (!match) return null;
+  return match[0].replace(/[),.]+$/, "");
+}
+async function viewPr(branch, cwd, logger) {
+  const result = await runCommand("gh", ["pr", "view", branch, "--json", "number,title,url,state,headRefName"], {
+    cwd,
+    logger,
+    verboseLabel: "gh",
+    verboseCommand: `gh pr view ${branch} --json number,title,url,state,headRefName`
+  });
+  if (result.exitCode !== 0) {
+    logger.warn(`gh pr view \u5931\u8D25: ${result.stderr}`);
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(result.stdout);
+    if (isGhPrInfo(parsed)) return parsed;
+    logger.warn("gh pr view \u8FD4\u56DE\u683C\u5F0F\u5F02\u5E38");
+    return null;
+  } catch (error) {
+    logger.warn(`\u89E3\u6790 gh pr view \u8F93\u51FA\u5931\u8D25: ${String(error)}`);
+    return null;
+  }
+}
+async function createPr(branch, config, cwd, logger) {
+  if (!config.enable) return null;
+  const args = buildPrCreateArgs(branch, config);
+  const result = await runCommand("gh", args, {
+    cwd,
+    logger,
+    verboseLabel: "gh",
+    verboseCommand: `gh ${args.join(" ")}`
+  });
+  if (result.exitCode !== 0) {
+    const output = `${result.stderr}
+${result.stdout}`.trim();
+    if (isPrAlreadyExistsMessage(output)) {
+      const existingPr = await viewPr(branch, cwd, logger);
+      if (existingPr) {
+        logger.warn(`\u521B\u5EFA PR \u5931\u8D25\uFF0C\u4F46\u68C0\u6D4B\u5230\u5DF2\u6709 PR\uFF0C\u89C6\u4E3A\u521B\u5EFA\u5B8C\u6210: ${existingPr.url}`);
+        return existingPr;
+      }
+      const fallbackUrl = extractPrUrl(output);
+      logger.warn("\u521B\u5EFA PR \u5931\u8D25\uFF0C\u63D0\u793A\u5DF2\u5B58\u5728 PR\uFF0C\u4F46\u8BFB\u53D6 PR \u4FE1\u606F\u5931\u8D25\uFF0C\u89C6\u4E3A\u521B\u5EFA\u5B8C\u6210");
+      return {
+        number: 0,
+        url: fallbackUrl ?? "\u672A\u83B7\u53D6\u5230\u94FE\u63A5",
+        title: "\u5DF2\u5B58\u5728 PR\uFF08\u672A\u83B7\u53D6\u8BE6\u60C5\uFF09",
+        state: "unknown",
+        headRefName: branch
+      };
+    }
+    logger.warn(`\u521B\u5EFA PR \u5931\u8D25: ${output || "\u672A\u77E5\u9519\u8BEF"}`);
+    return null;
+  }
+  return viewPr(branch, cwd, logger);
+}
+async function listFailedRuns(branch, cwd, logger) {
+  const result = await runCommand("gh", ["run", "list", "--branch", branch, "--json", "databaseId,name,status,conclusion,url", "--limit", "5"], {
+    cwd,
+    logger,
+    verboseLabel: "gh",
+    verboseCommand: `gh run list --branch ${branch} --json databaseId,name,status,conclusion,url --limit 5`
+  });
+  if (result.exitCode !== 0) {
+    logger.warn(`\u83B7\u53D6 Actions \u8FD0\u884C\u5931\u8D25: ${result.stderr}`);
+    return [];
+  }
+  try {
+    const runs = parseGhRunList(result.stdout);
+    const failed = runs.filter((run) => run.conclusion && run.conclusion !== "success");
+    if (failed.length === 0) {
+      logger.info("\u6700\u8FD1 5 \u6B21 Actions \u8FD0\u884C\u65E0\u5931\u8D25");
+    }
+    return failed;
+  } catch (error) {
+    logger.warn(`\u89E3\u6790 Actions \u8F93\u51FA\u5931\u8D25: ${String(error)}`);
+    return [];
+  }
+}
+
+// src/logger.ts
+var import_fs_extra6 = __toESM(require("fs-extra"));
+var wrap = (code) => (value) => `\x1B[${code}m${value}\x1B[0m`;
+var colors = {
+  blue: wrap("34"),
+  green: wrap("32"),
+  yellow: wrap("33"),
+  red: wrap("31"),
+  magenta: wrap("35"),
+  gray: wrap("90")
+};
+var Logger = class {
+  constructor(options = {}) {
+    this.verbose = options.verbose ?? false;
+    const trimmedPath = options.logFile?.trim();
+    this.logFile = trimmedPath && trimmedPath.length > 0 ? trimmedPath : void 0;
+    this.logFileEnabled = Boolean(this.logFile);
+    this.logFileErrored = false;
+    if (this.logFile) {
+      try {
+        import_fs_extra6.default.ensureFileSync(this.logFile);
+      } catch (error) {
+        this.disableFileWithError(error);
+      }
+    }
+  }
+  info(message) {
+    this.emit("log", colors.blue, "info", "  ", message);
+  }
+  success(message) {
+    this.emit("log", colors.green, "ok", "    ", message);
+  }
+  warn(message) {
+    this.emit("warn", colors.yellow, "warn", "  ", message);
+  }
+  error(message) {
+    this.emit("error", colors.red, "err", "   ", message);
+  }
+  debug(message) {
+    if (!this.verbose) return;
+    this.emit("log", colors.magenta, "dbg", "   ", message);
+  }
+  emit(method, colorizer, label, padding, message) {
+    const now = /* @__PURE__ */ new Date();
+    const consoleLine = this.formatConsoleLine(now, colorizer(label), padding, message);
+    const fileLine = this.formatFileLine(now, label, padding, message);
+    console[method](consoleLine);
+    this.writeFileLine(fileLine);
+  }
+  formatConsoleLine(date, label, padding, message) {
+    const timestamp = this.formatTimestamp(date);
+    return `${colors.gray(timestamp)} ${label}${padding}${message}`;
+  }
+  formatFileLine(date, label, padding, message) {
+    const timestamp = this.formatTimestamp(date);
+    return `${timestamp} ${label}${padding}${message}`;
+  }
+  writeFileLine(line) {
+    if (!this.logFileEnabled || !this.logFile) return;
+    try {
+      import_fs_extra6.default.appendFileSync(this.logFile, `${line}
+`, "utf8");
+    } catch (error) {
+      this.disableFileWithError(error);
+    }
+  }
+  disableFileWithError(error) {
+    this.logFileEnabled = false;
+    if (this.logFileErrored) return;
+    this.logFileErrored = true;
+    const message = error instanceof Error ? error.message : String(error);
+    const target = this.logFile ? ` (${this.logFile})` : "";
+    console.warn(`\u65E5\u5FD7\u6587\u4EF6\u5199\u5165\u5931\u8D25${target}\uFF0C\u5DF2\u505C\u6B62\u5199\u5165\uFF1A${message}`);
+  }
+  formatTimestamp(date) {
+    const year = date.getFullYear();
+    const month = pad2(date.getMonth() + 1);
+    const day = pad2(date.getDate());
+    const hours = pad2(date.getHours());
+    const minutes = pad2(date.getMinutes());
+    const seconds = pad2(date.getSeconds());
+    return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+  }
+};
+var defaultLogger = new Logger();
+
+// src/runtime-tracker.ts
+async function safeWrite(logFile, metadata, logger) {
+  try {
+    await writeRunMetadata(logFile, metadata);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger?.warn(`\u5199\u5165\u8FD0\u884C\u5143\u4FE1\u606F\u5931\u8D25: ${message}`);
+  }
+  try {
+    await upsertCurrentRegistry(logFile, metadata);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger?.warn(`\u66F4\u65B0 current.json \u5931\u8D25: ${message}`);
+  }
+}
+async function safeRemove(logFile, logger) {
+  try {
+    await removeCurrentRegistry(logFile);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger?.warn(`\u6E05\u7406 current.json \u5931\u8D25: ${message}`);
+  }
+}
+async function createRunTracker(options) {
+  const { logFile, command, path: path10, logger } = options;
+  if (!logFile) return null;
+  const update = async (round, tokenUsed) => {
+    const metadata = {
+      command,
+      round,
+      tokenUsed,
+      path: path10
+    };
+    await safeWrite(logFile, metadata, logger);
+  };
+  await update(0, 0);
+  return {
+    update,
+    finalize: async () => {
+      await safeRemove(logFile, logger);
+    }
+  };
+}
+
+// src/summary.ts
+var REQUIRED_SECTIONS = ["# \u53D8\u66F4\u6458\u8981", "# \u6D4B\u8BD5\u7ED3\u679C", "# \u98CE\u9669\u4E0E\u56DE\u6EDA"];
+function normalizeText(text) {
+  return text.replace(/\r\n?/g, "\n");
+}
+function compactLine(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function trimTail(text, limit, emptyFallback) {
+  const normalized = normalizeText(text).trim();
+  if (!normalized) return emptyFallback;
+  if (normalized.length <= limit) return normalized;
+  return `\uFF08\u5185\u5BB9\u8FC7\u957F\uFF0C\u4FDD\u7559\u6700\u540E ${limit} \u5B57\u7B26\uFF09
+${normalized.slice(-limit)}`;
+}
+function formatTestResultLines(testResults) {
+  if (!testResults || testResults.length === 0) {
+    return ["- \u672A\u8FD0\u884C\uFF08\u672C\u6B21\u672A\u6267\u884C\u6D4B\u8BD5\uFF09"];
+  }
+  return testResults.map((result) => {
+    const label = result.kind === "unit" ? "\u5355\u5143\u6D4B\u8BD5" : "e2e \u6D4B\u8BD5";
+    const status = result.success ? "\u901A\u8FC7" : `\u5931\u8D25\uFF08\u9000\u51FA\u7801 ${result.exitCode}\uFF09`;
+    const command = result.command ? `\uFF5C\u547D\u4EE4: ${result.command}` : "";
+    return `- ${label}: ${status} ${command}`.trim();
+  });
+}
+function formatTestResultsForPrompt(testResults) {
+  return formatTestResultLines(testResults).join("\n");
+}
+function buildSummaryLinesFromCommit(commitTitle, commitBody) {
+  const bulletLines = extractBulletLines(commitBody);
+  if (bulletLines.length > 0) return bulletLines;
+  const summary = stripCommitType(commitTitle);
+  return [`- ${summary}`];
+}
+function stripCommitType(title) {
+  const trimmed = compactLine(title);
+  if (!trimmed) return "\u66F4\u65B0\u8FED\u4EE3\u4EA7\u51FA";
+  const match = trimmed.match(/^[^:]+:\s*(.+)$/);
+  return match?.[1]?.trim() || trimmed;
+}
+function buildPrBody(summaryLines, testLines) {
+  const riskLines = ["- \u98CE\u9669\uFF1A\u5F85\u8BC4\u4F30", "- \u56DE\u6EDA\uFF1Agit revert \u5BF9\u5E94\u63D0\u4EA4\u6216\u5173\u95ED PR"];
+  return [
+    "# \u53D8\u66F4\u6458\u8981",
+    summaryLines.join("\n"),
+    "",
+    "# \u6D4B\u8BD5\u7ED3\u679C",
+    testLines.join("\n"),
+    "",
+    "# \u98CE\u9669\u4E0E\u56DE\u6EDA",
+    riskLines.join("\n")
+  ].join("\n");
+}
+function buildSummaryPrompt(input) {
+  const planSnippet = trimTail(input.plan, 2e3, "\uFF08\u8BA1\u5212\u4E3A\u7A7A\uFF09");
+  const notesSnippet = trimTail(input.notes, 4e3, "\uFF08notes \u4E3A\u7A7A\uFF09");
+  const aiSnippet = trimTail(input.lastAiOutput, 3e3, "\uFF08\u672C\u8F6E\u65E0 AI \u8F93\u51FA\uFF09");
+  const statusSnippet = trimTail(input.gitStatus, 1e3, "\uFF08git status \u4E3A\u7A7A\uFF09");
+  const diffSnippet = trimTail(input.diffStat, 1e3, "\uFF08diff \u7EDF\u8BA1\u4E3A\u7A7A\uFF09");
+  const testSummary = formatTestResultsForPrompt(input.testResults);
+  return [
+    "# \u89D2\u8272",
+    "\u4F60\u662F\u8D44\u6DF1\u5DE5\u7A0B\u5E08\uFF0C\u9700\u8981\u4E3A\u672C\u6B21\u8FED\u4EE3\u751F\u6210\u63D0\u4EA4\u4FE1\u606F\u4E0E PR \u6587\u6848\u3002",
+    "# \u4EFB\u52A1",
+    "\u57FA\u4E8E\u8F93\u5165\u4FE1\u606F\u8F93\u51FA\u4E25\u683C JSON\uFF08\u4E0D\u8981 markdown\u3001\u4E0D\u8981\u4EE3\u7801\u5757\u3001\u4E0D\u8981\u591A\u4F59\u6587\u5B57\uFF09\u3002",
+    "\u8981\u6C42\uFF1A",
+    "- \u5168\u90E8\u4E2D\u6587\u3002",
+    "- commitTitle / prTitle \u4F7F\u7528 Conventional Commits \u683C\u5F0F\uFF1A<type>: <\u6982\u8981>\uFF0C\u7B80\u6D01\u5177\u4F53\uFF0C\u4E0D\u8981\u51FA\u73B0\u201C\u81EA\u52A8\u8FED\u4EE3\u63D0\u4EA4/\u81EA\u52A8 PR\u201D\u7B49\u5B57\u6837\u3002",
+    "- commitBody \u4E3A\u591A\u884C\u8981\u70B9\u5217\u8868\uFF08\u53EF\u4E3A\u7A7A\u5B57\u7B26\u4E32\uFF09\u3002",
+    "- prBody \u4E3A Markdown\uFF0C\u5FC5\u987B\u5305\u542B\u6807\u9898\uFF1A# \u53D8\u66F4\u6458\u8981\u3001# \u6D4B\u8BD5\u7ED3\u679C\u3001# \u98CE\u9669\u4E0E\u56DE\u6EDA\uFF0C\u5E76\u5728\u53D8\u66F4\u6458\u8981\u4E2D\u4F53\u73B0\u5DE5\u4F5C\u603B\u7ED3\u3002",
+    "- \u4E0D\u786E\u5B9A\u5904\u53EF\u57FA\u4E8E\u73B0\u6709\u4FE1\u606F\u5408\u7406\u63A8\u65AD\uFF0C\u4F46\u4E0D\u8981\u7F16\u9020\u6D4B\u8BD5\u7ED3\u679C\u3002",
+    "# \u8F93\u51FA JSON",
+    '{"commitTitle":"...","commitBody":"...","prTitle":"...","prBody":"..."}',
+    "# \u8F93\u5165\u4FE1\u606F",
+    `\u4EFB\u52A1: ${compactLine(input.task) || "\uFF08\u7A7A\uFF09"}`,
+    `\u5206\u652F: ${input.branchName ?? "\uFF08\u672A\u77E5\uFF09"}`,
+    "\u8BA1\u5212\uFF08\u8282\u9009\uFF09:",
+    planSnippet,
+    "notes\uFF08\u8282\u9009\uFF09:",
+    notesSnippet,
+    "\u6700\u8FD1\u4E00\u6B21 AI \u8F93\u51FA\uFF08\u8282\u9009\uFF09:",
+    aiSnippet,
+    "\u6D4B\u8BD5\u7ED3\u679C:",
+    testSummary,
+    "git status --short:",
+    statusSnippet,
+    "git diff --stat:",
+    diffSnippet
+  ].join("\n\n");
+}
+function pickString(record, keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value.trim();
+    }
+  }
+  return null;
+}
+function extractJson(text) {
+  const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  if (fenced?.[1]) return fenced[1].trim();
+  const start = text.indexOf("{");
+  const end = text.lastIndexOf("}");
+  if (start >= 0 && end > start) {
+    return text.slice(start, end + 1).trim();
+  }
+  return null;
+}
+function normalizeTitle(title) {
+  return compactLine(title);
+}
+function normalizeBody(body) {
+  if (!body) return void 0;
+  const normalized = normalizeText(body).trim();
+  return normalized.length > 0 ? normalized : void 0;
+}
+function extractBulletLines(text) {
+  if (!text) return [];
+  const lines = normalizeText(text).split("\n").map((line) => line.trim()).filter(Boolean);
+  const bullets = lines.filter((line) => line.startsWith("- ") || line.startsWith("* "));
+  return bullets.map((line) => line.startsWith("* ") ? `- ${line.slice(2).trim()}` : line);
+}
+function parseDeliverySummary(output) {
+  const jsonText = extractJson(output);
+  if (!jsonText) return null;
+  try {
+    const parsed = JSON.parse(jsonText);
+    let commitTitle = pickString(parsed, ["commitTitle", "commit_message", "commitMessage", "commit_title"]);
+    let commitBody = pickString(parsed, ["commitBody", "commit_body"]);
+    let prTitle = pickString(parsed, ["prTitle", "pr_title"]);
+    let prBody = pickString(parsed, ["prBody", "pr_body"]);
+    const commitObj = parsed.commit;
+    if ((!commitTitle || !commitBody) && typeof commitObj === "object" && commitObj !== null) {
+      const commitRecord = commitObj;
+      commitTitle = commitTitle ?? pickString(commitRecord, ["title", "commitTitle"]);
+      commitBody = commitBody ?? pickString(commitRecord, ["body", "commitBody"]);
+    }
+    const prObj = parsed.pr;
+    if ((!prTitle || !prBody) && typeof prObj === "object" && prObj !== null) {
+      const prRecord = prObj;
+      prTitle = prTitle ?? pickString(prRecord, ["title", "prTitle"]);
+      prBody = prBody ?? pickString(prRecord, ["body", "prBody"]);
+    }
+    if (!commitTitle || !prTitle || !prBody) return null;
+    const normalizedCommitTitle = normalizeTitle(commitTitle);
+    const normalizedPrTitle = normalizeTitle(prTitle);
+    const normalizedCommitBody = normalizeBody(commitBody);
+    const normalizedPrBody = normalizeText(prBody).trim();
+    if (!normalizedCommitTitle || !normalizedPrTitle || !normalizedPrBody) return null;
+    return {
+      commitTitle: normalizedCommitTitle,
+      commitBody: normalizedCommitBody,
+      prTitle: normalizedPrTitle,
+      prBody: normalizedPrBody
+    };
+  } catch {
+    return null;
+  }
+}
+function buildFallbackSummary(input) {
+  const taskLine = compactLine(input.task);
+  const shortTask = taskLine.length > 50 ? `${taskLine.slice(0, 50)}...` : taskLine;
+  const baseTitle = shortTask || "\u66F4\u65B0\u8FED\u4EE3\u4EA7\u51FA";
+  const title = `chore: ${baseTitle}`;
+  const summaryLines = [`- ${baseTitle}`];
+  const testLines = formatTestResultLines(input.testResults);
+  const prBody = buildPrBody(summaryLines, testLines);
+  return {
+    commitTitle: title,
+    commitBody: summaryLines.join("\n"),
+    prTitle: title,
+    prBody
+  };
+}
+function ensurePrBodySections(prBody, fallback) {
+  const normalized = normalizeText(prBody).trim();
+  const hasAll = REQUIRED_SECTIONS.every((section) => normalized.includes(section));
+  if (hasAll) return normalized;
+  const summaryLines = buildSummaryLinesFromCommit(fallback.commitTitle, fallback.commitBody);
+  const testLines = formatTestResultLines(fallback.testResults);
+  return buildPrBody(summaryLines, testLines);
+}
+
+// src/webhook.ts
+var DEFAULT_TIMEOUT_MS = 8e3;
+function normalizeWebhookUrls(urls) {
+  if (!urls || urls.length === 0) return [];
+  return urls.map((url) => url.trim()).filter((url) => url.length > 0);
+}
+function buildWebhookPayload(input) {
+  return {
+    event: input.event,
+    task: input.task,
+    branch: input.branch ?? "",
+    iteration: input.iteration,
+    stage: input.stage,
+    timestamp: input.timestamp ?? isoNow()
+  };
+}
+function resolveFetcher(fetcher) {
+  if (fetcher) return fetcher;
+  const globalFetcher = globalThis.fetch;
+  if (typeof globalFetcher !== "function") return null;
+  return globalFetcher;
+}
+async function postWebhook(url, payload, timeoutMs, logger, fetcher) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetcher(url, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      logger.warn(`webhook \u8BF7\u6C42\u5931\u8D25\uFF08${response.status} ${response.statusText}\uFF09\uFF1A${url}`);
+    } else {
+      logger.debug(`webhook \u901A\u77E5\u6210\u529F\uFF1A${url}`);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.warn(`webhook \u901A\u77E5\u5F02\u5E38\uFF1A${url}\uFF5C${message}`);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function sendWebhookNotifications(config, payload, logger, fetcher) {
+  const urls = normalizeWebhookUrls(config?.urls);
+  if (urls.length === 0) return;
+  const resolvedFetcher = resolveFetcher(fetcher);
+  if (!resolvedFetcher) {
+    logger.warn("\u5F53\u524D Node \u73AF\u5883\u4E0D\u652F\u6301 fetch\uFF0C\u5DF2\u8DF3\u8FC7 webhook \u901A\u77E5");
+    return;
+  }
+  const timeoutMs = config?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  await Promise.all(urls.map((url) => postWebhook(url, payload, timeoutMs, logger, resolvedFetcher)));
+}
+
+// src/loop.ts
+async function ensureWorkflowFiles(workflowFiles) {
+  await ensureFile(workflowFiles.workflowDoc, "# AI \u5DE5\u4F5C\u6D41\u7A0B\u57FA\u7EBF\n");
+  await ensureFile(workflowFiles.planFile, "# \u8BA1\u5212\n");
+  await ensureFile(workflowFiles.notesFile, "# \u6301\u4E45\u5316\u8BB0\u5FC6\n");
+}
+var MAX_TEST_LOG_LENGTH = 4e3;
+function trimOutput(output, limit = MAX_TEST_LOG_LENGTH) {
+  if (!output) return "";
+  if (output.length <= limit) return output;
+  return `${output.slice(0, limit)}
+\u2026\u2026\uFF08\u8F93\u51FA\u5DF2\u622A\u65AD\uFF0C\u539F\u59CB\u957F\u5EA6 ${output.length} \u5B57\u7B26\uFF09`;
+}
+async function safeCommandOutput(command, args, cwd, logger, label, verboseCommand) {
+  const result = await runCommand(command, args, {
+    cwd,
+    logger,
+    verboseLabel: label,
+    verboseCommand
+  });
+  if (result.exitCode !== 0) {
+    logger.warn(`${label} \u547D\u4EE4\u5931\u8D25: ${result.stderr || result.stdout}`);
+    return "";
+  }
+  return result.stdout.trim();
+}
+async function runSingleTest(kind, command, cwd, logger) {
+  const label = kind === "unit" ? "\u5355\u5143\u6D4B\u8BD5" : "e2e \u6D4B\u8BD5";
+  logger.info(`\u6267\u884C${label}: ${command}`);
+  const result = await runCommand("bash", ["-lc", command], {
+    cwd,
+    logger,
+    verboseLabel: "shell",
+    verboseCommand: `bash -lc "${command}"`
+  });
+  const success = result.exitCode === 0;
+  if (success) {
+    logger.success(`${label}\u5B8C\u6210`);
+  } else {
+    logger.warn(`${label}\u5931\u8D25\uFF08\u9000\u51FA\u7801 ${result.exitCode}\uFF09`);
+  }
+  return {
+    kind,
+    command,
+    success,
+    exitCode: result.exitCode,
+    stdout: trimOutput(result.stdout.trim()),
+    stderr: trimOutput(result.stderr.trim())
+  };
+}
+async function runTests(config, workDir, logger) {
+  const results = [];
+  if (config.runTests && config.tests.unitCommand) {
+    const unitResult = await runSingleTest("unit", config.tests.unitCommand, workDir, logger);
+    results.push(unitResult);
+  }
+  if (config.runE2e && config.tests.e2eCommand) {
+    const e2eResult = await runSingleTest("e2e", config.tests.e2eCommand, workDir, logger);
+    results.push(e2eResult);
+  }
+  return results;
+}
+function reRootPath(filePath, repoRoot, workDir) {
+  const relative = import_node_path8.default.relative(repoRoot, filePath);
+  if (relative.startsWith("..")) return filePath;
+  return import_node_path8.default.join(workDir, relative);
+}
+function reRootWorkflowFiles(workflowFiles, repoRoot, workDir) {
+  if (repoRoot === workDir) return workflowFiles;
+  return {
+    workflowDoc: reRootPath(workflowFiles.workflowDoc, repoRoot, workDir),
+    notesFile: reRootPath(workflowFiles.notesFile, repoRoot, workDir),
+    planFile: reRootPath(workflowFiles.planFile, repoRoot, workDir)
+  };
+}
+function buildBodyFile(workDir) {
+  return import_node_path8.default.join(workDir, "memory", "pr-body.md");
+}
+async function writePrBody(bodyPath, content, appendExisting) {
+  await import_fs_extra7.default.mkdirp(import_node_path8.default.dirname(bodyPath));
+  let finalContent = content.trim();
+  if (appendExisting) {
+    const existing = await readFileSafe(bodyPath);
+    const trimmedExisting = existing.trim();
+    if (trimmedExisting.length > 0) {
+      finalContent = `${trimmedExisting}
+
+---
+
+${finalContent}`;
+    }
+  }
+  await import_fs_extra7.default.writeFile(bodyPath, `${finalContent}
+`, "utf8");
+}
+async function cleanupWorktreeIfSafe(context) {
+  const { repoRoot, workDir, branchName, prInfo, worktreeCreated, logger } = context;
+  if (!worktreeCreated) {
+    logger.debug("worktree \u5E76\u975E\u672C\u6B21\u521B\u5EFA\uFF0C\u8DF3\u8FC7\u81EA\u52A8\u6E05\u7406");
+    return;
+  }
+  if (workDir === repoRoot) {
+    logger.debug("\u5F53\u524D\u672A\u4F7F\u7528\u72EC\u7ACB worktree\uFF0C\u8DF3\u8FC7\u81EA\u52A8\u6E05\u7406");
+    return;
+  }
+  if (!branchName) {
+    logger.warn("\u672A\u80FD\u786E\u5B9A worktree \u5206\u652F\u540D\uFF0C\u4FDD\u7559\u5DE5\u4F5C\u76EE\u5F55\u4EE5\u514D\u4E22\u5931\u8FDB\u5EA6");
+    return;
+  }
+  const clean = await isWorktreeClean(workDir, logger);
+  if (!clean) {
+    logger.warn("worktree \u4ECD\u6709\u672A\u63D0\u4EA4\u53D8\u66F4\uFF0C\u5DF2\u4FDD\u7559\u5DE5\u4F5C\u76EE\u5F55");
+    return;
+  }
+  const pushed = await isBranchPushed(branchName, workDir, logger);
+  if (!pushed) {
+    logger.warn(`\u5206\u652F ${branchName} \u5C1A\u672A\u63A8\u9001\u5230\u8FDC\u7AEF\uFF0C\u5DF2\u4FDD\u7559 worktree`);
+    return;
+  }
+  if (!prInfo) {
+    logger.warn("\u672A\u68C0\u6D4B\u5230\u5173\u8054 PR\uFF0C\u5DF2\u4FDD\u7559 worktree");
+    return;
+  }
+  await removeWorktree(workDir, repoRoot, logger);
+}
+async function runLoop(config) {
+  const logger = new Logger({ verbose: config.verbose, logFile: config.logFile });
+  const repoRoot = await getRepoRoot(config.cwd, logger);
+  logger.debug(`\u4ED3\u5E93\u6839\u76EE\u5F55: ${repoRoot}`);
+  const worktreeResult = config.git.useWorktree ? await ensureWorktree(config.git, repoRoot, logger) : { path: repoRoot, created: false };
+  const workDir = worktreeResult.path;
+  const worktreeCreated = worktreeResult.created;
+  logger.debug(`\u5DE5\u4F5C\u76EE\u5F55: ${workDir}`);
+  const commandLine = formatCommandLine(process.argv);
+  const runTracker = await createRunTracker({
+    logFile: config.logFile,
+    command: commandLine,
+    path: workDir,
+    logger
+  });
+  let branchName = config.git.branchName;
+  let lastRound = 0;
+  let runError = null;
+  const notifyWebhook = async (event, iteration, stage) => {
+    const payload = buildWebhookPayload({
+      event,
+      task: config.task,
+      branch: branchName,
+      iteration,
+      stage
+    });
+    await sendWebhookNotifications(config.webhooks, payload, logger);
+  };
+  try {
+    if (!branchName) {
+      try {
+        branchName = await getCurrentBranch(workDir, logger);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.warn(`\u8BFB\u53D6\u5206\u652F\u540D\u5931\u8D25\uFF0Cwebhook \u4E2D\u5C06\u7F3A\u5931\u5206\u652F\u4FE1\u606F\uFF1A${message}`);
+      }
+    }
+    await notifyWebhook("task_start", 0, "\u4EFB\u52A1\u5F00\u59CB");
+    if (config.skipInstall) {
+      logger.info("\u5DF2\u8DF3\u8FC7\u4F9D\u8D56\u68C0\u67E5");
+    } else {
+      await ensureDependencies(workDir, logger);
+    }
+    const workflowFiles = reRootWorkflowFiles(config.workflowFiles, repoRoot, workDir);
+    await ensureWorkflowFiles(workflowFiles);
+    const planContent = await readFileSafe(workflowFiles.planFile);
+    if (planContent.trim().length === 0) {
+      logger.warn("plan \u6587\u4EF6\u4E3A\u7A7A\uFF0C\u5EFA\u8BAE AI \u9996\u8F6E\u751F\u6210\u8BA1\u5212");
+    }
+    const aiConfig = config.ai;
+    let accumulatedUsage = null;
+    let lastTestResults = null;
+    let lastAiOutput = "";
+    let prInfo = null;
+    let prFailed = false;
+    for (let i = 1; i <= config.iterations; i += 1) {
+      await notifyWebhook("iteration_start", i, `\u5F00\u59CB\u7B2C ${i} \u8F6E\u8FED\u4EE3`);
+      const workflowGuide = await readFileSafe(workflowFiles.workflowDoc);
+      const plan = await readFileSafe(workflowFiles.planFile);
+      const notes = await readFileSafe(workflowFiles.notesFile);
+      logger.debug(`\u52A0\u8F7D\u63D0\u793A\u4E0A\u4E0B\u6587\uFF0C\u957F\u5EA6\uFF1Aworkflow=${workflowGuide.length}, plan=${plan.length}, notes=${notes.length}`);
+      const prompt = buildPrompt({
+        task: config.task,
+        workflowGuide,
+        plan,
+        notes,
+        iteration: i
+      });
+      logger.debug(`\u7B2C ${i} \u8F6E\u63D0\u793A\u957F\u5EA6: ${prompt.length}`);
+      logger.info(`\u7B2C ${i} \u8F6E\u63D0\u793A\u6784\u5EFA\u5B8C\u6210\uFF0C\u8C03\u7528 AI CLI...`);
+      const aiResult = await runAi(prompt, aiConfig, logger, workDir);
+      accumulatedUsage = mergeTokenUsage(accumulatedUsage, aiResult.usage);
+      lastAiOutput = aiResult.output;
+      const hitStop = aiResult.output.includes(config.stopSignal);
+      let testResults = [];
+      const shouldRunTests = config.runTests || config.runE2e;
+      if (shouldRunTests) {
+        try {
+          testResults = await runTests(config, workDir, logger);
+        } catch (error) {
+          const errorMessage = String(error);
+          logger.warn(`\u6D4B\u8BD5\u6267\u884C\u5F02\u5E38: ${errorMessage}`);
+          testResults = [{
+            kind: "unit",
+            command: config.tests.unitCommand ?? "\u672A\u77E5\u6D4B\u8BD5\u547D\u4EE4",
+            success: false,
+            exitCode: -1,
+            stdout: "",
+            stderr: trimOutput(errorMessage)
+          }];
+        }
+      }
+      const record = formatIterationRecord({
+        iteration: i,
+        prompt,
+        aiOutput: aiResult.output,
+        timestamp: isoNow(),
+        testResults
+      });
+      await appendSection(workflowFiles.notesFile, record);
+      logger.success(`\u5DF2\u5C06\u7B2C ${i} \u8F6E\u8F93\u51FA\u5199\u5165 ${workflowFiles.notesFile}`);
+      lastTestResults = testResults;
+      lastRound = i;
+      await runTracker?.update(i, accumulatedUsage?.totalTokens ?? 0);
+      const hasTestFailure = testResults.some((result) => !result.success);
+      if (hitStop && !hasTestFailure) {
+        logger.info(`\u68C0\u6D4B\u5230\u505C\u6B62\u6807\u8BB0 ${config.stopSignal}\uFF0C\u63D0\u524D\u7ED3\u675F\u5FAA\u73AF`);
+        break;
+      }
+      if (hitStop && hasTestFailure) {
+        logger.info(`\u68C0\u6D4B\u5230\u505C\u6B62\u6807\u8BB0 ${config.stopSignal}\uFF0C\u4F46\u6D4B\u8BD5\u5931\u8D25\uFF0C\u7EE7\u7EED\u8FDB\u5165\u4E0B\u4E00\u8F6E\u4FEE\u590D`);
+      }
+    }
+    const lastTestFailed = lastTestResults?.some((result) => !result.success) ?? false;
+    if (lastTestFailed) {
+      logger.warn("\u5B58\u5728\u672A\u901A\u8FC7\u7684\u6D4B\u8BD5\uFF0C\u5DF2\u8DF3\u8FC7\u81EA\u52A8\u63D0\u4EA4/\u63A8\u9001/PR");
+    }
+    let deliverySummary = null;
+    const shouldPrepareDelivery = !lastTestFailed && (config.autoCommit || config.pr.enable);
+    if (shouldPrepareDelivery) {
+      const [gitStatus, diffStat] = await Promise.all([
+        safeCommandOutput("git", ["status", "--short"], workDir, logger, "git", "git status --short"),
+        safeCommandOutput("git", ["diff", "--stat"], workDir, logger, "git", "git diff --stat")
+      ]);
+      const summaryPrompt = buildSummaryPrompt({
+        task: config.task,
+        plan: await readFileSafe(workflowFiles.planFile),
+        notes: await readFileSafe(workflowFiles.notesFile),
+        lastAiOutput,
+        testResults: lastTestResults,
+        gitStatus,
+        diffStat,
+        branchName
+      });
+      try {
+        const summaryResult = await runAi(summaryPrompt, aiConfig, logger, workDir);
+        accumulatedUsage = mergeTokenUsage(accumulatedUsage, summaryResult.usage);
+        deliverySummary = parseDeliverySummary(summaryResult.output);
+        if (!deliverySummary) {
+          logger.warn("AI \u603B\u7ED3\u8F93\u51FA\u89E3\u6790\u5931\u8D25\uFF0C\u4F7F\u7528\u515C\u5E95\u6587\u6848");
+        }
+      } catch (error) {
+        logger.warn(`AI \u603B\u7ED3\u751F\u6210\u5931\u8D25: ${String(error)}`);
+      }
+      if (!deliverySummary) {
+        deliverySummary = buildFallbackSummary({ task: config.task, testResults: lastTestResults });
+      }
+    }
+    await runTracker?.update(lastRound, accumulatedUsage?.totalTokens ?? 0);
+    if (config.autoCommit && !lastTestFailed) {
+      const summary = deliverySummary ?? buildFallbackSummary({ task: config.task, testResults: lastTestResults });
+      const commitMessage = {
+        title: summary.commitTitle,
+        body: summary.commitBody
+      };
+      await commitAll(commitMessage, workDir, logger).catch((error) => {
+        logger.warn(String(error));
+      });
+    }
+    if (config.autoPush && branchName && !lastTestFailed) {
+      await pushBranch(branchName, workDir, logger).catch((error) => {
+        logger.warn(String(error));
+      });
+    }
+    if (config.pr.enable && branchName && !lastTestFailed) {
+      logger.info("\u5F00\u59CB\u521B\u5EFA PR...");
+      const summary = deliverySummary ?? buildFallbackSummary({ task: config.task, testResults: lastTestResults });
+      const prTitleCandidate = config.pr.title?.trim() || summary.prTitle;
+      const prBodyContent = ensurePrBodySections(summary.prBody, {
+        commitTitle: summary.commitTitle,
+        commitBody: summary.commitBody,
+        testResults: lastTestResults
+      });
+      const bodyFile = config.pr.bodyPath ?? buildBodyFile(workDir);
+      await writePrBody(bodyFile, prBodyContent, Boolean(config.pr.bodyPath));
+      const createdPr = await createPr(branchName, { ...config.pr, title: prTitleCandidate, bodyPath: bodyFile }, workDir, logger);
+      prInfo = createdPr;
+      if (createdPr) {
+        logger.success(`PR \u5DF2\u521B\u5EFA: ${createdPr.url}`);
+        const failedRuns = await listFailedRuns(branchName, workDir, logger);
+        if (failedRuns.length > 0) {
+          failedRuns.forEach((run) => {
+            logger.warn(`Actions \u5931\u8D25: ${run.name} (${run.status}/${run.conclusion ?? "unknown"}) ${run.url}`);
+          });
+        }
+      } else {
+        prFailed = true;
+        logger.error("PR \u521B\u5EFA\u5931\u8D25\uFF0C\u8BE6\u89C1\u4E0A\u65B9 gh \u8F93\u51FA");
+      }
+    } else if (branchName && !config.pr.enable) {
+      logger.info("\u672A\u5F00\u542F PR \u521B\u5EFA\uFF08--pr \u672A\u4F20\uFF09\uFF0C\u5C1D\u8BD5\u67E5\u770B\u5DF2\u6709 PR");
+      const existingPr = await viewPr(branchName, workDir, logger);
+      prInfo = existingPr;
+      if (existingPr) logger.info(`\u5DF2\u6709 PR: ${existingPr.url}`);
+    }
+    if (accumulatedUsage) {
+      const input = accumulatedUsage.inputTokens ?? "-";
+      const output = accumulatedUsage.outputTokens ?? "-";
+      logger.info(`Token \u6D88\u8017\u6C47\u603B\uFF1A\u8F93\u5165 ${input}\uFF5C\u8F93\u51FA ${output}\uFF5C\u603B\u8BA1 ${accumulatedUsage.totalTokens}`);
+    } else {
+      logger.info("\u672A\u89E3\u6790\u5230 Token \u6D88\u8017\u4FE1\u606F\uFF0C\u53EF\u68C0\u67E5 AI CLI \u8F93\u51FA\u683C\u5F0F\u662F\u5426\u5305\u542B token \u63D0\u793A");
+    }
+    if (lastTestFailed || prFailed) {
+      throw new Error("\u6D41\u7A0B\u5B58\u5728\u672A\u89E3\u51B3\u7684\u95EE\u9898\uFF08\u6D4B\u8BD5\u672A\u901A\u8FC7\u6216 PR \u521B\u5EFA\u5931\u8D25\uFF09");
+    }
+    if (config.git.useWorktree && workDir !== repoRoot) {
+      await cleanupWorktreeIfSafe({
+        repoRoot,
+        workDir,
+        branchName,
+        prInfo,
+        worktreeCreated,
+        logger
+      });
+    }
+    logger.success(`wheel-ai \u8FED\u4EE3\u6D41\u7A0B\u7ED3\u675F\uFF5CToken \u603B\u8BA1 ${accumulatedUsage?.totalTokens ?? "\u672A\u77E5"}`);
+  } catch (error) {
+    runError = error instanceof Error ? error.message : String(error);
+    throw error;
+  } finally {
+    const stage = runError ? "\u4EFB\u52A1\u7ED3\u675F\uFF08\u5931\u8D25\uFF09" : "\u4EFB\u52A1\u7ED3\u675F";
+    await notifyWebhook("task_end", lastRound, stage);
+    await runTracker?.finalize();
+  }
+}
+
+// src/monitor.ts
+var import_fs_extra8 = __toESM(require("fs-extra"));
+var import_node_path9 = __toESM(require("path"));
+var REFRESH_INTERVAL = 1e3;
+function getTerminalSize2() {
+  const rows = process.stdout.rows ?? 24;
+  const columns = process.stdout.columns ?? 80;
+  return { rows, columns };
+}
+function truncateLine2(line, width) {
+  if (width <= 0) return "";
+  if (line.length <= width) return line;
+  return line.slice(0, width);
+}
+async function readLogLines2(logFile) {
+  try {
+    const content = await import_fs_extra8.default.readFile(logFile, "utf8");
+    const normalized = content.replace(/\r\n?/g, "\n");
+    const lines = normalized.split("\n");
+    return lines.length > 0 ? lines : [""];
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return [`\uFF08\u65E0\u6CD5\u8BFB\u53D6\u65E5\u5FD7\u6587\u4EF6\uFF1A${message}\uFF09`];
+  }
+}
+async function loadTasks(logsDir) {
+  const registry = await readCurrentRegistry();
+  const entries = Object.entries(registry).sort(([a], [b]) => a.localeCompare(b));
+  const tasks = await Promise.all(entries.map(async ([key, meta]) => {
+    const logFile = meta.logFile ?? import_node_path9.default.join(logsDir, key);
+    const lines = await readLogLines2(logFile);
+    return {
+      key,
+      logFile,
+      meta,
+      lines
+    };
+  }));
+  return tasks;
+}
+function buildHeader(state, columns) {
+  if (state.tasks.length === 0) {
+    return truncateLine2("\u6682\u65E0\u8FD0\u884C\u4E2D\u7684\u4EFB\u52A1\uFF0C\u6309 q \u9000\u51FA", columns);
+  }
+  const current = state.tasks[state.selectedIndex];
+  const total = state.tasks.length;
+  const index = state.selectedIndex + 1;
+  const title = `\u4EFB\u52A1 ${index}/${total} \uFF5C ${current.key} \uFF5C \u2190/\u2192 \u5207\u6362\u4EFB\u52A1  \u2191/\u2193 \u7FFB\u9875  q \u9000\u51FA`;
+  return truncateLine2(title, columns);
+}
+function buildStatus(task, page, columns, errorMessage) {
+  const meta = task.meta;
+  const status = `\u8F6E\u6B21 ${meta.round} \uFF5C Token ${meta.tokenUsed} \uFF5C \u9875 ${page.current}/${page.total} \uFF5C \u9879\u76EE ${meta.path}`;
+  const suffix = errorMessage ? ` \uFF5C \u5237\u65B0\u5931\u8D25\uFF1A${errorMessage}` : "";
+  return truncateLine2(`${status}${suffix}`, columns);
+}
+function getPageSize2(rows) {
+  return Math.max(1, rows - 2);
+}
+function render2(state) {
+  const { rows, columns } = getTerminalSize2();
+  const pageSize = getPageSize2(rows);
+  const header = buildHeader(state, columns);
+  if (state.tasks.length === 0) {
+    const filler = Array.from({ length: pageSize }, () => "");
+    const statusText = state.lastError ? `\u5237\u65B0\u5931\u8D25\uFF1A${state.lastError}` : "\u7B49\u5F85\u540E\u53F0\u4EFB\u52A1\u542F\u52A8\u2026";
+    const status2 = truncateLine2(statusText, columns);
+    const content2 = [header, ...filler, status2].join("\n");
+    process.stdout.write(`\x1B[2J\x1B[H${content2}`);
+    return;
+  }
+  const current = state.tasks[state.selectedIndex];
+  const lines = current.lines;
+  const maxOffset = Math.max(0, Math.ceil(lines.length / pageSize) - 1);
+  const offset = state.pageOffsets.get(current.key) ?? maxOffset;
+  const stick = state.stickToBottom.get(current.key) ?? true;
+  const nextOffset = Math.min(Math.max(stick ? maxOffset : offset, 0), maxOffset);
+  state.pageOffsets.set(current.key, nextOffset);
+  state.stickToBottom.set(current.key, nextOffset === maxOffset);
+  const start = nextOffset * pageSize;
+  const pageLines = lines.slice(start, start + pageSize).map((line) => truncateLine2(line, columns));
+  while (pageLines.length < pageSize) {
+    pageLines.push("");
+  }
+  const status = buildStatus(
+    current,
+    { current: nextOffset + 1, total: Math.max(1, maxOffset + 1) },
+    columns,
+    state.lastError
+  );
+  const content = [header, ...pageLines, status].join("\n");
+  process.stdout.write(`\x1B[2J\x1B[H${content}`);
+}
+function updateSelection(state, tasks) {
+  state.tasks = tasks;
+  if (tasks.length === 0) {
+    state.selectedIndex = 0;
+    state.selectedKey = void 0;
+    return;
+  }
+  if (state.selectedKey) {
+    const index = tasks.findIndex((task) => task.key === state.selectedKey);
+    if (index >= 0) {
+      state.selectedIndex = index;
+    } else {
+      state.selectedIndex = 0;
+    }
+  } else {
+    state.selectedIndex = 0;
+  }
+  state.selectedKey = tasks[state.selectedIndex]?.key;
+  const existing = new Set(tasks.map((task) => task.key));
+  for (const key of state.pageOffsets.keys()) {
+    if (!existing.has(key)) {
+      state.pageOffsets.delete(key);
+    }
+  }
+  for (const key of state.stickToBottom.keys()) {
+    if (!existing.has(key)) {
+      state.stickToBottom.delete(key);
+    }
+  }
+}
+function moveSelection(state, direction) {
+  if (state.tasks.length === 0) return;
+  const total = state.tasks.length;
+  state.selectedIndex = (state.selectedIndex + direction + total) % total;
+  state.selectedKey = state.tasks[state.selectedIndex]?.key;
+}
+function movePage(state, direction) {
+  if (state.tasks.length === 0) return;
+  const { rows } = getTerminalSize2();
+  const pageSize = getPageSize2(rows);
+  const current = state.tasks[state.selectedIndex];
+  const lines = current.lines;
+  const maxOffset = Math.max(0, Math.ceil(lines.length / pageSize) - 1);
+  const offset = state.pageOffsets.get(current.key) ?? maxOffset;
+  const nextOffset = Math.min(Math.max(offset + direction, 0), maxOffset);
+  state.pageOffsets.set(current.key, nextOffset);
+  state.stickToBottom.set(current.key, nextOffset === maxOffset);
+}
+function shouldExit2(input) {
+  if (input === "") return true;
+  if (input.toLowerCase() === "q") return true;
+  return false;
+}
+function handleInput(state, input) {
+  if (input.includes("\x1B[D")) {
+    moveSelection(state, -1);
+    return;
+  }
+  if (input.includes("\x1B[C")) {
+    moveSelection(state, 1);
+    return;
+  }
+  if (input.includes("\x1B[A")) {
+    movePage(state, -1);
+    return;
+  }
+  if (input.includes("\x1B[B")) {
+    movePage(state, 1);
+    return;
+  }
+}
+function setupCleanup2(cleanup) {
+  const exitHandler = () => {
+    cleanup();
+  };
+  const signalHandler = () => {
+    cleanup();
+    process.exit(0);
+  };
+  process.on("SIGINT", signalHandler);
+  process.on("SIGTERM", signalHandler);
+  process.on("exit", exitHandler);
+}
+async function runMonitor() {
+  if (!process.stdout.isTTY || !process.stdin.isTTY) {
+    console.log("\u5F53\u524D\u7EC8\u7AEF\u4E0D\u652F\u6301\u4EA4\u4E92\u5F0F monitor\u3002");
+    return;
+  }
+  const logsDir = getLogsDir();
+  const state = {
+    tasks: [],
+    selectedIndex: 0,
+    pageOffsets: /* @__PURE__ */ new Map(),
+    stickToBottom: /* @__PURE__ */ new Map()
+  };
+  let cleaned = false;
+  const cleanup = () => {
+    if (cleaned) return;
+    cleaned = true;
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+    }
+    process.stdout.write("\x1B[?25h");
+  };
+  setupCleanup2(cleanup);
+  process.stdout.write("\x1B[?25l");
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  let refreshing = false;
+  const refresh = async () => {
+    if (refreshing) return;
+    refreshing = true;
+    try {
+      const tasks = await loadTasks(logsDir);
+      state.lastError = void 0;
+      updateSelection(state, tasks);
+      render2(state);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      state.lastError = message;
+      render2(state);
+    } finally {
+      refreshing = false;
+    }
+  };
+  await refresh();
+  const timer = setInterval(refresh, REFRESH_INTERVAL);
+  process.stdin.on("data", (data) => {
+    const input = data.toString("utf8");
+    if (shouldExit2(input)) {
+      clearInterval(timer);
+      cleanup();
+      process.exit(0);
+    }
+    handleInput(state, input);
+    render2(state);
+  });
+  process.stdout.on("resize", () => {
+    render2(state);
+  });
+}
+
+// src/cli.ts
+function parseInteger(value, defaultValue) {
+  const parsed = Number.parseInt(value, 10);
+  if (Number.isNaN(parsed)) return defaultValue;
+  return parsed;
+}
+function collect(value, previous) {
+  return [...previous, value];
+}
+function normalizeOptional(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function hasOption(argv, option) {
+  return argv.some((arg) => arg === option || arg.startsWith(`${option}=`));
+}
+function buildBackgroundArgs(argv, logFile, branchName, injectBranch = false) {
+  const rawArgs = argv.slice(1);
+  const filtered = rawArgs.filter((arg) => !(arg === "--background" || arg.startsWith("--background=")));
+  if (!hasOption(filtered, "--log-file")) {
+    filtered.push("--log-file", logFile);
+  }
+  if (injectBranch && branchName && !hasOption(filtered, "--branch")) {
+    filtered.push("--branch", branchName);
+  }
+  return filtered;
+}
+async function runCli(argv) {
+  const globalConfig = await loadGlobalConfig(defaultLogger);
+  const effectiveArgv = applyShortcutArgv(argv, globalConfig);
+  const program = new import_commander.Command();
+  program.name("wheel-ai").description("\u57FA\u4E8E AI CLI \u7684\u6301\u7EED\u8FED\u4EE3\u5F00\u53D1\u5DE5\u5177").version("1.0.0");
+  program.command("run").requiredOption("-t, --task <task>", "\u9700\u8981\u5B8C\u6210\u7684\u4EFB\u52A1\u63CF\u8FF0\uFF08\u4F1A\u8FDB\u5165 AI \u63D0\u793A\uFF09").option("-i, --iterations <number>", "\u6700\u5927\u8FED\u4EE3\u6B21\u6570", (value) => parseInteger(value, 5), 5).option("--ai-cli <command>", "AI CLI \u547D\u4EE4", "claude").option("--ai-args <args...>", "AI CLI \u53C2\u6570", []).option("--ai-prompt-arg <flag>", "\u7528\u4E8E\u4F20\u5165 prompt \u7684\u53C2\u6570\uFF08\u4E3A\u7A7A\u5219\u4F7F\u7528 stdin\uFF09").option("--notes-file <path>", "\u6301\u4E45\u5316\u8BB0\u5FC6\u6587\u4EF6", defaultNotesPath()).option("--plan-file <path>", "\u8BA1\u5212\u6587\u4EF6", defaultPlanPath()).option("--workflow-doc <path>", "AI \u5DE5\u4F5C\u6D41\u7A0B\u8BF4\u660E\u6587\u4EF6", defaultWorkflowDoc()).option("--worktree", "\u5728\u72EC\u7ACB worktree \u4E0A\u6267\u884C", false).option("--branch <name>", "worktree \u5206\u652F\u540D\uFF08\u9ED8\u8BA4\u81EA\u52A8\u751F\u6210\u6216\u5F53\u524D\u5206\u652F\uFF09").option("--worktree-path <path>", "worktree \u8DEF\u5F84\uFF0C\u9ED8\u8BA4 ../worktrees/<branch>").option("--base-branch <name>", "\u521B\u5EFA\u5206\u652F\u7684\u57FA\u7EBF\u5206\u652F", "main").option("--skip-install", "\u8DF3\u8FC7\u5F00\u59CB\u4EFB\u52A1\u524D\u7684\u4F9D\u8D56\u68C0\u67E5", false).option("--run-tests", "\u8FD0\u884C\u5355\u5143\u6D4B\u8BD5\u547D\u4EE4", false).option("--run-e2e", "\u8FD0\u884C e2e \u6D4B\u8BD5\u547D\u4EE4", false).option("--unit-command <cmd>", "\u5355\u5143\u6D4B\u8BD5\u547D\u4EE4", "yarn test").option("--e2e-command <cmd>", "e2e \u6D4B\u8BD5\u547D\u4EE4", "yarn e2e").option("--auto-commit", "\u81EA\u52A8 git commit", false).option("--auto-push", "\u81EA\u52A8 git push", false).option("--pr", "\u4F7F\u7528 gh \u521B\u5EFA PR", false).option("--pr-title <title>", "PR \u6807\u9898").option("--pr-body <path>", "PR \u63CF\u8FF0\u6587\u4EF6\u8DEF\u5F84\uFF08\u53EF\u7559\u7A7A\u81EA\u52A8\u751F\u6210\uFF09").option("--draft", "\u4EE5\u8349\u7A3F\u5F62\u5F0F\u521B\u5EFA PR", false).option("--reviewer <user...>", "PR reviewers", collect, []).option("--webhook <url>", "webhook \u901A\u77E5 URL\uFF08\u53EF\u91CD\u590D\uFF09", collect, []).option("--webhook-timeout <ms>", "webhook \u8BF7\u6C42\u8D85\u65F6\uFF08\u6BEB\u79D2\uFF09", (value) => parseInteger(value, 8e3)).option("--stop-signal <token>", "AI \u8F93\u51FA\u4E2D\u7684\u505C\u6B62\u6807\u8BB0", "<<DONE>>").option("--log-file <path>", "\u65E5\u5FD7\u8F93\u51FA\u6587\u4EF6\u8DEF\u5F84").option("--background", "\u5207\u5165\u540E\u53F0\u8FD0\u884C", false).option("-v, --verbose", "\u8F93\u51FA\u8C03\u8BD5\u65E5\u5FD7", false).action(async (options) => {
+    const useWorktree = Boolean(options.worktree);
+    const branchInput = normalizeOptional(options.branch);
+    const logFileInput = normalizeOptional(options.logFile);
+    const background = Boolean(options.background);
+    let branchName = branchInput;
+    if (useWorktree && !branchName) {
+      branchName = generateBranchName();
+    }
+    let logFile = logFileInput;
+    if (background && !logFile) {
+      let branchForLog = branchName;
+      if (!branchForLog) {
+        try {
+          const current = await getCurrentBranch(process.cwd(), defaultLogger);
+          branchForLog = current || "detached";
+        } catch {
+          branchForLog = "unknown";
+        }
+      }
+      logFile = buildAutoLogFilePath(branchForLog);
+    }
+    if (background) {
+      if (!logFile) {
+        throw new Error("\u540E\u53F0\u8FD0\u884C\u9700\u8981\u6307\u5B9A\u65E5\u5FD7\u6587\u4EF6");
+      }
+      const args = buildBackgroundArgs(effectiveArgv, logFile, branchName, useWorktree && !branchInput);
+      const child = (0, import_node_child_process.spawn)(process.execPath, [...process.execArgv, ...args], {
+        detached: true,
+        stdio: "ignore"
+      });
+      child.unref();
+      const displayLogFile = resolvePath(process.cwd(), logFile);
+      console.log(`\u5DF2\u5207\u5165\u540E\u53F0\u8FD0\u884C\uFF0C\u65E5\u5FD7\u8F93\u51FA\u81F3 ${displayLogFile}`);
+      return;
+    }
+    const cliOptions = {
+      task: options.task,
+      iterations: options.iterations,
+      aiCli: options.aiCli,
+      aiArgs: options.aiArgs ?? [],
+      aiPromptArg: options.aiPromptArg,
+      notesFile: options.notesFile,
+      planFile: options.planFile,
+      workflowDoc: options.workflowDoc,
+      useWorktree,
+      branch: branchName,
+      worktreePath: options.worktreePath,
+      baseBranch: options.baseBranch,
+      runTests: Boolean(options.runTests),
+      runE2e: Boolean(options.runE2e),
+      unitCommand: options.unitCommand,
+      e2eCommand: options.e2eCommand,
+      autoCommit: Boolean(options.autoCommit),
+      autoPush: Boolean(options.autoPush),
+      pr: Boolean(options.pr),
+      prTitle: options.prTitle,
+      prBody: options.prBody,
+      draft: Boolean(options.draft),
+      reviewers: options.reviewer ?? [],
+      webhookUrls: options.webhook ?? [],
+      webhookTimeout: options.webhookTimeout,
+      stopSignal: options.stopSignal,
+      logFile,
+      verbose: Boolean(options.verbose),
+      skipInstall: Boolean(options.skipInstall)
+    };
+    const config = buildLoopConfig(cliOptions, process.cwd());
+    await runLoop(config);
+  });
+  program.command("monitor").description("\u67E5\u770B\u540E\u53F0\u8FD0\u884C\u65E5\u5FD7").action(async () => {
+    await runMonitor();
+  });
+  program.command("logs").description("\u67E5\u770B\u5386\u53F2\u65E5\u5FD7").action(async () => {
+    await runLogsViewer();
+  });
+  await program.parseAsync(effectiveArgv);
+}
+if (require.main === module) {
+  runCli(process.argv).catch((error) => {
+    const message = error instanceof Error ? error.stack ?? error.message : String(error);
+    defaultLogger.error(message);
+    process.exitCode = 1;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runCli
+});
+//# sourceMappingURL=cli.js.map