@jphutchins/code-review 0.1.0-alpha.24 → 0.1.0-alpha.26

package/README.md

@@ -41,6 +41,7 @@ npx @jphutchins/code-review <subcommand>
 | `gather` | Resolve the PR from the CI head SHA and gather the review inputs (diff with git-diff fallback, PR context, prior bot review, failing-job logs) into the workspace for the agent |
 | `parse-command` | Resolve a PR's head from its number and parse a ChatOps trigger comment (`/code-review [24m] [$1.00] <instructions>`) into review overrides — the on-demand comment trigger |
 | `react` | Add/remove a GitHub comment reaction — the ChatOps acknowledgement (👀 on receipt, 🚀 on completion) |
+| `await-ci` | Wait for a PR head's CI run to conclude and emit its real conclusion + run id — so an on-demand comment review routes on the CI result (success → full, failure → mechanic) instead of reviewing blind |
 | `render` | Render the sticky-comment markdown from findings + usage + prices |
 | `inline` | Build the GitHub reviews `comments[]` payload from findings + diff (in-diff validation; strays demote to the summary) |
 | `adapt` | Map a native agent-CLI result envelope onto the abstract result envelope (`src/schema.ts`) |
@@ -71,6 +72,13 @@ in [templates/](templates/). See [docs/adapters.md](docs/adapters.md) for the ad
    introducing PR won't review itself — then open a test PR.
 5. First run: consider `egress-policy: audit` to discover the real allowlist, then switch to `block`
    ([SPEC Appendix A](SPEC.md#appendix-a--reference-realization-github-actions-non-normative)).
+6. Optional — add on-demand reviews too: copy
+   [examples/workflows/review-on-comment.yaml](examples/workflows/review-on-comment.yaml) so a
+   write-access user can comment `/code-review [24m] [$1.00] <instructions>` on a PR to review it
+   now, with an optional per-run budget and focus. Comment before CI finishes and it waits for CI and
+   routes on the real result (success → full review, failure → mechanic), same as the CI trigger. See the
+   [ChatOps section](examples/workflows/README.md#comment--chatops-trigger-on-demand-reviews) for the
+   security model.
 
 Every model knob is committed step `env` on the workflow's triage and review steps — models,
 efforts, the subagent model, and the tier aliases, right where each is consumed — edited and

package/dist/index.js

@@ -9,6 +9,7 @@ import { Ajv2020 } from 'ajv/dist/2020.js';
 import _addFormats from 'ajv-formats';
 import * as t from 'io-ts';
 import { execFile } from 'child_process';
+import { PathReporter } from 'io-ts/lib/PathReporter.js';
 
 // src/cost.ts
 var defaultWarn = (message) => {
@@ -460,12 +461,12 @@ var sumTranscriptUsage = (entries) => {
     },
     { totals: /* @__PURE__ */ new Map(), turns: 0, seen: /* @__PURE__ */ new Set() }
   );
-  const models = [...summed.totals].map(([model, t6]) => ({
+  const models = [...summed.totals].map(([model, t7]) => ({
     model,
-    input_tokens: t6.input,
-    output_tokens: t6.output,
-    cache_read_tokens: t6.cacheRead,
-    cache_write_tokens: t6.cacheWrite
+    input_tokens: t7.input,
+    output_tokens: t7.output,
+    cache_read_tokens: t7.cacheRead,
+    cache_write_tokens: t7.cacheWrite
   }));
   const bounds = entries.reduce(
     (acc, entry) => {
@@ -802,7 +803,7 @@ var writesToDraft = (toolName, toolInput, draftPath) => {
   const targets = [draftPath, basename(draftPath), "$DRAFT", "${DRAFT}"];
   if (WRITE_TOOLS.has(toolName)) {
     const fp = rec?.["file_path"] ?? rec?.["notebook_path"];
-    if (typeof fp === "string" && targets.some((t6) => fp === t6 || basename(fp) === basename(t6)))
+    if (typeof fp === "string" && targets.some((t7) => fp === t7 || basename(fp) === basename(t7)))
       return true;
   }
   if (toolName === "Bash") {
@@ -898,9 +899,9 @@ var parseWallMs = (raw) => {
 };
 var parseEpochSecMs = (raw) => {
   if (raw === void 0) return null;
-  const t6 = raw.trim();
-  if (!/^\d+$/.test(t6)) return null;
-  const n = Number.parseInt(t6, 10);
+  const t7 = raw.trim();
+  if (!/^\d+$/.test(t7)) return null;
+  const n = Number.parseInt(t7, 10);
   return Number.isFinite(n) && n > 0 ? n * 1e3 : null;
 };
 var anchoredElapsedMs = (src) => {
@@ -1054,18 +1055,27 @@ var runGhApi = (args, stdin, env) => new Promise((resolve3, reject) => {
 });
 
 // src/pr.ts
+var CANDIDATE_JQ = ".[] | {number: .number, state: .state, headRef: .head.ref, headSha: .head.sha}";
+var parseCandidates = (stdout) => parseJsonl(stdout);
 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));
+  const direct = parseCandidates(
+    await ghApi([`repos/${repo}/commits/${headSha}/pulls`, "--jq", CANDIDATE_JQ])
+  );
+  if (direct.length > 0) return direct;
+  const open = parseCandidates(
+    await ghApi([
+      `repos/${repo}/pulls?state=open&per_page=100`,
+      "--paginate",
+      "--jq",
+      CANDIDATE_JQ
+    ])
+  );
+  return open.filter((c) => c.headSha === headSha);
 };
 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];
+  const chosen = scoped.find((c) => c.state === "open") ?? 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 };
 };
@@ -1315,8 +1325,8 @@ var priorBotCommentIds = (raw, botLogin) => {
   const nodes = conn?.nodes;
   if (!Array.isArray(nodes)) return { ids: [], truncated };
   const logins = [botLogin.replace(/\[bot\]$/, ""), botLogin];
-  const ids = nodes.flatMap((t6) => {
-    const cnodes = t6.comments?.nodes;
+  const ids = nodes.flatMap((t7) => {
+    const cnodes = t7.comments?.nodes;
     return Array.isArray(cnodes) ? cnodes.map((c) => priorBotCommentId(c, logins)).filter((id) => id !== null) : [];
   });
   return { ids, truncated };
@@ -1764,6 +1774,54 @@ var react = async (input, ghApi = runGhApi) => {
     await removeReactions(input.repo, input.commentId, input.remove, ghApi);
   }
 };
+var RunCodec = t.type({
+  id: t.number,
+  name: t.union([t.string, t.null]),
+  status: t.union([t.string, t.null]),
+  conclusion: t.union([t.string, t.null]),
+  run_number: t.number
+});
+var RunsCodec = t.type({ workflow_runs: t.array(RunCodec) });
+var resolveCiRun = async (repo, headSha, workflowName, ghApi) => {
+  const stdout = await ghApi([`repos/${repo}/actions/runs?head_sha=${headSha}&per_page=100`]);
+  const decoded = RunsCodec.decode(JSON.parse(stdout));
+  if (decoded._tag === "Left")
+    throw new Error(
+      `workflow runs for ${headSha} did not match the expected shape: ${PathReporter.report(decoded).join("; ")}`
+    );
+  const runs = decoded.right.workflow_runs;
+  const latest = 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 },
+    seenNames: [...new Set(runs.flatMap((r) => r.name === null ? [] : [r.name]))]
+  };
+};
+var awaitCiConclusion = async (repo, headSha, options, deps = { ghApi: runGhApi, sleep: defaultSleep, elapsedMs: monotonicElapsed() }) => {
+  const poll = async () => {
+    const { run, seenNames } = await resolveCiRun(repo, headSha, options.workflowName, deps.ghApi);
+    if (run !== null && run.status === "completed")
+      return { kind: "concluded", conclusion: run.conclusion ?? "unknown", runId: run.id };
+    if (deps.elapsedMs() >= options.timeoutMs)
+      return { kind: "timed-out", runId: run === null ? null : run.id, seenNames };
+    await deps.sleep(options.pollIntervalMs);
+    return poll();
+  };
+  return poll();
+};
+var defaultSleep = (ms) => new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
+var monotonicElapsed = () => {
+  const start = Date.now();
+  return () => Date.now() - start;
+};
+var renderCiOutputs = (outcome) => outcome.kind === "concluded" ? `ci_settled=true
+ci_conclusion=${outcome.conclusion}
+ci_run_id=${String(outcome.runId)}
+` : `ci_settled=false
+ci_run_id=${outcome.runId === null ? "" : String(outcome.runId)}
+`;
 var renderOutputs = (result) => {
   switch (result.kind) {
     case "skip":
@@ -3302,6 +3360,10 @@ var requirePositiveInt = (raw, flag) => {
   const n = Number.parseInt(raw, 10);
   return Number.isInteger(n) && n > 0 && /^\d+$/.test(raw) ? n : fail(`${flag} must be a positive integer; got "${raw}"`);
 };
+var requireWallMs = (raw, flag, fallback) => {
+  const ms = parseWallMs(raw || fallback);
+  return ms === null ? fail(`${flag} must be a duration like 30m, 15s, or 1h (got "${raw ?? ""}")`) : ms;
+};
 var parseCommandCmd = defineCommand({
   meta: {
     name: "parse-command",
@@ -3394,6 +3456,46 @@ var reactCmd = defineCommand({
     );
   }
 });
+var awaitCiCmd = defineCommand({
+  meta: {
+    name: "await-ci",
+    description: "Wait for the PR head's CI workflow run to conclude, then emit its REAL conclusion + run id to $GITHUB_OUTPUT (ci_settled, ci_conclusion, ci_run_id). The on-demand comment trigger uses this so it routes on the same CI result the CI-completion trigger would \u2014 success \u2192 full review, failure \u2192 mechanic with that run's logs \u2014 instead of reviewing blind. Polls until the run completes or the timeout elapses; ci_settled=false \u21D2 no conclusive result (caller should decline to review, not guess)."
+  },
+  args: {
+    repo: { type: "string", description: "Repository (owner/name)", required: true },
+    "head-sha": {
+      type: "string",
+      description: "PR head SHA to find the CI run for (resolved from the trusted PR number)",
+      required: true
+    },
+    "ci-workflow": {
+      type: "string",
+      description: 'CI workflow name to wait for \u2014 the name: of your CI workflow (default: "CI")'
+    },
+    timeout: {
+      type: "string",
+      description: "Give up waiting after this wall (default: 30m)"
+    },
+    "poll-interval": {
+      type: "string",
+      description: "How often to re-check the run status (default: 15s)"
+    }
+  },
+  run: async ({ args }) => {
+    const workflowName = args["ci-workflow"] || "CI";
+    const outcome = await awaitCiConclusion(args.repo, args["head-sha"], {
+      workflowName,
+      pollIntervalMs: requireWallMs(args["poll-interval"], "--poll-interval", "15s"),
+      timeoutMs: requireWallMs(args.timeout, "--timeout", "30m")
+    });
+    process.stderr.write(
+      outcome.kind === "concluded" ? `code-review await-ci: CI run ${String(outcome.runId)} ("${workflowName}") concluded "${outcome.conclusion}"
+` : `code-review await-ci: no run named "${workflowName}" concluded before the timeout \u2014 not reviewing.${outcome.seenNames.length > 0 ? ` Workflow names seen for this head SHA: ${outcome.seenNames.join(", ")} \u2014 check --ci-workflow matches one.` : " No workflow runs were seen for this head SHA at all."}
+`
+    );
+    process.stdout.write(renderCiOutputs(outcome));
+  }
+});
 var main = defineCommand({
   meta: {
     name: "code-review",
@@ -3404,6 +3506,7 @@ var main = defineCommand({
     gather: gatherCmd,
     "parse-command": parseCommandCmd,
     react: reactCmd,
+    "await-ci": awaitCiCmd,
     render: renderCmd,
     inline: inlineCmd,
     post: postCmd,