@jphutchins/code-review 0.1.0-alpha.32 → 0.1.0-alpha.34

package/dist/index.js

@@ -773,24 +773,35 @@ var DEFAULT_RESERVE = {
   frac: 0.15,
   growth: 0.25,
   flatUsd: 0.02,
-  flatMs: 12e4
+  flatMs: 12e4,
+  flatMem: 2 * 1024 * 1024 * 1024
 };
 var SOFT_MULTIPLE = 2;
-var costAxis = (i) => i.spentUsd !== null && i.budgetUsd !== null && i.budgetUsd > 0 ? { used: i.spentUsd, limit: i.budgetUsd, flat: i.reserve.flatUsd } : null;
-var timeAxis = (i) => i.elapsedMs !== null && i.wallMs !== null && i.wallMs > 0 ? { used: i.elapsedMs, limit: i.wallMs, flat: i.reserve.flatMs } : null;
-var axisSeverity = (a, reserve) => {
-  const usedFrac = Math.min(1, Math.max(0, a.used / a.limit));
-  const effFrac = reserve.frac + reserve.growth * usedFrac;
-  const hardReserve = Math.max(a.flat, effFrac * a.limit);
+var growingReserve = (used, limit, flat, r) => {
+  const usedFrac = Math.min(1, Math.max(0, used / limit));
+  return Math.max(flat, (r.frac + r.growth * usedFrac) * limit);
+};
+var costAxis = (i) => i.spentUsd !== null && i.budgetUsd !== null && i.budgetUsd > 0 ? {
+  used: i.spentUsd,
+  limit: i.budgetUsd,
+  hardReserve: growingReserve(i.spentUsd, i.budgetUsd, i.reserve.flatUsd, i.reserve)
+} : null;
+var timeAxis = (i) => i.elapsedMs !== null && i.wallMs !== null && i.wallMs > 0 ? {
+  used: i.elapsedMs,
+  limit: i.wallMs,
+  hardReserve: growingReserve(i.elapsedMs, i.wallMs, i.reserve.flatMs, i.reserve)
+} : null;
+var axisSeverity = (a) => {
   const remaining = a.limit - a.used;
-  if (remaining <= hardReserve) return 2;
-  if (remaining <= SOFT_MULTIPLE * hardReserve) return 1;
+  if (remaining <= a.hardReserve) return 2;
+  if (remaining <= SOFT_MULTIPLE * a.hardReserve) return 1;
   return 0;
 };
 var decideBudget = (i) => {
-  const worst = [costAxis(i), timeAxis(i)].filter((a) => a !== null).reduce((max, a) => Math.max(max, axisSeverity(a, i.reserve)), 0);
+  const worst = [costAxis(i), timeAxis(i)].filter((a) => a !== null).reduce((max, a) => Math.max(max, axisSeverity(a)), 0);
   return worst === 2 ? { kind: "hard" } : worst === 1 ? { kind: "soft" } : { kind: "ok" };
 };
+var memoryCritical = (availMemBytes, totalMemBytes, floorBytes) => availMemBytes !== null && totalMemBytes !== null && totalMemBytes > 0 && availMemBytes <= floorBytes;
 var pct = (n) => `${String(Math.round(n * 100))}%`;
 var money = (n) => `$${n.toFixed(2)}`;
 var mins = (ms) => `${(ms / 6e4).toFixed(1)}m`;
@@ -845,6 +856,7 @@ var lastValidPath = (draftPath) => {
 };
 var mainHasWrittenDraft = (draftMtimeMs, seedMarkerMtimeMs) => draftMtimeMs !== null && (seedMarkerMtimeMs === null || draftMtimeMs > seedMarkerMtimeMs);
 var spawnFloorMessage = (draftPath) => `Write your own first-pass findings to ${draftPath} before spawning subagents \u2014 a review must never depend on subagents alone, and a pre-seeded draft does not count until you have revised it yourself this run. Write ${draftPath} from what you have read so far (preliminary findings are fine), run \`code-review validate ${draftPath} --explain\` until it passes, then fan out; your subagents run in the background, so keep refining the draft as their reports arrive.`;
+var memoryPressureMessage = (draftPath) => `System memory is critically low right now, so another subagent can't be spawned \u2014 a fresh process is the fastest way to tip the runner into an out-of-memory kill that would lose the whole review. Don't wind down: keep reading code directly and keep folding the reports from subagents already running into ${draftPath}, then try spawning again in a moment \u2014 this clears as soon as running subagents finish and free their memory.`;
 var forceBackgroundSpawn = (toolInput) => ({
   hookSpecificOutput: {
     hookEventName: "PreToolUse",
@@ -890,6 +902,8 @@ var evaluateBudgetHook = (input, params) => {
       if (phase.kind === "hard" && blockedDuringConvergence(toolName, rec["tool_input"]))
         return denyPreTool(budgetMessage(inputs, phase, params.draftPath, isSubagent));
       if (SPAWN_TOOLS.has(toolName)) {
+        if (memoryCritical(params.availMemBytes, params.totalMemBytes, params.reserve.flatMem))
+          return denyPreTool(memoryPressureMessage(params.draftPath));
         if (!isSubagent && !params.mainDraftWritten)
           return denyPreTool(spawnFloorMessage(params.draftPath));
         return forceBackgroundSpawn(rec["tool_input"]);
@@ -936,6 +950,21 @@ var parseFraction = (raw, fallback) => {
   const n = Number.parseFloat(raw);
   return Number.isFinite(n) && n >= 0 && n <= 1 ? n : fallback;
 };
+var BYTE_UNIT = {
+  "": 1,
+  k: 1024,
+  m: 1024 * 1024,
+  g: 1024 * 1024 * 1024,
+  t: 1024 * 1024 * 1024 * 1024
+};
+var parseByteSize = (raw) => {
+  const m = /^(\d+(?:\.\d+)?)\s*([kmgt])?(?:i?b)?$/i.exec(raw.trim());
+  if (m === null) return null;
+  const [, num = "", unit = ""] = m;
+  const n = Number.parseFloat(num);
+  const mult = BYTE_UNIT[unit.toLowerCase()];
+  return Number.isFinite(n) && mult !== void 0 ? n * mult : null;
+};
 var budgetHookCommand = (draftPath, opts) => [
   "code-review budget-hook --draft",
   shellQuote(draftPath),
@@ -945,7 +974,8 @@ var budgetHookCommand = (draftPath, opts) => [
   ...opts.reserveFrac ? ["--reserve-frac", shellQuote(opts.reserveFrac)] : [],
   ...opts.reserveGrowth ? ["--reserve-growth", shellQuote(opts.reserveGrowth)] : [],
   ...opts.reserveUsd ? ["--reserve-usd", shellQuote(opts.reserveUsd)] : [],
-  ...opts.reserveWall ? ["--reserve-wall", shellQuote(opts.reserveWall)] : []
+  ...opts.reserveWall ? ["--reserve-wall", shellQuote(opts.reserveWall)] : [],
+  ...opts.reserveMem ? ["--reserve-mem", shellQuote(opts.reserveMem)] : []
 ].join(" ");
 
 // src/format.ts
@@ -1068,9 +1098,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) => {
@@ -1759,6 +1789,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;
@@ -1965,12 +2123,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]))]
   };
 };
@@ -2722,7 +2880,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,
@@ -2734,7 +2892,7 @@ var renderCmd = defineCommand({
       testReport,
       postedAt: formatUtc(/* @__PURE__ */ new Date())
     });
-    process.stdout.write(output);
+    process.stdout.write(output2);
   }
 });
 var inlineCmd = defineCommand({
@@ -2874,6 +3032,18 @@ var snapshotIfValid = (draftPath) => {
     );
   }
 };
+var readMemInfo = () => {
+  try {
+    const text = readFileSync("/proc/meminfo", "utf8");
+    const kb = (key2) => {
+      const m = new RegExp(`^${key2}:\\s+(\\d+)\\s+kB`, "m").exec(text);
+      return m?.[1] !== void 0 ? Number(m[1]) * 1024 : null;
+    };
+    return { availBytes: kb("MemAvailable"), totalBytes: kb("MemTotal") };
+  } catch {
+    return { availBytes: null, totalBytes: null };
+  }
+};
 var budgetHookCmd = defineCommand({
   meta: {
     name: "budget-hook",
@@ -2912,19 +3082,24 @@ var budgetHookCmd = defineCommand({
     "reserve-wall": {
       type: "string",
       description: "Flat wall-clock wind-down floor (e.g. 2m, 120s), whichever is larger with --reserve-frac (default: 2m)"
+    },
+    "reserve-mem": {
+      type: "string",
+      description: "Free-RAM floor (e.g. 2g, 1536m) below which new subagent spawns are denied until memory recovers; not a convergence axis (default: 2g)"
     }
   },
   run: async ({ args }) => {
     try {
       const draftPath = resolve$1(args.draft);
       const input = readStdinJSON();
+      const mem = readMemInfo();
       const transcriptPath = transcriptPathOf(input);
       const tree = transcriptPath ? readTranscriptTree(resolve$1(transcriptPath)) : void 0;
       const usage = tree ? sumTranscriptUsage(tree.entries) : void 0;
       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({
@@ -2934,11 +3109,14 @@ var budgetHookCmd = defineCommand({
           nowMs: Date.now()
         }),
         wallMs,
+        availMemBytes: mem.availBytes,
+        totalMemBytes: mem.totalBytes,
         reserve: {
           frac: parseFraction(args["reserve-frac"], DEFAULT_RESERVE.frac),
           growth: parseFraction(args["reserve-growth"], DEFAULT_RESERVE.growth),
           flatUsd: parseBudgetUsd(args["reserve-usd"]) ?? DEFAULT_RESERVE.flatUsd,
-          flatMs: args["reserve-wall"] ? parseWallMs(args["reserve-wall"]) ?? DEFAULT_RESERVE.flatMs : DEFAULT_RESERVE.flatMs
+          flatMs: args["reserve-wall"] ? parseWallMs(args["reserve-wall"]) ?? DEFAULT_RESERVE.flatMs : DEFAULT_RESERVE.flatMs,
+          flatMem: args["reserve-mem"] ? parseByteSize(args["reserve-mem"]) ?? DEFAULT_RESERVE.flatMem : DEFAULT_RESERVE.flatMem
         },
         draftPath,
         mainDraftWritten: mainHasWrittenDraft(
@@ -2948,7 +3126,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)}
@@ -3015,6 +3193,10 @@ var printSettingsCmd = defineCommand({
     "reserve-wall": {
       type: "string",
       description: "Flat wall-clock wind-down floor (e.g. 2m), whichever is larger with --reserve-frac (default: 2m)"
+    },
+    "reserve-mem": {
+      type: "string",
+      description: "Free-RAM floor (e.g. 2g) below which new subagent spawns are denied until memory recovers (default: 2g)"
     }
   },
   run: async ({ args }) => {
@@ -3036,7 +3218,8 @@ var printSettingsCmd = defineCommand({
         reserveFrac: args["reserve-frac"],
         reserveGrowth: args["reserve-growth"],
         reserveUsd: args["reserve-usd"],
-        reserveWall: args["reserve-wall"]
+        reserveWall: args["reserve-wall"],
+        reserveMem: args["reserve-mem"]
       }
     });
     process.stdout.write(`${JSON.stringify(settings)}
@@ -3762,6 +3945,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);
@@ -3935,6 +4204,8 @@ var main = defineCommand({
     inline: inlineCmd,
     post: postCmd,
     announce: announceCmd,
+    "check-run": checkRunCmd,
+    "report-incomplete": reportIncompleteCmd,
     cost: costCmd,
     "check-cost": checkCostCmd,
     validate: validateCmd,