@linghun/tui 0.1.0

package/dist/chunk-WQMSRO4D.js

@@ -0,0 +1,489 @@
+import {
+  rememberBackgroundTask
+} from "./chunk-ZZ2CNCXJ.js";
+import {
+  createProcessGuard
+} from "./chunk-JHGWGH2C.js";
+import {
+  formatBackgroundTask
+} from "./chunk-UDQT5CWK.js";
+import {
+  LINGHUN_VERIFICATION_COMMAND_TIMEOUT_MS
+} from "./chunk-IWUIOLMF.js";
+import {
+  isRecord
+} from "./chunk-QLRTQHTR.js";
+import {
+  truncateDisplay,
+  writeLine
+} from "./chunk-OMZYPQVA.js";
+
+// src/verification-command-runtime.ts
+import { spawn } from "child_process";
+import { randomUUID } from "crypto";
+import { mkdir, readFile, stat, writeFile } from "fs/promises";
+import { join } from "path";
+import { resolveStoragePaths } from "@linghun/config";
+async function createVerificationPlan(projectPath, mode) {
+  if (mode === "smoke") {
+    return [
+      {
+        kind: "smoke",
+        command: `node -e "console.log('linghun verify smoke')"`,
+        reason: "\u6700\u5C0F\u5408\u6210 smoke\uFF1A\u4EC5\u786E\u8BA4 Verification Runner \u53EF\u6267\u884C\u547D\u4EE4\u5E76\u5F52\u6863 evidence\uFF1B\u4E0D\u662F\u771F\u5B9E provider/TUI/render/report \u4E3B\u94FE smoke\u3002",
+        synthetic: true
+      }
+    ];
+  }
+  const packageJson = await safeReadJson(join(projectPath, "package.json"));
+  const scripts = isRecord(packageJson?.scripts) ? packageJson.scripts : {};
+  const packageManager = await detectPackageManager(projectPath);
+  if (mode === "real-smoke") {
+    return createRealSmokePlan(scripts, packageManager);
+  }
+  const steps = [];
+  addPackageStep(
+    steps,
+    scripts,
+    "typecheck",
+    "typecheck",
+    "TypeScript \u7C7B\u578B\u68C0\u67E5\u3002 ",
+    packageManager
+  );
+  addPackageStep(steps, scripts, "test", "test", "\u9879\u76EE\u6D4B\u8BD5\u5957\u4EF6\u3002 ", packageManager);
+  addPackageStep(steps, scripts, "lint", "lint", "lint \u9759\u6001\u68C0\u67E5\u3002 ", packageManager);
+  addPackageStep(steps, scripts, "build", "build", "\u6784\u5EFA\u9A8C\u8BC1\u3002 ", packageManager);
+  addPackageStep(steps, scripts, "smoke", "smoke", "\u9879\u76EE\u81EA\u5B9A\u4E49 smoke \u9A8C\u8BC1\u3002 ", packageManager);
+  if (steps.length > 0) {
+    if (mode === "focused") {
+      const focused = steps.filter(
+        (step) => step.kind === "typecheck" || step.kind === "test" || step.kind === "lint"
+      );
+      return focused.length > 0 ? focused : steps.slice(0, 1);
+    }
+    return steps;
+  }
+  if (mode === "focused") {
+    return [
+      {
+        kind: "smoke",
+        command: "node --version",
+        reason: "\u672A\u53D1\u73B0\u9879\u76EE focused \u9A8C\u8BC1\u811A\u672C\uFF0C\u964D\u7EA7\u4E3A Node \u8FD0\u884C\u73AF\u5883 self-check\uFF1B\u8FD9\u662F synthetic\uFF0C\u4E0D\u80FD\u5F53\u4F5C real-smoke\u3002",
+        synthetic: true
+      }
+    ];
+  }
+  return [
+    {
+      kind: "smoke",
+      command: "node --version",
+      reason: "\u672A\u53D1\u73B0\u9879\u76EE\u9A8C\u8BC1\u811A\u672C\uFF0C\u964D\u7EA7\u4E3A Node \u8FD0\u884C\u73AF\u5883 smoke \u68C0\u67E5\u3002",
+      synthetic: true
+    }
+  ];
+}
+function createVerificationUnavailableReport(kind, reason) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: randomUUID(),
+    status: "partial",
+    summary: `PARTIAL\uFF1A${kind} \u672A\u8FD0\u884C\uFF0C\u672A\u751F\u6210 PASS \u8BC1\u636E\u3002`,
+    commands: [],
+    unverified: [`${kind}: ${reason}`],
+    risk: [`${kind} \u7F3A\u5C11\u53EF\u6267\u884C\u5165\u53E3\uFF1B\u4E0D\u5F97\u58F0\u79F0\u9A8C\u8BC1\u901A\u8FC7\u3002`],
+    startedAt: now,
+    endedAt: now,
+    durationMs: 0,
+    nextAction: kind === "real-smoke" ? "\u5728 package.json \u589E\u52A0\u771F\u5B9E smoke \u811A\u672C\u540E\u8FD0\u884C /verify real-smoke\uFF0C\u6216\u660E\u786E\u964D\u7EA7\u4E3A synthetic self-check\u3002" : "\u8865\u5145\u9879\u76EE\u9A8C\u8BC1\u811A\u672C\uFF0C\u6216\u8FD0\u884C /verify smoke \u53EA\u505A runner self-check\u3002"
+  };
+}
+function addPackageStep(steps, scripts, scriptName, kind, reason, packageManager = "pnpm") {
+  if (typeof scripts[scriptName] !== "string") {
+    return;
+  }
+  steps.push({ kind, command: formatPackageManagerCommand(packageManager, scriptName), reason });
+}
+function createRealSmokePlan(scripts, packageManager) {
+  if (typeof scripts.smoke === "string") {
+    return [
+      {
+        kind: "smoke",
+        command: formatPackageManagerCommand(packageManager, "smoke"),
+        reason: "\u9879\u76EE\u81EA\u5B9A\u4E49 real-smoke\uFF1A\u4F7F\u7528 package.json smoke \u811A\u672C\uFF1B\u975E synthetic\uFF0C\u53EF\u4F5C\u4E3A\u771F\u5B9E smoke \u5019\u9009\u8BC1\u636E\u3002",
+        synthetic: false
+      }
+    ];
+  }
+  const candidates = [
+    {
+      scriptName: "smoke:tui-stdin",
+      reason: "\u9879\u76EE TUI stdin real-smoke\uFF1A\u8986\u76D6\u771F\u5B9E CLI/TUI \u8F93\u5165\u4E3B\u94FE\uFF1B\u975E synthetic\uFF0C\u53EF\u4F5C\u4E3A\u771F\u5B9E smoke \u5019\u9009\u8BC1\u636E\u3002"
+    },
+    {
+      scriptName: "smoke:live-provider",
+      reason: "\u9879\u76EE live-provider real-smoke\uFF1A\u8986\u76D6\u771F\u5B9E provider \u8BF7\u6C42\u4E3B\u94FE\uFF1B\u975E synthetic\uFF0C\u53EF\u4F5C\u4E3A\u771F\u5B9E provider smoke \u5019\u9009\u8BC1\u636E\u3002"
+    }
+  ];
+  return candidates.filter((candidate) => typeof scripts[candidate.scriptName] === "string").map((candidate) => ({
+    kind: "smoke",
+    command: formatPackageManagerCommand(packageManager, candidate.scriptName),
+    reason: candidate.reason,
+    synthetic: false
+  }));
+}
+async function detectPackageManager(projectPath) {
+  if (await fileExists(join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
+  if (await fileExists(join(projectPath, "package-lock.json"))) return "npm";
+  if (await fileExists(join(projectPath, "yarn.lock"))) return "yarn";
+  if (await fileExists(join(projectPath, "bun.lockb")) || await fileExists(join(projectPath, "bun.lock"))) {
+    return "bun";
+  }
+  return "pnpm";
+}
+function formatPackageManagerCommand(packageManager, scriptName) {
+  if (packageManager === "npm") return `npm run ${scriptName}`;
+  if (packageManager === "yarn") return `corepack yarn ${scriptName}`;
+  if (packageManager === "bun") return `bun run ${scriptName}`;
+  return `corepack pnpm ${scriptName}`;
+}
+async function fileExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runVerificationPlan(plan, context, sessionId, output, appendBackgroundTaskEvent) {
+  const runId = randomUUID();
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const logRoot = join(
+    resolveStoragePaths(context.config, context.projectPath).logs,
+    "verification"
+  );
+  await mkdir(logRoot, { recursive: true });
+  const controller = new AbortController();
+  context.activeVerificationAbortController = controller;
+  context.interrupt = { type: "running", taskId: runId, canCancel: true };
+  const task = {
+    id: runId,
+    kind: "verification",
+    title: "Verification Runner",
+    status: "running",
+    currentStep: "preparing verification",
+    progress: { completed: 0, total: plan.length, label: "verify" },
+    startedAt,
+    updatedAt: startedAt,
+    heartbeatIntervalMs: 3e4,
+    staleAfterMs: 12e4,
+    logPath: logRoot,
+    hasOutput: false,
+    userVisibleSummary: `\u9A8C\u8BC1\u5DF2\u542F\u52A8\uFF1A${plan.length} \u4E2A\u6B65\u9AA4\u3002\u53EF\u7528 /background \u67E5\u770B\u8BE6\u60C5\u3002`,
+    nextAction: "\u7B49\u5F85 PASS / FAIL / PARTIAL \u7ED3\u679C\uFF0C\u5931\u8D25\u540E\u6309\u5EFA\u8BAE\u4FEE\u590D\u5E76\u590D\u8DD1 /verify\u3002"
+  };
+  rememberBackgroundTask(context, task);
+  await context.store.appendEvent(sessionId, {
+    type: "verification_start",
+    run: { id: runId, plan, startedAt },
+    createdAt: startedAt
+  });
+  await appendBackgroundTaskEvent(context, sessionId, task);
+  writeLine(output, formatBackgroundTask(task, context.language));
+  const results = [];
+  const unverified = [];
+  const risk = [];
+  try {
+    for (const [index, step] of plan.entries()) {
+      const stepStarted = Date.now();
+      task.currentStep = `${step.kind} ${index + 1}/${plan.length}`;
+      task.progress = { completed: index, total: plan.length, label: step.kind };
+      task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await appendBackgroundTaskEvent(context, sessionId, task);
+      writeLine(output, `\u9A8C\u8BC1\u6B65\u9AA4\uFF1A${task.currentStep} \xB7 ${step.command}`);
+      const logPath = join(logRoot, `${runId}-${index + 1}-${step.kind}.log`);
+      const result = await runVerificationCommand(
+        step.command,
+        context.projectPath,
+        controller.signal
+      );
+      const durationMs = Date.now() - stepStarted;
+      const runnerErrorLine = result.runnerError ? `runner error ${result.runnerError}
+` : "";
+      const fullLog = `$ ${step.command}
+exit code ${result.exitCode}
+outcome ${result.outcome}
+${runnerErrorLine}duration ${durationMs}ms
+
+${result.output}`;
+      await writeFile(logPath, fullLog, "utf8");
+      const summary = summarizeVerificationOutput(
+        result.output,
+        result.exitCode,
+        result.runnerError
+      );
+      const wasMarkedStale = task.status === "stale";
+      const commandStatus = result.outcome === "cancelled" ? "cancelled" : result.outcome === "timeout" ? "timeout" : wasMarkedStale ? "stale" : result.runnerError ? "partial" : result.exitCode === 0 ? "pass" : "fail";
+      if (commandStatus === "fail") {
+        risk.push(`${step.kind} \u5931\u8D25\uFF1A${summary}`);
+      }
+      if (commandStatus === "partial") {
+        unverified.push(`${step.kind} runner error\uFF1A${summary}`);
+        risk.push(`${step.kind} runner/toolchain \u517C\u5BB9\u98CE\u9669\uFF1A${summary}`);
+      }
+      if (commandStatus === "cancelled" || commandStatus === "timeout") {
+        unverified.push(`${step.kind} ${commandStatus}\uFF1A${summary}`);
+        risk.push(`${step.kind} \u672A\u5B8C\u6210\uFF1A${commandStatus}\uFF1B\u4E0D\u5F97\u751F\u6210 PASS \u8BC1\u636E\u3002`);
+      }
+      if (commandStatus === "stale") {
+        unverified.push(`${step.kind} stale\uFF1A${summary}`);
+        risk.push(`${step.kind} \u66FE\u88AB\u6807\u8BB0\u4E3A stale\uFF1B\u5373\u4F7F\u547D\u4EE4\u968F\u540E\u7ED3\u675F\uFF0C\u4E5F\u4E0D\u5F97\u751F\u6210 PASS \u8BC1\u636E\u3002`);
+      }
+      results.push({
+        ...step,
+        status: commandStatus,
+        exitCode: result.exitCode,
+        durationMs,
+        logPath,
+        summary,
+        runnerError: result.runnerError
+      });
+      task.lastOutputAt = (/* @__PURE__ */ new Date()).toISOString();
+      task.hasOutput = Boolean(result.output.trim());
+      if (commandStatus === "cancelled" || commandStatus === "timeout" || commandStatus === "stale") {
+        break;
+      }
+    }
+    const endedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const failed = results.filter((item) => item.status === "fail");
+    const partial = results.filter((item) => item.status === "partial");
+    const cancelled = results.filter((item) => item.status === "cancelled");
+    const timedOut = results.filter((item) => item.status === "timeout");
+    const stale = results.filter((item) => item.status === "stale");
+    const hasRunnerError = partial.some((item) => item.runnerError);
+    const status = cancelled.length > 0 ? "cancelled" : timedOut.length > 0 ? "timeout" : stale.length > 0 ? "stale" : failed.length > 0 ? "fail" : partial.length > 0 || unverified.length > 0 ? "partial" : "pass";
+    const syntheticOnlyPass = status === "pass" && results.every((item) => item.synthetic === true || item.status !== "pass");
+    const report = {
+      id: runId,
+      status,
+      summary: status === "pass" ? syntheticOnlyPass ? "SELF-CHECK\uFF1Asynthetic self-check \u5DF2\u901A\u8FC7\uFF1B\u771F\u5B9E\u9A8C\u8BC1\u672A\u8FD0\u884C\uFF0C\u4E0D\u80FD\u4F5C\u4E3A\u771F\u5B9E PASS \u8BC1\u636E\u3002" : `PASS\uFF1A${results.length} \u4E2A\u9A8C\u8BC1\u6B65\u9AA4\u901A\u8FC7\u3002` : status === "fail" ? `FAIL\uFF1A${failed.length}/${results.length} \u4E2A\u9A8C\u8BC1\u6B65\u9AA4\u5931\u8D25\u3002` : status === "cancelled" ? "CANCELLED\uFF1A\u9A8C\u8BC1\u5DF2\u53D6\u6D88\uFF0C\u672A\u751F\u6210 PASS \u8BC1\u636E\u3002" : status === "timeout" ? "TIMEOUT\uFF1A\u9A8C\u8BC1\u8D85\u65F6\uFF0C\u672A\u751F\u6210 PASS \u8BC1\u636E\u3002" : status === "stale" ? "STALE\uFF1A\u9A8C\u8BC1\u4EFB\u52A1\u7591\u4F3C\u5361\u4F4F\uFF0C\u672A\u751F\u6210 PASS \u8BC1\u636E\u3002" : hasRunnerError ? "PARTIAL\uFF1A\u9A8C\u8BC1\u547D\u4EE4\u5DF2\u8FD0\u884C\uFF0C\u4F46 runner/toolchain \u9000\u51FA\u6E05\u7406\u5F02\u5E38\u3002" : `PARTIAL\uFF1A${unverified.length} \u9879\u672A\u9A8C\u8BC1\u3002`,
+      commands: results,
+      unverified,
+      risk,
+      logPath: logRoot,
+      startedAt,
+      endedAt,
+      durationMs: Date.parse(endedAt) - Date.parse(startedAt),
+      nextAction: status === "pass" ? "\u53EF\u7EE7\u7EED\u5BA1\u67E5\u7ED3\u679C\u6216\u8FDB\u5165\u4EA4\u4ED8\u603B\u7ED3\u3002" : hasRunnerError ? "\u67E5\u770B runner error \u65E5\u5FD7\uFF0C\u8BB0\u5F55 Node \u7248\u672C\uFF0C\u5E76\u5EFA\u8BAE\u7528 Node 22 LTS \u590D\u6838\u3002" : "\u5148\u67E5\u770B\u5931\u8D25\u547D\u4EE4\u4E0E\u65E5\u5FD7\uFF0C\u4FEE\u590D\u540E\u590D\u8DD1 /verify\u3002"
+    };
+    task.status = status === "fail" ? "failed" : status === "cancelled" || status === "timeout" || status === "stale" ? status : "completed";
+    task.result = status;
+    task.currentStep = status === "pass" ? "verification finished" : `verification ${status}`;
+    task.progress = { completed: results.length, total: plan.length, label: "verify" };
+    task.updatedAt = endedAt;
+    task.nextAction = report.nextAction;
+    task.userVisibleSummary = report.summary;
+    await appendBackgroundTaskEvent(context, sessionId, task);
+    await context.store.appendEvent(sessionId, {
+      type: "verification_end",
+      report,
+      createdAt: endedAt
+    });
+    return report;
+  } finally {
+    if (context.activeVerificationAbortController === controller) {
+      context.activeVerificationAbortController = void 0;
+    }
+    context.interrupt = { type: "idle" };
+  }
+}
+async function runVerificationCommand(command, cwd, signal, timeoutMs = LINGHUN_VERIFICATION_COMMAND_TIMEOUT_MS) {
+  return new Promise((resolveCommand) => {
+    const detached = process.platform !== "win32";
+    const child = spawn(command, { cwd, shell: true, detached, windowsHide: true });
+    const guard = createProcessGuard();
+    guard.track(child, { detached, label: "verification" });
+    let output = "";
+    let settled = false;
+    let forceTimer;
+    const scheduleForceStop = () => {
+      forceTimer = setTimeout(() => guard.requestStop(true), 1e3);
+    };
+    const settle = (result) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timeout);
+      if (forceTimer && result.outcome === void 0) {
+        clearTimeout(forceTimer);
+      }
+      signal?.removeEventListener("abort", onAbort);
+      resolveCommand({ ...result, outcome: result.outcome ?? "completed" });
+    };
+    const onAbort = () => {
+      const runnerError = "runner cancelled by interrupt";
+      output = output ? `${output}
+${runnerError}` : runnerError;
+      guard.requestStop(false);
+      scheduleForceStop();
+      settle({ exitCode: 1, output, outcome: "cancelled", runnerError });
+    };
+    const timeout = setTimeout(() => {
+      const runnerError = `runner timeout after ${timeoutMs}ms`;
+      output = output ? `${output}
+${runnerError}` : runnerError;
+      guard.requestStop(false);
+      scheduleForceStop();
+      settle({ exitCode: 1, output, outcome: "timeout", runnerError });
+    }, timeoutMs);
+    if (signal?.aborted) {
+      onAbort();
+      return;
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+    child.stdout.on("data", (chunk) => {
+      output += chunk.toString("utf8");
+    });
+    child.stderr.on("data", (chunk) => {
+      output += chunk.toString("utf8");
+    });
+    child.on("error", (error) => {
+      const runnerError = `runner error: ${error.message}`;
+      settle({
+        exitCode: 1,
+        output: output ? `${output}
+${runnerError}` : runnerError,
+        runnerError
+      });
+    });
+    child.on("close", (code, childSignal) => {
+      const exitCode = code ?? 1;
+      const runnerError = detectRunnerCompatibilityError(output, exitCode, childSignal);
+      settle({ exitCode, output, runnerError });
+    });
+  });
+}
+function detectRunnerCompatibilityError(output, exitCode, signal) {
+  if (signal) {
+    return `runner stopped by signal ${signal}`;
+  }
+  if (exitCode === 0) {
+    return void 0;
+  }
+  const ansiPattern = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+  const normalized = output.replace(ansiPattern, "");
+  const vitestPassed = /Test Files\s+\d+\s+passed/i.test(normalized) && /Tests\s+\d+\s+passed/i.test(normalized);
+  const nodeCleanupError = normalized.includes("TypeError: emitter.removeListener is not a function") || normalized.includes("emitter.removeListener is not a function");
+  if (vitestPassed && nodeCleanupError) {
+    return "runner/toolchain cleanup error after tests passed; verify again with Node 22 LTS";
+  }
+  const childSignal = normalized.match(/\bSIG(?:TERM|KILL|INT|HUP|ABRT)\b/);
+  if (childSignal) {
+    return `runner/child stopped by signal ${childSignal[0]}`;
+  }
+  return void 0;
+}
+function createReviewReport(context) {
+  const changedFiles = context.tools.changedFiles.length > 0 ? context.tools.changedFiles : ["\u672A\u8BB0\u5F55\u6539\u52A8"];
+  const verification = context.lastVerification;
+  const conservativeStatuses = [
+    "fail",
+    "partial",
+    "cancelled",
+    "timeout",
+    "stale"
+  ];
+  const conservative = verification ? conservativeStatuses.includes(verification.status) : true;
+  const priority = verification?.status === "fail" || verification?.status === "timeout" || verification?.status === "stale" ? "P0" : conservative ? "P1" : "P2";
+  const risk = verification ? verification.risk.length > 0 ? verification.risk.join("; ") : `\u6700\u8FD1\u9A8C\u8BC1\u4E3A ${verification.status.toUpperCase()}` : "\u5C1A\u672A\u8FD0\u884C /verify\uFF0C\u4E0D\u80FD\u58F0\u79F0 PASS \u6216\u5DF2\u9A8C\u8BC1\u3002";
+  const suggestion = verification?.status === "fail" ? "\u5148\u6309\u5931\u8D25\u547D\u4EE4\u65E5\u5FD7\u4FEE\u590D\uFF0C\u518D\u590D\u8DD1 /verify\u3002" : verification?.status === "partial" ? "\u5148\u67E5\u770B runner error \u65E5\u5FD7\uFF1B\u5982\u4E3A Node/\u5DE5\u5177\u94FE\u9000\u51FA\u6E05\u7406\u5F02\u5E38\uFF0C\u5EFA\u8BAE\u7528 Node 22 LTS \u590D\u6838\u3002" : verification?.status === "cancelled" ? "\u9A8C\u8BC1\u5DF2\u53D6\u6D88\uFF1B\u5148\u786E\u8BA4\u53D6\u6D88\u539F\u56E0\uFF0C\u518D\u590D\u8DD1 /verify\uFF0C\u5F53\u524D\u4E0D\u5F97\u7ED9 PASS verdict\u3002" : verification?.status === "timeout" ? "\u9A8C\u8BC1\u8D85\u65F6\uFF1B\u5148\u67E5\u770B\u65E5\u5FD7\u548C\u8FDB\u7A0B\u6E05\u7406\u60C5\u51B5\uFF0C\u7F29\u5C0F\u547D\u4EE4\u6216\u4FEE\u590D\u5361\u4F4F\u70B9\u540E\u590D\u8DD1\u3002" : verification?.status === "stale" ? "\u9A8C\u8BC1\u4EFB\u52A1\u7591\u4F3C\u5361\u4F4F\uFF1B\u5148\u67E5\u770B /background \u548C\u65E5\u5FD7\uFF0C\u5FC5\u8981\u65F6 /interrupt \u540E\u590D\u8DD1\u3002" : verification ? "\u7ED3\u5408 diff \u4EBA\u5DE5\u786E\u8BA4\u9700\u6C42\u8986\u76D6\uFF1B\u5982\u6709\u65B0\u6539\u52A8\u8BF7\u590D\u8DD1 /verify\u3002" : "\u5148\u8FD0\u884C /verify \u6216 /verify plan\uFF0C\u5F62\u6210 test_result evidence\u3002";
+  return [
+    "Review Report",
+    `- Priority: ${priority}`,
+    `- Files: ${changedFiles.join(", ")}`,
+    `- Risk: ${risk}`,
+    `- Verdict: ${verification?.status === "pass" ? "SCOPED_PASS_WITH_EVIDENCE" : "CONSERVATIVE_NO_PASS"}`,
+    `- Suggestion: ${suggestion}`
+  ].join("\n");
+}
+function formatVerificationPlan(plan, language) {
+  const header = language === "en-US" ? "Verification plan:" : "\u9A8C\u8BC1\u8BA1\u5212\uFF1A";
+  return [
+    header,
+    ...plan.map((step, index) => `${index + 1}. [${step.kind}] ${step.command} \u2014 ${step.reason}`)
+  ].join("\n");
+}
+function formatVerificationReport(report, language) {
+  return formatVerificationReportLines(report, language, true).join("\n");
+}
+function formatVerificationTaskSummary(report, language) {
+  return formatVerificationReportLines(report, language, false).join("\n");
+}
+function formatVerificationReportLines(report, language, includeCommandDetails) {
+  const statusLabel = report.status.toUpperCase();
+  const statusAlreadyShown = new RegExp(`^${statusLabel}(?:\\s|:|\uFF1A)`, "u").test(report.summary);
+  const summary = statusAlreadyShown ? report.summary : `${statusLabel} ${report.summary}`;
+  const syntheticOnlyPass = report.status === "pass" && report.commands.length > 0 && report.commands.every((command) => command.synthetic === true || command.status !== "pass");
+  const lines = [
+    summary,
+    language === "en-US" ? `Duration: ${report.durationMs}ms` : `\u8017\u65F6\uFF1A${report.durationMs}ms`
+  ];
+  if (syntheticOnlyPass) {
+    lines.push(
+      language === "en-US" ? "Real verification did not run; this is not enough evidence for a real PASS." : "\u771F\u5B9E\u9A8C\u8BC1\u672A\u8FD0\u884C\uFF1B\u8FD9\u4E0D\u8DB3\u4EE5\u8BC1\u660E\u771F\u5B9E PASS\u3002"
+    );
+  }
+  if (includeCommandDetails) {
+    for (const command of report.commands) {
+      lines.push(
+        `- [${command.status.toUpperCase()}] ${command.command} (${command.durationMs}ms) log: ${command.logPath ?? "\u65E0\u65E5\u5FD7"}`
+      );
+      if (command.status !== "pass") {
+        lines.push(`  \u6458\u8981\uFF1A${command.summary}`);
+      }
+    }
+  }
+  if (includeCommandDetails && report.unverified.length > 0) {
+    lines.push(`\u672A\u9A8C\u8BC1\uFF1A${report.unverified.join("; ")}`);
+  }
+  lines.push(`\u4E0B\u4E00\u6B65\uFF1A${report.nextAction}`);
+  if (!includeCommandDetails) {
+    lines.push(language === "en-US" ? "Details: /verify last" : "\u8BE6\u60C5\uFF1A/verify last");
+  }
+  return lines;
+}
+function formatVerificationLast(report, language) {
+  if (!report) {
+    return language === "en-US" ? "No verification has run yet." : "\u8FD8\u6CA1\u6709\u6700\u8FD1\u9A8C\u8BC1\u7ED3\u679C\u3002";
+  }
+  return formatVerificationReport(report, language);
+}
+function summarizeVerificationOutput(output, exitCode, runnerError) {
+  const lines = output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const tail = lines.slice(-6).join(" | ");
+  const summary = tail ? truncateDisplay(tail, 240) : "\u65E0\u8F93\u51FA";
+  return runnerError ? `exit code ${exitCode}; runner error ${runnerError}; ${summary}` : `exit code ${exitCode}; ${summary}`;
+}
+async function safeReadJson(path) {
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+export {
+  createVerificationPlan,
+  createVerificationUnavailableReport,
+  addPackageStep,
+  runVerificationPlan,
+  runVerificationCommand,
+  detectRunnerCompatibilityError,
+  createReviewReport,
+  formatVerificationPlan,
+  formatVerificationReport,
+  formatVerificationTaskSummary,
+  formatVerificationLast,
+  summarizeVerificationOutput,
+  safeReadJson
+};

package/dist/chunk-WV6YJGZR.js

@@ -0,0 +1,81 @@
+// src/context-estimator.ts
+import { extname } from "path";
+var DEFAULT_BYTES_PER_TOKEN = 4;
+var FILE_TYPE_BYTES_PER_TOKEN = {
+  ".json": 2,
+  ".jsonl": 2
+};
+function bytesPerTokenForFileType(fileExt) {
+  const normalized = normalizeFileExt(fileExt);
+  return FILE_TYPE_BYTES_PER_TOKEN[normalized] ?? DEFAULT_BYTES_PER_TOKEN;
+}
+function estimateTokensFromBytesForFileType(bytes, fileExt) {
+  const safeBytes = Number.isFinite(bytes) ? Math.max(0, bytes) : 0;
+  return Math.max(1, Math.ceil(safeBytes / bytesPerTokenForFileType(fileExt)));
+}
+function estimateFileTokens(filePath, bytes) {
+  return estimateTokensFromBytesForFileType(bytes, extname(filePath));
+}
+function normalizeFileExt(fileExt) {
+  const trimmed = (fileExt ?? "").trim().toLowerCase();
+  if (!trimmed) return "";
+  return trimmed.startsWith(".") ? trimmed : `.${trimmed}`;
+}
+function estimateValueChars(value, depth = 0) {
+  if (value === null || value === void 0) return 4;
+  if (typeof value === "string") return value.length + 2;
+  if (typeof value === "number" || typeof value === "boolean") return String(value).length;
+  if (depth > 8) return 16;
+  if (Array.isArray(value)) {
+    let size = 2;
+    for (const item of value) {
+      size += estimateValueChars(item, depth + 1) + 1;
+    }
+    return size;
+  }
+  if (typeof value === "object") {
+    let size = 2;
+    for (const key of Object.keys(value)) {
+      size += key.length + 3;
+      size += estimateValueChars(value[key], depth + 1) + 1;
+    }
+    return size;
+  }
+  return 8;
+}
+function estimateToolCallsCharsLocal(toolCalls) {
+  if (!toolCalls || toolCalls.length === 0) return 2;
+  let size = 2;
+  for (const call of toolCalls) {
+    size += call.id.length + call.name.length + 28;
+    size += estimateValueChars(call.input);
+  }
+  return size;
+}
+function estimateModelMessageChars(messages) {
+  return messages.reduce((total, message) => {
+    if (message.role === "assistant") {
+      return total + message.content.length + estimateToolCallsCharsLocal(message.toolCalls);
+    }
+    return total + message.content.length;
+  }, 0);
+}
+function estimateTranscriptContextChars(transcript) {
+  return transcript.reduce((total, event) => {
+    if (event.type === "user_message") return total + event.text.length;
+    if (event.type === "assistant_text_delta") return total + event.text.length;
+    if (event.type === "tool_call_start") return total + estimateValueChars(event.input);
+    if (event.type === "tool_result") return total + estimateValueChars(event.content);
+    return total;
+  }, 0);
+}
+
+export {
+  bytesPerTokenForFileType,
+  estimateTokensFromBytesForFileType,
+  estimateFileTokens,
+  estimateValueChars,
+  estimateToolCallsCharsLocal,
+  estimateModelMessageChars,
+  estimateTranscriptContextChars
+};