dev-loops 0.1.0

package/scripts/github/probe-copilot-review.mjs

@@ -0,0 +1,323 @@
+#!/usr/bin/env node
+import { setTimeout as delay } from "node:timers/promises";
+import { buildParseError, formatCliError, isCopilotLogin, isDirectCliRun, parseJsonText, parseReviewThreads } from "../_core-helpers.mjs";
+import { parsePositiveInteger, requireOptionValue, runChild } from "../_cli-primitives.mjs";
+import { parseRepoSlug } from "@dev-loops/core/github/repo-slug";
+import {
+  DEFAULT_POLL_INTERVAL_MS,
+  COPILOT_REVIEW_WAIT_TIMEOUT_MS,
+} from "@dev-loops/core/loop/policy-constants";
+
+/** Maximum interval between heartbeat outputs during watch delays.
+ *  Must be shorter than pi-subagents default needsAttentionAfterMs (60s). */
+const WATCH_HEARTBEAT_MS = 45_000; // 45 seconds
+const REMOVED_FLAGS = new Set([
+  "--poll-interval-ms",
+  "--timeout-ms",
+]);
+const USAGE = `Usage: probe-copilot-review.mjs --repo <owner/name> --pr <number>
+Poll for fresh Copilot review activity on a GitHub pull request.
+Required:
+  --repo <owner/name>           Repository slug (e.g. owner/repo)
+  --pr <number>                 Pull request number
+Output (stdout, JSON):
+  { "ok": true, "status": "changed"|"timeout"|"idle", "repo": "...", "pr": N, "attempts": N,
+    "newComments": [...], "newReviews": [...], "newIssueComments": [...] }
+Activity statuses:
+  changed    Fresh Copilot review activity found (check newComments/newReviews/newIssueComments)
+  timeout    Watch period elapsed with no fresh Copilot activity
+  idle       Zero-timeout single check found no change
+Diagnostic output (stderr):
+  Progress/heartbeat (during watch):
+    { "ok": true, "type": "watch_heartbeat", "elapsedMs": N, "totalBudgetMs": N, "poll": N, "maxPolls": N }
+  Argument/usage errors:
+    { "ok": false, "error": "...", "usage": "..." }
+  gh/runtime failures:
+    { "ok": false, "error": "..." }
+Exit codes:
+  0  Success
+  1  Argument error or gh failure`.trim();
+const COPILOT_ACTIVITY_QUERY = [
+  "query($owner: String!, $name: String!, $pr: Int!) {",
+  "  repository(owner: $owner, name: $name) {",
+  "    pullRequest(number: $pr) {",
+  "      reviewThreads(first: 100) {",
+  "        nodes {",
+  "          id",
+  "          isResolved",
+  "          comments(first: 100) {",
+  "            nodes {",
+  "              id",
+  "              body",
+  "              author {",
+  "                login",
+  "                __typename",
+  "              }",
+  "            }",
+  "          }",
+  "        }",
+  "      }",
+  "      reviews(first: 100) {",
+  "        nodes {",
+  "          id",
+  "          body",
+  "          author {",
+  "            login",
+  "            __typename",
+  "          }",
+  "        }",
+  "      }",
+  "      comments(first: 100) {",
+  "        nodes {",
+  "          id",
+  "          body",
+  "          author {",
+  "            login",
+  "            __typename",
+  "          }",
+  "        }",
+  "      }",
+  "    }",
+  "  }",
+  "}",
+].join("\n");
+const parseError = buildParseError(USAGE);
+function rejectRemovedFlag(token) {
+  throw parseError(
+    `${token} has been removed. Poll interval and timeout are centralized policy constants. Omit the flag.`,
+  );
+}
+export function parseWatchCliArgs(argv) {
+  const args = [...argv];
+  const options = {
+    help: false,
+    repo: undefined,
+    pr: undefined,
+    pollIntervalMs: DEFAULT_POLL_INTERVAL_MS,
+    timeoutMs: COPILOT_REVIEW_WAIT_TIMEOUT_MS,
+  };
+  while (args.length > 0) {
+    const token = args.shift();
+    if (token === "--help" || token === "-h") {
+      options.help = true;
+      return options;
+    }
+    if (REMOVED_FLAGS.has(token)) {
+      rejectRemovedFlag(token);
+    }
+    if (token === "--repo") {
+      options.repo = requireOptionValue(args, "--repo", parseError).trim();
+      continue;
+    }
+    if (token === "--pr") {
+      options.pr = parsePositiveInteger(requireOptionValue(args, "--pr", parseError), "--pr", parseError);
+      continue;
+    }
+    throw parseError(`Unknown argument: ${token}`);
+  }
+  if (options.repo === undefined || options.pr === undefined) {
+    throw parseError("Watching Copilot review requires both --repo <owner/name> and --pr <number>");
+  }
+  try {
+    parseRepoSlug(options.repo);
+  } catch (error) {
+    throw parseError(error instanceof Error ? error.message : String(error));
+  }
+  return options;
+}
+async function fetchGithubCopilotActivityPayload(
+  { repo, pr },
+  { env = process.env, ghCommand = "gh" } = {},
+) {
+  const { owner, name } = parseRepoSlug(repo);
+  const result = await runChild(
+    ghCommand,
+    [
+      "api",
+      "graphql",
+      "--field",
+      `owner=${owner}`,
+      "--field",
+      `name=${name}`,
+      "--field",
+      `pr=${pr}`,
+      "--field",
+      `query=${COPILOT_ACTIVITY_QUERY}`,
+    ],
+    env,
+  );
+  if (result.code !== 0) {
+    const detail = result.stderr.trim() || `exit code ${result.code}`;
+    throw new Error(`gh command failed: ${detail}`);
+  }
+  return parseJsonText(result.stdout);
+}
+function normalizeAuthorLogin(author) {
+  return typeof author?.login === "string" ? author.login : "";
+}
+function normalizeBody(body) {
+  return typeof body === "string" ? body.trim() : "";
+}
+function extractCopilotReviews(payload) {
+  const reviews = payload?.data?.repository?.pullRequest?.reviews?.nodes;
+  if (!Array.isArray(reviews)) {
+    return [];
+  }
+  return reviews
+    .filter((review) => isCopilotLogin(normalizeAuthorLogin(review?.author)))
+    .map((review) => ({
+      id: String(review?.id ?? ""),
+      authorLogin: normalizeAuthorLogin(review?.author),
+      body: normalizeBody(review?.body),
+    }))
+    .filter((review) => review.id.length > 0);
+}
+function extractCopilotIssueComments(payload) {
+  const comments = payload?.data?.repository?.pullRequest?.comments?.nodes;
+  if (!Array.isArray(comments)) {
+    return [];
+  }
+  return comments
+    .filter((comment) => isCopilotLogin(normalizeAuthorLogin(comment?.author)))
+    .map((comment) => ({
+      id: String(comment?.id ?? ""),
+      authorLogin: normalizeAuthorLogin(comment?.author),
+      body: normalizeBody(comment?.body),
+    }))
+    .filter((comment) => comment.id.length > 0);
+}
+function parseCopilotActivity(payload) {
+  const parsedThreads = parseReviewThreads(payload);
+  const newComments = (parsedThreads?.comments ?? [])
+    .filter((comment) => isCopilotLogin(comment.author?.login))
+    .map((comment) => ({
+      id: comment.id,
+      threadId: comment.threadId,
+      authorLogin: comment.author?.login ?? "",
+      body: comment.body,
+    }));
+  return {
+    reviewThreadComments: newComments,
+    reviews: extractCopilotReviews(payload),
+    issueComments: extractCopilotIssueComments(payload),
+  };
+}
+export function findFreshCopilotActivity(baseline, current) {
+  const baselineCommentIds = new Set((baseline?.reviewThreadComments ?? []).map((comment) => comment.id));
+  const baselineReviewIds = new Set((baseline?.reviews ?? []).map((review) => review.id));
+  const baselineIssueCommentIds = new Set((baseline?.issueComments ?? []).map((comment) => comment.id));
+  return {
+    newComments: (current?.reviewThreadComments ?? []).filter((comment) => !baselineCommentIds.has(comment.id)),
+    newReviews: (current?.reviews ?? []).filter((review) => !baselineReviewIds.has(review.id)),
+    newIssueComments: (current?.issueComments ?? []).filter((comment) => !baselineIssueCommentIds.has(comment.id)),
+  };
+}
+function buildNoChangePayload(status, repo, pr, attempts) {
+  return {
+    ok: true,
+    status,
+    repo,
+    pr,
+    attempts,
+    newComments: [],
+    newReviews: [],
+    newIssueComments: [],
+  };
+}
+export async function watchCopilotReview(
+  options,
+  {
+    env = process.env,
+    ghCommand = "gh",
+  } = {},
+) {
+  const baseline = parseCopilotActivity(await fetchGithubCopilotActivityPayload(
+    { repo: options.repo, pr: options.pr },
+    { env, ghCommand },
+  ));
+  const attemptBudget = buildAttemptBudget(options.timeoutMs, options.pollIntervalMs);
+  const watchStartedAtMs = Date.now();
+  for (let attempt = 1; attempt <= attemptBudget; attempt += 1) {
+    if (!(options.timeoutMs === 0 && attempt === 1)) {
+      const pollDelayMs = buildPollDelayMs(
+        watchStartedAtMs,
+        options.timeoutMs,
+        options.pollIntervalMs,
+        attempt,
+      );
+      if (pollDelayMs > 0) {
+        let remainingMs = pollDelayMs;
+        while (remainingMs > 0) {
+          const chunkMs = Math.min(WATCH_HEARTBEAT_MS, remainingMs);
+          await delay(chunkMs);
+          remainingMs -= chunkMs;
+          if (remainingMs > 0) {
+            const nowMs = Date.now();
+            process.stderr.write(
+              JSON.stringify({
+                ok: true,
+                type: "watch_heartbeat",
+                elapsedMs: nowMs - watchStartedAtMs,
+                totalBudgetMs: options.timeoutMs,
+                poll: attempt,
+                maxPolls: attemptBudget,
+              }) + "\n",
+            );
+          }
+        }
+      }
+    }
+    const current = parseCopilotActivity(await fetchGithubCopilotActivityPayload(
+      { repo: options.repo, pr: options.pr },
+      { env, ghCommand },
+    ));
+    const activity = findFreshCopilotActivity(baseline, current);
+    if (activity.newComments.length > 0 || activity.newReviews.length > 0 || activity.newIssueComments.length > 0) {
+      return {
+        ok: true,
+        status: "changed",
+        repo: options.repo,
+        pr: options.pr,
+        attempts: attempt,
+        ...activity,
+      };
+    }
+  }
+  const status = options.timeoutMs === 0 ? "idle" : "timeout";
+  return buildNoChangePayload(status, options.repo, options.pr, attemptBudget);
+}
+export function buildAttemptBudget(timeoutMs, pollIntervalMs) {
+  if (timeoutMs === 0) {
+    return 1;
+  }
+  return Math.max(1, Math.ceil(timeoutMs / pollIntervalMs));
+}
+export function buildPollDelayMs(watchStartedAtMs, timeoutMs, pollIntervalMs, attempt, nowMs = Date.now()) {
+  if (timeoutMs === 0) {
+    return 0;
+  }
+  const scheduledAtMs = watchStartedAtMs + Math.min(timeoutMs, attempt * pollIntervalMs);
+  return Math.max(0, scheduledAtMs - nowMs);
+}
+export async function runCli(
+  argv = process.argv.slice(2),
+  {
+    stdout = process.stdout,
+    env = process.env,
+    ghCommand = "gh",
+  } = {},
+) {
+  const options = parseWatchCliArgs(argv);
+  if (options.help) {
+    stdout.write(`${USAGE}\n`);
+    return;
+  }
+  const result = await watchCopilotReview(options, { env, ghCommand });
+  stdout.write(`${JSON.stringify(result)}\n`);
+}
+if (isDirectCliRun(import.meta.url)) {
+  runCli().catch((error) => {
+    process.stderr.write(`${formatCliError(error)}\n`);
+    process.exitCode = 1;
+  });
+}

package/scripts/github/ready-for-review.mjs

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+import { buildParseError, formatCliError, isDirectCliRun, parseJsonText, summarizeGateReviewComments, summarizeGateReviewCommentMarkers } from "../_core-helpers.mjs";
+import { parsePrNumber, requireOptionValue, runChild } from "../_cli-primitives.mjs";
+import { parseRepoSlug } from "@dev-loops/core/github/repo-slug";
+import { loadDevLoopConfig, resolveGateConfig } from "@dev-loops/core/config";
+
+const USAGE = `Usage: ready-for-review.mjs --repo <owner/name> --pr <number>\nWrapper around gh pr ready that enforces gate-evidence validation.`;
+const parseError = buildParseError(USAGE);
+const PR_VIEW_QUERY = `query($owner:String!, $name:String!, $number:Int!) { repository(owner:$owner, name:$name) { pullRequest(number:$number) { id, isDraft, headRefOid, state, mergeStateStatus } } }`;
+
+export function parseReadyForReviewCliArgs(argv) {
+  const args = [...argv], opts = { help: false, repo: undefined, pr: undefined };
+  while (args.length > 0) {
+    const token = args.shift();
+    if (token === "--help" || token === "-h") { opts.help = true; return opts; }
+    if (token === "--repo") { opts.repo = requireOptionValue(args, "--repo", parseError).trim(); continue; }
+    if (token === "--pr") { opts.pr = parsePrNumber(requireOptionValue(args, "--pr", parseError), parseError); continue; }
+    throw parseError(`Unknown argument: ${token}`);
+  }
+  if (!opts.repo || opts.pr === undefined) throw parseError("ready-for-review requires --repo and --pr");
+  parseRepoSlug(opts.repo);
+  return opts;
+}
+
+async function runGhJson(args, { env, ghCommand }) {
+  const result = await runChild(ghCommand, args, env);
+  if (result.code !== 0) throw new Error(`gh command failed: ${result.stderr.trim() || `exit code ${result.code}`}`);
+  return parseJsonText(result.stdout);
+}
+
+async function fetchPrState({ repo, pr }, { env, ghCommand }) {
+  const [owner, name] = repo.split("/");
+  const r = await runGhJson(["api", "graphql", "-f", `query=${PR_VIEW_QUERY}`, "-f", `owner=${owner}`, "-f", `name=${name}`, "-F", `number=${pr}`], { env, ghCommand });
+  const d = r?.data?.repository?.pullRequest;
+  if (!d) throw new Error(`Could not fetch PR #${pr}`);
+  return { id: d.id, isDraft: d.isDraft === true, headRefOid: typeof d.headRefOid === "string" ? d.headRefOid.trim() : null, state: typeof d.state === "string" ? d.state.trim() : null, mergeStateStatus: typeof d.mergeStateStatus === "string" ? d.mergeStateStatus.trim() : null };
+}
+
+async function fetchCiStatus({ repo, pr }, { env, ghCommand }) {
+  const result = await runChild(ghCommand, ["pr", "checks", String(pr), "--repo", repo, "--json", "bucket,state,name,workflow"], env);
+  if (result.code !== 0 && result.code !== 1 && result.code !== 8) throw new Error(`gh pr checks failed`);
+  const stdout = result.stdout.trim();
+  if (!stdout) return { status: "none" };
+  const payload = parseJsonText(stdout);
+  if (!Array.isArray(payload)) return { status: "none" };
+  const buck = (c = {}) => { const b = typeof c?.bucket === "string" ? c.bucket.trim().toLowerCase() : ""; if (b) return b; const s = typeof c?.state === "string" ? c.state.trim().toLowerCase() : ""; if (["success","passed","pass"].includes(s)) return "pass"; if (["skipped","skipping"].includes(s)) return "skipping"; if (["pending","queued","in_progress","waiting"].includes(s)) return "pending"; if (["failure","failed","fail","error","timed_out","startup_failure"].includes(s)) return "fail"; if (["cancel","cancelled"].includes(s)) return "cancel"; return s||"unknown"; };
+  const checks = payload.map(c => ({ bucket: buck(c) }));
+  const blocking = checks.filter(c => !["pass","skipping"].includes(c.bucket));
+  return { status: blocking.length === 0 ? "success" : "blocked", blockingSummary: blocking.length > 0 ? `Blocking: ${blocking.map(c=>c.bucket).join(", ")}` : null };
+}
+
+async function fetchGateEvidence({ repo, pr, headSha }, { env, ghCommand }) {
+  const r = await runChild(ghCommand, ["api", "--paginate", "--slurp", `repos/${repo}/issues/${pr}/comments?per_page=100`], env);
+  if (r.code !== 0) throw new Error(`Failed to fetch PR comments`);
+  const raw = parseJsonText(r.stdout), comments = Array.isArray(raw) ? (raw.every(e=>Array.isArray(e)) ? raw.flat() : raw) : [];
+  const cs = summarizeGateReviewComments(comments), ms = summarizeGateReviewCommentMarkers(comments, { headSha });
+  const dg = cs.draft_gate ? { ...cs.draft_gate, visible: true } : { visible: false };
+  const dm = ms.draft_gate ? { ...ms.draft_gate, visible: true, contractComplete: ms.draft_gate.contractComplete === true } : { visible: false, contractComplete: false };
+  const mh = dm.headSha && headSha && headSha.startsWith(dm.headSha);
+  const chc = dm.visible && mh && dm.verdict === "clean" && dm.contractComplete;
+  const cee = dg.visible && dg.verdict === "clean" && dg.headSha;
+  const cphm = !chc && dg.headSha && headSha && headSha.startsWith(dg.headSha) && dg.verdict === "clean";
+  return { draftGate: dg, draftGateMarker: dm, currentHeadClean: chc, cleanEvidenceExists: cee, effectiveHeadClean: chc || cphm };
+}
+
+export async function readyForReview(options, { env = process.env, ghCommand = "gh", repoRoot = process.cwd() } = {}) {
+  const { config } = await loadDevLoopConfig({ repoRoot });
+  const draftGateConfig = resolveGateConfig(config, "draft");
+  const requireCi = draftGateConfig?.requireCi !== false;
+  const prState = await fetchPrState({ repo: options.repo, pr: options.pr }, { env, ghCommand });
+  const headSha = prState.headRefOid;
+  if (!headSha) throw new Error(`Could not resolve head SHA`);
+  if (!prState.isDraft) throw new Error(`PR #${options.pr} is not in draft state`);
+  if (requireCi) { const ci = await fetchCiStatus({ repo: options.repo, pr: options.pr }, { env, ghCommand }); if (ci.status === "blocked") throw new Error(`PR #${options.pr} has blocking CI checks`); if (ci.status !== "success") throw new Error(`PR #${options.pr} CI is not green`); }
+  const gate = await fetchGateEvidence({ repo: options.repo, pr: options.pr, headSha }, { env, ghCommand });
+  if (!gate.cleanEvidenceExists && !gate.effectiveHeadClean) throw new Error(`No visible clean draft_gate evidence on ${headSha.slice(0,7)}`);
+  if (!gate.effectiveHeadClean) { const mv = gate.draftGateMarker?.visible; const mh = gate.draftGateMarker?.headSha; throw new Error(mv && mh ? `PR #${options.pr} draft_gate marker does not match current head ${headSha.slice(0,7)}. Re-run draft gate.` : `PR #${options.pr} draft_gate marker is missing or incomplete on current head ${headSha.slice(0,7)}. Re-run draft gate.`); }
+  const readyResult = await runChild(ghCommand, ["pr", "ready", String(options.pr), "--repo", options.repo], env);
+  if (readyResult.code !== 0) throw new Error(`gh pr ready failed`);
+  return { ok: true, action: "marked_ready", repo: options.repo, pr: options.pr, headSha, draftGateSatisfied: gate.effectiveHeadClean };
+}
+
+export async function main(argv = process.argv.slice(2), runtime = {}) {
+  const options = parseReadyForReviewCliArgs(argv);
+  if (options.help) { process.stdout.write(`${USAGE}\n`); return 0; }
+  const result = await readyForReview(options, runtime);
+  process.stdout.write(`${JSON.stringify(result)}\n`);
+  return 0;
+}
+
+if (isDirectCliRun(import.meta.url)) {
+  main().then(c => { process.exitCode = c; }).catch(e => { process.stderr.write(`${formatCliError(e, { usage: USAGE })}\n`); process.exitCode = 1; });
+}