@mmerterden/multi-agent-pipeline 20.21.0 → 20.23.0

package/pipeline/scripts/_supertypes.mjs

@@ -0,0 +1,133 @@
+/**
+ * @file _supertypes.mjs  -  the types a declaration header names as its parents.
+ *
+ * Reads the header text that follows a type's name in a stripped body (comments
+ * and strings already blanked) and returns the simple names of its superclass,
+ * protocols or interfaces. Three syntaxes cover the stacks the graph indexes:
+ *
+ *   colon    Swift and Kotlin: `Name<T>(ctor): A, B<X>() where ...  {`
+ *   parens   Python: `Name(A, B, metaclass=M):`
+ *   extends  TypeScript / JavaScript: `Name<T> extends A implements B, C {`
+ *
+ * Only names that start with a letter or underscore are kept, qualified names
+ * reduce to their last segment, and generic arguments, constructor calls and
+ * Kotlin delegation (`by impl`) are dropped. A name the graph does not define
+ * (String, Codable) simply produces no edge.
+ *
+ * Zero runtime dependencies (ADR-0004).
+ *
+ * @module pipeline/scripts/_supertypes
+ */
+
+const HEADER_MAX = 4000;
+const OPEN = { "(": ")", "<": ">", "[": "]" };
+const CLOSE = new Set([")", ">", "]"]);
+
+/** `->` and `=>` are arrows, not the end of a generic argument list. */
+const isArrow = (text, i) => text[i] === ">" && (text[i - 1] === "-" || text[i - 1] === "=");
+
+/**
+ * The header from `start` to the `{` that opens the body (or `;`, or Python's
+ * closing `:`) at bracket depth 0, capped so a declaration with no body cannot
+ * read on into the file.
+ */
+function headerText(body, start, syntax) {
+  let depth = 0;
+  const end = Math.min(body.length, start + HEADER_MAX);
+  for (let i = start; i < end; i++) {
+    const c = body[i];
+    if (c in OPEN) depth++;
+    else if (CLOSE.has(c) && depth > 0 && !isArrow(body, i)) depth--;
+    else if (depth === 0 && (c === "{" || c === ";")) return body.slice(start, i);
+    else if (depth === 0 && syntax === "parens" && c === ":") return body.slice(start, i);
+  }
+  return body.slice(start, end);
+}
+
+/** Split on commas at bracket depth 0. */
+function splitTop(text) {
+  const parts = [];
+  let depth = 0;
+  let cur = "";
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (c in OPEN) depth++;
+    else if (CLOSE.has(c) && depth > 0 && !isArrow(text, i)) depth--;
+    if (c === "," && depth === 0) {
+      parts.push(cur);
+      cur = "";
+    } else cur += c;
+  }
+  parts.push(cur);
+  return parts;
+}
+
+/** Skip one balanced bracket group starting at `i` when `text[i]` is `open`. */
+function skipGroup(text, i, open) {
+  if (text[i] !== open) return i;
+  const close = OPEN[open];
+  let depth = 0;
+  for (let j = i; j < text.length; j++) {
+    if (text[j] === open) depth++;
+    else if (text[j] === close && !isArrow(text, j) && --depth === 0) return j + 1;
+  }
+  return text.length;
+}
+
+function simpleName(raw) {
+  const item = raw.replace(/^\s*(?:@[\w.]+(?:\([^)]*\))?\s*)+/, "").replace(/`/g, "");
+  const m = /^\s*(?:out\s+|in\s+)?([A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*)/.exec(item);
+  if (!m || item.includes("=")) return null;
+  return m[1].split(".").pop();
+}
+
+function names(list) {
+  const out = [];
+  for (const item of splitTop(list)) {
+    const n = simpleName(item);
+    if (n && !out.includes(n)) out.push(n);
+  }
+  return out;
+}
+
+/**
+ * @param {string} body - stripped source
+ * @param {number} start - offset just past the declared name
+ * @param {"colon"|"parens"|"extends"} syntax
+ * @returns {string[]} simple supertype names, in header order
+ */
+export function supertypesAt(body, start, syntax) {
+  const header = headerText(body, start, syntax);
+  if (syntax === "parens") {
+    const m = /^\s*\(/.exec(header);
+    if (!m) return [];
+    const end = skipGroup(header, m[0].length - 1, "(");
+    return names(header.slice(m[0].length, end - 1));
+  }
+  if (syntax === "extends") {
+    let k = 0;
+    while (k < header.length && /\s/.test(header[k])) k++;
+    const rest = header.slice(skipGroup(header, k, "<"));
+    const out = [];
+    const ext = /\bextends\s+([\s\S]*?)(?=\bimplements\b|$)/.exec(rest);
+    const imp = /\bimplements\s+([\s\S]*)$/.exec(rest);
+    for (const part of [ext?.[1], imp?.[1]])
+      if (part) for (const n of names(part)) if (!out.includes(n)) out.push(n);
+    return out;
+  }
+  let i = 0;
+  while (i < header.length && /\s/.test(header[i])) i++;
+  i = skipGroup(header, i, "<");
+  let j = i;
+  while (j < header.length && /\s/.test(header[j])) j++;
+  const ctor =
+    /^(?:@[A-Za-z_][\w.]*(?:\([^)]*\))?\s+)*(?:(?:private|protected|internal|public)\s+)?constructor\s*/.exec(
+      header.slice(j),
+    );
+  if (ctor) j += ctor[0].length;
+  j = skipGroup(header, j, "(");
+  while (j < header.length && /\s/.test(header[j])) j++;
+  if (header[j] !== ":") return [];
+  const list = header.slice(j + 1).split(/\bwhere\b/)[0];
+  return names(list.replace(/\bby\s+[^,]*/g, ""));
+}

package/pipeline/scripts/analysis-story-body.mjs

@@ -16,6 +16,11 @@ import { escapeJiraWiki, wikiLink } from "./jira-wiki-escape.mjs";
 import { redesignSections } from "../lib/analysis-sections.mjs";
 
 const MAX_CRITERIA = 8;
+
+// Panel border colours of a story section, the ones testers read stories in:
+// the user story, the acceptance criteria, and every other section.
+const PANEL = { story: "#d4d39e", criteria: "#d4a19e", info: "#9eb6d4" };
+const panel = (colour, lines) => [`{panel:borderColor=${colour}}`, ...lines, "{panel}", ""];
 const MAX_DESIGN_LINKS = 5;
 
 // A criterion that describes a refusal, an error or an alternative path. One is
@@ -152,19 +157,30 @@ function linksOf(story, lines, ctx) {
 
 function render({ userStory, acceptance, currentVsTarget, links }, sourceIds) {
   const out = [];
-  if (userStory) out.push("h3. User story", escapeJiraWiki(userStory), "");
+  if (userStory) out.push(...panel(PANEL.story, ["h3. User story", escapeJiraWiki(userStory)]));
   if (acceptance.length) {
-    out.push("h3. Acceptance criteria", ...acceptance.map((a) => `# ${escapeJiraWiki(a)}`), "");
+    out.push(
+      ...panel(PANEL.criteria, [
+        "h3. Acceptance criteria",
+        ...acceptance.map((a) => `# ${escapeJiraWiki(a)}`),
+      ]),
+    );
   }
   if (currentVsTarget.length) {
-    out.push("h3. Current vs target", "||Id||Status||Where||");
-    for (const r of currentVsTarget) {
-      out.push(`|${escapeJiraWiki(r.id)}|${escapeJiraWiki(r.status)}|${escapeJiraWiki(r.where)}|`);
-    }
-    out.push("");
+    out.push(
+      ...panel(PANEL.info, [
+        "h3. Current vs target",
+        "||Id||Status||Where||",
+        ...currentVsTarget.map(
+          (r) => `|${escapeJiraWiki(r.id)}|${escapeJiraWiki(r.status)}|${escapeJiraWiki(r.where)}|`,
+        ),
+      ]),
+    );
   }
   if (links.length) {
-    out.push("h3. Links", ...links.map((l) => `* ${wikiLink(l.label, l.url)}`), "");
+    out.push(
+      ...panel(PANEL.info, ["h3. Links", ...links.map((l) => `* ${wikiLink(l.label, l.url)}`)]),
+    );
   }
   out.push(
     `Sources: ${escapeJiraWiki(sourceIds.length ? sourceIds.join(", ") : "derived from the section heading")}`,

package/pipeline/scripts/capture-flush.sh

@@ -66,7 +66,10 @@ LOGS="${LOGS_ROOT:-$HOME/.claude/logs/multi-agent}"
 SCRIPTS="$HOME/.claude/scripts"
 [ -d "$SCRIPTS" ] || SCRIPTS="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)"
 
-say() { [ "$QUIET" -eq 1 ] && return 0; printf '%s\n' "$1"; }
+say() {
+  [ "$QUIET" -eq 1 ] && return 0
+  if [ "$JSON" -eq 1 ]; then printf '%s\n' "$1" >&2; else printf '%s\n' "$1"; fi
+}
 
 # Resolve the run to flush.
 #
@@ -110,8 +113,37 @@ fi
 # Phase 4 removes the worktree once the PR is open, so the salvaged copy under
 # artifactsPath is tried FIRST. Reading the worktree path first would degrade
 # silently for exactly the runs this script exists to rescue.
+#
+# After those, each worktree's newest `.pipeline/triage-round-<N>.json`: Phase 3
+# writes every round there itself, and the copy to triage-output.json is a
+# separate step a run can die before. A multi-repo run names its worktrees only
+# under projects[], so those are read too, and the state directory last.
+newest_round() {
+  [ -d "$1/.pipeline" ] || return 0
+  ls -t "$1"/.pipeline/triage-round-*.json 2>/dev/null | head -1
+}
+WORKTREES=$( { [ -n "$WORKTREE" ] && printf '%s\n' "$WORKTREE"; jq -r '.projects[]?.worktreePath // empty' "$STATE" 2>/dev/null; } | awk 'NF && !seen[$0]++')
 TRIAGE=""
-for cand in "${ARTIFACTS:+$ARTIFACTS/triage-output.json}" "${WORKTREE:+$WORKTREE/triage-output.json}"; do
+CANDIDATES=("${ARTIFACTS:+$ARTIFACTS/triage-output.json}")
+# Within one worktree the newer of the copy and the newest round wins: a run
+# that died before the copy step leaves the previous round in the copy.
+newest_in_worktree() {
+  local copy="$1/triage-output.json" round
+  round=$(newest_round "$1")
+  if [ -f "$copy" ] && [ -n "$round" ]; then
+    ls -t "$copy" "$round" 2>/dev/null | head -1
+  elif [ -f "$copy" ]; then
+    printf '%s\n' "$copy"
+  else
+    printf '%s\n' "$round"
+  fi
+}
+while IFS= read -r wt; do
+  [ -n "$wt" ] || continue
+  CANDIDATES+=("$(newest_in_worktree "$wt")")
+done <<< "$WORKTREES"
+CANDIDATES+=("$(dirname "$STATE")/triage-output.json")
+for cand in "${CANDIDATES[@]}"; do
   [ -n "$cand" ] && [ -f "$cand" ] && { TRIAGE="$cand"; break; }
 done
 
@@ -136,12 +168,38 @@ run_store() {
   esac
 }
 
+# The store is named after the run's repository, never after the directory this
+# script happens to run in: a SessionEnd hook fires wherever the session was.
+# A live worktree resolves to its main checkout's folder, the same name the
+# readers derive; otherwise the project recorded in the state.
+slug_of_worktree() {
+  [ -d "$1" ] || return 0
+  local main
+  main=$(git -C "$1" worktree list --porcelain 2>/dev/null | sed -n '1s/^worktree //p')
+  [ -n "$main" ] || return 0
+  basename "$main" .git
+}
+SLUG=""
+while IFS= read -r wt; do
+  [ -n "$wt" ] && [ -z "$SLUG" ] && SLUG=$(slug_of_worktree "$wt")
+done <<< "$WORKTREES"
+plain_slug() {
+  case "$1" in
+    "" | .* | *[!A-Za-z0-9._-]*) return 0 ;;
+  esac
+  printf '%s' "$1"
+}
+SLUG=$(plain_slug "$SLUG")
+[ -n "$SLUG" ] || SLUG=$(plain_slug "$(jq -r '.project // .projects[0].name // empty' "$STATE" 2>/dev/null)")
+SLUG_ARGS=()
+[ -n "$SLUG" ] && SLUG_ARGS=(--repo-slug "$SLUG")
+
 if [ -n "$TRIAGE" ]; then
   INGESTED=$(run_store ingest \
-    node "$SCRIPTS/triage-memory.mjs" ingest --triage "$TRIAGE" --state "$STATE")
+    node "$SCRIPTS/triage-memory.mjs" ingest --triage "$TRIAGE" --state "$STATE" ${SLUG_ARGS[@]+"${SLUG_ARGS[@]}"})
   if [ -n "$TASK_ID" ]; then
     DISTILLED=$(run_store distill \
-      node "$SCRIPTS/learnings-ledger.mjs" from-triage --triage "$TRIAGE" --task "$TASK_ID")
+      node "$SCRIPTS/learnings-ledger.mjs" from-triage --triage "$TRIAGE" --task "$TASK_ID" ${SLUG_ARGS[@]+"${SLUG_ARGS[@]}"})
   fi
 fi
 

package/pipeline/scripts/code-graph-rules/android.json

@@ -51,6 +51,7 @@
     }
   ],
   "referenceKinds": ["class", "interface", "object", "enum", "record", "typealias"],
+  "supertypes": { "syntax": "colon", "kinds": ["class", "interface", "object", "enum"] },
   "referenceKindsNote": "fun is deliberately absent, for the reason Swift's rules record for func: a bare lowercase name matched across files is almost never a call to that exact declaration, and on a large app the generic ones (invoke, build, create, get) take the top god-node slots purely because each happened to be declared once. Composables are the tempting exception - they are capitalised and behave like types - but they are declared with fun, so including them means including every other fun with them.",
   "ignoredIdentifiers": [
     "this",

package/pipeline/scripts/code-graph-rules/ios.json

@@ -51,6 +51,11 @@
     }
   ],
   "referenceKinds": ["class", "struct", "enum", "protocol", "actor", "typealias"],
+  "supertypes": {
+    "syntax": "colon",
+    "kinds": ["class", "struct", "enum", "protocol", "actor"],
+    "extensionPattern": "\\bextension\\s+([A-Z][A-Za-z0-9_.]*)"
+  },
   "referenceKindsNote": "func is deliberately absent. A bare lowercase method name matched across files is almost never a call to that exact declaration: on a large Swift app `with`, `size`, `name`, `image` and `model` took the top god-node slots purely because each happened to be declared in exactly one file. Functions still reach the graph through their `defines` edge, so they stay findable by name.",
   "ignoredIdentifiers": [
     "self",

package/pipeline/scripts/code-graph-rules/node.json

@@ -46,6 +46,7 @@
     }
   ],
   "referenceKinds": ["class", "interface", "type", "enum", "const"],
+  "supertypes": { "syntax": "extends", "kinds": ["class", "interface"] },
   "referenceKindsNote": "function is deliberately absent, for the reason Swift's rules record for func: a bare name matched across files is almost never a call to that exact declaration, and the generic ones (run, main, get, parse, handler) would take the top god-node slots purely because each happened to be declared once. Functions still reach the graph through their defines edge, so they stay findable by name. const is present but narrowed to an uppercase-initial declaration at column 0, which is what a component, a singleton or an exported table looks like; a lowercase const is a local and is not a declaration anyone references across files. Measured on this repo (126 sources): including function put `ok` at degree 52, `f` at 38, `tokens` at 15 and `arg` at 12 - local helper names that happen to be declared exactly once, so the ambiguity rule does not catch them either. Excluding it leaves a thin symbol layer, and that is the honest shape of this stack: a JavaScript module's exported unit is usually a function, so the useful graph here is the import graph between files. `graph-affected \"<file>.mjs\"` answers who imports a module, which is the question this stack actually gets asked.",
   "ignoredIdentifiers": [
     "this",

package/pipeline/scripts/code-graph-rules/python.json

@@ -30,6 +30,7 @@
     }
   ],
   "referenceKinds": ["class"],
+  "supertypes": { "syntax": "parens", "kinds": ["class"] },
   "referenceKindsNote": "def is deliberately absent, for the reason Swift's rules record for func and the node rules record with measurements: a bare lowercase name matched across files is almost never a call to that exact declaration, and Python's convention of short module-level helpers (main, run, load, parse, setup) makes it worse than most. Functions still reach the graph through their defines edge, so they stay findable by name.",
   "ignoredIdentifiers": [
     "self",

package/pipeline/scripts/diff-risk-score.mjs

@@ -16,11 +16,18 @@
  *   ui_critical       -  *View.swift / *Screen.kt / Configuration   w=1.5
  *   migration         -  DB schema / migration path                 w=4.0
  *   test_lines_removed -  test file shrinks (removed > added)       w=3.0
+ *   dependents_reached -  distinct non-test files that depend on the  w=2.0
+ *                         changed declarations, two rings out, from
+ *                         the code graph; only with --graph, capped
+ *                         at 20 so one hub cannot outweigh a
+ *                         security path
  *
  * Inputs:
  *   --base <ref>     Base ref. Default: origin/main, fallback: main
  *   --head <ref>     Head ref. Default: HEAD
  *   --diff <path>    Pre-computed diff file (skip git invocation)
+ *   --graph <path>   Code graph (graph-build.mjs). Adds dependents_reached;
+ *                    an unreadable graph is reported on stderr and skipped
  *   --root <path>    Repo root for git -C. Default: cwd
  *   --task-id <id>   Tag the output with a task id (no functional effect)
  *   --top <N>        Truncate `files` to top N. Default: keep all,
@@ -40,7 +47,9 @@
 
 import { readFileSync, existsSync } from "node:fs";
 import { execFileSync } from "node:child_process";
-import { unquoteGitPath, unquotePathIfNeeded } from "./git-path.mjs";
+import { unquoteGitPath } from "./git-path.mjs";
+import { affected } from "./graph-affected.mjs";
+import { parseDiffFiles, changedSymbols, graphSide } from "./_diff-impact.mjs";
 
 const argv = process.argv.slice(2);
 const flags = {};
@@ -65,6 +74,9 @@ const DIFF_FILE = flags.diff || null;
 const TASK_ID = flags["task-id"] || null;
 const TOP = flags.top ? Number(flags.top) : null;
 const PRETTY = flags.json === true;
+const GRAPH_FILE = flags.graph && flags.graph !== true ? flags.graph : null;
+const DEPENDENTS_CAP = 20;
+const DEPENDENTS_DEPTH = 2;
 
 function git(args) {
   return execFileSync("git", ["-C", ROOT, ...args], { encoding: "utf8" }).trim();
@@ -95,7 +107,7 @@ function loadDiff() {
     if (!existsSync(DIFF_FILE)) throw new Error(`diff file not found: ${DIFF_FILE}`);
     return readFileSync(DIFF_FILE, "utf8");
   }
-  return git(["diff", "--unified=0", `${BASE}...${HEAD}`]);
+  return git(["diff", "--unified=0", "--src-prefix=a/", "--dst-prefix=b/", `${BASE}...${HEAD}`]);
 }
 
 function loadNumstat() {
@@ -118,16 +130,30 @@ function loadNumstat() {
     }
     return Array.from(map.entries()).map(([path, v]) => ({ path, ...v }));
   }
-  const out = git(["diff", "--numstat", `${BASE}...${HEAD}`]);
+  // -z: paths are raw (never quoted), and a rename is `A\tR\t\0old\0new\0`,
+  // so the new path is read directly instead of parsed out of `{a => b}`.
+  const out = execFileSync("git", ["-C", ROOT, "diff", "--numstat", "-z", `${BASE}...${HEAD}`], {
+    encoding: "utf8",
+  });
   if (!out) return [];
-  return out.split("\n").map((line) => {
-    const [a, r, ...rest] = line.split("\t");
-    return {
-      path: unquotePathIfNeeded(rest.join("\t")),
+  const fields = out.split("\0");
+  const rows = [];
+  for (let i = 0; i < fields.length; i++) {
+    const head = fields[i];
+    if (!head) continue;
+    const [a, r, path] = head.split("\t");
+    let name = path;
+    if (path === "") {
+      name = fields[i + 2];
+      i += 2;
+    }
+    rows.push({
+      path: name,
       added: a === "-" ? 0 : Number(a) || 0,
       removed: r === "-" ? 0 : Number(r) || 0,
-    };
-  });
+    });
+  }
+  return rows;
 }
 
 const SECURITY_GLOBS = [
@@ -332,6 +358,47 @@ function buildRow(stat, addedLines, allChangedPaths) {
   };
 }
 
+function loadGraphOrNull(path) {
+  try {
+    const graph = JSON.parse(readFileSync(path, "utf8"));
+    if (!Array.isArray(graph.nodes) || !Array.isArray(graph.edges))
+      throw new Error("not a code graph");
+    return graph;
+  } catch (e) {
+    process.stderr.write(
+      `diff-risk-score: graph unreadable at ${path}, dependents_reached skipped: ${e.message}\n`,
+    );
+    return null;
+  }
+}
+
+/**
+ * Add dependents_reached to each row whose changed declarations have
+ * dependents in the graph. Test files are not counted as dependents: a change
+ * that only its own tests use is not wide.
+ */
+function addGraphSignal(rows, graph, diffText, root) {
+  const side = graphSide(graph, { root });
+  const diffFiles = parseDiffFiles(diffText);
+  for (const row of rows) {
+    const f = diffFiles.find((x) => (x.newPath || x.oldPath) === row.path);
+    if (!f) continue;
+    const path = side === "old" ? f.oldPath || f.newPath : f.newPath || f.oldPath;
+    const r = side === "old" ? f.oldRanges : f.newRanges;
+    if (!r.length) continue;
+    const { seeds } = changedSymbols(graph, new Map([[path, r]]));
+    if (!seeds.length) continue;
+    const hits = affected({ graph, seeds, depth: DEPENDENTS_DEPTH });
+    const files = new Set(
+      hits.filter((h) => h.node?.path && !h.node.isTest).map((h) => h.node.path),
+    );
+    if (!files.size) continue;
+    const w = 2.0;
+    row.signals.push({ name: "dependents_reached", weight: w, value: files.size });
+    row.score = Math.round((row.score + Math.min(files.size, DEPENDENTS_CAP) * 2 * w) * 100) / 100;
+  }
+}
+
 function main() {
   // Resolve the base ref ONCE, before any git diff runs. loadNumstat() and
   // loadDiff() both interpolate BASE; resolving it lazily inside loadDiff()
@@ -348,6 +415,10 @@ function main() {
   const rows = numstat.map((stat) =>
     buildRow(stat, perFileAdded.get(stat.path) || [], allChangedPaths),
   );
+  if (GRAPH_FILE) {
+    const graph = loadGraphOrNull(GRAPH_FILE);
+    if (graph) addGraphSignal(rows, graph, diffText, ROOT);
+  }
   rows.sort((a, b) => b.score - a.score || a.path.localeCompare(b.path));
 
   const totals = {

package/pipeline/scripts/git-path.mjs

@@ -61,3 +61,24 @@ export function unquotePathIfNeeded(s) {
   }
   return s;
 }
+
+/**
+ * The path a `---` or `+++` diff header names (the text after that marker): a
+ * quoted path ends at its closing quote, which git may follow with a tab, and
+ * an unquoted one ends at a tab.
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+export function diffHeaderPath(text) {
+  if (text.startsWith('"')) {
+    for (let i = 1; i < text.length; i++) {
+      if (text[i] === "\\") {
+        i++;
+        continue;
+      }
+      if (text[i] === '"') return unquoteGitPath(text.slice(1, i));
+    }
+  }
+  return text.replace(/\t.*$/, "");
+}