@jphutchins/code-review 0.1.0-alpha.31 → 0.1.0-alpha.33

package/dist/index.js

@@ -1068,9 +1068,9 @@ 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;
+  const latest2 = tableFor(kind).find((entry) => entry.latest);
+  if (!latest2) throw new Error(`Registry invariant violated \u2014 no latest entry for "${kind}"`);
+  return latest2.defaultVersion;
 };
 var bundledSchemaPath = (relativePath) => resolve$1(import.meta.dirname, "..", "schema", relativePath);
 var schemaPathFor = (kind, version) => {
@@ -1105,27 +1105,61 @@ var resolvers = {
   prices: (raw) => resolveSingleVersion("prices", raw)
 };
 var resolve = (kind, raw) => resolvers[kind](raw);
-var describeEndpoint = (args) => args.find((a) => a === "graphql" || a.includes("/") && !a.startsWith("-")) ?? args[0] ?? "(no endpoint)";
-var runGhApi = (args, stdin, env) => new Promise((resolve3, reject) => {
+var MAX_BUFFER = 100 * 1024 * 1024;
+var MAX_TIMEOUT_MS = 2147483647;
+var parseTimeoutMs = (raw, fallback) => {
+  if (raw === void 0 || !/^\d+$/.test(raw)) return fallback;
+  const parsed = Number(raw);
+  return parsed > 0 && parsed <= MAX_TIMEOUT_MS ? parsed : fallback;
+};
+var SUBPROCESS_TIMEOUT_ENV = "CODE_REVIEW_SUBPROCESS_TIMEOUT_MS";
+var DEFAULT_SUBPROCESS_TIMEOUT_MS = 12e4;
+var subprocessTimeoutMs = () => parseTimeoutMs(process.env[SUBPROCESS_TIMEOUT_ENV], DEFAULT_SUBPROCESS_TIMEOUT_MS);
+var classifyExecError = (err, stderr, timeoutMs) => {
+  const e = err;
+  const stderrStr = stderr.trim();
+  if (e.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER")
+    return `output exceeded ${String(MAX_BUFFER)} bytes (killed)`;
+  if (e.killed === true)
+    return `no response within ${String(timeoutMs)}ms (killed a hung child)${stderrStr ? `: ${stderrStr}` : ""}`;
+  return stderrStr || errMsg(err);
+};
+var execFileWithTimeout = (spec) => new Promise((resolve3, reject) => {
   const child = execFile(
-    "gh",
-    ["api", ...args],
-    { env: { ...process.env, ...env }, encoding: "utf-8", maxBuffer: 100 * 1024 * 1024 },
+    spec.command,
+    [...spec.args],
+    {
+      ...spec.env ? { env: { ...process.env, ...spec.env } } : {},
+      encoding: "utf-8",
+      maxBuffer: MAX_BUFFER,
+      timeout: spec.timeoutMs,
+      killSignal: "SIGKILL"
+    },
     (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 ${describeEndpoint(args)} failed: ${stderrStr || errStr}`));
-      } else {
-        resolve3(stdout);
-      }
+      if (err)
+        reject(
+          new Error(`${spec.label} failed: ${classifyExecError(err, stderr, spec.timeoutMs)}`)
+        );
+      else resolve3(stdout);
     }
   );
-  if (stdin !== void 0) {
-    child.stdin?.end(stdin);
+  if (spec.stdin !== void 0) {
+    child.stdin?.on("error", () => void 0);
+    child.stdin?.end(spec.stdin);
   }
 });
 
+// src/gh.ts
+var describeEndpoint = (args) => args.find((a) => a === "graphql" || a.includes("/") && !a.startsWith("-")) ?? args[0] ?? "(no endpoint)";
+var runGhApi = (args, stdin, env) => execFileWithTimeout({
+  command: "gh",
+  args: ["api", ...args],
+  label: `gh api ${describeEndpoint(args)}`,
+  timeoutMs: subprocessTimeoutMs(),
+  env,
+  stdin
+});
+
 // src/pr.ts
 var CANDIDATE_JQ = ".[] | {number: .number, state: .state, headRef: .head.ref, headSha: .head.sha}";
 var parseCandidates = (stdout) => parseJsonl(stdout);
@@ -1725,6 +1759,134 @@ var announce = async (input, ghApi = runGhApi) => {
     ghApi
   );
 };
+var incompleteBody = (headSha, runUrl, existingBody) => {
+  const notice = `${DEFAULT_MARKER}
+
+\u26A0\uFE0F **Code review did not complete** for \`${headSha.slice(0, 7)}\` \u2014 the review job failed ([run](${runUrl})). Re-request the review; do not treat this round as spent.`;
+  const carried = existingBody ? carryForwardMarkers(existingBody) : "";
+  return carried ? `${notice}
+
+${carried}` : notice;
+};
+var reportIncomplete = async (input, ghApi = runGhApi) => {
+  const candidates = await fetchPrCandidates(input.repo, input.headSha, ghApi);
+  const resolution = resolvePr(candidates, input.headBranch);
+  if (resolution.kind !== "open") {
+    process.stderr.write(
+      `No open PR for ${input.headSha} \u2014 nothing to report (${resolution.kind})
+`
+    );
+    return;
+  }
+  const existing = await findBotComment(
+    input.repo,
+    resolution.prNumber,
+    input.botLogin,
+    DEFAULT_MARKER,
+    ghApi
+  );
+  if (existing !== null && parseReviewComplete(existing.body)) {
+    process.stderr.write(`Sticky already reflects a completed review \u2014 leaving it in place
+`);
+    return;
+  }
+  if (existing !== null && !existing.body.includes(input.runUrl)) {
+    process.stderr.write(`Sticky belongs to another run \u2014 leaving it in place
+`);
+    return;
+  }
+  await upsertSticky(
+    input.repo,
+    resolution.prNumber,
+    existing,
+    incompleteBody(input.headSha, input.runUrl, existing?.body),
+    ghApi
+  );
+};
+
+// src/checkrun.ts
+var CHECK_RUN_NAME = "Code review";
+var latest = (checks) => checks.reduce(
+  (best, c) => best === null || c.id > best.id ? c : best,
+  null
+);
+var isOpen = (status) => status === "in_progress" || status === "queued";
+var settled = /* @__PURE__ */ new Set(["success", "neutral", "skipped"]);
+var decideCheckAction = (checks, intent) => {
+  const head = latest(checks);
+  switch (intent) {
+    case "in_progress":
+      return head !== null && isOpen(head.status) ? { kind: "noop", reason: "a check is already in progress for this head" } : { kind: "create", status: "in_progress" };
+    case "neutral":
+      if (head === null) return { kind: "create", status: "completed", conclusion: "neutral" };
+      return head.status === "completed" && head.conclusion === "neutral" ? { kind: "noop", reason: "the check already records this completed review" } : { kind: "patch", id: head.id, status: "completed", conclusion: "neutral" };
+    case "failure":
+      if (head === null) return { kind: "create", status: "completed", conclusion: "failure" };
+      if (head.status === "completed" && head.conclusion !== null && settled.has(head.conclusion))
+        return { kind: "noop", reason: "a completed review already recorded this head" };
+      return head.status === "completed" && head.conclusion === "failure" ? { kind: "noop", reason: "the check already records this failure" } : { kind: "patch", id: head.id, status: "completed", conclusion: "failure" };
+  }
+};
+var CHECK_JQ = ".check_runs[] | {id: .id, status: .status, conclusion: .conclusion}";
+var fetchChecks = async (repo, headSha, ghApi) => parseJsonl(
+  await ghApi([
+    `repos/${repo}/commits/${headSha}/check-runs?check_name=${encodeURIComponent(CHECK_RUN_NAME)}&per_page=100`,
+    "--paginate",
+    "--jq",
+    CHECK_JQ
+  ])
+);
+var output = (intent, runUrl) => {
+  switch (intent) {
+    case "in_progress":
+      return {
+        title: "Code review in progress",
+        summary: `The review is running \u2014 [see the run](${runUrl}).`
+      };
+    case "neutral":
+      return {
+        title: "Code review complete",
+        summary: `The review was posted \u2014 [see the run](${runUrl}).`
+      };
+    case "failure":
+      return {
+        title: "Code review did not complete",
+        summary: `The review job failed \u2014 [see the run](${runUrl}). Re-request the review; do not treat this round as spent.`
+      };
+  }
+};
+var checkRun = async (input, ghApi = runGhApi) => {
+  const action = decideCheckAction(
+    await fetchChecks(input.repo, input.headSha, ghApi),
+    input.intent
+  );
+  if (action.kind === "noop") {
+    process.stderr.write(`code-review check-run: ${action.reason} \u2014 leaving it
+`);
+    return;
+  }
+  const body = action.kind === "create" ? {
+    name: CHECK_RUN_NAME,
+    head_sha: input.headSha,
+    status: action.status,
+    details_url: input.runUrl,
+    ...action.conclusion ? { conclusion: action.conclusion } : {},
+    output: output(input.intent, input.runUrl)
+  } : {
+    status: action.status,
+    conclusion: action.conclusion,
+    details_url: input.runUrl,
+    output: output(input.intent, input.runUrl)
+  };
+  const endpoint = action.kind === "create" ? [`--method`, `POST`, `repos/${input.repo}/check-runs`, `--input`, `-`] : [
+    `--method`,
+    `PATCH`,
+    `repos/${input.repo}/check-runs/${String(action.id)}`,
+    `--input`,
+    `-`
+  ];
+  await ghApi(endpoint, JSON.stringify(body));
+};
 var DURATION_RE = /^(\d+)(h|m|s)$/;
 var USD_RE = /^\$(\d+(?:\.\d+)?)$/;
 var toSeconds = (n, unit) => unit === "h" ? n * 3600 : unit === "m" ? n * 60 : n;
@@ -1931,12 +2093,12 @@ var resolveCiRun = async (repo, headSha, workflowName, ghApi) => {
 `
     );
   }
-  const latest = runs.filter((r) => r.name === workflowName).reduce(
+  const latest2 = runs.filter((r) => r.name === workflowName).reduce(
     (best, r) => best === null || r.run_number > best.run_number ? r : best,
     null
   );
   return {
-    run: latest === null ? null : { id: latest.id, status: latest.status ?? "unknown", conclusion: latest.conclusion },
+    run: latest2 === null ? null : { id: latest2.id, status: latest2.status ?? "unknown", conclusion: latest2.conclusion },
     seenNames: [...new Set(runs.flatMap((r) => r.name === null ? [] : [r.name]))]
   };
 };
@@ -1988,21 +2150,11 @@ stacked=${String(result.stacked)}
 `;
   }
 };
-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 runGit = (args) => execFileWithTimeout({
+  command: "git",
+  args,
+  label: `git ${args.join(" ")}`,
+  timeoutMs: subprocessTimeoutMs()
 });
 var PrMetaCodec = t.type({
   changed_files: t.number,
@@ -2698,7 +2850,7 @@ var renderCmd = defineCommand({
     const prices = decode(PriceMapCodec.decode(readJSON(priceResolution.path)), "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({
+    const output2 = render({
       findings,
       envelope,
       prices,
@@ -2710,7 +2862,7 @@ var renderCmd = defineCommand({
       testReport,
       postedAt: formatUtc(/* @__PURE__ */ new Date())
     });
-    process.stdout.write(output);
+    process.stdout.write(output2);
   }
 });
 var inlineCmd = defineCommand({
@@ -2900,7 +3052,7 @@ var budgetHookCmd = defineCommand({
       const prices = args.prices ? tryReadPrices(args.prices) : null;
       const spentUsd = prices !== null && usage ? computeCost(usage.models, prices).totalCostUSD : null;
       const wallMs = args.wall ? parseWallMs(args.wall) : null;
-      const output = evaluateBudgetHook(input, {
+      const output2 = evaluateBudgetHook(input, {
         spentUsd,
         budgetUsd: parseBudgetUsd(args["budget-usd"]),
         elapsedMs: anchoredElapsedMs({
@@ -2924,7 +3076,7 @@ var budgetHookCmd = defineCommand({
       });
       if (asRecord(input)?.["hook_event_name"] === "PostToolBatch" && !isSubagentHookInput(input))
         snapshotIfValid(draftPath);
-      process.stdout.write(`${JSON.stringify(output)}
+      process.stdout.write(`${JSON.stringify(output2)}
 `);
     } catch (err) {
       process.stderr.write(`code-review budget-hook: degrading to no-op \u2014 ${errMsg(err)}
@@ -3290,7 +3442,7 @@ var noticeCmd = defineCommand({
   run: ({ args }) => {
     if (!isNoticeKind(args.kind)) {
       process.stderr.write(
-        `::warning::code-review notice: unrecognized kind "${args.kind}" \u2014 the pinned CLI is older than the workflow calling it; rendering a generic incomplete notice
+        `::warning::code-review notice: unrecognized kind "${annotationSafe(args.kind)}" \u2014 the pinned CLI is older than the workflow calling it; rendering a generic incomplete notice
 `
       );
       process.stdout.write(`${JSON.stringify(buildUnknownNoticeEnvelope(args.kind), null, 2)}
@@ -3738,6 +3890,92 @@ var announceCmd = defineCommand({
     );
   }
 });
+var isCheckIntent = (s) => s === "in_progress" || s === "neutral" || s === "failure";
+var checkRunCmd = defineCommand({
+  meta: {
+    name: "check-run",
+    description: "Upsert the native 'Code review' check-run on the head SHA \u2014 the attribution surface that appears in the PR's own checks list and (writing to the base repo) works for fork PRs too. `in_progress` at review start, `neutral` when the review completes, `failure` when it didn't. Forward-only: `failure` never overwrites a completed review."
+  },
+  args: {
+    repo: { type: "string", description: "Repository (owner/name)", required: true },
+    "head-sha": {
+      type: "string",
+      description: "Head SHA the check-run is anchored to",
+      required: true
+    },
+    status: {
+      type: "positional",
+      description: "One of: in_progress, neutral, failure",
+      required: true
+    },
+    "run-url": {
+      type: "string",
+      description: "Workflow run URL the check-run's details link to",
+      required: true
+    }
+  },
+  run: async ({ args }) => {
+    if (!isCheckIntent(args.status)) {
+      process.stderr.write(
+        `::warning::code-review check-run: unrecognized status "${annotationSafe(args.status)}" \u2014 expected in_progress, neutral, or failure; skipping
+`
+      );
+      return;
+    }
+    await checkRun({
+      repo: args.repo,
+      headSha: args["head-sha"],
+      intent: args.status,
+      runUrl: args["run-url"]
+    }).catch(
+      (err) => process.stderr.write(
+        `::warning::code-review check-run: could not upsert the check-run (${annotationSafe(errMsg(err))}) \u2014 continuing (attribution aid)
+`
+      )
+    );
+  }
+});
+var reportIncompleteCmd = defineCommand({
+  meta: {
+    name: "report-incomplete",
+    description: "Post (or update) the sticky when a review job hard-failed and posted nothing \u2014 an attributed 'did not complete' notice linking the run, telling the reader to re-request. Never buries a completed review, and never overwrites a superseding run's live in-progress placeholder. (A cancelled review is left to the superseding run that took over.)"
+  },
+  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
+    },
+    "run-url": {
+      type: "string",
+      description: "Workflow run URL the notice links to",
+      required: true
+    },
+    "bot-login": {
+      type: "string",
+      description: "Bot login to trust for the sticky comment upsert (default: github-actions[bot])"
+    },
+    "head-branch": {
+      type: "string",
+      description: "Head branch to disambiguate the PR when multiple share a commit"
+    }
+  },
+  run: async ({ args }) => {
+    await reportIncomplete({
+      repo: args.repo,
+      headSha: args["head-sha"],
+      botLogin: args["bot-login"] || "github-actions[bot]",
+      runUrl: args["run-url"],
+      headBranch: args["head-branch"]
+    }).catch(
+      (err) => process.stderr.write(
+        `::warning::code-review report-incomplete: could not post the failure notice (${annotationSafe(errMsg(err))}) \u2014 continuing
+`
+      )
+    );
+  }
+});
 var requireCeilingSec = (raw) => {
   if (raw === void 0) return null;
   const ms = parseWallMs(raw);
@@ -3911,6 +4149,8 @@ var main = defineCommand({
     inline: inlineCmd,
     post: postCmd,
     announce: announceCmd,
+    "check-run": checkRunCmd,
+    "report-incomplete": reportIncompleteCmd,
     cost: costCmd,
     "check-cost": checkCostCmd,
     validate: validateCmd,