@jphutchins/code-review 0.1.0-alpha.67 → 0.1.0-alpha.69

package/README.md

@@ -38,10 +38,10 @@ npx @jphutchins/code-review <subcommand>
 | Subcommand | What it does |
 | --- | --- |
 | `post` | Post a complete review from findings + envelope + diff — the one-call path. The findings are listed in the sticky summary; `--inline` renders the in-diff ones as comments on the diff instead. Also renders the review into `$GITHUB_STEP_SUMMARY`: the sticky is overwritten each round, the run summary keeps each round as it stood |
-| `gather` | Resolve the PR from the CI head SHA and gather the review inputs (diff with git-diff fallback, PR context, prior bot review, the implementer's answers (`Review-Response:` lines and verdict tables), failing-job logs) into the directory named by `--out-dir` (default: the current directory; the shipped workflows use `$RUNNER_TEMP/gather`) |
+| `gather` | Resolve the PR from the CI head SHA and gather the review inputs (diff with git-diff fallback, PR context, prior bot review, the implementer's answers (`Review-Response:` lines and verdict tables), the CI run's job logs — the failing jobs', up to 20, on a failure, the jobs that ran, up to 64, on a pass) into the directory named by `--out-dir` (default: the current directory; the shipped workflows use `$RUNNER_TEMP/gather`) |
 | `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 |
+| `await-ci` | Wait for a PR head's CI run to conclude and emit its real conclusion, run id and run attempt — so an on-demand comment review routes on the CI result (success → full, failure → mechanic) instead of reviewing blind |
 | `check-scope` | Validate + normalize the workflow's `scope` input (the languages/inputs the project accepts) and print the normalized list for the review prompt, or nothing when empty (the reviewer then infers scope from the README's first paragraph); a structurally malformed value is rejected rather than spliced in as-is |
 | `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) |

package/dist/index.js

@@ -574,7 +574,7 @@ var incompleteFindings = (summary) => ({
 var isIncompleteFindings = (findings) => findings.verdict === "error" && findings.findings.length === 0;
 
 // src/released.ts
-var RELEASED = "2026-10-10";
+var RELEASED = "2026-10-11";
 
 // src/cost.ts
 var defaultWarn = (message) => {
@@ -2373,6 +2373,7 @@ var render = (input) => {
     answeredReRaiseNote: input.answeredReRaiseNote ?? "",
     contested: contestedBudget.kept,
     unfinished: shownUnfinished(input.findings, isFullReviewRound),
+    unfinishedCaveat: unfinished.length > 0 ? ` \u2014 ${String(unfinished.length)} planned check${unfinished.length === 1 ? "" : "s"} went unfinished` : "",
     reviewUrl: input.reviewUrl ?? null,
     formatTokens: (n) => Number.isFinite(n) && n >= 0 ? n.toLocaleString("en-US") : "\u2014",
     // N/A (never a false $0.00) when no real price map was provided — real tokens, no rates to
@@ -2788,7 +2789,7 @@ var timeClause = (i) => i.elapsedMs === null ? null : i.wallMs !== null && i.wal
 var directive = (phase, draftPath, isSubagent) => {
   if (isSubagent)
     return phase.kind === "hard" ? `Budget nearly exhausted \u2014 STOP all new investigation now and report the findings you have back to the main agent in your reply, naming each check you planned but did not finish. Do not write ${draftPath} yourself; only the main agent writes it.` : `Wind down investigation and report the findings you have back to the main agent in your reply, naming each check you planned but did not finish \u2014 do not write ${draftPath} yourself; the main agent writes it, and you may run out of budget otherwise.`;
-  return phase.kind === "hard" ? `Budget nearly exhausted \u2014 STOP all new investigation now. Do not wait for subagents still running in the background. Write your COMPLETE findings from what you already have to ${draftPath}, listing in its \`unfinished\` field, when its schema has one, every check you or a subagent planned but did not finish, and run \`code-review validate ${draftPath} --explain\` until it passes (--explain prints the exact schema when the shape is wrong). Other tools are blocked until that draft is written.` : `Wind down investigation and write your COMPLETE findings to ${draftPath} now, listing in its \`unfinished\` field, when its schema has one, every check you or a subagent planned but did not finish, then run \`code-review validate ${draftPath} --explain\` (it prints the exact schema if the shape is wrong) \u2014 fold in the subagent reports you already have rather than waiting on stragglers; you may run out of budget before you finish otherwise.`;
+  return phase.kind === "hard" ? `Budget nearly exhausted \u2014 STOP all new investigation now. Do not wait for subagents still running in the background. Write your COMPLETE findings from what you already have to ${draftPath}, listing in its \`unfinished\` field, when its schema has one, every check you or a subagent planned but did not finish (never one a CI job already ran and passed), and run \`code-review validate ${draftPath} --explain\` until it passes (--explain prints the exact schema when the shape is wrong). Other tools are blocked until that draft is written.` : `Wind down investigation and write your COMPLETE findings to ${draftPath} now, listing in its \`unfinished\` field, when its schema has one, every check you or a subagent planned but did not finish (never one a CI job already ran and passed), then run \`code-review validate ${draftPath} --explain\` (it prints the exact schema if the shape is wrong) \u2014 fold in the subagent reports you already have rather than waiting on stragglers; you may run out of budget before you finish otherwise.`;
 };
 var budgetMessage = (i, phase, draftPath, isSubagent) => {
   const status = [spendClause(i), timeClause(i)].filter((c) => c !== null).join(" \xB7 ");
@@ -5058,14 +5059,17 @@ 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 RUN_JQ = ".workflow_runs[] | {id: .id, name: .name, status: .status, conclusion: .conclusion, run_number: .run_number}";
+var RunCodec = t.intersection([
+  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
+  }),
+  t.partial({ run_attempt: t.union([t.number, t.null]) })
+]);
+var RUN_JQ = ".workflow_runs[] | {id: .id, name: .name, status: .status, conclusion: .conclusion, run_number: .run_number, run_attempt: .run_attempt}";
 var resolveCiRun = async (repo, headSha, workflowName, ghApi) => {
   const endpoint = `repos/${repo}/actions/runs?head_sha=${headSha}&per_page=100`;
   const rows = parseJsonl(await ghApi([endpoint, "--paginate", "--jq", RUN_JQ]));
@@ -5085,7 +5089,12 @@ var resolveCiRun = async (repo, headSha, workflowName, ghApi) => {
     null
   );
   return {
-    run: latest === null ? null : { id: latest.id, status: latest.status ?? "unknown", conclusion: latest.conclusion },
+    run: latest === null ? null : {
+      id: latest.id,
+      status: latest.status ?? "unknown",
+      conclusion: latest.conclusion,
+      attempt: latest.run_attempt ?? null
+    },
     seenNames: [...new Set(runs.flatMap((r) => r.name === null ? [] : [r.name]))]
   };
 };
@@ -5104,7 +5113,12 @@ var awaitCiConclusion = async (repo, headSha, options, deps = { ghApi: runGhApi,
   const poll = async (lastSeenNames, lastRunId) => {
     const { run: run2, seenNames } = await safeResolve();
     if (run2 !== null && run2.status === "completed" && run2.conclusion !== null)
-      return { kind: "concluded", conclusion: run2.conclusion, runId: run2.id };
+      return {
+        kind: "concluded",
+        conclusion: run2.conclusion,
+        runId: run2.id,
+        runAttempt: run2.attempt
+      };
     const runId = run2 === null ? lastRunId : run2.id;
     const names = seenNames.length > 0 ? seenNames : lastSeenNames;
     if (deps.elapsedMs() >= options.timeoutMs)
@@ -5122,6 +5136,7 @@ var monotonicElapsed = () => {
 var renderCiOutputs = (outcome) => outcome.kind === "concluded" ? `ci_settled=true
 ci_conclusion=${outcome.conclusion}
 ci_run_id=${String(outcome.runId)}
+ci_run_attempt=${outcome.runAttempt === null ? "" : String(outcome.runAttempt)}
 ` : `ci_settled=false
 ci_run_id=${outcome.runId === null ? "" : String(outcome.runId)}
 `;
@@ -5137,6 +5152,8 @@ stacked=${String(result.stacked)}
 base_sha=${result.baseSha}
 staged_job_logs=${String(result.stagedJobLogs)}
 failing_jobs=${String(result.failingJobs)}
+ci_jobs_passed=${result.passedJobs === null ? "" : String(result.passedJobs.passed)}
+ci_jobs_ran=${result.passedJobs === null ? "" : String(result.passedJobs.ran)}
 `;
   }
 };
@@ -5174,14 +5191,25 @@ var IssueCommentCodec = t.intersection([
     author_association: t.union([t.string, t.null])
   })
 ]);
-var JobCodec = t.type({
-  id: t.number,
-  // A null name (an API edge) degrades to a nameless entry rather than aborting the whole gather —
-  // the identity the reproduction steer needs is best-effort, never load-bearing.
-  name: t.union([t.string, t.null]),
-  conclusion: t.union([t.string, t.null])
-});
-var JOBS_JQ = ".jobs[] | {id: .id, name: .name, conclusion: .conclusion}";
+var JobCodec = t.intersection([
+  t.type({
+    id: t.number,
+    // A null name (an API edge) degrades to a nameless entry rather than aborting the whole gather —
+    // the identity the reproduction steer needs is best-effort, never load-bearing.
+    name: t.union([t.string, t.null]),
+    conclusion: t.union([t.string, t.null])
+  }),
+  t.partial({ steps: t.array(t.string) })
+]);
+var JOBS_JQ = ".jobs[] | {id: .id, name: .name, conclusion: .conclusion, steps: [.steps[]? | .name? | strings]}";
+var parseRunAttempt = (raw) => {
+  if (raw === void 0 || raw === "") return void 0;
+  if (!/^[1-9][0-9]*$/.test(raw)) {
+    throw new Error(`--run-attempt must be a positive integer, got ${JSON.stringify(raw)}`);
+  }
+  return raw;
+};
+var jobsEndpoint = (repo, runId, runAttempt) => runAttempt === void 0 ? `repos/${repo}/actions/runs/${runId}/jobs` : `repos/${repo}/actions/runs/${runId}/attempts/${runAttempt}/jobs`;
 var fetchPrMeta = async (repo, prNumber, ghApi) => {
   const stdout = await ghApi([
     `repos/${repo}/pulls/${String(prNumber)}`,
@@ -5331,35 +5359,46 @@ var reviewsFrom = (reviews, botLogin) => boundedHuman(reviews, botLogin, "review
   body: clip(r.body)
 }));
 var MAX_STAGED_JOB_LOGS = 20;
-var downloadFailingJobLogs = async (repo, runId, outDir, ghApi) => {
-  const rows = parseJsonl(
-    await ghApi([`repos/${repo}/actions/runs/${runId}/jobs`, "--paginate", "--jq", JOBS_JQ])
+var stageJobLog = async (repo, jobId, outDir, ghApi) => {
+  try {
+    const log = await ghApi([`repos/${repo}/actions/jobs/${String(jobId)}/logs`]);
+    if (log.trim() === "no log available" || log.trim() === "") {
+      process.stderr.write(
+        `Warning: job ${String(jobId)} has no log available (placeholder body) \u2014 not staged
+`
+      );
+      return null;
+    }
+    const file = `job_${String(jobId)}.log`;
+    writeFileSync(join(outDir, file), log);
+    return file;
+  } catch (err) {
+    process.stderr.write(
+      `Warning: failed to download logs for job ${String(jobId)}: ${errMsg(err)} \u2014 continuing with the logs retrieved so far
+`
+    );
+    return null;
+  }
+};
+var listRunJobs = async (repo, runId, runAttempt, ghApi) => {
+  const decoded = t.array(JobCodec).decode(
+    parseJsonl(
+      await ghApi([jobsEndpoint(repo, runId, runAttempt), "--paginate", "--jq", JOBS_JQ])
+    )
   );
-  const decoded = t.array(JobCodec).decode(rows);
   if (decoded._tag === "Left") {
     throw new Error(`Jobs list for run ${runId} did not match the expected shape`);
   }
-  const failing = decoded.right.filter((j) => j.conclusion === "failure");
+  return decoded.right;
+};
+var downloadFailingJobLogs = async (repo, runId, runAttempt, outDir, ghApi) => {
+  const failing = (await listRunJobs(repo, runId, runAttempt, ghApi)).filter(
+    (j) => j.conclusion === "failure"
+  );
   const selected = failing.slice(0, MAX_STAGED_JOB_LOGS);
   let staged = 0;
   for (const job of selected) {
-    try {
-      const log = await ghApi([`repos/${repo}/actions/jobs/${String(job.id)}/logs`]);
-      if (log.trim() === "no log available" || log.trim() === "") {
-        process.stderr.write(
-          `Warning: job ${String(job.id)} has no log available (placeholder body) \u2014 not staged
-`
-        );
-        continue;
-      }
-      writeFileSync(join(outDir, `job_${String(job.id)}.log`), log);
-      staged += 1;
-    } catch (err) {
-      process.stderr.write(
-        `Warning: failed to download logs for job ${String(job.id)}: ${errMsg(err)} \u2014 continuing with the logs retrieved so far
-`
-      );
-    }
+    if (await stageJobLog(repo, job.id, outDir, ghApi) !== null) staged += 1;
   }
   writeFileSync(
     join(outDir, "failed_jobs.json"),
@@ -5387,6 +5426,65 @@ var downloadFailingJobLogs = async (repo, runId, outDir, ghApi) => {
   }
   return { staged, failing: failing.length };
 };
+var MAX_STAGED_PASSED_JOB_LOGS = 64;
+var PASSED_LOG_CONCURRENCY = 8;
+var stagePassedRun = async (repo, runId, runAttempt, outDir, ghApi) => {
+  try {
+    const jobs = await listRunJobs(repo, runId, runAttempt, ghApi);
+    const writeIndex = (logs2) => {
+      writeFileSync(
+        join(outDir, "ci_jobs.json"),
+        `${JSON.stringify(
+          jobs.map((j) => ({
+            name: j.name,
+            conclusion: j.conclusion,
+            steps: j.steps ?? [],
+            log: logs2.get(j.id) ?? null
+          })),
+          null,
+          2
+        )}
+`
+      );
+    };
+    writeIndex(/* @__PURE__ */ new Map());
+    const ran = jobs.filter((j) => j.conclusion !== "skipped");
+    const selected = ran.slice(0, MAX_STAGED_PASSED_JOB_LOGS);
+    const logs = await Array.from(
+      { length: Math.ceil(selected.length / PASSED_LOG_CONCURRENCY) },
+      (_, i) => selected.slice(i * PASSED_LOG_CONCURRENCY, (i + 1) * PASSED_LOG_CONCURRENCY)
+    ).reduce(async (staged, batch) => {
+      const prior = await staged;
+      const files = await Promise.all(
+        batch.map(async (job) => [job.id, await stageJobLog(repo, job.id, outDir, ghApi)])
+      );
+      return new Map([
+        ...prior,
+        ...files.flatMap(([id, file]) => file === null ? [] : [[id, file]])
+      ]);
+    }, Promise.resolve(/* @__PURE__ */ new Map()));
+    writeIndex(logs);
+    if (ran.length > selected.length) {
+      process.stderr.write(
+        `::warning::${annotationSafe(`${String(ran.length)} jobs ran in the passed run ${runId}; logs were staged for the first ${String(selected.length)} only`)}
+`
+      );
+    }
+    return {
+      staged: logs.size,
+      passed: {
+        passed: jobs.filter((j) => j.conclusion === "success").length,
+        ran: ran.length
+      }
+    };
+  } catch (err) {
+    process.stderr.write(
+      `::warning::${annotationSafe(`the passed CI run's jobs could not be staged (${errMsg(err)}) \u2014 the review knows CI passed, not what its jobs reported`)}
+`
+    );
+    return { staged: 0, passed: null };
+  }
+};
 var gather = async (input, ghApi = runGhApi, gitRun = runGit, readArtifact = ghArtifactReader) => {
   const candidates = await fetchPrCandidates(input.repo, input.headSha, ghApi);
   const resolution = resolvePr(candidates, input.headBranch);
@@ -5490,7 +5588,8 @@ var gather = async (input, ghApi = runGhApi, gitRun = runGit, readArtifact = ghA
       reviews: reviews === null ? [] : reviewsFrom(reviews, input.botLogin)
     })
   );
-  const jobLogs = input.conclusion === "failure" ? await downloadFailingJobLogs(input.repo, input.runId, input.outDir, ghApi) : { staged: 0, failing: 0 };
+  const jobLogs = input.conclusion === "failure" ? await downloadFailingJobLogs(input.repo, input.runId, input.runAttempt, input.outDir, ghApi) : { staged: 0, failing: 0 };
+  const passedRun = input.conclusion === "success" ? await stagePassedRun(input.repo, input.runId, input.runAttempt, input.outDir, ghApi) : { staged: 0, passed: null };
   return {
     kind: "gathered",
     pr: prNumber,
@@ -5498,8 +5597,9 @@ var gather = async (input, ghApi = runGhApi, gitRun = runGit, readArtifact = ghA
     diffSize: Buffer.byteLength(prDiff, "utf8"),
     stacked,
     baseSha: meta.base_sha,
-    stagedJobLogs: jobLogs.staged,
-    failingJobs: jobLogs.failing
+    stagedJobLogs: jobLogs.staged + passedRun.staged,
+    failingJobs: jobLogs.failing,
+    passedJobs: passedRun.passed
   };
 };
 
@@ -7081,7 +7181,7 @@ var stopGateCmd = defineCommand({
 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, untrusted PR conversation to triage, failing-job logs and the failing jobs' identities in failed_jobs.json) as files for the review agent"
+    description: "Resolve the PR from the CI head SHA and gather review inputs (diff with git-diff fallback, PR context, prior bot review, untrusted PR conversation to triage, the CI run's job logs \u2014 the failing jobs' with their identities in failed_jobs.json on a failure, the jobs that ran, up to 64, indexed in ci_jobs.json on a pass) as files for the review agent"
   },
   args: {
     repo: { type: "string", description: "Repository (owner/name)", required: true },
@@ -7101,12 +7201,16 @@ var gatherCmd = defineCommand({
     },
     "run-id": {
       type: "string",
-      description: "CI run id (from workflow_run.id); its failing jobs' logs are downloaded on failure",
+      description: "CI run id (from workflow_run.id); its job logs are downloaded \u2014 the failing jobs' on failure, the jobs that ran (up to 64) on success",
       required: true
     },
+    "run-attempt": {
+      type: "string",
+      description: "The CI run's attempt that triggered the review (from workflow_run.run_attempt); its jobs' logs are the ones staged, even after a re-run starts a newer attempt. Empty or omitted: the run's latest attempt"
+    },
     conclusion: {
       type: "string",
-      description: "CI conclusion (e.g. success | failure); failure triggers failing-job log download",
+      description: "CI conclusion (e.g. success | failure); failure stages the failing jobs' logs, success the logs of the jobs that ran (up to 64) and ci_jobs.json",
       required: true
     },
     "bot-login": {
@@ -7125,6 +7229,7 @@ var gatherCmd = defineCommand({
       headBranch: args["head-branch"],
       defaultBranch: args["default-branch"],
       runId: args["run-id"],
+      runAttempt: parseRunAttempt(args["run-attempt"]),
       conclusion: args.conclusion,
       botLogin: args["bot-login"] || "github-actions[bot]",
       outDir: args["out-dir"] ? resolve(args["out-dir"]) : process.cwd()
@@ -7522,7 +7627,7 @@ 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)."
+    description: "Wait for the PR head's CI workflow run to conclude, then emit its REAL conclusion, run id and run attempt to $GITHUB_OUTPUT (ci_settled, ci_conclusion, ci_run_id, ci_run_attempt). 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 },