@mmerterden/multi-agent-pipeline 20.2.1 → 20.3.1

package/pipeline/scripts/_stack-adapter.mjs

@@ -0,0 +1,678 @@
+#!/usr/bin/env node
+/**
+ * _stack-adapter.mjs  -  one place that knows how each stack builds, tests and
+ * proves it did.
+ *
+ * The adapter table is data (`../schemas/stack-adapters.json`); this module
+ * loads it, validates it without a schema library (the shipped package is
+ * dependency-free), resolves which adapters describe a repo, compiles the
+ * evidence markers and renders the build/test commands.
+ *
+ * Resolution has two layers. `stack-detect.sh` answers the coarse question
+ * (ios / android / web / backend) and owns the rules that need file content:
+ * the Android plugin versus a plain JVM Gradle build, and which side of a
+ * package.json a repo is on. The adapter layer then refines `backend` by the
+ * manifest that names the language (go.mod, Cargo.toml, pyproject.toml, ...),
+ * searched with the same prune set, so a vendored checkout or a build output
+ * directory never decides the stack.
+ *
+ * Usage:
+ *   node _stack-adapter.mjs resolve  --dir <repo> [--json]
+ *   node _stack-adapter.mjs markers  --stack <id> --claim build|test
+ *   node _stack-adapter.mjs command  --stack <id> --kind build|test|testFile [--dir <d>] [--var k=v ...]
+ *   node _stack-adapter.mjs list
+ *   node _stack-adapter.mjs validate [--file <path>]
+ *
+ * Exit: 0 ok · 1 invalid table / command not available · 2 usage
+ *
+ * @module pipeline/scripts/_stack-adapter
+ */
+
+import { spawnSync } from "node:child_process";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import {
+  detect as detectPackageManager,
+  hasScript,
+  runCommand,
+  testCommand,
+} from "./package-manager.mjs";
+import { invokedDirectly } from "../lib/invoked-directly.mjs";
+
+export const ADAPTERS_PATH = fileURLToPath(
+  new URL("../schemas/stack-adapters.json", import.meta.url),
+);
+export const STACK_DETECT = fileURLToPath(new URL("../lib/stack-detect.sh", import.meta.url));
+
+export const REQUIRED_ADAPTERS = [
+  "ios",
+  "android",
+  "web",
+  "backend-node",
+  "python",
+  "go",
+  "rust",
+  "jvm",
+];
+export const UNKNOWN = "unknown";
+export const COARSE_STACKS = ["ios", "android", "web", "backend"];
+export const PARSER_IDS = [
+  "xcodebuild",
+  "xcresult",
+  "junit-xml",
+  "gradle",
+  "maven",
+  "pytest",
+  "jest",
+  "vitest",
+  "node-test",
+  "go-test",
+  "go-test-json",
+  "cargo-test",
+];
+export const COMMAND_KINDS = ["build", "test", "testFile", "lint"];
+const CLAIMS = ["build", "test"];
+const MAX_PATTERN_LEN = 200;
+
+// Directory names stack-detect.sh prunes. A test compares the two lists.
+export const PRUNE_DIRS = [
+  "node_modules",
+  ".build",
+  "Pods",
+  "build",
+  "dist",
+  ".next",
+  ".gradle",
+  "DerivedData",
+  ".worktrees",
+  ".git",
+  "vendor",
+  "Carthage",
+];
+const MANIFEST_DEPTH = 3;
+
+export class AdapterError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = "AdapterError";
+    this.code = code;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Validation
+
+function compiles(pattern, flags) {
+  try {
+    return new RegExp(pattern, flags);
+  } catch {
+    return null;
+  }
+}
+
+function checkMarkerList(list, where, errors) {
+  if (!Array.isArray(list) || list.length === 0) {
+    errors.push(`${where} must be a non-empty array`);
+    return;
+  }
+  list.forEach((m, i) => {
+    const at = `${where}[${i}]`;
+    if (!m || typeof m.pattern !== "string" || m.pattern.length === 0) {
+      errors.push(`${at} has no pattern`);
+      return;
+    }
+    if (m.pattern.length > MAX_PATTERN_LEN) errors.push(`${at} is longer than ${MAX_PATTERN_LEN}`);
+    if (m.flags !== undefined && !/^[im]{0,2}$/.test(m.flags)) {
+      errors.push(`${at} flags must be i/m`);
+    }
+    if (!compiles(m.pattern, m.flags)) errors.push(`${at} is not a valid regex: ${m.pattern}`);
+  });
+}
+
+function checkCommand(cmd, where, errors) {
+  if (!cmd || typeof cmd !== "object") {
+    errors.push(`${where} must be an object`);
+    return;
+  }
+  const hasTemplate = typeof cmd.template === "string" && cmd.template.length > 0;
+  const hasScriptName = typeof cmd.packageScript === "string" && cmd.packageScript.length > 0;
+  if (hasTemplate === hasScriptName) {
+    errors.push(`${where} needs exactly one of template, packageScript`);
+  }
+  if (cmd.exitMarker !== undefined && !/^[^'\n]+$/.test(cmd.exitMarker)) {
+    errors.push(`${where}.exitMarker may not contain a quote or newline`);
+  }
+}
+
+function checkAdapter(id, a, errors) {
+  const at = (k) => `${id}.${k}`;
+  if (!a || typeof a !== "object") {
+    errors.push(`${id} must be an object`);
+    return;
+  }
+  if (typeof a.label !== "string" || !a.label) errors.push(`${at("label")} is required`);
+  const applicable = a.applicable !== false;
+
+  const d = a.detection;
+  if (!d || typeof d !== "object") errors.push(`${at("detection")} is required`);
+  else {
+    if (d.stackDetect !== undefined && !COARSE_STACKS.includes(d.stackDetect)) {
+      errors.push(`${at("detection.stackDetect")} must be one of ${COARSE_STACKS.join(", ")}`);
+    }
+    if (applicable && d.stackDetect === undefined && !(d.manifests || []).length) {
+      errors.push(`${at("detection")} needs stackDetect or manifests`);
+    }
+  }
+
+  if (!Array.isArray(a.commands)) errors.push(`${at("commands")} must be an array`);
+  else {
+    if (applicable && a.commands.length === 0) errors.push(`${at("commands")} is empty`);
+    a.commands.forEach((set, i) => {
+      for (const kind of ["build", "test"]) {
+        checkCommand(set?.[kind], `${at("commands")}[${i}].${kind}`, errors);
+      }
+      for (const kind of ["testFile", "lint"]) {
+        if (set?.[kind] !== undefined) {
+          checkCommand(set[kind], `${at("commands")}[${i}].${kind}`, errors);
+        }
+      }
+    });
+  }
+
+  if (!a.markers || typeof a.markers !== "object") errors.push(`${at("markers")} is required`);
+  else if (applicable) {
+    for (const claim of CLAIMS) {
+      for (const side of ["success", "failure"]) {
+        checkMarkerList(a.markers[claim]?.[side], `${at("markers")}.${claim}.${side}`, errors);
+      }
+      for (const extra of ["skipped", "loadError"]) {
+        if (a.markers[claim]?.[extra] !== undefined) {
+          checkMarkerList(a.markers[claim][extra], `${at("markers")}.${claim}.${extra}`, errors);
+        }
+      }
+    }
+  }
+
+  const parsers = a.testSummary?.parsers;
+  if (!Array.isArray(parsers)) errors.push(`${at("testSummary.parsers")} must be an array`);
+  else {
+    for (const p of parsers) {
+      if (!PARSER_IDS.includes(p)) {
+        errors.push(`${at("testSummary.parsers")} names unknown parser ${p}`);
+      }
+    }
+  }
+
+  if (!Array.isArray(a.testFilePatterns)) errors.push(`${at("testFilePatterns")} must be an array`);
+  else {
+    a.testFilePatterns.forEach((p, i) => {
+      if (!compiles(p)) errors.push(`${at("testFilePatterns")}[${i}] is not a valid regex`);
+    });
+  }
+
+  if (!a.truthSources || typeof a.truthSources !== "object") {
+    errors.push(`${at("truthSources")} is required`);
+  }
+
+  const refs = a.referencePatterns;
+  if (!refs || typeof refs !== "object") errors.push(`${at("referencePatterns")} is required`);
+  else {
+    for (const [kind, list] of Object.entries(refs)) {
+      (list || []).forEach((p, i) => {
+        const where = `${at("referencePatterns")}.${kind}[${i}]`;
+        if (!compiles(p)) errors.push(`${where} is not a valid regex`);
+        else if (!p.includes("(?<ref>")) errors.push(`${where} needs a (?<ref>...) capture group`);
+      });
+    }
+  }
+}
+
+/**
+ * Every problem with an adapter document, as readable strings. Empty = valid.
+ * @param {any} doc
+ * @returns {string[]}
+ */
+export function validateAdapters(doc) {
+  const errors = [];
+  if (!doc || typeof doc !== "object") return ["adapter document must be an object"];
+  if (doc.version !== "1.0.0") errors.push(`version must be "1.0.0"`);
+  const adapters = doc.adapters;
+  if (!adapters || typeof adapters !== "object") return [...errors, "adapters must be an object"];
+  for (const id of [...REQUIRED_ADAPTERS, UNKNOWN]) {
+    if (!adapters[id]) errors.push(`adapters.${id} is required`);
+  }
+  for (const [id, a] of Object.entries(adapters)) {
+    if (!/^[a-z][a-z0-9-]*$/.test(id)) errors.push(`adapter id ${id} is not lower-kebab-case`);
+    checkAdapter(id, a, errors);
+  }
+  if (adapters.unknown && adapters.unknown.applicable !== false) {
+    errors.push("adapters.unknown must set applicable: false");
+  }
+  if (!Array.isArray(doc.order)) errors.push("order must be an array");
+  else {
+    for (const id of doc.order) {
+      if (!adapters[id]) errors.push(`order names ${id}, which has no adapter`);
+    }
+    for (const id of REQUIRED_ADAPTERS) {
+      if (!doc.order.includes(id)) errors.push(`order is missing ${id}`);
+    }
+  }
+  return errors;
+}
+
+// ---------------------------------------------------------------------------
+// Loading
+
+const cache = new Map();
+
+/**
+ * Load and validate an adapter document. Cached per path.
+ * @param {string} [path]
+ */
+export function loadAdapters(path = ADAPTERS_PATH) {
+  if (cache.has(path)) return cache.get(path);
+  let doc;
+  try {
+    doc = JSON.parse(readFileSync(path, "utf8"));
+  } catch (err) {
+    throw new AdapterError("unreadable", `cannot read adapters ${path}: ${err.message}`);
+  }
+  const errors = validateAdapters(doc);
+  if (errors.length) {
+    throw new AdapterError("invalid", `invalid adapters ${path}:\n  ${errors.join("\n  ")}`);
+  }
+  cache.set(path, doc);
+  return doc;
+}
+
+/**
+ * The adapter for an id, with `id` and `applicable` filled in. An id nobody
+ * described resolves to the unknown adapter, unless `strict` - a caller that
+ * took the id from a flag wants the typo reported, not its gates switched off.
+ */
+export function getAdapter(id, { strict = false, doc = loadAdapters() } = {}) {
+  const found = Object.hasOwn(doc.adapters, id) ? doc.adapters[id] : null;
+  if (!found) {
+    if (strict) {
+      throw new AdapterError(
+        "unknown-id",
+        `no stack adapter "${id}" (known: ${Object.keys(doc.adapters).join(", ")})`,
+      );
+    }
+    return { id: UNKNOWN, ...doc.adapters[UNKNOWN], applicable: false };
+  }
+  return { id, ...found, applicable: found.applicable !== false };
+}
+
+/**
+ * Compiled markers for a claim, or null when the adapter has none for it.
+ * `skipped` are the lines a runner prints when the task the claim is about did
+ * not run at all (a skipped or source-less test task); `loadError` the lines
+ * that mean a test never compiled or loaded. Both empty when the adapter
+ * declares none.
+ * @returns {{success: RegExp[], failure: RegExp[], skipped: RegExp[], loadError: RegExp[]} | null}
+ */
+export function compileMarkers(adapter, claim) {
+  if (adapter.applicable === false) return null;
+  const set = adapter.markers?.[claim];
+  if (!set) return null;
+  const build = (list) => (list || []).map((m) => new RegExp(m.pattern, m.flags || ""));
+  return {
+    success: build(set.success),
+    failure: build(set.failure),
+    skipped: build(set.skipped),
+    loadError: build(set.loadError),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Resolution
+
+/**
+ * Run stack-detect.sh for the coarse classes.
+ * @returns {{stacks: string[], why: string, ok: boolean}}
+ */
+export function detectCoarse(dir) {
+  const res = spawnSync("bash", [STACK_DETECT, "--json", dir], {
+    encoding: "utf8",
+    timeout: 20000,
+  });
+  if (res.status !== 0 || !res.stdout) {
+    return {
+      stacks: [],
+      why: `stack-detect failed: ${res.error?.message || res.stderr || res.status}`,
+      ok: false,
+    };
+  }
+  try {
+    const out = JSON.parse(res.stdout);
+    return { stacks: out.stacks || [], why: out.why || "", ok: true };
+  } catch {
+    return { stacks: [], why: "stack-detect printed no JSON", ok: false };
+  }
+}
+
+function submodulePaths(root) {
+  try {
+    const text = readFileSync(join(root, ".gitmodules"), "utf8");
+    return new Set([...text.matchAll(/^\s*path\s*=\s*(.+?)\s*$/gm)].map((m) => m[1]));
+  } catch {
+    return new Set();
+  }
+}
+
+/**
+ * First manifest with one of `names` at the repo root, else within
+ * MANIFEST_DEPTH levels, skipping PRUNE_DIRS and submodules. Root first because
+ * the root manifest is the repo's own declaration; a deeper one usually belongs
+ * to somebody else.
+ */
+export function findManifest(root, names, { depth = MANIFEST_DEPTH } = {}) {
+  for (const n of names) {
+    if (existsSync(join(root, n))) return n;
+  }
+  const subs = submodulePaths(root);
+  let level = [""];
+  for (let d = 1; d <= depth; d++) {
+    const next = [];
+    for (const rel of level) {
+      let entries;
+      try {
+        entries = readdirSync(join(root, rel), { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const e of entries) {
+        if (!e.isDirectory() || PRUNE_DIRS.includes(e.name)) continue;
+        const child = rel ? `${rel}/${e.name}` : e.name;
+        if (subs.has(child)) continue;
+        for (const n of names) {
+          if (existsSync(join(root, child, n))) return `${child}/${n}`;
+        }
+        next.push(child);
+      }
+    }
+    level = next;
+  }
+  return null;
+}
+
+function isDir(p) {
+  try {
+    return statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Which adapters describe a repo.
+ *
+ * @param {string} dir
+ * @param {{doc?: object, coarse?: {stacks: string[], why: string}}} [opts]
+ * @returns {{primary: string, adapters: {id: string, evidence: string}[],
+ *            coarse: {stacks: string[], why: string}}}
+ */
+export function resolveStack(dir, { doc = loadAdapters(), coarse } = {}) {
+  if (!isDir(dir)) {
+    return { primary: UNKNOWN, adapters: [], coarse: { stacks: [], why: `unreadable: ${dir}` } };
+  }
+  const c = coarse ?? detectCoarse(dir);
+  const matched = new Map();
+  for (const [id, a] of Object.entries(doc.adapters)) {
+    if (a.applicable === false) continue;
+    const det = a.detection || {};
+    const evidence = [];
+    if (det.stackDetect) {
+      if (!c.stacks.includes(det.stackDetect)) continue;
+      evidence.push(`stack-detect:${det.stackDetect}`);
+    }
+    if (det.manifests?.length) {
+      const hit = findManifest(dir, det.manifests);
+      if (!hit) continue;
+      evidence.push(hit);
+    }
+    matched.set(id, evidence.join(" + "));
+  }
+  for (const [id, a] of Object.entries(doc.adapters)) {
+    if (!matched.has(id)) continue;
+    if ((a.detection?.notWith || []).some((other) => matched.has(other))) matched.delete(id);
+  }
+  const ordered = [
+    ...doc.order.filter((id) => matched.has(id)),
+    ...[...matched.keys()].filter((id) => !doc.order.includes(id)),
+  ];
+  return {
+    primary: ordered[0] ?? UNKNOWN,
+    adapters: ordered.map((id) => ({ id, evidence: matched.get(id) })),
+    coarse: { stacks: c.stacks, why: c.why },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Commands
+
+const shellQuote = (s) => `'${String(s).replace(/'/g, `'\\''`)}'`;
+const UNSAFE_IN_DOUBLE_QUOTES = /["$`\\\n]/;
+
+function insideDoubleQuotes(template, index) {
+  let open = false;
+  for (let i = 0; i < index; i++) {
+    if (template[i] === "\\") i++;
+    else if (template[i] === '"') open = !open;
+  }
+  return open;
+}
+
+function fileVars(vars) {
+  if (typeof vars.file !== "string") return vars;
+  const file = vars.file;
+  const slash = file.lastIndexOf("/");
+  const base = slash === -1 ? file : file.slice(slash + 1);
+  const dot = base.indexOf(".");
+  return {
+    fileDir: slash === -1 ? "." : file.slice(0, slash),
+    fileStem: dot === -1 ? base : base.slice(0, dot),
+    ...vars,
+  };
+}
+
+/**
+ * Substitute `{name}` slots. A slot inside double quotes is inserted raw after
+ * refusing any character that could end the quotes; a bare slot is
+ * single-quoted. Every slot without a value is reported at once.
+ */
+export function renderTemplate(template, vars = {}) {
+  const missing = [];
+  const out = template.replace(/\{([A-Za-z][A-Za-z0-9]*)\}/g, (whole, name, offset) => {
+    if (vars[name] === undefined || vars[name] === null || vars[name] === "") {
+      missing.push(name);
+      return whole;
+    }
+    const value = String(vars[name]);
+    if (insideDoubleQuotes(template, offset)) {
+      if (UNSAFE_IN_DOUBLE_QUOTES.test(value)) {
+        throw new AdapterError(
+          "unsafe-value",
+          `value for {${name}} contains a quote-breaking character`,
+        );
+      }
+      return value;
+    }
+    return shellQuote(value);
+  });
+  if (missing.length) {
+    throw new AdapterError(
+      "missing-var",
+      `no value for ${[...new Set(missing)].map((m) => `{${m}}`).join(", ")}`,
+    );
+  }
+  return out;
+}
+
+/**
+ * The command line for one kind of run.
+ *
+ * @param {string} id - adapter id
+ * @param {"build"|"test"|"testFile"|"lint"} kind
+ * @param {{dir?: string, vars?: Record<string,string>, doc?: object}} [opts]
+ * @returns {{command: string, adapter: string, kind: string, source: string}}
+ */
+export function commandFor(
+  id,
+  kind,
+  { dir = process.cwd(), vars = {}, doc = loadAdapters() } = {},
+) {
+  if (!COMMAND_KINDS.includes(kind)) {
+    throw new AdapterError("usage", `kind must be one of ${COMMAND_KINDS.join(", ")}`);
+  }
+  const adapter = getAdapter(id, { doc });
+  if (!adapter.applicable || adapter.commands.length === 0) {
+    throw new AdapterError("not-applicable", `stack "${adapter.id}" has no ${kind} command`);
+  }
+  const set =
+    adapter.commands.find((s) => s.when?.length && findManifest(dir, s.when, { depth: 0 })) ??
+    adapter.commands.find((s) => !s.when?.length);
+  const spec = set?.[kind];
+  if (!spec) {
+    throw new AdapterError("not-applicable", `stack "${adapter.id}" has no ${kind} command`);
+  }
+
+  const allVars = fileVars({ worktreePath: dir, ...vars });
+  let command;
+  let source;
+  if (spec.template) {
+    command = renderTemplate(spec.template, allVars);
+    source = "template";
+  } else {
+    if (!hasScript(dir, spec.packageScript)) {
+      throw new AdapterError(
+        "no-script",
+        `no ${spec.packageScript} script declared in package.json`,
+      );
+    }
+    const { pm } = detectPackageManager(dir);
+    const args = (spec.args || []).map((a) => renderTemplate(a, allVars));
+    command =
+      spec.packageScript === "test"
+        ? testCommand(pm, args)
+        : runCommand(pm, spec.packageScript, args);
+    source = `package-manager:${pm}`;
+  }
+  if (spec.exitMarker) command = `${command} && echo ${shellQuote(spec.exitMarker)}`;
+  return { command, adapter: adapter.id, kind, source };
+}
+
+/**
+ * A predicate that says whether a repo-relative path is a test file for any of
+ * the given adapters (all adapters when none are named).
+ */
+export function testFileMatcher(ids = [], { doc = loadAdapters() } = {}) {
+  const chosen = ids.length ? ids : Object.keys(doc.adapters);
+  const res = chosen.flatMap((id) =>
+    getAdapter(id, { doc }).testFilePatterns.map((p) => new RegExp(p)),
+  );
+  return (path) => res.some((re) => re.test(path));
+}
+
+// ---------------------------------------------------------------------------
+// CLI
+
+function usage(msg) {
+  if (msg) process.stderr.write(`_stack-adapter: ${msg}\n`);
+  process.stderr.write(
+    "usage: _stack-adapter.mjs resolve|markers|command|list|validate [--dir d] [--stack id] [--claim c] [--kind k] [--var k=v] [--file f] [--json]\n",
+  );
+  process.exit(2);
+}
+
+function parseArgs(argv) {
+  const opts = { vars: {} };
+  for (let i = 1; i < argv.length; i++) {
+    const a = argv[i];
+    const val = () => {
+      const v = argv[++i];
+      if (v === undefined) usage(`${a} needs a value`);
+      return v;
+    };
+    if (a === "--dir") opts.dir = val();
+    else if (a === "--stack") opts.stack = val();
+    else if (a === "--claim") opts.claim = val();
+    else if (a === "--kind") opts.kind = val();
+    else if (a === "--file") opts.file = val();
+    else if (a === "--json") opts.json = true;
+    else if (a === "--var") {
+      const kv = val();
+      const eq = kv.indexOf("=");
+      if (eq < 1) usage("--var needs key=value");
+      opts.vars[kv.slice(0, eq)] = kv.slice(eq + 1);
+    } else usage(`unexpected argument ${a}`);
+  }
+  return opts;
+}
+
+function main(argv) {
+  const mode = argv[0];
+  if (!mode || mode.startsWith("-")) usage("a mode is required");
+  const opts = parseArgs(argv);
+  const print = (v) =>
+    process.stdout.write(`${typeof v === "string" ? v : JSON.stringify(v, null, 2)}\n`);
+  try {
+    if (mode === "validate") {
+      loadAdapters(opts.file || ADAPTERS_PATH);
+      print("stack adapters: valid");
+      return 0;
+    }
+    if (mode === "list") {
+      const doc = loadAdapters();
+      print(Object.entries(doc.adapters).map(([id, a]) => ({ id, label: a.label })));
+      return 0;
+    }
+    if (mode === "resolve") {
+      const r = resolveStack(opts.dir || process.cwd());
+      print(
+        opts.json
+          ? r
+          : `${r.primary}${r.adapters.length > 1 ? ` (${r.adapters.map((a) => a.id).join(" ")})` : ""}`,
+      );
+      return 0;
+    }
+    if (mode === "markers") {
+      if (!opts.stack || !CLAIMS.includes(opts.claim)) {
+        usage("markers needs --stack and --claim build|test");
+      }
+      const m = compileMarkers(getAdapter(opts.stack, { strict: true }), opts.claim);
+      print(
+        m
+          ? { success: m.success.map(String), failure: m.failure.map(String) }
+          : { notApplicable: true },
+      );
+      return 0;
+    }
+    if (mode === "command") {
+      if (!opts.stack || !opts.kind) usage("command needs --stack and --kind");
+      getAdapter(opts.stack, { strict: true });
+      const c = commandFor(opts.stack, opts.kind, {
+        dir: opts.dir || process.cwd(),
+        vars: opts.vars,
+      });
+      print(opts.json ? c : c.command);
+      return 0;
+    }
+  } catch (err) {
+    if (err instanceof AdapterError) {
+      if (err.code === "unknown-id" || err.code === "usage") usage(err.message);
+      process.stderr.write(`_stack-adapter: ${err.message}\n`);
+      return 1;
+    }
+    throw err;
+  }
+  usage(`unknown mode ${mode}`);
+  return 2;
+}
+
+if (invokedDirectly(import.meta.url)) {
+  process.exit(main(process.argv.slice(2)));
+}

package/pipeline/scripts/_stack-routing.mjs

@@ -101,7 +101,7 @@ export const STACK_PATTERNS = {
     /(swiftui|swift-|ios-|hig-|apple-|storekit|widgetkit|healthkit|homekit|mapkit|musickit|passkit|pencilkit|realitykit|weatherkit|alarmkit|callkit|cloudkit|coreml|core-|eventkit|energykit|permissionkit|tipkit|shareplay|live-activities|background-processing|app-store|app-clips|app-intents|authentication|contacts-framework|device-integrity|macos-|natural-language|photos-camera|push-notifications|speech-recognition|swiftdata|vision-framework|debugging-instruments)/i,
   "ai-android-toolkit": /(android|compose-|kotlin-|room-database|retrofit-|gradle-|play-store)/i,
   "ai-backend-toolkit":
-    /(fastapi|nodejs|docker|api-pattern|api-security|github-actions|observability|^architecture$|monorepo|clean-code|debugging-strategies|agentflow|closed-loop|context-compression|python-patterns|database-patterns|rest-api-design|testing-backend|ci-cd-pipelines)/i,
+    /(fastapi|nodejs|docker|api-pattern|api-security|github-actions|observability|^architecture$|monorepo|clean-code|debugging-strategies|context-compression|python-patterns|database-patterns|rest-api-design|testing-backend|ci-cd-pipelines)/i,
   "ai-frontend-toolkit":
     /(react-|nextjs-|typescript-|tailwind-|vue-|web-accessibility|web-performance|css-modern|web-testing|html-semantic)/i,
 };