codetrellis 0.0.0-stage → 0.2.0

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

@@ -0,0 +1,584 @@
+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 architecture_rule_exports = {};
+__export(architecture_rule_exports, {
+  breachWords: () => breachWords,
+  breaks: () => breaks,
+  checkEdges: () => checkEdges,
+  grepReads: () => grepReads,
+  inPattern: () => inPattern,
+  lookAlike: () => lookAlike,
+  lookAlikeFix: () => lookAlikeFix,
+  parseArchitectureRule: () => parseArchitectureRule,
+  ruleEngine: () => ruleEngine,
+  ruleStatement: () => ruleStatement,
+  ruleWords: () => ruleWords,
+  tagsOf: () => tagsOf,
+  targetMatches: () => targetMatches
+});
+module.exports = __toCommonJS(architecture_rule_exports);
+var import_architecture_rules = require("../../shared/types/architecture-rules");
+var import_package_entry = require("../../shared/lib/package-entry");
+var import_symbol_entry = require("../../shared/lib/symbol-entry");
+var import_call_entry = require("../../shared/lib/call-entry");
+var import_folder_entry = require("../../shared/lib/folder-entry");
+var import_matcher = require("../../shared/lib/matcher");
+var import_fuzzy = require("../../shared/lib/fuzzy");
+var import_grep_entry = require("../../shared/lib/grep-entry");
+const ID_RE = /^[a-z0-9][a-z0-9-]{0,62}$/;
+const MAX_BECAUSE = 200;
+function patternProblem(name, v) {
+  if (typeof v !== "string" || v.trim() === "") return `${name} must be a folder or a pattern, like web/`;
+  const p = v.trim();
+  if (p.startsWith("/") || /^[a-zA-Z]:/.test(p) || p.includes("\\")) return `${name} must be relative to the project, like web/`;
+  if (p.split("/").includes("..")) return `${name} may not climb out of the project`;
+  return null;
+}
+function parseArchitectureRule(raw) {
+  const r = raw && typeof raw === "object" ? raw : {};
+  if (r.engine !== void 0 && !import_architecture_rules.RULE_ENGINES.includes(r.engine)) return { rule: null, problems: ["engine must be deterministic, fuzzy or agent"] };
+  if (r.engine === "agent" || r.kind === "agent") return parseAgentRule(r);
+  const parsed = parseByKind(r);
+  if (parsed.rule && r.engine !== void 0 && ruleEngine(parsed.rule) !== r.engine) {
+    return { rule: null, problems: [r.engine === "fuzzy" ? "engine fuzzy is a rule whose target says match: fuzzy" : `this rule's engine is ${ruleEngine(parsed.rule)}, not ${String(r.engine)}`] };
+  }
+  return parsed;
+}
+function ruleEngine(rule) {
+  return rule.kind === "agent" ? "agent" : rule.match === "fuzzy" ? "fuzzy" : "deterministic";
+}
+const MAX_WORDS = 1e3;
+function parseAgentRule(r) {
+  const problems = [];
+  if (typeof r.id !== "string" || !ID_RE.test(r.id)) problems.push("id must be a short slug, like money-through-ledger");
+  if (r.kind !== void 0 && r.kind !== "agent") problems.push("an agent rule has no kind: it is its words");
+  const words = r.rule ?? r.mayNotImport;
+  if (typeof words !== "string" || !words.trim()) problems.push("rule must be the words an agent judges by, like: Code that moves money records it through services/ledger.");
+  else if (words.length > MAX_WORDS) problems.push(`rule is at most ${MAX_WORDS} characters`);
+  const list = (v) => v === void 0 ? [] : typeof v === "string" ? [v] : Array.isArray(v) && v.every((x) => typeof x === "string") ? v : null;
+  const within = list(r.in);
+  if (within === null || within.length === 0) problems.push("in must list the files it is about, like src/");
+  for (const w of within ?? []) {
+    const p = patternProblem("in", w);
+    if (p) {
+      problems.push(p);
+      break;
+    }
+  }
+  const except = list(r.except);
+  if (except === null) problems.push("except must be a list of files or patterns");
+  for (const e of except ?? []) {
+    const p = patternProblem("except", e);
+    if (p) {
+      problems.push(p);
+      break;
+    }
+  }
+  commonProblems(r, problems);
+  if (problems.length > 0) return { rule: null, problems };
+  return {
+    rule: {
+      id: r.id,
+      kind: "agent",
+      from: "**",
+      mayNotImport: words.trim(),
+      in: within.map(normalise),
+      except: except.map(normalise),
+      ...common(r)
+    },
+    problems: []
+  };
+}
+function parseByKind(r) {
+  if (r.kind === "package") return parsePackageRule(r);
+  if (r.kind === "symbol") return parseSymbolRule(r);
+  if (r.kind === "calls") return parseCallRule(r);
+  if (r.kind === "folder") return parseFolderRule(r);
+  if (r.kind === "grep") return parseGrepRule(r);
+  const problems = [];
+  if (r.kind !== void 0 && r.kind !== "imports") problems.push("kind must be imports, package, symbol, calls, folder or grep (or engine: agent)");
+  if (typeof r.id !== "string" || !ID_RE.test(r.id)) problems.push("id must be a short slug, like web-not-db");
+  const fromProblem = patternProblem("from", r.from);
+  if (fromProblem) problems.push(fromProblem);
+  const toProblem = patternProblem("mayNotImport", r.mayNotImport);
+  if (toProblem) problems.push(toProblem);
+  const except = Array.isArray(r.except) ? r.except : r.except === void 0 ? [] : null;
+  if (except === null) problems.push("except must be a list of files or patterns");
+  for (const e of except ?? []) {
+    const p = patternProblem("except", e);
+    if (p) {
+      problems.push(p);
+      break;
+    }
+  }
+  commonProblems(r, problems);
+  if (!fromProblem && !toProblem && normalise(r.from) === normalise(r.mayNotImport)) problems.push("from and mayNotImport must differ");
+  if (problems.length > 0) return { rule: null, problems };
+  return {
+    rule: {
+      id: r.id,
+      from: normalise(r.from),
+      mayNotImport: normalise(r.mayNotImport),
+      except: except.map(normalise),
+      ...common(r)
+    },
+    problems: []
+  };
+}
+function parsePackageRule(r) {
+  const problems = [];
+  if (typeof r.id !== "string" || !ID_RE.test(r.id)) problems.push("id must be a short slug, like stripe-via-wrapper");
+  const { value: pkg, match: m, threshold: t } = (0, import_matcher.splitTarget)(r.package ?? r.mayNotImport);
+  const match = targetProblem(problems, pkg, m ?? r.match, import_package_entry.packageProblem, /^[a-z]+:/, "package", "npm:@aws-sdk/*");
+  const threshold = thresholdOf(problems, match, t ?? r.threshold);
+  const fromProblem = r.from === void 0 ? null : patternProblem("from", r.from);
+  if (fromProblem) problems.push(fromProblem);
+  const only = Array.isArray(r.only) ? r.only : r.only === void 0 ? [] : null;
+  if (only === null || only.length === 0 && match !== "fuzzy") problems.push("only must list the files that may import it, like src/payments/index.ts");
+  for (const o of only ?? []) {
+    const p = patternProblem("only", o);
+    if (p) {
+      problems.push(p);
+      break;
+    }
+  }
+  const except = Array.isArray(r.except) ? r.except : r.except === void 0 ? [] : null;
+  if (except === null) problems.push("except must be a list of packages, like npm:stripe/types");
+  for (const e of except ?? []) {
+    const p = (0, import_package_entry.packageProblem)(e);
+    if (p) {
+      problems.push(`except: ${p}`);
+      break;
+    }
+  }
+  commonProblems(r, problems);
+  if (problems.length > 0) return { rule: null, problems };
+  return {
+    rule: {
+      id: r.id,
+      kind: "package",
+      from: r.from === void 0 ? "**" : normalise(r.from),
+      mayNotImport: pkg.trim(),
+      ...match ? { match } : {},
+      ...threshold !== void 0 ? { threshold } : {},
+      only: only.map(normalise),
+      except: except.map((e) => e.trim()),
+      ...common(r)
+    },
+    problems: []
+  };
+}
+function parseSymbolRule(r) {
+  const problems = [];
+  if (typeof r.id !== "string" || !ID_RE.test(r.id)) problems.push("id must be a short slug, like charges-via-payments");
+  const { value: sym, match: m, threshold: t } = (0, import_matcher.splitTarget)(r.symbol ?? r.mayNotImport);
+  const match = targetProblem(problems, sym, m ?? r.match, import_symbol_entry.symbolProblem, /#/, "symbol", "src/db.ts#raw*");
+  const threshold = thresholdOf(problems, match, t ?? r.threshold);
+  if (match === "glob") {
+    const p = (0, import_symbol_entry.symbolProblem)(sym.replace(/\*/g, "x"));
+    if (p) problems.push(p);
+  }
+  const fromProblem = r.from === void 0 ? null : patternProblem("from", r.from);
+  if (fromProblem) problems.push(fromProblem);
+  const only = Array.isArray(r.only) ? r.only : r.only === void 0 ? [] : null;
+  if (only === null || only.length === 0 && match !== "fuzzy") problems.push("only must list the files that may import it, like src/payments/");
+  for (const o of only ?? []) {
+    const p = patternProblem("only", o);
+    if (p) {
+      problems.push(p);
+      break;
+    }
+  }
+  if (r.except !== void 0 && !(Array.isArray(r.except) && r.except.length === 0)) problems.push("a symbol rule has no except: name the files that may in only");
+  commonProblems(r, problems);
+  if (problems.length > 0) return { rule: null, problems };
+  return {
+    rule: {
+      id: r.id,
+      kind: "symbol",
+      from: r.from === void 0 ? "**" : normalise(r.from),
+      mayNotImport: normalise(sym),
+      ...match ? { match } : {},
+      ...threshold !== void 0 ? { threshold } : {},
+      only: only.map(normalise),
+      except: [],
+      ...common(r)
+    },
+    problems: []
+  };
+}
+function parseCallRule(r) {
+  const problems = [];
+  if (typeof r.id !== "string" || !ID_RE.test(r.id)) problems.push("id must be a short slug, like stripe-api-via-payments");
+  const { value: target, match: m, threshold: t } = (0, import_matcher.splitTarget)(r.calls ?? r.mayNotImport);
+  const match = targetProblem(problems, target, m ?? r.match, import_call_entry.callProblem, /^[a-z][a-z0-9-]*:/, "calls", "http:*.stripe.com");
+  const threshold = thresholdOf(problems, match, t ?? r.threshold);
+  const fromProblem = r.from === void 0 ? null : patternProblem("from", r.from);
+  if (fromProblem) problems.push(fromProblem);
+  const only = Array.isArray(r.only) ? r.only : r.only === void 0 ? [] : null;
+  if (only === null || only.length === 0 && match !== "fuzzy") problems.push("only must list the files that may make the call, like src/payments/");
+  for (const o of only ?? []) {
+    const p = patternProblem("only", o);
+    if (p) {
+      problems.push(p);
+      break;
+    }
+  }
+  if (r.except !== void 0 && !(Array.isArray(r.except) && r.except.length === 0)) problems.push("a call rule has no except: name the files that may in only");
+  commonProblems(r, problems);
+  if (problems.length > 0) return { rule: null, problems };
+  return {
+    rule: {
+      id: r.id,
+      kind: "calls",
+      from: r.from === void 0 ? "**" : normalise(r.from),
+      mayNotImport: match && match !== "fuzzy" ? target.trim() : (0, import_call_entry.normaliseCall)(target),
+      ...match ? { match } : {},
+      ...threshold !== void 0 ? { threshold } : {},
+      only: only.map(normalise),
+      except: [],
+      ...common(r)
+    },
+    problems: []
+  };
+}
+const MAX_GUIDE = 1e3;
+function parseFolderRule(r) {
+  const problems = [];
+  if (typeof r.id !== "string" || !ID_RE.test(r.id)) problems.push("id must be a short slug, like services-are-services");
+  const folder = r.folder ?? r.from;
+  const folderProblemWords = patternProblem("folder", folder);
+  if (folderProblemWords) problems.push(folderProblemWords);
+  const list = (v) => v === void 0 ? [] : typeof v === "string" ? [v] : Array.isArray(v) && v.every((x) => typeof x === "string") ? v : null;
+  const files = list(r.files);
+  if (files === null || files.some((f) => !f.trim() || f.includes("/"))) problems.push("files must be name patterns, like *-service.ts");
+  const kinds = list(r.kinds);
+  if (kinds === null || kinds.some((k) => !/^[a-z0-9]+$/i.test(k.replace(/^\./, "")))) problems.push("kinds must be file extensions, like ts");
+  if (r.exports !== void 0 && r.exports !== "one") problems.push("exports may only be one");
+  const guideOnly = r.strength === "guide" && typeof r.guide === "string" && r.guide.trim() !== "";
+  if (!problems.length && !guideOnly && (files ?? []).length === 0 && (kinds ?? []).length === 0 && r.exports === void 0) problems.push("a folder rule says what its files are: files, kinds or exports (or, at guide strength, only a guide)");
+  if (r.guide !== void 0 && (typeof r.guide !== "string" || r.guide.length > MAX_GUIDE)) problems.push(`guide must be words, at most ${MAX_GUIDE} characters`);
+  commonProblems(r, problems);
+  if (problems.length > 0) return { rule: null, problems };
+  return {
+    rule: {
+      id: r.id,
+      kind: "folder",
+      from: normalise(folder),
+      mayNotImport: "",
+      ...files.length ? { files: files.map((f) => f.trim()) } : {},
+      ...kinds.length ? { kinds: kinds.map((k) => k.replace(/^\./, "").toLowerCase()) } : {},
+      ...r.exports === "one" ? { exports: "one" } : {},
+      ...typeof r.guide === "string" && r.guide.trim() ? { guide: r.guide.trim() } : {},
+      except: [],
+      ...common(r)
+    },
+    problems: []
+  };
+}
+const MAX_GREP = 200;
+function parseGrepRule(r) {
+  const problems = [];
+  if (typeof r.id !== "string" || !ID_RE.test(r.id)) problems.push("id must be a short slug, like no-console-in-backend");
+  const list = (v) => v === void 0 ? [] : typeof v === "string" ? [v] : Array.isArray(v) && v.every((x) => typeof x === "string") ? v : null;
+  const within = list(r.in);
+  if (within === null || within.length === 0) problems.push("in must list the files it reads, like src/backend/");
+  for (const w of within ?? []) {
+    const p = patternProblem("in", w);
+    if (p) {
+      problems.push(p);
+      break;
+    }
+  }
+  const except = list(r.except);
+  if (except === null) problems.push("except must be a list of files or patterns");
+  for (const e of except ?? []) {
+    const p = patternProblem("except", e);
+    if (p) {
+      problems.push(p);
+      break;
+    }
+  }
+  const must = r.must !== void 0;
+  if (must === (r.mustNot !== void 0)) problems.push("a grep rule says mustNot (text no line may hold) or must (text one line must), not both");
+  const { value, match: m, threshold: t } = (0, import_matcher.splitTarget)(must ? r.must : r.mustNot);
+  const written = m ?? r.match;
+  const match = written === void 0 || written === null || written === "exact" ? null : written === "glob" || written === "regex" || written === "fuzzy" ? written : null;
+  if (written !== void 0 && written !== null && written !== "exact" && match === null) problems.push("match must be exact, glob, regex or fuzzy");
+  if (match === "fuzzy" && must) problems.push("a must rule needs its text, not one like it: fuzzy is for mustNot");
+  if (match === "fuzzy" && typeof value === "string" && !/^[A-Za-z_$][\w$]*$/.test(value.trim())) problems.push("a fuzzy grep rule looks for a word like one name, like requireAuth");
+  const threshold = thresholdOf(problems, match, t ?? r.threshold);
+  if (typeof value !== "string" || value.trim() === "") problems.push(`${must ? "must" : "mustNot"} must be the text to look for, like console.log(`);
+  else if (value.length > MAX_GREP) problems.push(`the text is at most ${MAX_GREP} characters`);
+  else if (match === "regex") {
+    const p = (0, import_matcher.regexProblem)(value.trim());
+    if (p) problems.push(p);
+  }
+  if (r.ignoreCase !== void 0 && typeof r.ignoreCase !== "boolean") problems.push("ignoreCase is true or false");
+  if (r.only !== void 0) problems.push("a grep rule has no only: say in which files it reads");
+  commonProblems(r, problems);
+  if (problems.length > 0) return { rule: null, problems };
+  return {
+    rule: {
+      id: r.id,
+      kind: "grep",
+      from: "**",
+      mayNotImport: value.trim(),
+      ...match ? { match } : {},
+      ...threshold !== void 0 ? { threshold } : {},
+      in: within.map(normalise),
+      ...must ? { must: true } : {},
+      ...r.ignoreCase === true ? { ignoreCase: true } : {},
+      except: except.map(normalise),
+      ...common(r)
+    },
+    problems: []
+  };
+}
+function grepReads(rule, relPath) {
+  return (rule.in ?? []).some((p) => inPattern(p, relPath)) && !rule.except.some((e) => inPattern(e, relPath));
+}
+function targetProblem(problems, value, match, exact, prefix, name, example) {
+  if (typeof value !== "string" || !value.trim()) {
+    problems.push(exact(value) ?? `${name} must be written`);
+    return null;
+  }
+  const kind = (0, import_matcher.matcherOf)(match, value.trim());
+  if (kind === "bad") {
+    problems.push("match must be exact, glob, regex or fuzzy");
+    return null;
+  }
+  if (kind === null) {
+    const p2 = exact(value);
+    if (p2) problems.push(p2);
+    return null;
+  }
+  if (kind === "fuzzy") {
+    const p2 = exact(value);
+    if (p2) {
+      problems.push(p2);
+      return null;
+    }
+    return kind;
+  }
+  if (!prefix.test(value.trim())) {
+    problems.push(`a ${kind} ${name} starts the way its entries do, like ${example}`);
+    return null;
+  }
+  const p = kind === "regex" ? (0, import_matcher.regexProblem)(value.trim()) : value.length > 200 ? "a glob is at most 200 characters" : null;
+  if (p) {
+    problems.push(p);
+    return null;
+  }
+  return kind;
+}
+function thresholdOf(problems, match, t) {
+  if (match !== "fuzzy") {
+    if (t !== void 0) problems.push("threshold is only for match: fuzzy");
+    return void 0;
+  }
+  if (t === void 0) return import_fuzzy.DEFAULT_THRESHOLD;
+  const p = (0, import_matcher.thresholdProblem)(t);
+  if (p) problems.push(p);
+  return p ? void 0 : t;
+}
+function lookAlikeFix(rule, entry) {
+  const score = lookAlike(rule, entry);
+  if (score === null) return null;
+  const [want, got] = rule.kind === "symbol" ? (0, import_fuzzy.comparedNames)(rule.kind, rule.mayNotImport, entry) : [rule.mayNotImport, entry];
+  return `${got} is ${(0, import_fuzzy.scoreWords)(score)} like ${want}: did you mean it?`;
+}
+function exactly(kind, target, entry) {
+  if (kind === "package") return (0, import_package_entry.packageMatches)(target, entry);
+  if (kind === "symbol") return (0, import_symbol_entry.symbolMatches)(target, entry);
+  if (kind === "calls") return (0, import_call_entry.callMatches)(target, entry);
+  return target === entry;
+}
+function lookAlike(rule, entry) {
+  if (rule.match !== "fuzzy" || exactly(rule.kind, rule.mayNotImport, entry) || !(0, import_fuzzy.comparedNames)(rule.kind, rule.mayNotImport, entry)) return null;
+  const score = (0, import_fuzzy.fuzzyScore)(rule.kind, rule.mayNotImport, entry);
+  return score >= (rule.threshold ?? import_fuzzy.DEFAULT_THRESHOLD) ? score : null;
+}
+function targetMatches(rule, entry) {
+  if (rule.match === "fuzzy") return lookAlike(rule, entry) !== null;
+  const m = rule.match;
+  if (rule.kind === "package") return m ? (0, import_matcher.underPattern)(m, rule.mayNotImport, entry) : (0, import_package_entry.packageMatches)(rule.mayNotImport, entry);
+  if (rule.kind === "symbol") {
+    if (!m) return (0, import_symbol_entry.symbolMatches)(rule.mayNotImport, entry);
+    const got = (0, import_symbol_entry.splitSymbol)(entry);
+    if (!got) return false;
+    if (got.name === "*") {
+      const at = rule.mayNotImport.lastIndexOf("#");
+      return at > 0 && (0, import_matcher.wholly)(m, rule.mayNotImport.slice(0, at), got.file);
+    }
+    return (0, import_matcher.wholly)(m, rule.mayNotImport, entry);
+  }
+  if (rule.kind === "calls") {
+    if (!m) return (0, import_call_entry.callMatches)(rule.mayNotImport, entry);
+    if (m === "regex") return (0, import_matcher.wholly)("regex", rule.mayNotImport, entry);
+    const [rk, rr] = [rule.mayNotImport.slice(0, rule.mayNotImport.indexOf(":")), rule.mayNotImport.slice(rule.mayNotImport.indexOf(":") + 1)];
+    const [ek, er] = [entry.slice(0, entry.indexOf(":")), entry.slice(entry.indexOf(":") + 1)];
+    if (rk !== ek) return false;
+    if (rk === "sql") return (0, import_matcher.wholly)("glob", rr.toLowerCase(), er.toLowerCase());
+    if (rk !== "http") return (0, import_matcher.wholly)("glob", rr, er);
+    const split = (x) => {
+      const i = x.indexOf("/");
+      return i < 0 ? [x, ""] : [x.slice(0, i), x.slice(i)];
+    };
+    const [rh, rp] = split(rr);
+    const [eh, ep] = split(er);
+    if (rh !== "" && !(0, import_matcher.wholly)("glob", rh.toLowerCase(), eh.toLowerCase())) return false;
+    return rp === "" || (0, import_matcher.underPattern)("glob", rp, ep);
+  }
+  return false;
+}
+function commonProblems(r, problems) {
+  if (r.because !== void 0 && (typeof r.because !== "string" || r.because.length > MAX_BECAUSE)) problems.push(`because must be words, at most ${MAX_BECAUSE} characters`);
+  if (r.strength !== void 0 && !import_architecture_rules.RULE_STRENGTHS.includes(r.strength)) problems.push("strength must be block, warn or guide");
+  if (r.tags !== void 0 && tagsOf(r.tags) === null) problems.push(`tags are short slugs, like pci, at most ${MAX_TAGS}`);
+}
+const TAG_RE = /^[a-z0-9][a-z0-9-]{0,31}$/;
+const MAX_TAGS = 10;
+function tagsOf(v) {
+  const xs = typeof v === "string" ? [v] : v;
+  if (!Array.isArray(xs) || xs.length > MAX_TAGS || !xs.every((x) => typeof x === "string" && TAG_RE.test(x.trim()))) return null;
+  return [...new Set(xs.map((x) => x.trim()))].sort();
+}
+function common(r) {
+  const tags = r.tags === void 0 ? null : tagsOf(r.tags);
+  return {
+    ...tags?.length ? { tags } : {},
+    because: typeof r.because === "string" ? r.because.trim() : "",
+    since: typeof r.since === "string" && !Number.isNaN(Date.parse(r.since)) ? r.since : (/* @__PURE__ */ new Date(0)).toISOString(),
+    by: typeof r.by === "string" ? r.by : "",
+    // Absent: written before strength existed, when every rule blocked (R4).
+    strength: r.strength ?? "block"
+  };
+}
+function normalise(p) {
+  return p.trim().replace(/^\.\//, "");
+}
+function inPattern(pattern, relPath) {
+  const p = relPath.replace(/^\.\//, "");
+  if (pattern.includes("*")) {
+    const re = new RegExp(`^${(0, import_matcher.globSource)(pattern)}$`);
+    return re.test(p);
+  }
+  if (pattern.endsWith("/")) return p.startsWith(pattern);
+  return p === pattern || p.startsWith(pattern + "/");
+}
+function breaks(rule, from, to) {
+  if (rule.kind === "agent") return false;
+  if (rule.kind === "grep") {
+    return (0, import_grep_entry.splitGrep)(to)?.key === (0, import_grep_entry.grepKey)(rule) && grepReads(rule, from);
+  }
+  if (rule.kind === "package") {
+    if (!(0, import_package_entry.isPackageEntry)(to) || !targetMatches(rule, to)) return false;
+    if (!inPattern(rule.from, from) || (rule.only ?? []).some((o) => inPattern(o, from))) return false;
+    return !rule.except.some((e) => (0, import_package_entry.packageMatches)(e, to));
+  }
+  if (rule.kind === "symbol") {
+    if (!(0, import_symbol_entry.isSymbolEntry)(to) || !targetMatches(rule, to)) return false;
+    if (from === (0, import_symbol_entry.splitSymbol)(to).file) return false;
+    return inPattern(rule.from, from) && !(rule.only ?? []).some((o) => inPattern(o, from));
+  }
+  if (rule.kind === "folder") {
+    return (0, import_folder_entry.isFileFact)(to) && inPattern(rule.from, from) && (0, import_folder_entry.folderProblem)(rule, to) !== null;
+  }
+  if (rule.kind === "calls") {
+    if (!(0, import_call_entry.isCallEntry)(to) || !targetMatches(rule, to)) return false;
+    return inPattern(rule.from, from) && !(rule.only ?? []).some((o) => inPattern(o, from));
+  }
+  if ((0, import_package_entry.isPackageEntry)(to) || (0, import_symbol_entry.isSymbolEntry)(to) || (0, import_call_entry.isCallEntry)(to) || (0, import_folder_entry.isFileFact)(to) || (0, import_grep_entry.isGrepEntry)(to)) return false;
+  if (!inPattern(rule.from, from) || inPattern(rule.mayNotImport, from)) return false;
+  if (!inPattern(rule.mayNotImport, to)) return false;
+  return !rule.except.some((e) => inPattern(e, to));
+}
+function checkEdges(rules, edges) {
+  const out = [];
+  for (const rule of rules) {
+    if (rule.strength === "guide") continue;
+    for (const e of edges) {
+      if (!breaks(rule, e.from, e.to)) continue;
+      out.push({ rule: rule.id, from: e.from, to: rule.kind === "folder" ? `folder:${(0, import_folder_entry.folderProblem)(rule, e.to)}` : e.to });
+    }
+  }
+  return out;
+}
+function ruleStatement(rule) {
+  const except = rule.except.length > 0 ? ` (except ${rule.except.join(", ")})` : "";
+  if (rule.kind === "agent") return `in ${(rule.in ?? []).join(", ")}${except}: ${rule.mayNotImport}`;
+  if (rule.kind === "grep") {
+    const files = `${(rule.in ?? []).join(", ")}${except}`;
+    return rule.must ? `every file in ${files} must contain ${(0, import_grep_entry.grepPatternWords)(rule)}` : `no file in ${files} may contain ${(0, import_grep_entry.grepPatternWords)(rule)}`;
+  }
+  if (rule.match === "fuzzy" && (rule.kind === "package" || rule.kind === "calls" || rule.kind === "symbol")) {
+    const where = rule.from && rule.from !== "**" ? `in ${rule.from}, ` : "";
+    const who = (rule.only ?? []).length ? `only ${(rule.only ?? []).join(", ")} may` : "nothing may";
+    const sym = rule.kind === "symbol" ? (0, import_symbol_entry.splitSymbol)(rule.mayNotImport) : null;
+    const what = rule.kind === "calls" ? `${rule.mayNotImport.startsWith("sql:") ? "use a table" : "make a call"} like ${(0, import_call_entry.callWords)(rule.mayNotImport)}` : `import a look-alike of ${sym ? `${sym.name} from ${sym.file}` : rule.mayNotImport}`;
+    return `${where}${who} ${what} (${(0, import_fuzzy.scoreWords)(rule.threshold ?? import_fuzzy.DEFAULT_THRESHOLD)} or closer)${except}`;
+  }
+  if (rule.match === "regex" && (rule.kind === "package" || rule.kind === "calls" || rule.kind === "symbol")) {
+    const where = rule.from && rule.from !== "**" ? `in ${rule.from}, ` : "";
+    const verb = rule.kind === "calls" ? "make a call" : "import anything";
+    return `${where}only ${(rule.only ?? []).join(", ")} may ${verb} matching /${rule.mayNotImport}/${except}`;
+  }
+  if (rule.kind === "package") {
+    const where = rule.from && rule.from !== "**" ? `in ${rule.from}, ` : "";
+    return `${where}only ${(rule.only ?? []).join(", ")} may import ${rule.mayNotImport}${except}`;
+  }
+  if (rule.kind === "folder") return (0, import_folder_entry.folderWords)(rule.from, rule);
+  if (rule.kind === "calls") {
+    const where = rule.from && rule.from !== "**" ? `in ${rule.from}, ` : "";
+    return `${where}only ${(rule.only ?? []).join(", ")} may ${callVerb(rule.mayNotImport)} ${(0, import_call_entry.callWords)(rule.mayNotImport)}`;
+  }
+  if (rule.kind === "symbol") {
+    const where = rule.from && rule.from !== "**" ? `in ${rule.from}, ` : "";
+    const sym = (0, import_symbol_entry.splitSymbol)(rule.mayNotImport);
+    return `${where}only ${(rule.only ?? []).join(", ")} may import ${sym ? `${sym.name} from ${sym.file}` : rule.mayNotImport}`;
+  }
+  return `${rule.from} may not import ${rule.mayNotImport}${except}`;
+}
+function callVerb(target) {
+  if (target.startsWith("exec:")) return "run";
+  if (target.startsWith("env:")) return "read";
+  return target.startsWith("sql:") ? "use" : target.startsWith("http:") ? "call" : "reach";
+}
+function ruleWords(rule) {
+  return `${ruleStatement(rule)}${rule.because ? `: ${rule.because}` : ""}`;
+}
+function breachWords(rule, b) {
+  return `${b.from} ${(0, import_grep_entry.isGrepEntry)(b.to) ? (0, import_grep_entry.grepWords)(b.to) : `imports ${b.to}`}, which the rule \u201C${ruleStatement({ ...rule, except: [] })}\u201D forbids${rule.because ? `: ${rule.because}` : ""}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  breachWords,
+  breaks,
+  checkEdges,
+  grepReads,
+  inPattern,
+  lookAlike,
+  lookAlikeFix,
+  parseArchitectureRule,
+  ruleEngine,
+  ruleStatement,
+  ruleWords,
+  tagsOf,
+  targetMatches
+});