dev-loops 0.5.0 → 0.7.1

package/scripts/github/detect-linked-issue-pr.mjs

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import { parseArgs } from "node:util";
 import { buildParseError, formatCliError, isDirectCliRun, parseJsonText } from "../_core-helpers.mjs";
-import { parseIssueNumber, requireTokenValue, runChild } from "../_cli-primitives.mjs";
+import { parseIssueNumber, requireTokenValue, runChild as defaultRunChild } from "../_cli-primitives.mjs";
 import { parseRepoSlug } from "@dev-loops/core/github/repo-slug";
+import { JQ_OUTPUT_PARSE_OPTIONS, JQ_OUTPUT_USAGE, emitResult, matchJqOutputToken } from "../lib/jq-output.mjs";
 export const LINKED_ISSUE_PR_QUERY = [
   "query($owner:String!, $name:String!, $issue:Int!, $after:String) {",
   "  repository(owner:$owner, name:$name) {",
@@ -28,6 +29,7 @@ export const LINKED_ISSUE_PR_QUERY = [
   "          }",
   "          ... on CrossReferencedEvent {",
   "            createdAt",
+  "            willCloseTarget",
   "            source {",
   "              __typename",
   "              ... on PullRequest {",
@@ -73,12 +75,18 @@ Error output (stderr, JSON):
   Argument/usage errors:
     { "ok": false, "error": "...", "usage": "..." }
   gh/runtime failures:
-    { "ok": false, "error": "..." }`.trim();
+    { "ok": false, "error": "..." }
+${JQ_OUTPUT_USAGE}`.trim();
 const parseError = buildParseError(USAGE);
 export function parseDetectLinkedIssuePrCliArgs(argv) {
   const { tokens } = parseArgs({
     args: [...argv],
-    options: { help: { type: "boolean", short: "h" }, repo: { type: "string" }, issue: { type: "string" } },
+    options: {
+      help: { type: "boolean", short: "h" },
+      repo: { type: "string" },
+      issue: { type: "string" },
+      ...JQ_OUTPUT_PARSE_OPTIONS,
+    },
     allowPositionals: true,
     strict: false,
     tokens: true,
@@ -107,6 +115,7 @@ export function parseDetectLinkedIssuePrCliArgs(argv) {
       options.issue = parseIssueNumber(requireTokenValue(token, parseError), parseError);
       continue;
     }
+    if (matchJqOutputToken(token, options, (t) => requireTokenValue(t, parseError))) continue;
     throw parseError(`Unknown argument: ${token.rawName}`);
   }
   if (options.repo === undefined || options.issue === undefined) {
@@ -162,6 +171,13 @@ function normalizeLinkedPrNode(node) {
     };
   }
   if (node.__typename === "CrossReferencedEvent") {
+    // Only a cross-reference that will CLOSE this issue owns its board status.
+    // A bare body-mention (willCloseTarget:false, e.g. "part of #X") must not
+    // create board-ownership linkage — otherwise every sibling a PR mentions
+    // gets dragged to In Progress and the resolver fails closed (#1130).
+    if (node.willCloseTarget !== true) {
+      return null;
+    }
     return {
       eventType: "CROSS_REFERENCED_EVENT",
       eventCreatedAt: node.createdAt,
@@ -253,7 +269,7 @@ export function selectLinkedIssuePr(candidates) {
   });
   return sorted[0] ?? null;
 }
-export async function detectLinkedIssuePr({ repo, issue }, { env = process.env, ghCommand = "gh" } = {}) {
+export async function detectLinkedIssuePr({ repo, issue }, { env = process.env, ghCommand = "gh", runChild = defaultRunChild } = {}) {
   const { owner, name } = parseRepoSlug(repo);
   const candidates = [];
   const closedUnmergedCandidates = [];
@@ -322,7 +338,7 @@ export async function detectLinkedIssuePr({ repo, issue }, { env = process.env,
 }
 export async function runCli(
   argv = process.argv.slice(2),
-  { stdout = process.stdout, env = process.env, ghCommand = "gh" } = {},
+  { stdout = process.stdout, stderr = process.stderr, env = process.env, ghCommand = "gh" } = {},
 ) {
   const options = parseDetectLinkedIssuePrCliArgs(argv);
   if (options.help) {
@@ -333,7 +349,7 @@ export async function runCli(
     { repo: options.repo, issue: options.issue },
     { env, ghCommand },
   );
-  stdout.write(`${JSON.stringify(result)}\n`);
+  process.exitCode = emitResult(result, { jq: options.jq, silent: options.silent, stdout, stderr });
 }
 if (isDirectCliRun(import.meta.url)) {
   runCli().catch((error) => {

package/scripts/github/edit-pr.mjs

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+import { readFile } from "node:fs/promises";
+import { readFileSync } from "node:fs";
+import { buildParseError, formatCliError, isDirectCliRun } from "../_core-helpers.mjs";
+import { parsePrNumber, requireTokenValue, runChild } from "../_cli-primitives.mjs";
+import { parseRepoSlug } from "@dev-loops/core/github/repo-slug";
+import { parseArgs } from "node:util";
+import { JQ_OUTPUT_PARSE_OPTIONS, JQ_OUTPUT_USAGE, emitResult, matchJqOutputToken } from "../lib/jq-output.mjs";
+
+const USAGE = `Usage: edit-pr.mjs --repo <owner/name> --pr <number> [--title <t>] [--body <b> | --body-file <path>] [--add-assignee <u>] [--remove-assignee <u>] [--milestone <m>]
+Edit PR title/body/assignees/milestone. Thin wrapper over \`gh pr edit\` — use this
+instead of an agent-level raw \`gh pr edit\` so the loop's internal-tooling record
+stays clean (siblings: view-pr.mjs, comment-issue.mjs; #1057).
+Required:
+  --repo <owner/name>           Repository slug (e.g. owner/repo)
+  --pr <number>                 Pull request number
+At least one edit:
+  --title <t>                   New PR title
+  --body <b>                    New PR body as a single argument
+  --body-file <path>            Read the new body from a file (- reads stdin)
+  --add-assignee <u>            Assignee to add (repeatable)
+  --remove-assignee <u>         Assignee to remove (repeatable)
+  --milestone <m>               Milestone to set (empty string clears it)
+                                (--title/--body/--body-file reject empty or
+                                whitespace-only values; use --milestone "" only
+                                to clear the milestone)
+Output (stdout, JSON):
+  { "ok": true, "repo": "owner/repo", "pr": 17, "edited": ["title", "body", ...] }
+Error output (stderr, JSON):
+  { "ok": false, "error": "...", "usage"?: "..." }
+${JQ_OUTPUT_USAGE}
+Exit codes:
+  0  Success
+  1  Argument error or gh failure
+  2  Invalid --jq filter`.trim();
+const parseError = buildParseError(USAGE);
+
+export function parseEditPrCliArgs(argv) {
+  const { tokens } = parseArgs({
+    args: [...argv],
+    options: {
+      help: { type: "boolean", short: "h" },
+      repo: { type: "string" },
+      pr: { type: "string" },
+      title: { type: "string" },
+      body: { type: "string" },
+      "body-file": { type: "string" },
+      "add-assignee": { type: "string", multiple: true },
+      "remove-assignee": { type: "string", multiple: true },
+      milestone: { type: "string" },
+      ...JQ_OUTPUT_PARSE_OPTIONS,
+    },
+    allowPositionals: true,
+    strict: false,
+    tokens: true,
+  });
+  const options = {
+    help: false,
+    repo: undefined,
+    pr: undefined,
+    title: undefined,
+    body: undefined,
+    bodyFile: undefined,
+    addAssignees: [],
+    removeAssignees: [],
+    milestone: undefined,
+    jq: undefined,
+    silent: false,
+  };
+  for (const token of tokens) {
+    if (token.kind === "positional") {
+      throw parseError(`Unknown argument: ${token.value}`);
+    }
+    if (token.kind !== "option") {
+      continue;
+    }
+    if (token.name === "help") {
+      options.help = true;
+      return options;
+    }
+    if (token.name === "repo") {
+      options.repo = requireTokenValue(token, parseError).trim();
+      continue;
+    }
+    if (token.name === "pr") {
+      options.pr = parsePrNumber(requireTokenValue(token, parseError), parseError);
+      continue;
+    }
+    if (token.name === "title") {
+      const title = requireTokenValue(token, parseError);
+      if (title.trim().length === 0) {
+        throw parseError("--title must not be empty or whitespace-only");
+      }
+      options.title = title;
+      continue;
+    }
+    if (token.name === "body") {
+      const body = requireTokenValue(token, parseError);
+      if (body.trim().length === 0) {
+        throw parseError("--body must not be empty or whitespace-only");
+      }
+      options.body = body;
+      continue;
+    }
+    if (token.name === "body-file") {
+      const rawPath = requireTokenValue(token, parseError).trim();
+      if (rawPath.length === 0) {
+        throw parseError("--body-file must be a non-empty path");
+      }
+      options.bodyFile = rawPath;
+      continue;
+    }
+    if (token.name === "add-assignee") {
+      const u = requireTokenValue(token, parseError).trim();
+      if (u.length === 0) throw parseError("--add-assignee must be a non-empty login");
+      options.addAssignees.push(u);
+      continue;
+    }
+    if (token.name === "remove-assignee") {
+      const u = requireTokenValue(token, parseError).trim();
+      if (u.length === 0) throw parseError("--remove-assignee must be a non-empty login");
+      options.removeAssignees.push(u);
+      continue;
+    }
+    if (token.name === "milestone") {
+      // Read the raw token value: an empty string is a valid milestone value
+      // (`gh pr edit --milestone ""` clears it), so this deliberately does NOT
+      // go through requireTokenValue (which rejects empty). Guard only a truly
+      // missing value (`--milestone` with no following token). A whitespace-only
+      // value is neither a clear nor a real milestone name — fail closed rather
+      // than forwarding it to gh for a less actionable error.
+      if (typeof token.value !== "string") {
+        throw parseError("--milestone requires a value (use an empty string to clear)");
+      }
+      if (token.value.length > 0 && token.value.trim().length === 0) {
+        throw parseError('--milestone must be a milestone name or "" to clear (whitespace-only is not allowed)');
+      }
+      options.milestone = token.value;
+      continue;
+    }
+    if (matchJqOutputToken(token, options, (t) => requireTokenValue(t, parseError))) continue;
+    throw parseError(`Unknown argument: ${token.rawName}`);
+  }
+  if (options.repo === undefined || options.pr === undefined) {
+    throw parseError("Editing a PR requires both --repo <owner/name> and --pr <number>");
+  }
+  if (options.body !== undefined && options.bodyFile !== undefined) {
+    throw parseError("--body and --body-file are mutually exclusive; pass only one");
+  }
+  const hasEdit =
+    options.title !== undefined ||
+    options.body !== undefined ||
+    options.bodyFile !== undefined ||
+    options.addAssignees.length > 0 ||
+    options.removeAssignees.length > 0 ||
+    options.milestone !== undefined;
+  if (!hasEdit) {
+    throw parseError("Editing a PR requires at least one of --title/--body/--body-file/--add-assignee/--remove-assignee/--milestone");
+  }
+  try {
+    parseRepoSlug(options.repo);
+  } catch (error) {
+    throw parseError(error instanceof Error ? error.message : String(error));
+  }
+  return options;
+}
+
+async function resolveBody(options) {
+  if (options.bodyFile === undefined) return options.body;
+  // Stdin (fd 0): the fs/promises readFile does NOT accept an integer fd, so read
+  // it synchronously via the callback-style API (which does). A real path stays on
+  // the async promise read.
+  const body =
+    options.bodyFile === "-" ? readFileSync(0, "utf8") : await readFile(options.bodyFile, "utf8");
+  // Fail closed on an empty / whitespace-only file so a blank --body-file cannot
+  // silently clear the PR body (USAGE promises --body/--title reject empties).
+  if (body.trim().length === 0) {
+    throw new Error(`--body-file ${options.bodyFile} is empty`);
+  }
+  return body;
+}
+
+// Build the `gh pr edit` args and the parallel `edited` list (which fields were
+// touched) so callers get a stable summary without re-reading the PR.
+async function buildEditArgs(options) {
+  const args = ["pr", "edit", String(options.pr), "--repo", options.repo];
+  const edited = [];
+  if (options.title !== undefined) {
+    args.push("--title", options.title);
+    edited.push("title");
+  }
+  // resolveBody still runs for validation (reads the file, throws on empty /
+  // whitespace-only). A REAL --body-file path is handed straight to gh so large
+  // bodies avoid command-length limits. But `--body-file -` (stdin) was already
+  // consumed by resolveBody reading fd 0; re-emitting `--body-file -` makes gh
+  // re-read an exhausted stdin and clear the body, so pass the resolved string
+  // inline via --body instead.
+  const body = await resolveBody(options);
+  if (body !== undefined) {
+    if (options.bodyFile !== undefined && options.bodyFile !== "-") {
+      args.push("--body-file", options.bodyFile);
+    } else {
+      args.push("--body", body);
+    }
+    edited.push("body");
+  }
+  for (const u of options.addAssignees) {
+    args.push("--add-assignee", u);
+  }
+  if (options.addAssignees.length > 0) edited.push("add-assignee");
+  for (const u of options.removeAssignees) {
+    args.push("--remove-assignee", u);
+  }
+  if (options.removeAssignees.length > 0) edited.push("remove-assignee");
+  if (options.milestone !== undefined) {
+    args.push("--milestone", options.milestone);
+    edited.push("milestone");
+  }
+  return { args, edited };
+}
+
+export async function editPr(options, { env = process.env, ghCommand = "gh", run = runChild } = {}) {
+  const { args, edited } = await buildEditArgs(options);
+  const result = await run(ghCommand, args, env);
+  if (result.code !== 0) {
+    const detail = result.stderr.trim() || `exit code ${result.code}`;
+    throw new Error(`gh pr edit failed: ${detail}`);
+  }
+  return { ok: true, repo: options.repo, pr: options.pr, edited };
+}
+
+export async function runCli(
+  argv = process.argv.slice(2),
+  { stdout = process.stdout, stderr = process.stderr, env = process.env, ghCommand = "gh", run = runChild } = {},
+) {
+  let options;
+  try {
+    options = parseEditPrCliArgs(argv);
+  } catch (error) {
+    stderr.write(`${formatCliError(error)}\n`);
+    return 1;
+  }
+  if (options.help) {
+    stdout.write(`${USAGE}\n`);
+    return 0;
+  }
+  let result;
+  try {
+    result = await editPr(options, { env, ghCommand, run });
+  } catch (error) {
+    stderr.write(`${JSON.stringify({ ok: false, error: error instanceof Error ? error.message : String(error) })}\n`);
+    return 1;
+  }
+  return emitResult(result, { jq: options.jq, silent: options.silent, stdout, stderr });
+}
+
+if (isDirectCliRun(import.meta.url)) {
+  runCli().then((code) => { process.exitCode = code; });
+}

package/scripts/github/fetch-ci-logs.mjs

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+import { buildParseError, formatCliError, isDirectCliRun, parseJsonText } from "../_core-helpers.mjs";
+import { parsePrNumber, requireTokenValue, runChild } from "../_cli-primitives.mjs";
+import { parseRepoSlug } from "@dev-loops/core/github/repo-slug";
+import { parseArgs } from "node:util";
+import { JQ_OUTPUT_PARSE_OPTIONS, JQ_OUTPUT_USAGE, emitResult, matchJqOutputToken } from "../lib/jq-output.mjs";
+
+const DEFAULT_TAIL_LINES = 200;
+
+const USAGE = `Usage: fetch-ci-logs.mjs --repo <owner/name> --pr <number> [--failed-only] [--tail <n>]
+Fetch the GitHub Actions CI run log tail for a PR's current head SHA. Thin wrapper
+over \`gh run list\` + \`gh run view --log\` — use this instead of an agent-level raw
+\`gh run view\` so the loop's internal-tooling record stays clean (#993). Complements
+probe-ci-status.mjs, which reports failed-check NAMES; this returns the LOG tail.
+(Siblings: list-issues.mjs, comment-issue.mjs.)
+Required:
+  --repo <owner/name>           Repository slug (e.g. owner/repo)
+  --pr <number>                 Pull request number
+Optional:
+  --failed-only                 Only include runs whose conclusion is failure
+                                (default: all Actions runs for the head SHA)
+  --tail <n>                    Lines of log tail to return per run (default 200)
+Output (stdout, JSON):
+  { "ok": true, "repo": "owner/repo", "pr": 17, "headSha": "abc123",
+    "runs": [{ "runId": 42, "name": "ci", "conclusion": "failure", "logTail": "..." }] }
+Notes:
+  Actions-only (gh run is GitHub Actions). CircleCI / external commit-status logs
+  are NOT covered — use the provider's UI for those (probe-ci-status names the check).
+Error output (stderr, JSON):
+  { "ok": false, "error": "...", "usage"?: "..." }
+${JQ_OUTPUT_USAGE}
+Exit codes:
+  0  Success
+  1  Argument error or gh failure
+  2  Invalid --jq filter`.trim();
+const parseError = buildParseError(USAGE);
+
+export function parseFetchCiLogsCliArgs(argv) {
+  const { tokens } = parseArgs({
+    args: [...argv],
+    options: {
+      help: { type: "boolean", short: "h" },
+      repo: { type: "string" },
+      pr: { type: "string" },
+      "failed-only": { type: "boolean" },
+      tail: { type: "string" },
+      ...JQ_OUTPUT_PARSE_OPTIONS,
+    },
+    allowPositionals: true,
+    strict: false,
+    tokens: true,
+  });
+  const options = {
+    help: false,
+    repo: undefined,
+    pr: undefined,
+    failedOnly: false,
+    tail: DEFAULT_TAIL_LINES,
+    jq: undefined,
+    silent: false,
+  };
+  for (const token of tokens) {
+    if (token.kind === "positional") {
+      throw parseError(`Unknown argument: ${token.value}`);
+    }
+    if (token.kind !== "option") {
+      continue;
+    }
+    if (token.name === "help") {
+      options.help = true;
+      return options;
+    }
+    if (token.name === "repo") {
+      options.repo = requireTokenValue(token, parseError).trim();
+      continue;
+    }
+    if (token.name === "pr") {
+      options.pr = parsePrNumber(requireTokenValue(token, parseError), parseError);
+      continue;
+    }
+    if (token.name === "failed-only") {
+      options.failedOnly = true;
+      continue;
+    }
+    if (token.name === "tail") {
+      const raw = requireTokenValue(token, parseError);
+      const value = Number(raw);
+      if (!Number.isInteger(value) || value < 1) {
+        throw parseError(`--tail must be a positive integer, got "${raw}"`);
+      }
+      options.tail = value;
+      continue;
+    }
+    if (matchJqOutputToken(token, options, (t) => requireTokenValue(t, parseError))) continue;
+    throw parseError(`Unknown argument: ${token.rawName}`);
+  }
+  if (options.repo === undefined || options.pr === undefined) {
+    throw parseError("Fetching CI logs 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 ghJson(run, ghCommand, args, env, label) {
+  const result = await run(ghCommand, args, env);
+  if (result.code !== 0) {
+    const detail = result.stderr.trim() || `exit code ${result.code}`;
+    throw new Error(`${label} failed: ${detail}`);
+  }
+  return parseJsonText(result.stdout, { label });
+}
+
+function tailLines(text, n) {
+  const lines = String(text).replace(/\r?\n$/u, "").split(/\r?\n/u);
+  return lines.slice(Math.max(0, lines.length - n)).join("\n");
+}
+
+export async function fetchCiLogs(options, { env = process.env, ghCommand = "gh", run = runChild } = {}) {
+  // 1. Resolve the PR's current head SHA — logs must be scoped to the head being
+  //    evaluated, not a stale push.
+  const pr = await ghJson(
+    run,
+    ghCommand,
+    ["pr", "view", String(options.pr), "--repo", options.repo, "--json", "headRefOid"],
+    env,
+    "gh pr view",
+  );
+  const headSha = typeof pr.headRefOid === "string" ? pr.headRefOid.trim() : "";
+  if (headSha.length === 0) {
+    throw new Error("gh pr view did not return headRefOid");
+  }
+
+  // 2. List Actions runs for that exact commit.
+  const runs = await ghJson(
+    run,
+    ghCommand,
+    ["run", "list", "--repo", options.repo, "--commit", headSha, "--json", "databaseId,name,conclusion,status"],
+    env,
+    "gh run list",
+  );
+  if (!Array.isArray(runs)) {
+    throw new Error("gh run list did not return a JSON array");
+  }
+  const selected = options.failedOnly
+    ? runs.filter((r) => String(r?.conclusion).toLowerCase() === "failure")
+    : runs;
+
+  // 3. Fetch each run's log tail. --log-failed restricts to failed steps when the
+  //    run failed; for non-failed runs it returns nothing, so fall back to --log.
+  const out = [];
+  for (const r of selected) {
+    const runId = Number.isInteger(r?.databaseId) ? r.databaseId : null;
+    if (runId === null) continue;
+    const conclusion = typeof r?.conclusion === "string" ? r.conclusion.toLowerCase() : null;
+    const logFlag = conclusion === "failure" ? "--log-failed" : "--log";
+    const logResult = await run(
+      ghCommand,
+      ["run", "view", String(runId), "--repo", options.repo, logFlag],
+      env,
+    );
+    // A log fetch failure for one run shouldn't abort the others (logs expire);
+    // record an empty tail with a note rather than throwing.
+    const logTail =
+      logResult.code === 0
+        ? tailLines(logResult.stdout, options.tail)
+        : `<log unavailable: ${logResult.stderr.trim() || `exit ${logResult.code}`}>`;
+    out.push({
+      runId,
+      name: typeof r?.name === "string" ? r.name : null,
+      conclusion,
+      logTail,
+    });
+  }
+  return { ok: true, repo: options.repo, pr: options.pr, headSha, runs: out };
+}
+
+export async function runCli(
+  argv = process.argv.slice(2),
+  { stdout = process.stdout, stderr = process.stderr, env = process.env, ghCommand = "gh", run = runChild } = {},
+) {
+  let options;
+  try {
+    options = parseFetchCiLogsCliArgs(argv);
+  } catch (error) {
+    stderr.write(`${formatCliError(error)}\n`);
+    return 1;
+  }
+  if (options.help) {
+    stdout.write(`${USAGE}\n`);
+    return 0;
+  }
+  let result;
+  try {
+    result = await fetchCiLogs(options, { env, ghCommand, run });
+  } catch (error) {
+    stderr.write(`${JSON.stringify({ ok: false, error: error instanceof Error ? error.message : String(error) })}\n`);
+    return 1;
+  }
+  return emitResult(result, { jq: options.jq, silent: options.silent, stdout, stderr });
+}
+
+if (isDirectCliRun(import.meta.url)) {
+  runCli().then((code) => { process.exitCode = code; });
+}