@jphutchins/code-review 0.1.0-alpha.1

package/dist/index.js

@@ -0,0 +1,1627 @@
+#!/usr/bin/env node
+import { defineCommand, runMain } from 'citty';
+import { readFileSync, writeFileSync } from 'fs';
+import { resolve as resolve$1, join } from 'path';
+import { Eta } from 'eta';
+import parseDiff from 'parse-diff';
+import { Ajv2020 } from 'ajv/dist/2020.js';
+import _addFormats from 'ajv-formats';
+import * as t from 'io-ts';
+import { execFile } from 'child_process';
+
+// src/cost.ts
+var defaultWarn = (message) => {
+  process.stderr.write(`${message}
+`);
+};
+var computeModelCost = (entry, prices, warn) => {
+  const p = prices.models[entry.model];
+  const cacheRead = entry.cache_read_tokens ?? 0;
+  const cacheWrite = entry.cache_write_tokens ?? 0;
+  if (!p) {
+    warn(
+      `code-review cost: unknown model "${entry.model}" \u2014 no entry in price map; cost for this model set to $0`
+    );
+    return {
+      model: entry.model,
+      inputTokens: entry.input_tokens,
+      outputTokens: entry.output_tokens,
+      cacheReadTokens: cacheRead,
+      cacheWriteTokens: cacheWrite,
+      costUSD: 0
+    };
+  }
+  const costUSD = (entry.input_tokens * p.in + entry.output_tokens * p.out + cacheRead * p.cache_read + cacheWrite * p.cache_write) / 1e6;
+  return {
+    model: entry.model,
+    inputTokens: entry.input_tokens,
+    outputTokens: entry.output_tokens,
+    cacheReadTokens: cacheRead,
+    cacheWriteTokens: cacheWrite,
+    costUSD
+  };
+};
+var computeCost = (models, prices, warn = defaultWarn) => {
+  const lines = models.map((entry) => computeModelCost(entry, prices, warn));
+  return {
+    lines,
+    totalInputTokens: lines.reduce((s, l) => s + l.inputTokens, 0),
+    totalOutputTokens: lines.reduce((s, l) => s + l.outputTokens, 0),
+    totalCacheReadTokens: lines.reduce((s, l) => s + l.cacheReadTokens, 0),
+    totalCacheWriteTokens: lines.reduce((s, l) => s + l.cacheWriteTokens, 0),
+    totalCostUSD: lines.reduce((s, l) => s + l.costUSD, 0)
+  };
+};
+
+// src/render.ts
+var escapeBackticks = (text) => text.replace(/```/g, "`` ` ``");
+var escapePipes = (text) => text.replace(/\|/g, "\\|");
+var escapeCodeBackticks = (text) => text.replace(/`/g, "-");
+var sanitizeFinding = (f) => ({
+  ...f,
+  title: escapePipes(f.title),
+  path: escapeCodeBackticks(f.path),
+  suggestion: f.suggestion ? escapeBackticks(f.suggestion) : f.suggestion
+});
+var render = (input) => {
+  const eta = new Eta({ autoTrim: false });
+  const usageAvailable = input.envelope !== null;
+  const costReport = input.envelope ? computeCost(input.envelope.models, input.prices) : null;
+  const route = input.route;
+  const modelNames = input.envelope ? input.envelope.models.map((m) => m.model).join(", ") : "";
+  const findings = input.findings.findings.map(sanitizeFinding);
+  const safeFindings = { ...input.findings, findings };
+  const uniqueFiles = [...new Set(findings.map((f) => f.path))];
+  return eta.renderString(input.template, {
+    findings: safeFindings,
+    envelope: input.envelope,
+    usageAvailable,
+    costReport,
+    route,
+    effort: input.effort ?? null,
+    modelNames,
+    testReport: input.testReport ?? null,
+    reviewedSha: input.reviewedSha ?? "0000000000000000000000000000000000000000",
+    totalCount: findings.length,
+    fileCount: uniqueFiles.length,
+    // REC-CO-1: nits (and only nits) fold into <details>; everything else stays visible.
+    visibleFindings: findings.filter((f) => f.severity !== "nit"),
+    nitFindings: findings.filter((f) => f.severity === "nit"),
+    suggestionCount: findings.filter((f) => f.suggestion).length,
+    formatTokens: (n) => Number.isFinite(n) && n >= 0 ? n.toLocaleString("en-US") : "\u2014",
+    formatCost: (n) => Number.isFinite(n) ? `$${n.toFixed(3)}` : "\u2014",
+    formatDuration: (ms) => {
+      if (!Number.isFinite(ms) || ms < 0) return "\u2014";
+      const s = Math.round(ms / 1e3);
+      return s >= 60 ? `${String(Math.floor(s / 60))}m ${String(s % 60)}s` : `${String(s)}s`;
+    },
+    verdictBadge: (v) => {
+      switch (v) {
+        case "approve":
+          return "\u2705 approved";
+        case "comment":
+          return "\u{1F4AC} comment";
+        case "changes":
+          return "\u{1F527} changes requested";
+        default:
+          return `\u2753 ${v}`;
+      }
+    },
+    severityEmoji: (s) => {
+      switch (s) {
+        case "critical":
+          return "\u{1F534}";
+        case "major":
+          return "\u{1F7E0}";
+        case "minor":
+          return "\u{1F535}";
+        case "nit":
+          return "\u26AA";
+        default:
+          return "\u2753";
+      }
+    }
+  });
+};
+var key = (path, line) => `${path}:${String(line)}`;
+var indexChanges = (keys, fpath, changes) => {
+  for (const change of changes) {
+    if (change.type === "normal") {
+      if (change.ln1 !== void 0) keys.add(key(fpath, change.ln1));
+      if (change.ln2 !== void 0) keys.add(key(fpath, change.ln2));
+    } else if (change.ln !== void 0) {
+      keys.add(key(fpath, change.ln));
+    }
+  }
+};
+var indexDiff = (diff) => {
+  const files = parseDiff(diff);
+  if (!Array.isArray(files)) return /* @__PURE__ */ new Set();
+  const keys = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const primary = file.from ?? file.to;
+    if (!primary) continue;
+    indexChanges(
+      keys,
+      primary,
+      file.chunks.flatMap((c) => c.changes)
+    );
+    if (file.to && file.to !== "/dev/null" && file.to !== primary) {
+      indexChanges(
+        keys,
+        file.to,
+        file.chunks.flatMap((c) => c.changes)
+      );
+    }
+  }
+  return keys;
+};
+var isInDiff = (index, path, line) => index.has(key(path, line));
+var isEmptyDiff = (diff) => {
+  if (diff.trim().length === 0) return true;
+  const files = parseDiff(diff);
+  return !Array.isArray(files) || files.length === 0 || files.every((f) => f.chunks.length === 0);
+};
+var defaultSide = (side) => side === "LEFT" ? "LEFT" : "RIGHT";
+var partitionFindings = (findings, index) => {
+  const inDiff = [];
+  const strays = [];
+  for (const f of findings) {
+    if (isInDiff(index, f.path, f.start_line) && isInDiff(index, f.path, f.end_line)) {
+      inDiff.push(f);
+    } else {
+      strays.push(f);
+    }
+  }
+  return { inDiff, strays };
+};
+
+// src/inline.ts
+var escapeBackticks2 = (text) => text.replace(/```/g, "`` ` ``");
+var buildCommentBody = (f) => {
+  const parts = [f.body];
+  if (f.suggestion !== null && f.suggestion !== void 0) {
+    const safe = escapeBackticks2(f.suggestion);
+    parts.push(`\`\`\`suggestion
+${safe}
+\`\`\``);
+  }
+  return parts.join("\n\n");
+};
+var renderCommentBody = (f, eta, template) => {
+  return eta.renderString(template, {
+    ...f,
+    suggestion: f.suggestion !== null && f.suggestion !== void 0 ? escapeBackticks2(f.suggestion) : null
+  });
+};
+var buildInlineComments = (findings, diff, inlineTemplate) => {
+  const index = indexDiff(diff);
+  const { inDiff, strays } = partitionFindings(findings, index);
+  const eta = inlineTemplate ? new Eta({ autoTrim: false }) : null;
+  const comments = inDiff.map((f) => {
+    const comment = {
+      path: f.path,
+      line: f.end_line,
+      side: defaultSide(f.side),
+      body: eta && inlineTemplate ? renderCommentBody(f, eta, inlineTemplate) : buildCommentBody(f)
+    };
+    if (f.start_line < f.end_line) {
+      return {
+        ...comment,
+        start_line: f.start_line,
+        start_side: defaultSide(f.side)
+      };
+    }
+    return comment;
+  });
+  return { comments, strays };
+};
+var renderStraysSection = (strays) => {
+  if (strays.length === 0) return "";
+  const items = strays.map(
+    (f) => `- **${f.severity}** \xB7 \`${f.path}:${String(f.start_line)}\` \u2014 ${f.title}`
+  );
+  return [
+    "",
+    "---",
+    "",
+    "#### \u26A0\uFE0F Findings on lines not in the diff (demoted to summary)",
+    "",
+    ...items
+  ].join("\n");
+};
+var SeverityCodec = t.union([
+  t.literal("critical"),
+  t.literal("major"),
+  t.literal("minor"),
+  t.literal("nit")
+]);
+var SideCodec = t.union([t.literal("RIGHT"), t.literal("LEFT")]);
+var VerdictCodec = t.union([t.literal("approve"), t.literal("comment"), t.literal("changes")]);
+var LineNumber = t.refinement(
+  t.number,
+  (n) => Number.isInteger(n) && n >= 1,
+  "LineNumber"
+);
+var Confidence = t.refinement(t.number, (n) => n >= 0 && n <= 1, "Confidence");
+var SCHEMA_VERSION_RE = /^(0|[1-9]\d*)\.(\d+)\.(\d+)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+var SchemaVersion = t.refinement(
+  t.string,
+  (s) => SCHEMA_VERSION_RE.test(s),
+  "SchemaVersion"
+);
+var FindingShape = t.intersection([
+  t.type({
+    path: t.string,
+    start_line: LineNumber,
+    end_line: LineNumber,
+    severity: SeverityCodec,
+    title: t.string,
+    body: t.string
+  }),
+  t.partial({
+    side: SideCodec,
+    suggestion: t.union([t.string, t.null]),
+    confidence: Confidence,
+    code: t.string,
+    code_url: t.string
+  })
+]);
+var EndGeStart = t.refinement(
+  FindingShape,
+  (f) => f.end_line >= f.start_line,
+  "EndGeStart"
+);
+var FindingCodec = t.exact(EndGeStart);
+var FindingsCodec = t.exact(
+  t.type({
+    schema_version: SchemaVersion,
+    summary: t.string,
+    verdict: VerdictCodec,
+    findings: t.array(FindingCodec)
+  })
+);
+var TriageCodec = t.type({
+  safe: t.boolean,
+  reasons: t.string
+});
+var TokenCount = t.refinement(
+  t.number,
+  (n) => Number.isInteger(n) && n >= 0,
+  "TokenCount"
+);
+var ModelUsageEntryCodec = t.intersection([
+  t.type({
+    model: t.string,
+    input_tokens: TokenCount,
+    output_tokens: TokenCount
+  }),
+  t.partial({
+    cache_read_tokens: TokenCount,
+    cache_write_tokens: TokenCount
+  })
+]);
+var ResultEnvelopeCodec = t.intersection([
+  t.type({
+    schema_version: t.string,
+    findings: FindingsCodec,
+    models: t.array(ModelUsageEntryCodec),
+    turns: TokenCount,
+    duration_ms: TokenCount
+  }),
+  t.partial({
+    vendor_cost_usd: t.union([t.number, t.null])
+  })
+]);
+var ModelPricesCodec = t.type({
+  in: t.number,
+  out: t.number,
+  cache_read: t.number,
+  cache_write: t.number
+});
+var PriceMapCodec = t.type({
+  _updated: t.string,
+  _unit: t.string,
+  models: t.record(t.string, ModelPricesCodec)
+});
+var TestFailureCodec = t.intersection([
+  t.type({ name: t.string }),
+  t.partial({ message: t.string })
+]);
+var TestSummaryCodec = t.intersection([
+  t.type({
+    passed: t.number,
+    failed: t.number,
+    total: t.number
+  }),
+  t.partial({
+    failures: t.array(TestFailureCodec)
+  })
+]);
+var DEFAULT_SCHEMA_VERSION = "0.2.0";
+
+// src/validate.ts
+var addFormats = _addFormats;
+var validatorCache = /* @__PURE__ */ new Map();
+var compileSchema = (schemaPath) => {
+  const cached = validatorCache.get(schemaPath);
+  if (cached) return cached;
+  let schemaJson;
+  try {
+    schemaJson = readFileSync(schemaPath, "utf-8");
+  } catch {
+    throw new Error(`Cannot read schema file: ${schemaPath}`);
+  }
+  let schema;
+  try {
+    schema = JSON.parse(schemaJson);
+  } catch {
+    throw new Error(`Invalid JSON in schema file: ${schemaPath}`);
+  }
+  const ajv = new Ajv2020({ allErrors: true, strict: true });
+  addFormats(ajv);
+  const validator = ajv.compile(schema);
+  validatorCache.set(schemaPath, validator);
+  return validator;
+};
+var validateAgainstSchema = (findings, schemaPath) => {
+  const validator = compileSchema(schemaPath);
+  const valid = validator(findings);
+  const errors = valid || !validator.errors ? [] : validator.errors.map((e) => `${e.instancePath} ${e.message ?? "unknown error"}`);
+  return { valid, errors };
+};
+var unsafeUnwrap = (decoded) => {
+  if (decoded._tag === "Right") return decoded.right;
+  throw new Error("io-ts decode failed \u2014 data does not match expected shape");
+};
+var identity = (decoded) => decoded;
+var findingsTable = [
+  {
+    minor: "0.2",
+    defaultVersion: DEFAULT_SCHEMA_VERSION,
+    schemaFile: "findings.schema.json",
+    codec: FindingsCodec,
+    normalize: identity,
+    latest: true
+  }
+];
+var triageTable = [
+  {
+    minor: "0.1",
+    defaultVersion: "0.1.0",
+    schemaFile: "triage.schema.json",
+    codec: TriageCodec,
+    normalize: identity,
+    latest: true
+  }
+];
+var pricesTable = [
+  {
+    minor: "0.1",
+    defaultVersion: "0.1.0",
+    schemaFile: "prices.schema.json",
+    codec: PriceMapCodec,
+    normalize: identity,
+    latest: true
+  }
+];
+var tables = {
+  findings: findingsTable,
+  triage: triageTable,
+  prices: pricesTable
+};
+var tableFor = (kind) => tables[kind];
+var majorMinor = (version) => version.split(".").slice(0, 2).join(".");
+var describeValidationError = (e) => {
+  const path = e.context.map((entry) => entry.key).filter((key2) => key2.length > 0).join(".");
+  return e.message ?? `${path || "(root)"}: invalid value ${JSON.stringify(e.value)}`;
+};
+var formatErrors = (errors) => errors.map(describeValidationError);
+var declaredVersion = (raw) => typeof raw === "object" && raw !== null && "schema_version" in raw ? typeof raw.schema_version === "string" ? raw.schema_version : void 0 : void 0;
+var supportedVersions = (kind) => tableFor(kind).map((entry) => entry.minor);
+var defaultVersion = (kind) => {
+  const latest = tableFor(kind).find((entry) => entry.latest);
+  if (!latest) throw new Error(`Registry invariant violated \u2014 no latest entry for "${kind}"`);
+  return latest.defaultVersion;
+};
+var bundledSchemaPath = (relativePath) => resolve$1(import.meta.dirname, "..", "schema", relativePath);
+var schemaPathFor = (kind, version) => {
+  const table = tableFor(kind);
+  const entry = version === void 0 ? table.find((v) => v.latest) : table.find((v) => v.minor === majorMinor(version));
+  if (!entry) {
+    throw new Error(
+      `Unsupported ${kind} schema version "${version ?? ""}" \u2014 supported: ${supportedVersions(kind).join(", ")}`
+    );
+  }
+  return bundledSchemaPath(entry.schemaFile);
+};
+var resolveFindings = (raw) => {
+  const version = declaredVersion(raw);
+  if (version === void 0) return { kind: "missing-version" };
+  const entry = findingsTable.find((v) => v.minor === majorMinor(version));
+  if (!entry) {
+    return { kind: "unsupported-version", version, supported: supportedVersions("findings") };
+  }
+  const decoded = entry.codec.decode(raw);
+  return decoded._tag === "Left" ? { kind: "invalid-shape", errors: formatErrors(decoded.left) } : { kind: "ok", version, value: entry.normalize(decoded.right) };
+};
+var resolveSingleVersion = (kind, raw) => {
+  const entry = tableFor(kind)[0];
+  if (!entry) throw new Error(`Registry invariant violated \u2014 no entry for "${kind}"`);
+  const decoded = entry.codec.decode(raw);
+  return decoded._tag === "Left" ? { kind: "invalid-shape", errors: formatErrors(decoded.left) } : { kind: "ok", version: entry.defaultVersion, value: entry.normalize(decoded.right) };
+};
+var resolvers = {
+  findings: resolveFindings,
+  triage: (raw) => resolveSingleVersion("triage", raw),
+  prices: (raw) => resolveSingleVersion("prices", raw)
+};
+var resolve = (kind, raw) => resolvers[kind](raw);
+var runGhApi = (args, stdin, env) => new Promise((resolve3, reject) => {
+  const child = execFile(
+    "gh",
+    ["api", ...args],
+    { env: { ...process.env, ...env }, encoding: "utf-8", maxBuffer: 100 * 1024 * 1024 },
+    (err, stdout, stderr) => {
+      if (err) {
+        const stderrStr = typeof stderr === "string" && stderr.trim() ? stderr.trim() : "";
+        const errStr = err instanceof Error ? err.message : "unknown error";
+        reject(new Error(`gh api failed: ${stderrStr || errStr}`));
+      } else {
+        resolve3(stdout);
+      }
+    }
+  );
+  if (stdin !== void 0) {
+    child.stdin?.end(stdin);
+  }
+});
+
+// src/pr.ts
+var fetchPrCandidates = async (repo, headSha, ghApi) => {
+  const stdout = await ghApi([
+    `repos/${repo}/commits/${headSha}/pulls`,
+    "--jq",
+    ".[] | {number: .number, state: .state, headRef: .head.ref}"
+  ]);
+  return stdout.trim().split("\n").filter(Boolean).map((line) => JSON.parse(line));
+};
+var resolvePr = (candidates, headBranch) => {
+  if (candidates.length === 0) return { kind: "none" };
+  const scoped = candidates.length > 1 && headBranch ? candidates.filter((c) => c.headRef === headBranch) : candidates;
+  const chosen = scoped[0] ?? candidates[0];
+  if (chosen === void 0) return { kind: "none" };
+  return chosen.state === "open" ? { kind: "open", prNumber: chosen.number } : { kind: "not-open", prNumber: chosen.number, state: chosen.state };
+};
+var fetchDiff = async (repo, prNumber, ghApi) => ghApi([
+  `repos/${repo}/pulls/${String(prNumber)}`,
+  "-H",
+  "Accept: application/vnd.github.v3.diff"
+]);
+
+// src/post.ts
+var DEFAULT_MARKER = "<!-- code-review -->";
+var MAX_SUGGESTION_LINES = 10;
+var REVIEWED_SHA_RE = /<!-- reviewed-sha: ([0-9a-f]{7,40}) -->/;
+var countSuggestionLines = (text) => text.split("\n").length;
+var checkLongSuggestions = (comments) => {
+  const longFiles = [];
+  const adjusted = comments.map((c) => {
+    const match = /```suggestion\n([\s\S]*?)\n```/.exec(c.body);
+    if (match?.[1] && countSuggestionLines(match[1]) > MAX_SUGGESTION_LINES) {
+      longFiles.push(`${c.path}:${String(c.line)}`);
+      return {
+        ...c,
+        body: c.body.replace(
+          /```suggestion\n[\s\S]*?\n```/,
+          "*(suggestion omitted \u2014 exceeds GitHub's ~10-line suggestion limit; see summary)*"
+        )
+      };
+    }
+    return c;
+  });
+  return { comments: adjusted, longFiles };
+};
+var extractReviewedSha = (commentBody) => REVIEWED_SHA_RE.exec(commentBody)?.[1] ?? null;
+var noticeFindings = (message) => ({
+  schema_version: DEFAULT_SCHEMA_VERSION,
+  summary: `### \u26A0\uFE0F ${message}`,
+  verdict: "comment",
+  findings: []
+});
+var loadFindings = (path) => {
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return { kind: "corrupt" };
+  }
+  const resolution = resolve("findings", raw);
+  switch (resolution.kind) {
+    case "ok":
+      return { kind: "ok", findings: resolution.value };
+    case "unsupported-version":
+      return { kind: "unsupported-schema-version", version: resolution.version };
+    case "invalid-shape":
+    case "missing-version":
+      return { kind: "invalid-shape" };
+  }
+};
+var noticeMessageFor = (result) => {
+  switch (result.kind) {
+    case "corrupt":
+      return "Review output was missing or malformed \u2014 the review did not complete. See the workflow run for logs.";
+    case "invalid-shape":
+      return "Review output was malformed \u2014 it did not conform to the findings schema. See the workflow run for logs.";
+    case "unsupported-schema-version": {
+      const supported = supportedVersions("findings").map((minor) => `${minor}.x`).join(", ");
+      return `Review output declares schema_version "${result.version}", which this commenter does not support (supported: ${supported}). See the workflow run for logs.`;
+    }
+  }
+};
+var loadEnvelope = (path) => {
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+  const decoded = ResultEnvelopeCodec.decode(raw);
+  return decoded._tag === "Right" ? decoded.right : null;
+};
+var loadTestReport = (path) => {
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(path, "utf-8"));
+  } catch (err) {
+    process.stderr.write(
+      `Warning: could not read test report at ${path}: ${err instanceof Error ? err.message : String(err)} \u2014 omitting test panel
+`
+    );
+    return void 0;
+  }
+  const decoded = TestSummaryCodec.decode(raw);
+  if (decoded._tag === "Left") {
+    process.stderr.write(
+      `Warning: test report at ${path} does not match the expected shape \u2014 omitting test panel
+`
+    );
+    return void 0;
+  }
+  return decoded.right;
+};
+var postInlineReview = async (repo, prNumber, headSha, comments, ghApi) => {
+  const body = JSON.stringify({
+    body: "",
+    commit_id: headSha,
+    event: "COMMENT",
+    comments: comments.map((c) => ({
+      path: c.path,
+      line: c.line,
+      side: c.side,
+      ...c.start_line !== void 0 && c.start_side !== void 0 ? { start_line: c.start_line, start_side: c.start_side } : {},
+      body: c.body
+    }))
+  });
+  await ghApi([`repos/${repo}/pulls/${String(prNumber)}/reviews`, "--input", "-"], body);
+};
+var findBotComment = async (repo, prNumber, botLogin, marker, ghApi) => {
+  const stdout = await ghApi(
+    [
+      `repos/${repo}/issues/${String(prNumber)}/comments`,
+      "--paginate",
+      "--jq",
+      ".[] | select(.user.login == env.CODE_REVIEW_BOT_LOGIN and (.body | startswith(env.CODE_REVIEW_MARKER))) | {id: .id, body: .body}"
+    ],
+    void 0,
+    { CODE_REVIEW_BOT_LOGIN: botLogin, CODE_REVIEW_MARKER: marker }
+  );
+  const lines = stdout.trim().split("\n").filter(Boolean);
+  if (lines.length === 0) return null;
+  const last = lines[lines.length - 1] ?? null;
+  if (last === null) return null;
+  const parsed = JSON.parse(last);
+  return { id: parsed.id, body: parsed.body };
+};
+var patchComment = async (repo, commentId, body, ghApi) => {
+  await ghApi(
+    [`repos/${repo}/issues/comments/${String(commentId)}`, "--input", "-"],
+    JSON.stringify({ body })
+  );
+};
+var postComment = async (repo, prNumber, body, ghApi) => {
+  await ghApi(
+    [`repos/${repo}/issues/${String(prNumber)}/comments`, "--input", "-"],
+    JSON.stringify({ body })
+  );
+};
+var upsertSticky = async (repo, prNumber, existing, body, ghApi) => {
+  if (existing !== null) {
+    await patchComment(repo, existing.id, body, ghApi);
+    process.stderr.write(
+      `Updated sticky comment #${String(existing.id)} on PR #${String(prNumber)}
+`
+    );
+  } else {
+    await postComment(repo, prNumber, body, ghApi);
+    process.stderr.write(`Posted new sticky comment on PR #${String(prNumber)}
+`);
+  }
+};
+var isBotReview = (r) => typeof r === "object" && r !== null && typeof r.id === "number" && typeof r.state === "string" && typeof r.user?.login === "string";
+var fetchBotReviewIds = async (repo, prNumber, botLogin, ghApi) => {
+  const stdout = await ghApi([`repos/${repo}/pulls/${String(prNumber)}/reviews`, "--paginate"]);
+  let reviews;
+  try {
+    reviews = JSON.parse(stdout || "[]");
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(reviews)) return [];
+  return reviews.filter((r) => isBotReview(r)).filter((r) => r.user.login === botLogin && r.state !== "DISMISSED").map((r) => r.id);
+};
+var dismissPriorBotReviews = async (repo, prNumber, botLogin, ghApi) => {
+  const ids = await fetchBotReviewIds(repo, prNumber, botLogin, ghApi);
+  for (const id of ids) {
+    try {
+      await ghApi(
+        [
+          `repos/${repo}/pulls/${String(prNumber)}/reviews/${String(id)}/dismissals`,
+          "-X",
+          "PUT",
+          "--input",
+          "-"
+        ],
+        JSON.stringify({ message: "Superseded by a new review for an updated commit." })
+      );
+    } catch (err) {
+      process.stderr.write(
+        `Warning: failed to dismiss prior review #${String(id)} on PR #${String(prNumber)}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+};
+var post = async (input, ghApi = runGhApi) => {
+  const candidates = await fetchPrCandidates(input.repo, input.headSha, ghApi);
+  const resolution = resolvePr(candidates, input.headBranch);
+  if (resolution.kind === "none") {
+    process.stderr.write(`No open PR for ${input.headSha} \u2014 nothing to post
+`);
+    process.exit(0);
+  }
+  if (resolution.kind === "not-open") {
+    process.stderr.write(
+      `PR #${String(resolution.prNumber)} for ${input.headSha} is not open (state: ${resolution.state}) \u2014 nothing to post
+`
+    );
+    process.exit(0);
+  }
+  const prNumber = resolution.prNumber;
+  const diff = await fetchDiff(input.repo, prNumber, ghApi);
+  const existingSticky = await findBotComment(
+    input.repo,
+    prNumber,
+    input.botLogin,
+    DEFAULT_MARKER,
+    ghApi
+  );
+  const previousReviewedSha = existingSticky ? extractReviewedSha(existingSticky.body) : null;
+  const isRerunOfSameSha = previousReviewedSha !== null && previousReviewedSha === input.headSha;
+  const prices = JSON.parse(readFileSync(input.pricesPath, "utf-8"));
+  const decodedPrices = PriceMapCodec.decode(prices);
+  if (decodedPrices._tag === "Left") {
+    throw new Error(`Price map at ${input.pricesPath} does not match the expected shape`);
+  }
+  const template = readFileSync(input.templatePath, "utf-8");
+  const inlineTemplate = input.inlineTemplatePath ? readFileSync(input.inlineTemplatePath, "utf-8") : void 0;
+  const renderNotice = (message) => render({
+    findings: noticeFindings(message),
+    envelope: null,
+    prices: decodedPrices.right,
+    template,
+    route: input.route,
+    reviewedSha: input.headSha,
+    effort: input.effort
+  });
+  if (isEmptyDiff(diff)) {
+    await upsertSticky(
+      input.repo,
+      prNumber,
+      existingSticky,
+      renderNotice("The diff for this PR is empty \u2014 nothing to review."),
+      ghApi
+    );
+    process.exit(0);
+  }
+  const findingsResult = loadFindings(input.findingsPath);
+  if (findingsResult.kind !== "ok") {
+    await upsertSticky(
+      input.repo,
+      prNumber,
+      existingSticky,
+      renderNotice(noticeMessageFor(findingsResult)),
+      ghApi
+    );
+    process.exit(0);
+  }
+  const findings = findingsResult.findings;
+  const envelope = loadEnvelope(input.envelopePath);
+  const testReport = input.testReportPath ? loadTestReport(input.testReportPath) : void 0;
+  if (envelope === null) {
+    const body2 = render({
+      findings,
+      envelope: null,
+      prices: decodedPrices.right,
+      template,
+      route: input.route,
+      reviewedSha: input.headSha,
+      effort: input.effort,
+      testReport
+    });
+    await upsertSticky(input.repo, prNumber, existingSticky, body2, ghApi);
+    process.stderr.write(
+      "Result envelope missing or malformed \u2014 posted sticky summary without usage/cost data; no inline review\n"
+    );
+    process.exit(0);
+  }
+  const { comments: rawComments, strays } = buildInlineComments(
+    findings.findings,
+    diff,
+    inlineTemplate
+  );
+  const { comments, longFiles } = checkLongSuggestions(rawComments);
+  for (const wf of longFiles) {
+    process.stderr.write(
+      `Warning: suggestion in ${wf} exceeds ${String(MAX_SUGGESTION_LINES)} lines \u2014 omitted from inline to avoid 422
+`
+    );
+  }
+  let body = render({
+    findings,
+    envelope,
+    prices: decodedPrices.right,
+    template,
+    route: input.route,
+    reviewedSha: input.headSha,
+    effort: input.effort,
+    testReport
+  });
+  const straysMd = renderStraysSection(strays);
+  if (straysMd.length > 0) body += straysMd;
+  if (longFiles.length > 0) {
+    body += `
+
+---
+
+> **Note:** ${String(longFiles.length)} suggestion(s) exceeded GitHub's ~10-line inline suggestion limit and were omitted from inline comments. See the findings above for details.
+`;
+  }
+  if (!isRerunOfSameSha && previousReviewedSha !== null) {
+    await dismissPriorBotReviews(input.repo, prNumber, input.botLogin, ghApi);
+  }
+  await upsertSticky(input.repo, prNumber, existingSticky, body, ghApi);
+  if (isRerunOfSameSha) {
+    process.stderr.write(
+      `Head SHA ${input.headSha} matches the previous review \u2014 updated sticky only, no new inline review
+`
+    );
+    return;
+  }
+  if (comments.length > 0) {
+    await postInlineReview(input.repo, prNumber, input.headSha, comments, ghApi);
+    process.stderr.write(
+      `Posted ${String(comments.length)} inline comments on PR #${String(prNumber)}
+`
+    );
+  }
+};
+var renderOutputs = (result) => {
+  switch (result.kind) {
+    case "skip":
+      return "skip=true\n";
+    case "gathered":
+      return `pr=${String(result.pr)}
+conclusion=${result.conclusion}
+diff_size=${String(result.diffSize)}
+`;
+  }
+};
+var runGit = (args) => new Promise((resolve3, reject) => {
+  execFile(
+    "git",
+    [...args],
+    { encoding: "utf-8", maxBuffer: 100 * 1024 * 1024 },
+    (err, stdout, stderr) => {
+      if (err) {
+        const stderrStr = typeof stderr === "string" && stderr.trim() ? stderr.trim() : "";
+        const errStr = err instanceof Error ? err.message : "unknown error";
+        reject(new Error(`git ${args.join(" ")} failed: ${stderrStr || errStr}`));
+      } else {
+        resolve3(stdout);
+      }
+    }
+  );
+});
+var PrMetaCodec = t.type({
+  changed_files: t.number,
+  base_sha: t.string,
+  title: t.string,
+  body: t.union([t.string, t.null])
+});
+var IssueCommentCodec = t.type({
+  id: t.number,
+  body: t.union([t.string, t.null]),
+  user: t.type({ login: t.string })
+});
+var IssueCommentsCodec = t.array(IssueCommentCodec);
+var JobCodec = t.type({ id: t.number, conclusion: t.union([t.string, t.null]) });
+var JobsResponseCodec = t.type({ jobs: t.array(JobCodec) });
+var fetchPrMeta = async (repo, prNumber, ghApi) => {
+  const stdout = await ghApi([
+    `repos/${repo}/pulls/${String(prNumber)}`,
+    "--jq",
+    "{changed_files: .changed_files, base_sha: .base.sha, title: .title, body: .body}"
+  ]);
+  const decoded = PrMetaCodec.decode(JSON.parse(stdout));
+  if (decoded._tag === "Left") {
+    throw new Error(`PR metadata for #${String(prNumber)} did not match the expected shape`);
+  }
+  return decoded.right;
+};
+var fetchApiDiff = async (repo, prNumber, ghApi) => {
+  try {
+    return await fetchDiff(repo, prNumber, ghApi);
+  } catch {
+    return null;
+  }
+};
+var fetchPriorReview = async (repo, prNumber, botLogin, ghApi) => {
+  try {
+    const stdout = await ghApi([`repos/${repo}/issues/${String(prNumber)}/comments`, "--paginate"]);
+    const decoded = IssueCommentsCodec.decode(JSON.parse(stdout || "[]"));
+    if (decoded._tag === "Left") return null;
+    const byBot = decoded.right.filter((c) => c.user.login === botLogin);
+    const last = byBot[byBot.length - 1];
+    return last ? { id: last.id, body: last.body } : null;
+  } catch {
+    return null;
+  }
+};
+var downloadFailingJobLogs = async (repo, runId, outDir, ghApi) => {
+  const stdout = await ghApi([`repos/${repo}/actions/runs/${runId}/jobs`]);
+  const decoded = JobsResponseCodec.decode(JSON.parse(stdout));
+  if (decoded._tag === "Left") {
+    throw new Error(`Jobs list for run ${runId} did not match the expected shape`);
+  }
+  for (const job of decoded.right.jobs.filter((j) => j.conclusion === "failure")) {
+    try {
+      const log = await ghApi([`repos/${repo}/actions/jobs/${String(job.id)}/logs`]);
+      writeFileSync(join(outDir, `job_${String(job.id)}.log`), log);
+    } catch (err) {
+      process.stderr.write(
+        `Warning: failed to download logs for job ${String(job.id)}: ${err instanceof Error ? err.message : String(err)} \u2014 continuing with the logs retrieved so far
+`
+      );
+    }
+  }
+};
+var gather = async (input, ghApi = runGhApi, gitRun = runGit) => {
+  const candidates = await fetchPrCandidates(input.repo, input.headSha, ghApi);
+  const resolution = resolvePr(candidates, input.headBranch);
+  if (resolution.kind === "none") {
+    process.stderr.write(`No open PR for ${input.headSha} \u2014 nothing to review
+`);
+    return { kind: "skip" };
+  }
+  if (resolution.kind === "not-open") {
+    process.stderr.write(
+      `PR #${String(resolution.prNumber)} for ${input.headSha} is not open (state: ${resolution.state}) \u2014 nothing to review
+`
+    );
+    return { kind: "skip" };
+  }
+  const prNumber = resolution.prNumber;
+  const meta = await fetchPrMeta(input.repo, prNumber, ghApi);
+  const apiDiff = await fetchApiDiff(input.repo, prNumber, ghApi);
+  const diff = apiDiff !== null && !(apiDiff.length === 0 && meta.changed_files > 0) ? apiDiff : await (async () => {
+    process.stderr.write(
+      `PR diff fetch failed or was empty for ${String(meta.changed_files)} changed files \u2014 falling back to git diff
+`
+    );
+    await gitRun(["fetch", "origin", input.headSha]);
+    return gitRun(["diff", meta.base_sha, input.headSha]);
+  })();
+  writeFileSync(join(input.outDir, "pr.diff"), diff);
+  writeFileSync(
+    join(input.outDir, "pr_context.json"),
+    JSON.stringify({ title: meta.title, body: meta.body })
+  );
+  const prior = await fetchPriorReview(input.repo, prNumber, input.botLogin, ghApi);
+  writeFileSync(
+    join(input.outDir, "prior_review.json"),
+    prior === null ? "null" : JSON.stringify(prior)
+  );
+  if (input.conclusion === "failure") {
+    await downloadFailingJobLogs(input.repo, input.runId, input.outDir, ghApi);
+  }
+  return {
+    kind: "gathered",
+    pr: prNumber,
+    conclusion: input.conclusion,
+    diffSize: Buffer.byteLength(diff, "utf8")
+  };
+};
+var fieldOf = (raw, key2) => typeof raw === "object" && raw !== null && key2 in raw ? raw[key2] : void 0;
+var parseNativeForExtraction = (raw) => ({
+  result: fieldOf(raw, "result"),
+  structuredOutput: fieldOf(raw, "structured_output"),
+  isError: fieldOf(raw, "is_error"),
+  subtype: fieldOf(raw, "subtype"),
+  apiErrorStatus: fieldOf(raw, "api_error_status")
+});
+var isNullish = (value) => value === null || value === void 0;
+var isErrorEnvelope = (native) => native.isError === true || !isNullish(native.subtype) && native.subtype !== "success" || !isNullish(native.apiErrorStatus);
+var describeErrorEnvelope = (native) => {
+  const parts = [
+    ...native.isError === true ? ["is_error=true"] : [],
+    ...!isNullish(native.subtype) && native.subtype !== "success" ? [`subtype=${JSON.stringify(native.subtype)}`] : [],
+    ...!isNullish(native.apiErrorStatus) ? [`api_error_status=${JSON.stringify(native.apiErrorStatus)}`] : []
+  ];
+  return `agent run did not complete successfully (${parts.join(", ")})`;
+};
+var withDefaultSchemaVersion = (candidate) => typeof candidate === "object" && candidate !== null && !Array.isArray(candidate) && !("schema_version" in candidate) ? { ...candidate, schema_version: defaultVersion("findings") } : candidate;
+var normalizeCandidate = (kind, candidate) => kind === "findings" ? withDefaultSchemaVersion(candidate) : candidate;
+var candidateVersion = (kind, candidate) => {
+  if (kind !== "findings") return void 0;
+  const version = fieldOf(candidate, "schema_version");
+  return typeof version === "string" ? version : void 0;
+};
+var safeSchemaPathFor = (kind, version) => {
+  try {
+    return schemaPathFor(kind, version);
+  } catch {
+    return null;
+  }
+};
+var canonicalize = (value) => Array.isArray(value) ? value.map(canonicalize) : value !== null && typeof value === "object" ? Object.fromEntries(
+  Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => [k, canonicalize(v)])
+) : value;
+var dedupCandidates = (candidates) => {
+  const seen = /* @__PURE__ */ new Set();
+  return candidates.filter((c) => {
+    const key2 = JSON.stringify(canonicalize(c.candidate));
+    if (seen.has(key2)) return false;
+    seen.add(key2);
+    return true;
+  });
+};
+var gateCandidate = (kind, rawCandidate) => {
+  const candidate = normalizeCandidate(kind, rawCandidate);
+  const schemaPath = safeSchemaPathFor(kind, candidateVersion(kind, candidate));
+  if (schemaPath === null) return null;
+  if (!validateAgainstSchema(candidate, schemaPath).valid) return null;
+  const resolution = resolve(kind, candidate);
+  return resolution.kind === "ok" ? { version: resolution.version, candidate } : null;
+};
+var tryParseJson = (text) => {
+  try {
+    return { ok: true, value: JSON.parse(text) };
+  } catch {
+    return { ok: false };
+  }
+};
+var readFileOrNull = (path) => {
+  try {
+    return readFileSync(path, "utf-8");
+  } catch {
+    return null;
+  }
+};
+var candidateFromJsonText = (kind, text) => {
+  if (text === null) return null;
+  const parsed = tryParseJson(text);
+  return parsed.ok ? gateCandidate(kind, parsed.value) : null;
+};
+var FENCE_OPEN = /^\s*(`{3,})/;
+var FENCE_MARKER_ONLY = /^`+$/;
+var scanLine = (state, line) => {
+  if (state.openLength === null) {
+    const opened = FENCE_OPEN.exec(line)?.[1]?.length;
+    return opened !== void 0 ? { blocks: state.blocks, openLength: opened, buffer: [] } : state;
+  }
+  const trimmed = line.trim();
+  const closes = FENCE_MARKER_ONLY.test(trimmed) && trimmed.length >= state.openLength;
+  return closes ? { blocks: [...state.blocks, state.buffer.join("\n")], openLength: null, buffer: [] } : { ...state, buffer: [...state.buffer, line] };
+};
+var scanFencedBlocks = (text) => text.split("\n").reduce(scanLine, { blocks: [], openLength: null, buffer: [] }).blocks;
+var describeLadderFailure = (outcome) => {
+  switch (outcome.kind) {
+    case "error-envelope":
+      return `review did not complete: ${outcome.detail}`;
+    case "none":
+      return `could not recover a validating candidate: ${outcome.detail}`;
+    case "ambiguous":
+      return `ambiguous candidates: ${outcome.detail}`;
+  }
+};
+var okOutcome = (gated) => ({
+  kind: "ok",
+  version: gated.version,
+  candidate: gated.candidate
+});
+var extractStructured = (input) => {
+  const native = parseNativeForExtraction(input.native);
+  if (isErrorEnvelope(native)) {
+    return { kind: "error-envelope", detail: describeErrorEnvelope(native) };
+  }
+  if (input.kind === "findings" && input.agentFilePath !== void 0) {
+    const fromFile = candidateFromJsonText(input.kind, readFileOrNull(input.agentFilePath));
+    if (fromFile) return okOutcome(fromFile);
+  }
+  if (native.structuredOutput !== void 0) {
+    const fromStructured = gateCandidate(input.kind, native.structuredOutput);
+    if (fromStructured) return okOutcome(fromStructured);
+  }
+  if (typeof native.result === "string") {
+    const fromResult = candidateFromJsonText(input.kind, native.result.trim());
+    if (fromResult) return okOutcome(fromResult);
+    const fencedCandidates = dedupCandidates(
+      scanFencedBlocks(native.result).map((block) => candidateFromJsonText(input.kind, block)).filter((gated) => gated !== null)
+    );
+    const [survivor, ...rest] = fencedCandidates;
+    if (survivor !== void 0 && rest.length === 0) return okOutcome(survivor);
+    if (survivor !== void 0) {
+      return {
+        kind: "ambiguous",
+        detail: `${String(fencedCandidates.length)} distinct fenced JSON blocks each validate against the ${input.kind} schema \u2014 refusing to pick one`
+      };
+    }
+  }
+  return {
+    kind: "none",
+    detail: `no --agent-file, structured_output, JSON result, or fenced block validated against the ${input.kind} schema`
+  };
+};
+
+// src/adapt.ts
+var left = (message) => ({ _tag: "Left", left: message });
+var right = (value) => ({ _tag: "Right", right: value });
+var isAdapterName = (name) => name === "claude-code";
+var ClaudeCodeModelUsageEntryCodec = t.intersection([
+  t.type({
+    inputTokens: t.number,
+    outputTokens: t.number
+  }),
+  t.partial({
+    cacheReadInputTokens: t.number,
+    cacheCreationInputTokens: t.number,
+    costUSD: t.number
+  })
+]);
+var ClaudeCodeEnvelopeCodec = t.intersection([
+  t.type({
+    modelUsage: t.record(t.string, ClaudeCodeModelUsageEntryCodec),
+    num_turns: t.number,
+    duration_ms: t.number
+  }),
+  t.partial({
+    total_cost_usd: t.union([t.number, t.null]),
+    structured_output: t.unknown
+  })
+]);
+var mapModelUsage = (modelUsage) => Object.entries(modelUsage).map(([model, entry]) => ({
+  model,
+  input_tokens: entry.inputTokens,
+  output_tokens: entry.outputTokens,
+  ...entry.cacheReadInputTokens !== void 0 ? { cache_read_tokens: entry.cacheReadInputTokens } : {},
+  ...entry.cacheCreationInputTokens !== void 0 ? { cache_write_tokens: entry.cacheCreationInputTokens } : {}
+}));
+var adaptClaudeCode = (native, agentFilePath) => {
+  const outcome = extractStructured({ kind: "findings", native, agentFilePath });
+  if (outcome.kind !== "ok") {
+    return left(describeLadderFailure(outcome));
+  }
+  const resolution = resolve("findings", outcome.candidate);
+  return resolution.kind === "ok" ? right({
+    schema_version: resolution.version,
+    findings: resolution.value,
+    models: mapModelUsage(native.modelUsage),
+    turns: native.num_turns,
+    duration_ms: native.duration_ms,
+    vendor_cost_usd: native.total_cost_usd ?? null
+  }) : left(
+    "internal error: the extraction ladder validated a candidate the registry then rejected"
+  );
+};
+var adapt = (adapterName, native, agentFilePath) => {
+  switch (adapterName) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- exhaustive by design; AdapterName grows (e.g. "opencode") without collapsing this switch to an if
+    case "claude-code": {
+      const decoded = ClaudeCodeEnvelopeCodec.decode(native);
+      if (decoded._tag === "Left") {
+        return left("native envelope does not match the Claude Code output shape");
+      }
+      return adaptClaudeCode(decoded.right, agentFilePath);
+    }
+  }
+};
+
+// src/index.ts
+var readJSON = (path) => {
+  try {
+    return JSON.parse(readFileSync(resolve$1(path), "utf-8"));
+  } catch (err) {
+    fail(`Cannot read ${path}: ${err instanceof Error ? err.message : String(err)}`);
+    throw new Error("unreachable", { cause: err });
+  }
+};
+var fail = (msg) => {
+  process.stderr.write(`${msg}
+`);
+  process.exit(1);
+};
+var decode = (either, label) => {
+  try {
+    return unsafeUnwrap(either);
+  } catch {
+    fail(`${label} does not match expected shape`);
+  }
+  throw new Error("unreachable");
+};
+var unwrapAdapt = (either) => {
+  try {
+    if (either._tag === "Left") throw new Error(either.left);
+    return either.right;
+  } catch (err) {
+    fail(err instanceof Error ? err.message : String(err));
+  }
+  throw new Error("unreachable");
+};
+var bundledPath = (...segments) => resolve$1(import.meta.dirname, "..", ...segments);
+var packageVersion = JSON.parse(readFileSync(bundledPath("package.json"), "utf-8")).version;
+var resolveTemplatePath = (templateArg) => templateArg ? resolve$1(templateArg) : bundledPath("templates", "comment.eta");
+var resolvePricesPath = (pricesArg) => {
+  if (pricesArg) return resolve$1(pricesArg);
+  process.stderr.write(
+    "code-review: no --prices given \u2014 using the bundled example prices (all zero); cost figures will be $0\n"
+  );
+  return bundledPath("schema", "prices.example.json");
+};
+var TEST_REPORT_DESCRIPTION = 'Path to a JSON test summary: {"passed": number, "failed": number, "total": number, "failures"?: [{"name": string, "message"?: string}]}';
+var renderCmd = defineCommand({
+  meta: {
+    name: "render",
+    description: "Render a code-review comment from findings + usage + prices"
+  },
+  args: {
+    findings: {
+      type: "positional",
+      description: "Path to findings JSON",
+      required: true
+    },
+    template: {
+      type: "string",
+      description: "Path to Eta template file (default: bundled templates/comment.eta)"
+    },
+    usage: {
+      type: "string",
+      description: "Path to result envelope JSON (from agent CLI)",
+      required: true
+    },
+    prices: {
+      type: "string",
+      description: "Path to price map JSON (default: bundled schema/prices.example.json \u2014 all zero)"
+    },
+    "reviewed-sha": {
+      type: "string",
+      description: "SHA of the last reviewed commit"
+    },
+    route: {
+      type: "string",
+      description: 'Review route label (e.g. "full review" or "mechanic")',
+      required: true
+    },
+    effort: {
+      type: "string",
+      description: 'Effort label to render in the route line (e.g. "max" or "low"); omitted when absent'
+    },
+    "test-report": {
+      type: "string",
+      description: TEST_REPORT_DESCRIPTION
+    }
+  },
+  run: async ({ args }) => {
+    const findings = decode(FindingsCodec.decode(readJSON(args.findings)), "findings");
+    const envelope = decode(ResultEnvelopeCodec.decode(readJSON(args.usage)), "envelope");
+    const templatePath = resolveTemplatePath(args.template);
+    const pricesPath = resolvePricesPath(args.prices);
+    const prices = decode(PriceMapCodec.decode(readJSON(pricesPath)), "prices");
+    const template = readFileSync(templatePath, "utf-8");
+    const testReport = args["test-report"] ? decode(TestSummaryCodec.decode(readJSON(args["test-report"])), "test report") : void 0;
+    const output = render({
+      findings,
+      envelope,
+      prices,
+      template,
+      reviewedSha: args["reviewed-sha"],
+      route: args.route,
+      effort: args.effort,
+      testReport
+    });
+    process.stdout.write(output);
+  }
+});
+var inlineCmd = defineCommand({
+  meta: {
+    name: "inline",
+    description: "Build GitHub reviews comments[] payload from findings + diff"
+  },
+  args: {
+    findings: {
+      type: "positional",
+      description: "Path to findings JSON",
+      required: true
+    },
+    diff: {
+      type: "string",
+      description: "Path to PR diff file",
+      required: true
+    },
+    template: {
+      type: "string",
+      description: "Path to inline comment Eta template (default: built-in format)"
+    }
+  },
+  run: async ({ args }) => {
+    const findings = decode(FindingsCodec.decode(readJSON(args.findings)), "findings");
+    const diff = readFileSync(resolve$1(args.diff), "utf-8");
+    const inlineTemplate = args.template ? readFileSync(resolve$1(args.template), "utf-8") : void 0;
+    const { comments, strays } = buildInlineComments(findings.findings, diff, inlineTemplate);
+    process.stdout.write(
+      JSON.stringify({ comments, strays, stray_markdown: renderStraysSection(strays) }, null, 2)
+    );
+  }
+});
+var costCmd = defineCommand({
+  meta: {
+    name: "cost",
+    description: "Recompute USD cost from the envelope's models array + price map"
+  },
+  args: {
+    envelope: {
+      type: "positional",
+      description: "Path to result envelope JSON",
+      required: true
+    },
+    prices: {
+      type: "string",
+      description: "Path to price map JSON",
+      required: true
+    }
+  },
+  run: async ({ args }) => {
+    const envelope = decode(ResultEnvelopeCodec.decode(readJSON(args.envelope)), "envelope");
+    const prices = decode(PriceMapCodec.decode(readJSON(args.prices)), "prices");
+    const report = computeCost(envelope.models, prices);
+    process.stdout.write(JSON.stringify(report, null, 2));
+  }
+});
+var declaredSchemaVersion = (raw) => typeof raw === "object" && raw !== null && "schema_version" in raw ? typeof raw.schema_version === "string" ? raw.schema_version : void 0 : void 0;
+var derivedSchemaVersion = (kind, raw) => kind === "findings" ? declaredSchemaVersion(raw) : void 0;
+var validateCmd = defineCommand({
+  meta: {
+    name: "validate",
+    description: "Validate a findings/triage/prices JSON document against the canonical schema"
+  },
+  args: {
+    document: {
+      type: "positional",
+      description: "Path to the JSON document to validate (of the given --kind)",
+      required: true
+    },
+    kind: {
+      type: "string",
+      description: "Schema kind to validate against: findings | triage | prices (default: findings)"
+    },
+    schema: {
+      type: "string",
+      description: "Path to a schema file (wins over --kind; default: the bundled schema derived from --kind, --schema-version, the document's declared schema_version, or the bundled latest)"
+    },
+    "schema-version": {
+      type: "string",
+      description: "Schema major.minor version to validate against (default: the document's declared schema_version for findings, or the kind's latest)"
+    }
+  },
+  run: async ({ args }) => {
+    const kind = requireSchemaKind(args.kind || "findings");
+    const documentRaw = readJSON(args.document);
+    const schemaPath = args.schema ? resolve$1(args.schema) : requireSchemaPath(kind, args["schema-version"] || derivedSchemaVersion(kind, documentRaw));
+    const { valid, errors } = validateAgainstSchema(documentRaw, schemaPath);
+    if (valid) {
+      process.stdout.write("\u2705 valid\n");
+    } else {
+      process.stderr.write("\u274C invalid\n");
+      for (const e of errors) process.stderr.write(`  - ${e}
+`);
+      process.exit(1);
+    }
+  }
+});
+var adaptCmd = defineCommand({
+  meta: {
+    name: "adapt",
+    description: "Map a native agent-CLI result envelope onto the abstract SPEC \xA76.1 envelope"
+  },
+  args: {
+    native: {
+      type: "positional",
+      description: "Path to the native result envelope JSON (from the agent CLI)",
+      required: true
+    },
+    adapter: {
+      type: "string",
+      description: 'Adapter to use (currently: "claude-code")',
+      required: true
+    },
+    "agent-file": {
+      type: "string",
+      description: "Path to a file the agent was told to write its own validated findings JSON to (wins over the native envelope's structured_output/result when it validates)"
+    }
+  },
+  run: async ({ args }) => {
+    const envelope = unwrapAdapt(
+      adapt(requireAdapterName(args.adapter), readJSON(args.native), args["agent-file"])
+    );
+    process.stdout.write(`${JSON.stringify(envelope, null, 2)}
+`);
+  }
+});
+var isExtractSchemaKind = (s) => s === "findings" || s === "triage";
+var requireExtractSchemaKind = (name) => {
+  if (isExtractSchemaKind(name)) return name;
+  fail(`Unknown kind "${name}" for extract \u2014 expected one of: findings, triage`);
+  throw new Error("unreachable");
+};
+var failClosedTriage = (outcome) => ({
+  safe: false,
+  reasons: describeLadderFailure(outcome)
+});
+var extractCmd = defineCommand({
+  meta: {
+    name: "extract",
+    description: "Recover findings/triage JSON from a native agent-CLI result envelope via the deterministic extraction ladder"
+  },
+  args: {
+    native: {
+      type: "positional",
+      description: "Path to the native result envelope JSON (from the agent CLI)",
+      required: true
+    },
+    adapter: {
+      type: "string",
+      description: 'Adapter whose native envelope shape to extract from (currently: "claude-code")',
+      required: true
+    },
+    kind: {
+      type: "string",
+      description: "Schema kind to extract: findings | triage",
+      required: true
+    },
+    "agent-file": {
+      type: "string",
+      description: "Path to a file the agent was told to write its own validated JSON to (findings only \u2014 a documented no-op for triage)"
+    }
+  },
+  run: async ({ args }) => {
+    requireAdapterName(args.adapter);
+    const kind = requireExtractSchemaKind(args.kind);
+    const outcome = extractStructured({
+      kind,
+      native: readJSON(args.native),
+      agentFilePath: args["agent-file"]
+    });
+    if (outcome.kind === "ok") {
+      process.stdout.write(`${JSON.stringify(outcome.candidate, null, 2)}
+`);
+      return;
+    }
+    if (kind === "triage") {
+      process.stdout.write(`${JSON.stringify(failClosedTriage(outcome), null, 2)}
+`);
+      return;
+    }
+    fail(describeLadderFailure(outcome));
+  }
+});
+var requireAdapterName = (name) => {
+  if (isAdapterName(name)) return name;
+  fail(`Unknown adapter "${name}" \u2014 supported: claude-code`);
+  throw new Error("unreachable");
+};
+var isSchemaKind = (s) => s === "findings" || s === "triage" || s === "prices";
+var requireSchemaKind = (name) => {
+  if (isSchemaKind(name)) return name;
+  fail(`Unknown schema "${name}" \u2014 expected one of: findings, triage, prices`);
+  throw new Error("unreachable");
+};
+var requireSchemaPath = (kind, version) => {
+  try {
+    return schemaPathFor(kind, version);
+  } catch (err) {
+    fail(err instanceof Error ? err.message : String(err));
+  }
+  throw new Error("unreachable");
+};
+var printSchemaCmd = defineCommand({
+  meta: {
+    name: "print-schema",
+    description: "Print a bundled schema JSON"
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "Schema to print: findings | triage | prices",
+      required: true
+    },
+    "schema-version": {
+      type: "string",
+      description: "Schema major.minor version to print (default: latest)"
+    }
+  },
+  run: async ({ args }) => {
+    const schemaKind = requireSchemaKind(args.name);
+    const schemaPath = requireSchemaPath(schemaKind, args["schema-version"]);
+    process.stdout.write(readFileSync(schemaPath, "utf-8"));
+  }
+});
+var gatherCmd = defineCommand({
+  meta: {
+    name: "gather",
+    description: "Resolve the PR from the CI head SHA and gather review inputs (diff with git-diff fallback, PR context, prior bot review, failing-job logs) as files for the review agent"
+  },
+  args: {
+    repo: { type: "string", description: "Repository (owner/name)", required: true },
+    "head-sha": {
+      type: "string",
+      description: "Trusted head SHA to resolve the PR (from workflow_run.head_sha)",
+      required: true
+    },
+    "head-branch": {
+      type: "string",
+      description: "Head branch to disambiguate the PR when multiple share a commit"
+    },
+    "run-id": {
+      type: "string",
+      description: "CI run id (from workflow_run.id); its failing jobs' logs are downloaded on failure",
+      required: true
+    },
+    conclusion: {
+      type: "string",
+      description: "CI conclusion (e.g. success | failure); failure triggers failing-job log download",
+      required: true
+    },
+    "bot-login": {
+      type: "string",
+      description: "Bot login whose last PR comment is captured as prior review (default: github-actions[bot])"
+    },
+    "out-dir": {
+      type: "string",
+      description: "Directory to write gathered files into (default: current directory)"
+    }
+  },
+  run: async ({ args }) => {
+    const result = await gather({
+      repo: args.repo,
+      headSha: args["head-sha"],
+      headBranch: args["head-branch"],
+      runId: args["run-id"],
+      conclusion: args.conclusion,
+      botLogin: args["bot-login"] || "github-actions[bot]",
+      outDir: args["out-dir"] ? resolve$1(args["out-dir"]) : process.cwd()
+    });
+    process.stdout.write(renderOutputs(result));
+  }
+});
+var postCmd = defineCommand({
+  meta: {
+    name: "post",
+    description: "Post a complete review (inline comments + sticky summary) from findings + envelope + diff"
+  },
+  args: {
+    findings: {
+      type: "positional",
+      description: "Path to findings JSON",
+      required: true
+    },
+    "head-sha": {
+      type: "string",
+      description: "Trusted head SHA to resolve the PR (from workflow_run.head_sha)",
+      required: true
+    },
+    repo: {
+      type: "string",
+      description: "Repository (owner/name)",
+      required: true
+    },
+    usage: {
+      type: "string",
+      description: "Path to result envelope JSON (from agent CLI)",
+      required: true
+    },
+    prices: {
+      type: "string",
+      description: "Path to price map JSON (default: bundled schema/prices.example.json \u2014 all zero)"
+    },
+    template: {
+      type: "string",
+      description: "Path to Eta template file for the summary comment (default: bundled templates/comment.eta)"
+    },
+    "inline-template": {
+      type: "string",
+      description: "Path to inline comment Eta template (default: built-in format)"
+    },
+    route: {
+      type: "string",
+      description: 'Review route label (e.g. "full review" or "mechanic")',
+      required: true
+    },
+    "bot-login": {
+      type: "string",
+      description: "Bot login to trust for sticky comment upsert (default: github-actions[bot])"
+    },
+    "head-branch": {
+      type: "string",
+      description: "Head branch to disambiguate PR when multiple share a commit"
+    },
+    effort: {
+      type: "string",
+      description: 'Effort label to render in the route line (e.g. "max" or "low"); omitted when absent'
+    },
+    "test-report": {
+      type: "string",
+      description: TEST_REPORT_DESCRIPTION
+    }
+  },
+  run: async ({ args }) => {
+    await post({
+      repo: args.repo,
+      headSha: args["head-sha"],
+      botLogin: args["bot-login"] || "github-actions[bot]",
+      findingsPath: args.findings,
+      envelopePath: args.usage,
+      pricesPath: resolvePricesPath(args.prices),
+      templatePath: resolveTemplatePath(args.template),
+      inlineTemplatePath: args["inline-template"] ? resolve$1(args["inline-template"]) : void 0,
+      route: args.route,
+      headBranch: args["head-branch"],
+      effort: args.effort,
+      testReportPath: args["test-report"]
+    });
+  }
+});
+var main = defineCommand({
+  meta: {
+    name: "code-review",
+    version: packageVersion,
+    description: "Deterministic commenter for agentic PR review \u2014 gather, render, inline, post, adapt, extract, cost, and validate findings JSON"
+  },
+  subCommands: {
+    gather: gatherCmd,
+    render: renderCmd,
+    inline: inlineCmd,
+    post: postCmd,
+    cost: costCmd,
+    validate: validateCmd,
+    adapt: adaptCmd,
+    extract: extractCmd,
+    "print-schema": printSchemaCmd
+  }
+});
+if (!process.env["VITEST"]) {
+  await runMain(main);
+}
+
+export { main };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map