codetrellis 0.0.0-stage → 0.3.0

package/src/backend/services/resolvers/ruby.js

@@ -0,0 +1,103 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ruby_exports = {};
+__export(ruby_exports, {
+  rubyResolver: () => rubyResolver
+});
+module.exports = __toCommonJS(ruby_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_base = require("./base");
+const RB_EXTS = [".rb", ".rake"];
+const STDLIB = /* @__PURE__ */ new Set([
+  "json",
+  "yaml",
+  "set",
+  "date",
+  "time",
+  "uri",
+  "net/http",
+  "fileutils",
+  "logger",
+  "digest",
+  "openssl",
+  "base64",
+  "csv",
+  "stringio",
+  "pathname",
+  "securerandom",
+  "singleton",
+  "forwardable",
+  "ostruct",
+  "erb",
+  "tempfile",
+  "rails",
+  "active_record",
+  "active_support",
+  "action_controller",
+  "rspec",
+  "minitest",
+  "sinatra",
+  "rack",
+  "sidekiq"
+]);
+function isLikelyGem(source) {
+  if (STDLIB.has(source)) return true;
+  const head = source.split("/")[0];
+  return STDLIB.has(head);
+}
+function resolve(ctx) {
+  const { importSource, importerPath, knownFiles, systems } = ctx;
+  if (!importSource) return null;
+  const source = importSource.replace(/\.rb$/, "");
+  if (ctx.isRelative || source.startsWith(".")) {
+    const base = import_node_path.default.resolve(import_node_path.default.dirname(importerPath), source);
+    return (0, import_base.tryExtensions)(base, knownFiles, RB_EXTS);
+  }
+  if (isLikelyGem(source)) return null;
+  const containing = (0, import_base.findContainingSystem)(importerPath, systems);
+  const roots = [];
+  if (containing) {
+    roots.push(containing.rootPath);
+    roots.push(import_node_path.default.join(containing.rootPath, "lib"));
+    roots.push(import_node_path.default.join(containing.rootPath, "app"));
+  }
+  roots.push(ctx.projectRoot, import_node_path.default.join(ctx.projectRoot, "lib"), import_node_path.default.join(ctx.projectRoot, "app"));
+  for (const root of roots) {
+    const hit = (0, import_base.tryExtensions)(import_node_path.default.join(root, source), knownFiles, RB_EXTS);
+    if (hit) return hit;
+  }
+  return null;
+}
+const rubyResolver = {
+  languages: ["ruby"],
+  resolve
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rubyResolver
+});

package/src/backend/services/resolvers/rust.js

@@ -0,0 +1,77 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var rust_exports = {};
+__export(rust_exports, {
+  rustResolver: () => rustResolver
+});
+module.exports = __toCommonJS(rust_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_base = require("./base");
+const RS_EXTS = [".rs"];
+const RS_MOD_SUFFIXES = ["/mod.rs"];
+const STD_PREFIXES = /* @__PURE__ */ new Set(["std", "core", "alloc"]);
+function resolve(ctx) {
+  const { importSource, importerPath, knownFiles, systems } = ctx;
+  if (!importSource) return null;
+  const segments = importSource.split("::").filter((s) => s.length > 0);
+  if (segments.length === 0) return null;
+  const head = segments[0];
+  if (STD_PREFIXES.has(head)) return null;
+  const containing = (0, import_base.findContainingSystem)(importerPath, systems);
+  if (head === "crate") {
+    if (!containing) return null;
+    const crateRoot = import_node_path.default.join(containing.rootPath, "src");
+    const subpath = segments.slice(1, -1).join("/");
+    const base = import_node_path.default.join(crateRoot, subpath);
+    return (0, import_base.tryExtensions)(base, knownFiles, [...RS_EXTS, ...RS_MOD_SUFFIXES]) ?? (0, import_base.tryExtensions)(import_node_path.default.join(crateRoot, "lib"), knownFiles, RS_EXTS);
+  }
+  if (head === "self" || head === "super") {
+    const importerDir = import_node_path.default.dirname(importerPath);
+    let baseDir = importerDir;
+    if (head === "super") baseDir = import_node_path.default.dirname(importerDir);
+    const tail = segments.slice(1).join("/");
+    return (0, import_base.tryExtensions)(import_node_path.default.join(baseDir, tail), knownFiles, [...RS_EXTS, ...RS_MOD_SUFFIXES]);
+  }
+  for (const sys of systems) {
+    if (sys.language !== "rust") continue;
+    if (sys.name === head || sys.packageName === head) {
+      const crateRoot = import_node_path.default.join(sys.rootPath, "src");
+      const subpath = segments.slice(1).join("/");
+      return (0, import_base.tryExtensions)(import_node_path.default.join(crateRoot, subpath), knownFiles, [...RS_EXTS, ...RS_MOD_SUFFIXES]) ?? (0, import_base.tryExtensions)(import_node_path.default.join(crateRoot, "lib"), knownFiles, RS_EXTS);
+    }
+  }
+  return null;
+}
+const rustResolver = {
+  languages: ["rust"],
+  resolve
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rustResolver
+});

package/src/backend/services/resolvers/swift.js

@@ -0,0 +1,98 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var swift_exports = {};
+__export(swift_exports, {
+  swiftResolver: () => swiftResolver
+});
+module.exports = __toCommonJS(swift_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_base = require("./base");
+const EXTERNAL_MODULES = /* @__PURE__ */ new Set([
+  "Foundation",
+  "UIKit",
+  "AppKit",
+  "SwiftUI",
+  "Combine",
+  "CoreData",
+  "CoreGraphics",
+  "CoreLocation",
+  "CoreImage",
+  "AVFoundation",
+  "MapKit",
+  "WebKit",
+  "Network",
+  "OSLog",
+  "Dispatch",
+  "XCTest",
+  "Testing",
+  "Swift",
+  "ObjectiveC",
+  "Darwin",
+  "Security",
+  "CryptoKit",
+  "StoreKit",
+  "WidgetKit",
+  "ActivityKit",
+  "Charts",
+  "PhotosUI",
+  "UserNotifications",
+  "Alamofire",
+  "SnapKit",
+  "RxSwift",
+  "Kingfisher"
+]);
+const SOURCE_ROOTS = ["Sources", "Tests", "src", ""];
+function resolve(ctx) {
+  const { importSource, importerPath, knownFiles, systems } = ctx;
+  if (!importSource) return null;
+  if (EXTERNAL_MODULES.has(importSource)) return null;
+  const containing = (0, import_base.findContainingSystem)(importerPath, systems);
+  const searchRoots = containing ? [containing.rootPath, ctx.projectRoot] : [ctx.projectRoot];
+  for (const base of searchRoots) {
+    for (const root of SOURCE_ROOTS) {
+      const dir = import_node_path.default.join(base, root, importSource);
+      const hit = (0, import_base.pickRepresentativeFile)(dir, knownFiles, {
+        extensions: [".swift"],
+        // `Sources/BillingCore/BillingCore.swift` is the SwiftPM
+        // template's own entry file, so it is the best representative
+        // when it exists.
+        prefer: importSource
+      });
+      if (hit) return hit;
+    }
+  }
+  return null;
+}
+const swiftResolver = {
+  languages: ["swift"],
+  resolve
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  swiftResolver
+});

package/src/backend/services/resolvers/typescript.js

@@ -0,0 +1,71 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var typescript_exports = {};
+__export(typescript_exports, {
+  typescriptResolver: () => typescriptResolver
+});
+module.exports = __toCommonJS(typescript_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_base = require("./base");
+function resolve(ctx) {
+  const { importSource, importerPath, knownFiles, aliasMap } = ctx;
+  if (importSource.startsWith(".") || importSource.startsWith("/")) {
+    const importerDir = import_node_path.default.dirname(importerPath);
+    const basePath = importSource.startsWith("/") ? importSource : import_node_path.default.resolve(importerDir, importSource);
+    return (0, import_base.tryExtensions)(basePath, knownFiles);
+  }
+  for (const mapping of aliasMap) {
+    const { alias, rootPath, entries } = mapping;
+    if (importSource === alias) {
+      if (entries) {
+        for (const e of entries) {
+          const candidate = import_node_path.default.resolve(rootPath, e);
+          if (knownFiles.has(candidate)) return candidate;
+        }
+      }
+      const indexHit = (0, import_base.tryExtensions)(import_node_path.default.join(rootPath, "index"), knownFiles) ?? (0, import_base.tryExtensions)(import_node_path.default.join(rootPath, "src/index"), knownFiles);
+      if (indexHit) return indexHit;
+      continue;
+    }
+    if (importSource.startsWith(alias + "/")) {
+      const subpath = importSource.slice(alias.length + 1);
+      const basePath = import_node_path.default.resolve(rootPath, subpath);
+      const hit = (0, import_base.tryExtensions)(basePath, knownFiles);
+      if (hit) return hit;
+    }
+  }
+  return null;
+}
+const typescriptResolver = {
+  languages: ["typescript", "javascript"],
+  resolve
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  typescriptResolver
+});

package/src/backend/services/retention.js

@@ -0,0 +1,54 @@
+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 retention_exports = {};
+__export(retention_exports, {
+  DAY_MS: () => DAY_MS,
+  DEFAULT_RETENTION_DAYS: () => DEFAULT_RETENTION_DAYS,
+  DEVICE_LOG_CAP: () => DEVICE_LOG_CAP,
+  retentionCutoff: () => retentionCutoff,
+  retentionDays: () => retentionDays,
+  retentionWords: () => retentionWords
+});
+module.exports = __toCommonJS(retention_exports);
+var import_settings_service = require("./settings-service");
+const DAY_MS = 24 * 60 * 60 * 1e3;
+const DEFAULT_RETENTION_DAYS = 14;
+const DEVICE_LOG_CAP = 1e4;
+function retentionDays() {
+  try {
+    return (0, import_settings_service.getSettings)().data.retentionDays;
+  } catch {
+    return DEFAULT_RETENTION_DAYS;
+  }
+}
+function retentionCutoff(now = Date.now(), days = retentionDays()) {
+  return days === null ? null : now - days * DAY_MS;
+}
+function retentionWords(days = retentionDays()) {
+  if (days === null) return "everything";
+  return days === 365 ? "a year" : `${days} days`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DAY_MS,
+  DEFAULT_RETENTION_DAYS,
+  DEVICE_LOG_CAP,
+  retentionCutoff,
+  retentionDays,
+  retentionWords
+});

package/src/backend/services/review-architecture.js

@@ -0,0 +1,236 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var review_architecture_exports = {};
+__export(review_architecture_exports, {
+  architectureMarkdown: () => architectureMarkdown,
+  architectureOf: () => architectureOf,
+  callChanges: () => callChanges,
+  folderLinks: () => folderLinks,
+  folderOf: () => folderOf,
+  packagesIn: () => packagesIn
+});
+module.exports = __toCommonJS(review_architecture_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_node_child_process = require("node:child_process");
+var import_snapshot_compare_service = require("./snapshot-compare-service");
+var import_ast_parser = require("./ast-parser");
+var import_rules_at = require("./rules-at");
+var import_architecture_rule = require("./architecture-rule");
+var import_rule_changes = require("./rule-changes");
+var import_review_risk = require("./review-risk");
+const MAX_PARSED = 200;
+const MAX_BYTES = 512 * 1024;
+function git(root, args) {
+  try {
+    return (0, import_node_child_process.execFileSync)("git", ["-C", root, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 16 * 1024 * 1024, timeout: 2e4 });
+  } catch {
+    return null;
+  }
+}
+function at(root, commit, rel) {
+  const text = git(root, ["show", `${commit}:./${rel}`]);
+  return text !== null && text.length <= MAX_BYTES ? text : null;
+}
+function folderOf(p) {
+  const parts = p.replace(/\\/g, "/").replace(/^\.\//, "").split("/");
+  if (parts.length <= 1) return ".";
+  return parts.slice(0, Math.min(2, parts.length - 1)).join("/");
+}
+function folderLinks(added, removed) {
+  const links = /* @__PURE__ */ new Map();
+  const note = (e, change) => {
+    const from = folderOf(e.from);
+    const to = folderOf(e.to);
+    if (from === to) return;
+    const k = `${from}>${to}`;
+    let l = links.get(k);
+    if (!l) links.set(k, l = { from, to, added: 0, removed: 0, examples: [] });
+    l[change]++;
+    if (l.examples.length < 3) l.examples.push({ ...e, change });
+  };
+  for (const e of added) note(e, "added");
+  for (const e of removed) note(e, "removed");
+  return [...links.values()].sort((a, b) => b.added - a.added || b.removed - a.removed || a.from.localeCompare(b.from) || a.to.localeCompare(b.to));
+}
+function packagesIn(manifest, text) {
+  const out = /* @__PURE__ */ new Set();
+  if (!text) return out;
+  const base = import_node_path.default.posix.basename(manifest);
+  if (base === "package.json") {
+    try {
+      const j = JSON.parse(text);
+      for (const k of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
+        const deps = j[k];
+        if (deps && typeof deps === "object") for (const name of Object.keys(deps)) out.add(name);
+      }
+    } catch {
+    }
+  } else if (base === "requirements.txt") {
+    for (const line of text.split("\n")) {
+      const m = /^\s*([A-Za-z0-9][A-Za-z0-9._-]*)/.exec(line.replace(/#.*/, ""));
+      if (m && !line.trim().startsWith("-")) out.add(m[1].toLowerCase());
+    }
+  } else if (base === "go.mod") {
+    let block = false;
+    for (const line of text.split("\n")) {
+      const t = line.replace(/\/\/.*/, "").trim();
+      if (/^require\s*\($/.test(t)) {
+        block = true;
+        continue;
+      }
+      if (block && t === ")") {
+        block = false;
+        continue;
+      }
+      const m = block ? /^(\S+)\s+\S+/.exec(t) : /^require\s+(\S+)\s+\S+/.exec(t);
+      if (m) out.add(m[1]);
+    }
+  }
+  return out;
+}
+const ECOSYSTEM = { "package.json": "npm", "requirements.txt": "pip", "go.mod": "go" };
+function describeCall(c) {
+  if ((c.kind === "http_call" || c.kind === "http_route") && c.urlPattern) return `${c.method ? `${c.method} ` : ""}${c.urlPattern}`;
+  if (c.kind === "sql_query") return c.sqlText?.trim().split(/\s+/).slice(0, 6).join(" ") ?? c.context ?? null;
+  if (c.kind === "entry" && c.urlPattern) return c.urlPattern;
+  return null;
+}
+function callChanges(file, before, after) {
+  const key = (c) => `${c.kind}|${describeCall(c)}`;
+  const was = new Set(before.map(key));
+  const now = new Set(after.map(key));
+  const out = [];
+  for (const c of after) {
+    const what = describeCall(c);
+    if (what && !was.has(key(c))) out.push({ file, line: c.line, kind: c.kind, what, change: "added" });
+  }
+  for (const c of before) {
+    const what = describeCall(c);
+    if (what && !now.has(key(c))) out.push({ file, line: c.line, kind: c.kind, what, change: "removed" });
+  }
+  return out;
+}
+const plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+const CALL_WORDS = {
+  http_call: "an HTTP call to",
+  http_route: "a route,",
+  sql_query: "SQL:",
+  subprocess: "a command:",
+  env_lookup: "an environment variable:",
+  entry: ""
+};
+async function architectureOf(projectRoot, baseRef, headRef) {
+  const base = git(projectRoot, ["rev-parse", "--verify", "--quiet", `${baseRef}^{commit}`])?.trim();
+  const head = git(projectRoot, ["rev-parse", "--verify", "--quiet", `${headRef}^{commit}`])?.trim();
+  if (!base) return { error: `${baseRef} is not a commit in this repository` };
+  if (!head) return { error: `${headRef} is not a commit in this repository` };
+  const cmp = (0, import_snapshot_compare_service.compareSnapshots)(`commit:${base}`, `commit:${head}`, projectRoot);
+  const rel = (p) => (import_node_path.default.isAbsolute(p) ? import_node_path.default.relative(projectRoot, p) : p).split(import_node_path.default.sep).join("/");
+  const edgesKnown = cmp.ok && cmp.result.edgesComparable;
+  const added = cmp.ok && edgesKnown ? cmp.result.diff.addedEdges.map((e) => ({ from: rel(e.source), to: rel(e.target) })) : [];
+  const removed = cmp.ok && edgesKnown ? cmp.result.diff.removedEdges.map((e) => ({ from: rel(e.source), to: rel(e.target) })) : [];
+  const folders = folderLinks(added, removed);
+  const changed = (git(projectRoot, ["diff", "--name-only", "--no-renames", base, head, "--"]) ?? "").split("\n").map((s) => s.trim()).filter(Boolean);
+  const packages = [];
+  for (const f of changed) {
+    const eco = ECOSYSTEM[import_node_path.default.posix.basename(f)];
+    if (!eco) continue;
+    const was = packagesIn(f, at(projectRoot, base, f));
+    const now = packagesIn(f, at(projectRoot, head, f));
+    const a = [...now].filter((p) => !was.has(p)).sort();
+    const r = [...was].filter((p) => !now.has(p)).sort();
+    if (a.length || r.length) packages.push({ manifest: f, ecosystem: eco, added: a, removed: r });
+  }
+  const calls = [];
+  for (const f of changed.slice(0, MAX_PARSED)) {
+    const before = at(projectRoot, base, f);
+    const after = at(projectRoot, head, f);
+    let b = [];
+    let h = [];
+    try {
+      b = before !== null ? (0, import_ast_parser.parseVirtualFile)(import_node_path.default.join(projectRoot, f), before)?.callsites ?? [] : [];
+    } catch {
+      b = [];
+    }
+    try {
+      h = after !== null ? (0, import_ast_parser.parseVirtualFile)(import_node_path.default.join(projectRoot, f), after)?.callsites ?? [] : [];
+    } catch {
+      h = [];
+    }
+    calls.push(...callChanges(f, b, h));
+  }
+  const rules = [];
+  const baseRules = await (0, import_rules_at.rulesAt)(projectRoot, base);
+  const headRules = await (0, import_rules_at.rulesAt)(projectRoot, head);
+  if (baseRules) {
+    for (const b of (0, import_architecture_rule.checkEdges)(baseRules.rules, added)) {
+      const r = baseRules.rules.find((x) => x.id === b.rule);
+      rules.push({ rule: r.id, words: (0, import_architecture_rule.ruleWords)(r), kind: "breach", detail: `${b.from} now imports ${b.to}, which it forbids` });
+    }
+    if (headRules) {
+      for (const c of (0, import_rule_changes.diffRules)(baseRules.rules, headRules.rules, added)) {
+        rules.push({ rule: c.rule, words: c.after ? (0, import_architecture_rule.ruleWords)(c.after) : c.before ? (0, import_architecture_rule.ruleWords)(c.before) : c.rule, kind: c.effect, detail: c.words });
+      }
+    }
+  }
+  const words = [];
+  for (const r of rules.filter((x) => x.kind === "breach" || x.kind === "loosens")) words.push(r.kind === "breach" ? `\u2717 ${r.detail} (${r.rule})` : r.detail);
+  for (const c of calls.filter((x) => x.change === "added")) words.push(`Adds ${CALL_WORDS[c.kind] ? `${CALL_WORDS[c.kind]} ` : ""}${c.what} (${c.file}:${c.line})`);
+  for (const p of packages) {
+    if (p.added.length) words.push(`Adds ${plural(p.added.length, `${p.ecosystem} package`)}: ${p.added.join(", ")} (${p.manifest})`);
+    if (p.removed.length) words.push(`Drops ${plural(p.removed.length, `${p.ecosystem} package`)}: ${p.removed.join(", ")} (${p.manifest})`);
+  }
+  for (const l of folders) {
+    const bits = [l.added ? `${plural(l.added, "import")} added` : "", l.removed ? `${plural(l.removed, "import")} removed` : ""].filter(Boolean).join(", ");
+    words.push(`${l.from} \u2192 ${l.to}: ${bits}`);
+  }
+  for (const c of calls.filter((x) => x.change === "removed")) words.push(`Drops ${CALL_WORDS[c.kind] ? `${CALL_WORDS[c.kind]} ` : ""}${c.what} (${c.file})`);
+  for (const r of rules.filter((x) => x.kind === "tightens" || x.kind === "reworded")) words.push(r.detail);
+  if (!edgesKnown) words.push("The imports between folders are not known: one side's import graph could not be read.");
+  const inputs = await (0, import_review_risk.riskInputs)(projectRoot, changed, headRef);
+  const order = (0, import_review_risk.riskOrder)(changed, inputs);
+  return { base, head, edgesKnown, folders, packages, calls, rules, words, order };
+}
+function architectureMarkdown(a) {
+  const lines = ["### What this change does to the architecture", ""];
+  const shown = a.words.filter((w) => !w.startsWith("The imports between folders are not known"));
+  if (shown.length === 0) lines.push("No imports between folders, outside packages, cross-system calls or rules change.");
+  else for (const w of a.words) lines.push(`- ${w}`);
+  if (shown.length === 0 && !a.edgesKnown) lines.push("", "_The imports between folders are not known: one side's import graph could not be read._");
+  if (a.order?.length) lines.push("", (0, import_review_risk.riskMarkdown)(a.order));
+  return lines.join("\n");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  architectureMarkdown,
+  architectureOf,
+  callChanges,
+  folderLinks,
+  folderOf,
+  packagesIn
+});