codetrellis 0.0.0-stage → 0.2.0

package/src/shared/lib/check-compare.js

@@ -0,0 +1,42 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key2 of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key2) && key2 !== except)
+        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var check_compare_exports = {};
+__export(check_compare_exports, {
+  compareRuns: () => compareRuns
+});
+module.exports = __toCommonJS(check_compare_exports);
+const key = (f) => `${f.rule}\0${f.path}\0${f.imports}`;
+function compareRuns(a, b) {
+  const [before, after] = a.at <= b.at ? [a, b] : [b, a];
+  const was = new Map(before.findings.map((f) => [key(f), f]));
+  const now = new Map(after.findings.map((f) => [key(f), f]));
+  const added = after.findings.filter((f) => !was.has(key(f)));
+  const fixed = before.findings.filter((f) => !now.has(key(f)));
+  const unchanged = after.findings.filter((f) => was.has(key(f)));
+  const ruleLine = (s) => / now imports .*, which the rule “/.test(s);
+  const saysBefore = new Set(before.says.filter((s) => !ruleLine(s)));
+  const saysAfter = new Set(after.says.filter((s) => !ruleLine(s)));
+  const saysAdded = [...saysAfter].filter((s) => !saysBefore.has(s));
+  const saysGone = [...saysBefore].filter((s) => !saysAfter.has(s));
+  const words = [`${added.length + saysAdded.length} new`, `${fixed.length + saysGone.length} fixed`, `${unchanged.length} unchanged`].join(" \xB7 ");
+  return { added, fixed, unchanged, saysAdded, saysGone, words };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compareRuns
+});

package/src/shared/lib/check-words.js

@@ -0,0 +1,216 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var check_words_exports = {};
+__export(check_words_exports, {
+  exitWords: () => exitWords,
+  fails: () => fails,
+  findingLine: () => findingLine,
+  findingNext: () => findingNext,
+  findingTitle: () => findingTitle,
+  headline: () => headline,
+  otherFindings: () => otherFindings,
+  otherNotes: () => otherNotes,
+  reachWords: () => reachWords,
+  renderMarkdown: () => renderMarkdown,
+  renderText: () => renderText,
+  ruleFix: () => ruleFix,
+  ruleLine: () => ruleLine,
+  rulebookLines: () => rulebookLines,
+  suiteCounts: () => suiteCounts,
+  suiteGroups: () => suiteGroups,
+  whatWords: () => whatWords
+});
+module.exports = __toCommonJS(check_words_exports);
+var import_grep_entry = require("./grep-entry");
+var import_call_entry = require("./call-entry");
+const plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+function ruleFix(rule) {
+  if ((rule.kind === "package" || rule.kind === "symbol" || rule.kind === "calls") && rule.only?.length) return `use ${rule.only.join(" or ")} instead`;
+  if ((rule.kind === void 0 || rule.kind === "imports" || rule.kind === "package") && rule.except.length) return `import ${rule.except.join(" or ")} instead`;
+  return null;
+}
+function reachWords(target) {
+  if ((0, import_grep_entry.isGrepEntry)(target)) return (0, import_grep_entry.grepWords)(target);
+  if (target.startsWith("http:")) return `calls ${target.slice(5)}`;
+  if (target.startsWith("sql:")) return `uses the table ${target.slice(4)}`;
+  if (target.startsWith("folder:")) return target.slice(7);
+  if (target.startsWith("exec:")) return `runs ${target.slice(5)}`;
+  if (target.startsWith("env:")) return `reads the environment variable ${target.slice(4)}`;
+  if ((0, import_call_entry.isOwnKind)(target)) return `reaches ${target}`;
+  return `imports ${target}`;
+}
+function findingLine(r) {
+  return `${r.path} now ${reachWords(r.imports)}, which the rule \u201C${r.words}\u201D forbids${r.because ? `: ${r.because}` : ""}`;
+}
+function findingTitle(r) {
+  return `${r.path}${r.line ? `:${r.line}` : ""} ${reachWords(r.imports)}`;
+}
+function findingNext(r) {
+  return r.fix || r.because || null;
+}
+function ruleLine(words, r) {
+  return `${words}${r?.fix && r.because ? `: ${r.because}` : ""}`;
+}
+function fails(r, strict = false) {
+  return r.strength === "block" || strict;
+}
+const GLYPH = { fail: "\u2717", warn: "\u26A0", hold: "\u2713" };
+function suiteGroups(c) {
+  const failing = new Set(c.says);
+  const groups = /* @__PURE__ */ new Map();
+  const group = (suite) => {
+    let g = groups.get(suite);
+    if (!g) groups.set(suite, g = { suite, blocks: 0, warns: 0, holds: 0, rules: [] });
+    return g;
+  };
+  for (const r of c.rules) {
+    const g = group(r.suite ?? "architecture");
+    let entry = g.rules.find((x) => x.rule === r.rule);
+    if (!entry) {
+      entry = { rule: r.rule, words: r.words, strength: r.strength, failing: failing.has(`${GLYPH.fail} ${findingLine(r)}`), findings: [] };
+      g.rules.push(entry);
+      if (entry.failing) g.blocks += 1;
+      else g.warns += 1;
+    }
+    entry.findings.push(r);
+  }
+  for (const k of c.checked ?? []) {
+    if (k.strength === "guide") continue;
+    const g = group(k.suite);
+    if (!g.rules.some((x) => x.rule === k.rule)) g.holds += 1;
+  }
+  for (const g of groups.values()) {
+    g.rules.sort((a, b) => Number(b.failing) - Number(a.failing) || a.rule.localeCompare(b.rule));
+    for (const r of g.rules) r.findings.sort((a, b) => a.path.localeCompare(b.path) || a.imports.localeCompare(b.imports));
+  }
+  return [...groups.values()].sort((a, b) => b.blocks + b.warns - (a.blocks + a.warns) || a.suite.localeCompare(b.suite));
+}
+function suiteCounts(g) {
+  return [
+    g.blocks ? `${GLYPH.fail} ${g.blocks} ${g.blocks === 1 ? "blocks" : "block"}` : null,
+    g.warns ? `${GLYPH.warn} ${g.warns} ${g.warns === 1 ? "warns" : "warn"}` : null,
+    g.holds ? `${GLYPH.hold} ${plural(g.holds, "rule")} ${g.holds === 1 ? "holds" : "hold"}` : null
+  ].filter(Boolean).join(" \xB7 ");
+}
+function otherFindings(c) {
+  const mine = /* @__PURE__ */ new Set([
+    ...c.rules.map((r) => `${GLYPH.fail} ${findingLine(r)}`),
+    ...c.rulebook.map((b) => b.words)
+  ]);
+  return c.says.filter((s) => !mine.has(s));
+}
+function otherNotes(c) {
+  const mine = new Set(c.rules.map((r) => `${GLYPH.warn} ${findingLine(r)} (the rule warns; it does not fail the check)`));
+  const rulebook = new Set(c.rulebook.map((b) => b.words));
+  return c.notes.filter((n) => !mine.has(n) && !rulebook.has(n));
+}
+function rulebookLines(c) {
+  return c.rulebook.map((b) => b.words);
+}
+function whatWords(c) {
+  return `${plural(c.files, "changed file")}${c.base ? ` since ${c.base}` : ""}`;
+}
+function headline(c) {
+  const what = whatWords(c);
+  if (c.scope) return c.ok ? `Conforms to ${c.scope}: ${what}. They add no import those rules forbid, and loosen none of them.` : `Does not conform to ${c.scope} (${what}):`;
+  return c.ok ? `Conforms: ${what}. No breakpoint holds them, none of their tests fail or are older than the code, no done task fails its checks, no doc that describes them is stale, they add no import an architecture rule forbids, and they loosen no rule.` : `Does not conform (${what}):`;
+}
+function exitWords(c) {
+  if (c.ok) return "Nothing blocks this change (exit 0).";
+  return `${plural(c.says.length, "finding")} ${c.says.length === 1 ? "blocks" : "block"} this change (exit 3).`;
+}
+const ANSI = { [GLYPH.fail]: "31", [GLYPH.warn]: "33", [GLYPH.hold]: "32", "\u25A0": "35" };
+function paint(line, color, bold = "") {
+  if (!color) return line;
+  let out = line.replace(/[✗⚠✓■]/g, (g) => `\x1B[${ANSI[g]}m${g}\x1B[0m`);
+  if (bold && out.startsWith(bold)) out = `\x1B[1m${bold}\x1B[0m${out.slice(bold.length)}`;
+  return out;
+}
+function renderText(c, opts = {}) {
+  const color = opts.color === true;
+  const lines = [headline(c)];
+  const groups = suiteGroups(c);
+  for (const g of groups) {
+    lines.push("", paint(`${g.suite}  ${suiteCounts(g)}`, color, g.suite));
+    for (const r of g.rules) {
+      if (r.findings.length === 0) continue;
+      const glyph = r.failing ? GLYPH.fail : GLYPH.warn;
+      lines.push("", paint(`  ${glyph} ${r.rule}   ${ruleLine(r.words, r.findings[0])}`, color));
+      for (const f of r.findings) {
+        lines.push(`      ${findingTitle(f)}${f.text ? `   ${f.text.trim()}` : ""}`);
+        const next = findingNext(f);
+        if (next) lines.push(`      \u2192 ${next}`);
+      }
+    }
+  }
+  const rulebook = rulebookLines(c);
+  if (rulebook.length) lines.push("", "rulebook", ...rulebook.map((l) => paint(`  ${l}`, color)));
+  const other = otherFindings(c);
+  if (other.length) lines.push("", "also", ...other.map((l) => paint(`  ${l}`, color)));
+  const notes = otherNotes(c);
+  if (notes.length) lines.push("", "notes", ...notes.map((l) => paint(`  ${l}`, color)));
+  if (c.rulesNote) lines.push("", c.rulesNote);
+  lines.push("", exitWords(c));
+  return lines.join("\n");
+}
+const code = (s) => `\`${s.replace(/`/g, "\u02CB")}\``;
+function renderMarkdown(c) {
+  const lines = [
+    `### CodeTrellis check: ${c.ok ? "conforms" : "does not conform"}${c.scope ? ` (${c.scope})` : ""}`,
+    "",
+    `${whatWords(c)} \xB7 ${exitWords(c)}`
+  ];
+  for (const g of suiteGroups(c)) {
+    lines.push("", `**${g.suite}** \xB7 ${suiteCounts(g)}`);
+    for (const r of g.rules) {
+      for (const f of r.findings) {
+        lines.push("", `- ${r.failing ? GLYPH.fail : GLYPH.warn} **${code(findingTitle(f))}** \xB7 ${code(r.rule)} (${r.strength})  `, `  ${ruleLine(r.words, f)}  `);
+        const next = findingNext(f);
+        if (next) lines.push(`  \u2192 ${next}`);
+      }
+    }
+  }
+  const section = (title, items) => {
+    if (items.length) lines.push("", `**${title}**`, "", ...items.map((l) => `- ${l}`));
+  };
+  section("rulebook", rulebookLines(c));
+  section("also", otherFindings(c));
+  section("notes", otherNotes(c));
+  if (c.rulesNote) lines.push("", `_${c.rulesNote}_`);
+  return lines.join("\n");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  exitWords,
+  fails,
+  findingLine,
+  findingNext,
+  findingTitle,
+  headline,
+  otherFindings,
+  otherNotes,
+  reachWords,
+  renderMarkdown,
+  renderText,
+  ruleFix,
+  ruleLine,
+  rulebookLines,
+  suiteCounts,
+  suiteGroups,
+  whatWords
+});

package/src/shared/lib/csv.js

@@ -0,0 +1,62 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var csv_exports = {};
+__export(csv_exports, {
+  csvShape: () => csvShape,
+  parseCsv: () => parseCsv
+});
+module.exports = __toCommonJS(csv_exports);
+function parseCsv(text) {
+  const rows = [];
+  let row = [];
+  let field = "";
+  let quoted = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (quoted) {
+      if (ch === '"' && text[i + 1] === '"') {
+        field += '"';
+        i++;
+      } else if (ch === '"') quoted = false;
+      else field += ch;
+    } else if (ch === '"') quoted = true;
+    else if (ch === ",") {
+      row.push(field);
+      field = "";
+    } else if (ch === "\n" || ch === "\r") {
+      if (ch === "\r" && text[i + 1] === "\n") i++;
+      row.push(field);
+      rows.push(row);
+      row = [];
+      field = "";
+    } else field += ch;
+  }
+  if (field !== "" || row.length) {
+    row.push(field);
+    rows.push(row);
+  }
+  return rows;
+}
+function csvShape(rows) {
+  return { rows: rows.length, cols: Math.max(0, ...rows.map((r) => r.length)) };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  csvShape,
+  parseCsv
+});

package/src/shared/lib/folder-entry.js

@@ -0,0 +1,87 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var folder_entry_exports = {};
+__export(folder_entry_exports, {
+  exportCount: () => exportCount,
+  fileFact: () => fileFact,
+  folderProblem: () => folderProblem,
+  folderWords: () => folderWords,
+  isFileFact: () => isFileFact,
+  nameMatches: () => nameMatches,
+  parseFileFact: () => parseFileFact
+});
+module.exports = __toCommonJS(folder_entry_exports);
+const FACT_RE = /^file:([^:/]+):(\d+|\?)$/;
+const basename = (p) => p.slice(p.lastIndexOf("/") + 1);
+function fileFact(path, exportCount2) {
+  return `file:${basename(path)}:${exportCount2 === null ? "?" : exportCount2}`;
+}
+function isFileFact(s) {
+  return FACT_RE.test(s);
+}
+function parseFileFact(s) {
+  const m = FACT_RE.exec(s);
+  return m ? { name: m[1], exports: m[2] === "?" ? null : Number(m[2]) } : null;
+}
+function nameMatches(pattern, name) {
+  const re = new RegExp(`^${pattern.split("*").map((p) => p.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join(".*")}$`);
+  return re.test(name);
+}
+const extOf = (name) => {
+  const i = name.lastIndexOf(".");
+  return i > 0 ? name.slice(i + 1).toLowerCase() : "";
+};
+function folderProblem(terms, fact) {
+  const f = parseFileFact(fact);
+  if (!f) return null;
+  if (terms.kinds?.length && !terms.kinds.includes(extOf(f.name))) {
+    return `is a ${extOf(f.name) ? `.${extOf(f.name)}` : "extensionless"} file, not ${terms.kinds.map((k) => `.${k}`).join(" or ")}`;
+  }
+  if (terms.files?.length && !terms.files.some((p) => nameMatches(p, f.name))) {
+    return `is named ${f.name}, not ${terms.files.join(" or ")}`;
+  }
+  if (terms.exports === "one" && f.exports !== null && f.exports > 1) return `exports ${f.exports} names, not one`;
+  return null;
+}
+function folderWords(folder, terms) {
+  const parts = [
+    terms.kinds?.length ? `are ${terms.kinds.map((k) => `.${k}`).join(" or ")} files` : null,
+    terms.files?.length ? `are named ${terms.files.join(" or ")}` : null,
+    terms.exports === "one" ? "export one thing each" : null
+  ].filter(Boolean);
+  if (!parts.length) return `files in ${folder} follow its guide`;
+  const said = parts.length === 1 ? parts[0] : `${parts.slice(0, -1).join(", ")} and ${parts[parts.length - 1]}`;
+  return `files in ${folder} ${said}`;
+}
+const MARKS_EXPORTS = /* @__PURE__ */ new Set(["typescript", "tsx", "javascript", "jsx"]);
+function exportCount(language, symbols) {
+  const top = symbols.filter((s) => !/[.#(]/.test(s.name));
+  if (MARKS_EXPORTS.has(language)) return top.filter((s) => s.modifiers.includes("export")).length;
+  if (language === "python") return top.filter((s) => !s.name.startsWith("_")).length;
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  exportCount,
+  fileFact,
+  folderProblem,
+  folderWords,
+  isFileFact,
+  nameMatches,
+  parseFileFact
+});

package/src/shared/lib/freeze-words.js

@@ -0,0 +1,60 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var freeze_words_exports = {};
+__export(freeze_words_exports, {
+  describeFreezeChange: () => describeFreezeChange,
+  formatUntil: () => formatUntil
+});
+module.exports = __toCommonJS(freeze_words_exports);
+function formatUntil(iso) {
+  const t = Date.parse(iso);
+  if (Number.isNaN(t)) return iso;
+  return `${new Date(t).toISOString().slice(0, 16).replace("T", " ")} UTC`;
+}
+const plans = (n) => `${n} plan${n === 1 ? "" : "s"}`;
+function describeFreezeChange(before, after) {
+  const wasActive = Boolean(before?.active);
+  const parts = [];
+  if (!wasActive && after.active) {
+    let s = "froze the project";
+    if (after.reason) s += ` ("${after.reason}")`;
+    s += after.until ? ` until ${formatUntil(after.until)}` : " with no end";
+    parts.push(s);
+  } else if (wasActive && !after.active) {
+    parts.push("lifted the freeze");
+  } else if (after.active) {
+    if ((before?.reason ?? null) !== after.reason) {
+      parts.push(after.reason ? `changed the reason to "${after.reason}"` : "removed the reason");
+    }
+    if ((before?.until ?? null) !== after.until) {
+      parts.push(after.until ? `moved the end to ${formatUntil(after.until)}` : "removed the end date");
+    }
+  }
+  const had = new Set(before?.allowedPlanUids ?? []);
+  const has = new Set(after.allowedPlanUids);
+  const added = [...has].filter((u) => !had.has(u)).length;
+  const removed = [...had].filter((u) => !has.has(u)).length;
+  if (added) parts.push(`exempted ${plans(added)}`);
+  if (removed && after.active) parts.push(`removed the exemption for ${plans(removed)}`);
+  return parts.join(", ") || "changed the freeze";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  describeFreezeChange,
+  formatUntil
+});

package/src/shared/lib/fuzzy.js

@@ -0,0 +1,84 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fuzzy_exports = {};
+__export(fuzzy_exports, {
+  DEFAULT_THRESHOLD: () => DEFAULT_THRESHOLD,
+  comparedNames: () => comparedNames,
+  fuzzyScore: () => fuzzyScore,
+  normaliseName: () => normaliseName,
+  scoreWords: () => scoreWords,
+  similarity: () => similarity,
+  wordsOf: () => wordsOf
+});
+module.exports = __toCommonJS(fuzzy_exports);
+const DEFAULT_THRESHOLD = 0.85;
+const MAX_NAME = 200;
+function normaliseName(s) {
+  return s.slice(0, MAX_NAME).replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(/[-_./:@\s]+/).filter(Boolean).join(" ").toLowerCase();
+}
+function distance(a, b) {
+  const rows = Array.from({ length: a.length + 1 }, (_, i) => [i, ...Array(b.length).fill(0)]);
+  for (let j = 1; j <= b.length; j++) rows[0][j] = j;
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      rows[i][j] = Math.min(rows[i - 1][j] + 1, rows[i][j - 1] + 1, rows[i - 1][j - 1] + cost);
+      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) rows[i][j] = Math.min(rows[i][j], rows[i - 2][j - 2] + 1);
+    }
+  }
+  return rows[a.length][b.length];
+}
+function similarity(a, b) {
+  const x = normaliseName(a);
+  const y = normaliseName(b);
+  const longer = Math.max(x.length, y.length);
+  return longer === 0 ? 1 : 1 - distance(x, y) / longer;
+}
+const scoreWords = (n) => n.toFixed(2);
+function comparedNames(kind, target, entry) {
+  const colon = (s) => s.indexOf(":");
+  if (kind === "package" || kind === "calls") {
+    const [tk, tr] = [target.slice(0, colon(target)), target.slice(colon(target) + 1)];
+    const [ek, er] = [entry.slice(0, colon(entry)), entry.slice(colon(entry) + 1)];
+    if (colon(target) < 0 || colon(entry) < 0 || tk !== ek) return null;
+    if (kind === "calls" && tk === "http" && !tr.includes("/")) return [tr, er.split("/")[0]];
+    return [tr, er];
+  }
+  if (kind === "symbol") {
+    const tn = target.slice(target.lastIndexOf("#") + 1);
+    const en = entry.slice(entry.lastIndexOf("#") + 1);
+    if (!entry.includes("#") || en === "*") return null;
+    return [tn, en];
+  }
+  return [target, entry];
+}
+function fuzzyScore(kind, target, entry) {
+  const pair = comparedNames(kind, target, entry);
+  return pair ? similarity(pair[0], pair[1]) : 0;
+}
+const wordsOf = (line) => line.match(/[A-Za-z_$][\w$]*/g) ?? [];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_THRESHOLD,
+  comparedNames,
+  fuzzyScore,
+  normaliseName,
+  scoreWords,
+  similarity,
+  wordsOf
+});

package/src/shared/lib/git-state-words.js

@@ -0,0 +1,80 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var git_state_words_exports = {};
+__export(git_state_words_exports, {
+  gitStateChip: () => gitStateChip,
+  gitStateWords: () => gitStateWords,
+  shortDate: () => shortDate,
+  sourceWords: () => sourceWords
+});
+module.exports = __toCommonJS(git_state_words_exports);
+const HOW = {
+  merge: "merge commit",
+  "fast-forward": "fast-forward",
+  "squash-or-rebase": "squash or rebase",
+  "names-key": "a commit names it",
+  "pull-request": "pull request"
+};
+const SOURCE = { git: "git", github: "GitHub", gitlab: "GitLab", bitbucket: "Bitbucket" };
+function sourceWords(s) {
+  return `from ${SOURCE[s.source]}`;
+}
+const refOf = (r) => r.ref ?? `#${r.number}`;
+function reviewParts(r) {
+  const parts = [];
+  if (r.checks === "passing") parts.push("checks passing");
+  else if (r.checks === "failing") parts.push("checks failing");
+  else if (r.checks === "pending") parts.push("checks running");
+  if (r.changesRequested) parts.push("changes requested");
+  if (r.approvals) parts.push(`${r.approvals} approval${r.approvals === 1 ? "" : "s"}`);
+  return parts;
+}
+function shortDate(unixSeconds) {
+  return new Date(unixSeconds * 1e3).toLocaleDateString("en-GB", { day: "numeric", month: "short", timeZone: "UTC" });
+}
+function gitStateWords(s) {
+  switch (s.state) {
+    case "merged": {
+      const how = s.how === "pull-request" && s.review ? refOf(s.review) : s.how ? HOW[s.how] : null;
+      const parts = [how, s.at ? shortDate(s.at) : null].filter(Boolean);
+      return `merged${s.base ? ` into ${s.base}` : ""}${parts.length ? ` (${parts.join(", ")})` : ""}`;
+    }
+    case "in-review": {
+      const parts = s.review ? reviewParts(s.review) : [];
+      return `in review${s.review ? ` (${refOf(s.review)})` : ""}${parts.length ? `, ${parts.join(", ")}` : ""}`;
+    }
+    case "closed":
+      return `closed without merging${s.review ? ` (${refOf(s.review)}${s.at ? `, ${shortDate(s.at)}` : ""})` : ""}`;
+    case "pushed":
+      return `pushed, not merged${s.unpushed ? `; ${s.unpushed} commit${s.unpushed === 1 ? "" : "s"} not pushed yet` : ""}`;
+    case "building":
+      return `building on ${s.branch}, not pushed`;
+    default:
+      return `no ${s.branch} branch yet`;
+  }
+}
+function gitStateChip(s) {
+  return s.state === "none" ? "" : s.state === "in-review" ? "in review" : s.state;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  gitStateChip,
+  gitStateWords,
+  shortDate,
+  sourceWords
+});