codetrellis 0.0.0-stage → 0.2.0

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

@@ -0,0 +1,235 @@
+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 typescript_exports = {};
+__export(typescript_exports, {
+  javascriptPlugin: () => javascriptPlugin,
+  tsxPlugin: () => tsxPlugin,
+  typescriptPlugin: () => typescriptPlugin
+});
+module.exports = __toCommonJS(typescript_exports);
+var import_base = require("./base");
+function extractSymbols(node) {
+  const symbols = [];
+  for (const child of node.children) {
+    const symbol = nodeToSymbol(child);
+    if (symbol) symbols.push(symbol);
+  }
+  return symbols;
+}
+function callSignature(fn, declaredType) {
+  const params = fn.childForFieldName("parameters") ?? fn.childForFieldName("parameter");
+  return (0, import_base.signatureOf)(
+    (0, import_base.shapeOf)(fn.childForFieldName("type_parameters")),
+    params && params.type !== "formal_parameters" ? `(${(0, import_base.shapeOf)(params)})` : (0, import_base.shapeOf)(params),
+    (0, import_base.shapeOf)(fn.childForFieldName("return_type")),
+    // `const f: Handler = (req) => …`: the declared type is part of its shape.
+    declaredType ? (0, import_base.shapeOf)(declaredType) : null
+  );
+}
+const sig = (signature) => signature ? { signature } : {};
+function nodeToSymbol(node) {
+  const modifiers = extractModifiers(node);
+  switch (node.type) {
+    case "function_declaration":
+    case "generator_function_declaration": {
+      const name = node.childForFieldName("name")?.text || "anonymous";
+      return { name, kind: "function", startLine: node.startPosition.row + 1, endLine: node.endPosition.row + 1, children: [], modifiers, ...sig(callSignature(node)) };
+    }
+    case "class_declaration": {
+      const name = node.childForFieldName("name")?.text || "anonymous";
+      const body = node.childForFieldName("body");
+      const children = body ? extractClassMembers(body) : [];
+      return { name, kind: "class", startLine: node.startPosition.row + 1, endLine: node.endPosition.row + 1, children, modifiers };
+    }
+    case "interface_declaration": {
+      const name = node.childForFieldName("name")?.text || "anonymous";
+      const shape = (0, import_base.signatureOf)(
+        (0, import_base.shapeOf)(node.childForFieldName("type_parameters")),
+        ...node.children.filter((c) => c.type === "extends_type_clause").map((c) => ` ${(0, import_base.shapeOf)(c)} `),
+        (0, import_base.shapeOf)(node.childForFieldName("body"))
+      );
+      return { name, kind: "interface", startLine: node.startPosition.row + 1, endLine: node.endPosition.row + 1, children: [], modifiers, ...sig(shape) };
+    }
+    case "type_alias_declaration": {
+      const name = node.childForFieldName("name")?.text || "anonymous";
+      const shape = (0, import_base.signatureOf)((0, import_base.shapeOf)(node.childForFieldName("type_parameters")), (0, import_base.shapeOf)(node.childForFieldName("value")));
+      return { name, kind: "type", startLine: node.startPosition.row + 1, endLine: node.endPosition.row + 1, children: [], modifiers, ...sig(shape) };
+    }
+    case "enum_declaration": {
+      const name = node.childForFieldName("name")?.text || "anonymous";
+      return { name, kind: "enum", startLine: node.startPosition.row + 1, endLine: node.endPosition.row + 1, children: [], modifiers, ...sig((0, import_base.signatureOf)((0, import_base.shapeOf)(node.childForFieldName("body")))) };
+    }
+    case "lexical_declaration":
+    case "variable_declaration": {
+      const declarators = node.children.filter((c) => c.type === "variable_declarator");
+      for (const decl of declarators) {
+        const name = decl.childForFieldName("name")?.text;
+        const value = decl.childForFieldName("value");
+        if (!name) continue;
+        if (value && (value.type === "arrow_function" || value.type === "function_expression" || value.type === "function")) {
+          return { name, kind: "function", startLine: node.startPosition.row + 1, endLine: node.endPosition.row + 1, children: [], modifiers, ...sig(callSignature(value, decl.childForFieldName("type"))) };
+        }
+      }
+      return null;
+    }
+    case "export_statement": {
+      const declaration = node.childForFieldName("declaration") || node.children.find(
+        (c) => c.type !== "export" && c.type !== "default" && c.type !== "comment"
+      );
+      if (declaration) {
+        const sym = nodeToSymbol(declaration);
+        if (sym) {
+          sym.modifiers = [.../* @__PURE__ */ new Set([...sym.modifiers, "export"])];
+          return sym;
+        }
+      }
+      return null;
+    }
+    default:
+      return null;
+  }
+}
+function extractClassMembers(body) {
+  const members = [];
+  for (const child of body.children) {
+    if (child.type === "method_definition" || child.type === "public_field_definition" || child.type === "property_definition") {
+      const name = child.childForFieldName("name")?.text || "anonymous";
+      const kind = child.type === "method_definition" ? "method" : "variable";
+      const modifiers = extractModifiers(child);
+      const signature = kind === "method" ? callSignature(child) : (0, import_base.signatureOf)((0, import_base.shapeOf)(child.childForFieldName("type")));
+      members.push({
+        name,
+        kind,
+        startLine: child.startPosition.row + 1,
+        endLine: child.endPosition.row + 1,
+        children: [],
+        modifiers,
+        ...sig(signature)
+      });
+    }
+  }
+  return members;
+}
+function extractModifiers(node) {
+  const mods = [];
+  if (node.parent?.type === "export_statement") mods.push("export");
+  for (const child of node.children) {
+    if (child.type === "async") mods.push("async");
+    if (child.type === "static") mods.push("static");
+    if (child.type === "readonly") mods.push("readonly");
+    if (child.type === "abstract") mods.push("abstract");
+    if (child.type === "accessibility_modifier") mods.push(child.text);
+  }
+  return mods;
+}
+function extractImports(node) {
+  const imports = [];
+  for (const child of node.children) {
+    if (child.type !== "import_statement") continue;
+    const source = child.childForFieldName("source")?.text?.replace(/['"]/g, "") || "";
+    const specifiers = [];
+    let isDefault = false;
+    let isNamespace = false;
+    for (const c of child.children) {
+      if (c.type !== "import_clause") continue;
+      for (const cc of c.children) {
+        if (cc.type === "identifier") {
+          isDefault = true;
+          specifiers.push(cc.text);
+        }
+        if (cc.type === "named_imports") {
+          for (const spec of cc.children) {
+            if (spec.type === "import_specifier") {
+              const name = spec.childForFieldName("name")?.text || spec.text;
+              specifiers.push(name);
+            }
+          }
+        }
+        if (cc.type === "namespace_import") {
+          isNamespace = true;
+          specifiers.push(cc.children.find((x) => x.type === "identifier")?.text || "*");
+        }
+      }
+    }
+    imports.push({ source, specifiers, isDefault, isNamespace });
+  }
+  for (const child of node.children) {
+    if (child.type !== "export_statement") continue;
+    const sourceNode = child.childForFieldName("source");
+    if (!sourceNode) continue;
+    const source = sourceNode.text.replace(/['"]/g, "");
+    const clause = child.children.find((c) => c.type === "export_clause");
+    const nsExport = child.children.find((c) => c.type === "namespace_export");
+    if (clause) {
+      const specifiers = clause.children.filter((c) => c.type === "export_specifier").map((c) => c.childForFieldName("name")?.text ?? c.text);
+      imports.push({ source, specifiers, isDefault: false, isNamespace: false, isReexport: true });
+    } else {
+      const ns = nsExport?.children.find((c) => c.type === "identifier")?.text;
+      imports.push({ source, specifiers: [ns ?? "*"], isDefault: false, isNamespace: true, isReexport: true });
+    }
+  }
+  return imports;
+}
+function extractExports(node) {
+  const exports2 = [];
+  for (const child of node.children) {
+    if (child.type !== "export_statement") continue;
+    const isDefault = child.children.some((c) => c.type === "default");
+    const declaration = child.childForFieldName("declaration") || child.children.find(
+      (c) => c.type !== "export" && c.type !== "default" && c.type !== ";" && c.type !== "comment"
+    );
+    if (declaration) {
+      const sym = nodeToSymbol(declaration);
+      if (sym) exports2.push({ name: sym.name, kind: sym.kind, isDefault });
+    }
+  }
+  return exports2;
+}
+const typescriptPlugin = {
+  language: "typescript",
+  extensions: [".ts"],
+  grammarFile: "tree-sitter-typescript.wasm",
+  grammarKey: "typescript",
+  extractSymbols,
+  extractImports,
+  extractExports
+};
+const tsxPlugin = {
+  language: "typescript",
+  extensions: [".tsx"],
+  grammarFile: "tree-sitter-tsx.wasm",
+  grammarKey: "tsx",
+  extractSymbols,
+  extractImports,
+  extractExports
+};
+const javascriptPlugin = {
+  language: "javascript",
+  extensions: [".js", ".jsx", ".mjs", ".cjs"],
+  grammarFile: "tree-sitter-javascript.wasm",
+  grammarKey: "javascript",
+  extractSymbols,
+  extractImports,
+  extractExports
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  javascriptPlugin,
+  tsxPlugin,
+  typescriptPlugin
+});

package/src/backend/services/pattern-scan.js

@@ -0,0 +1,65 @@
+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 pattern_scan_exports = {};
+__export(pattern_scan_exports, {
+  notePatternsRead: () => notePatternsRead,
+  refreshPatternFinds: () => refreshPatternFinds
+});
+module.exports = __toCommonJS(pattern_scan_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_database = require("./database");
+var import_patterns = require("./patterns");
+const MAX_BYTES = 2 * 1024 * 1024;
+const lastStamp = /* @__PURE__ */ new Map();
+function refreshPatternFinds(projectRoot, files) {
+  const stamp = (0, import_patterns.patternStamp)(projectRoot);
+  const was = lastStamp.get(projectRoot);
+  lastStamp.set(projectRoot, stamp);
+  if (was === stamp) return null;
+  if (was === void 0 && stamp === "" && !(0, import_database.hasPatternCallsites)()) return null;
+  const found = [];
+  for (const file of files) {
+    let content;
+    try {
+      if (import_node_fs.default.statSync(file).size > MAX_BYTES || file.toLowerCase().endsWith(".sql")) continue;
+      content = import_node_fs.default.readFileSync(file, "utf-8");
+    } catch {
+      continue;
+    }
+    found.push({ path: file, callsites: (0, import_patterns.patternCallsitesFor)(file, content) });
+  }
+  return (0, import_database.replacePatternCallsites)(found);
+}
+function notePatternsRead(projectRoot) {
+  lastStamp.set(projectRoot, (0, import_patterns.patternStamp)(projectRoot));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  notePatternsRead,
+  refreshPatternFinds
+});

package/src/backend/services/patterns.js

@@ -0,0 +1,281 @@
+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 patterns_exports = {};
+__export(patterns_exports, {
+  PATTERNS_DIR: () => PATTERNS_DIR,
+  forgetPatternRoots: () => forgetPatternRoots,
+  parsePatterns: () => parsePatterns,
+  patternCallsites: () => patternCallsites,
+  patternCallsitesFor: () => patternCallsitesFor,
+  patternRootOf: () => patternRootOf,
+  patternStamp: () => patternStamp,
+  readPatterns: () => readPatterns
+});
+module.exports = __toCommonJS(patterns_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_yaml = require("yaml");
+var import_architecture_rule = require("./architecture-rule");
+var import_confined_fs = require("./confined-fs");
+var import_shared = require("./callsites/shared");
+var import_call_entry = require("../../shared/lib/call-entry");
+var import_matcher = require("../../shared/lib/matcher");
+const PATTERNS_DIR = ".codetrellis/patterns";
+const ID_RE = /^[a-z0-9][a-z0-9-]{0,62}$/;
+const MAX_PATTERNS = 200;
+const MAX_FIND = 200;
+const MAX_LINE = 2e3;
+const MAX_PER_FILE = 1e3;
+const RECHECK_MS = 2e3;
+const EMPTY = { patterns: [], problems: [], stamp: "" };
+const list = (v) => v === void 0 ? [] : typeof v === "string" ? [v] : Array.isArray(v) && v.every((x) => typeof x === "string") ? v : null;
+const relative = (p) => !p.startsWith("/") && !/^[a-zA-Z]:/.test(p) && !p.includes("\\") && !p.split("/").includes("..");
+function parsePatterns(file, text) {
+  const problems = [];
+  let raw;
+  try {
+    raw = (0, import_yaml.parse)(text, { maxAliasCount: 0 });
+  } catch (err) {
+    return { patterns: [], problems: [`${file}: not YAML (${err.message.split("\n")[0]})`] };
+  }
+  const items = raw && typeof raw === "object" && !Array.isArray(raw) ? raw.patterns : null;
+  if (!Array.isArray(items)) return { patterns: [], problems: [`${file}: a pattern file holds patterns: a list`] };
+  const patterns = [];
+  for (const item of items) {
+    const r = item && typeof item === "object" ? item : {};
+    const why = [];
+    const id = typeof r.id === "string" && ID_RE.test(r.id) ? r.id : null;
+    if (!id) why.push("id must be a short slug, like payments-sdk");
+    const within = list(r.in);
+    const except = list(r.except);
+    if (within === null || !within.every(relative)) why.push("in must be paths in the project, like services/");
+    if (except === null || !except.every(relative)) why.push("except must be paths in the project");
+    const { value, match } = (0, import_matcher.splitTarget)(r.find);
+    const m = match ?? r.match;
+    const kind = m === void 0 || m === null || m === "exact" ? null : m === "glob" || m === "regex" ? m : "bad";
+    if (kind === "bad") why.push("find matches exact, glob or regex");
+    if (typeof value !== "string" || !value.trim()) why.push("find must be the text to look for, like paymentsClient.charge(");
+    else if (value.length > MAX_FIND) why.push(`find is at most ${MAX_FIND} characters`);
+    else if (kind === "regex") {
+      const p = (0, import_matcher.regexProblem)(value);
+      if (p) why.push(p);
+    }
+    const is = typeof r.is === "string" ? r.is.trim() : "";
+    const shaped = is.replace(/\$[1-9]/g, "x");
+    if (!is) why.push("is must say what it is, like http:api.stripe.com/v1/charges or queue:orders.$1");
+    else {
+      const isWhy = (0, import_call_entry.callProblem)(shaped);
+      if (isWhy) why.push(`is: ${isWhy}`);
+    }
+    if (/\$[1-9]/.test(is) && kind !== "regex") why.push("is may use $1 only when find is a regex");
+    if (r.method !== void 0 && (typeof r.method !== "string" || !/^[A-Za-z]+$/.test(r.method))) why.push("method is an HTTP verb, like POST");
+    if (r.side !== void 0) {
+      if (r.side !== "sends" && r.side !== "receives") why.push("side is sends or receives: which end of the entry this code is");
+      else if (is && !(0, import_call_entry.isOwnKind)(shaped)) why.push("side is for a kind of your own, like queue:orders.$1; an HTTP call pairs with its route already");
+    }
+    if (why.length) {
+      problems.push(`${file}: ${id ?? "a pattern"}: ${why.join("; ")}`);
+      continue;
+    }
+    if (patterns.length >= MAX_PATTERNS) {
+      problems.push(`${file}: more than ${MAX_PATTERNS} patterns; the rest were not read`);
+      break;
+    }
+    patterns.push({
+      id,
+      file,
+      in: within,
+      except,
+      find: { match: kind, value },
+      is,
+      ...typeof r.method === "string" ? { method: r.method.toUpperCase() } : {},
+      ...r.side === "sends" || r.side === "receives" ? { side: r.side } : {}
+    });
+  }
+  return { patterns, problems };
+}
+const books = /* @__PURE__ */ new Map();
+function readPatterns(projectRoot, now = Date.now()) {
+  const hit = books.get(projectRoot);
+  if (hit && now - hit.checked < RECHECK_MS) return hit.book;
+  let dir;
+  let names;
+  try {
+    if (!import_node_fs.default.existsSync(import_node_path.default.join(projectRoot, PATTERNS_DIR))) {
+      books.set(projectRoot, { checked: now, book: EMPTY });
+      return EMPTY;
+    }
+    dir = (0, import_confined_fs.resolveWithin)(projectRoot, PATTERNS_DIR, "patterns folder");
+    names = import_node_fs.default.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".yaml")).map((e) => e.name).sort();
+  } catch {
+    books.set(projectRoot, { checked: now, book: EMPTY });
+    return EMPTY;
+  }
+  const stamp = names.map((n) => {
+    try {
+      const s = import_node_fs.default.statSync(import_node_path.default.join(dir, n));
+      return `${n}:${s.size}:${s.mtimeMs}`;
+    } catch {
+      return n;
+    }
+  }).join("|");
+  if (hit && hit.book.stamp === stamp) {
+    books.set(projectRoot, { checked: now, book: hit.book });
+    return hit.book;
+  }
+  const patterns = [];
+  const problems = [];
+  for (const name of names) {
+    let text;
+    try {
+      text = (0, import_confined_fs.readTextWithin)(projectRoot, `${PATTERNS_DIR}/${name}`, "pattern file");
+    } catch {
+      problems.push(`${name}: could not be read`);
+      continue;
+    }
+    const got = parsePatterns(name, text);
+    const ids = new Set(patterns.map((p) => p.id));
+    for (const p of got.patterns) {
+      if (ids.has(p.id)) problems.push(`${name}: ${p.id} is already a pattern in ${patterns.find((x) => x.id === p.id).file}`);
+      else patterns.push(p);
+    }
+    problems.push(...got.problems);
+  }
+  const book = { patterns, problems, stamp };
+  books.set(projectRoot, { checked: now, book });
+  return book;
+}
+const roots = /* @__PURE__ */ new Map();
+let rootsSince = 0;
+const ROOTS_MS = 5e3;
+function patternRootOf(absFile, now = Date.now()) {
+  if (now - rootsSince > ROOTS_MS) {
+    roots.clear();
+    rootsSince = now;
+  }
+  const start = import_node_path.default.dirname(import_node_path.default.resolve(absFile));
+  const walked = [];
+  let dir = start;
+  let found;
+  for (; ; ) {
+    if (roots.has(dir)) {
+      found = roots.get(dir);
+      break;
+    }
+    walked.push(dir);
+    if (import_node_fs.default.existsSync(import_node_path.default.join(dir, PATTERNS_DIR))) {
+      found = dir;
+      break;
+    }
+    const up = import_node_path.default.dirname(dir);
+    if (up === dir) {
+      found = null;
+      break;
+    }
+    dir = up;
+  }
+  for (const d of walked) roots.set(d, found ?? null);
+  if (roots.size > 2e4) roots.clear();
+  return found ?? null;
+}
+function forgetPatternRoots() {
+  roots.clear();
+  books.clear();
+}
+const compiled = /* @__PURE__ */ new Map();
+function finder(p) {
+  const key = `${p.find.match}\0${p.find.value}`;
+  let re = compiled.get(key);
+  if (!re) {
+    const escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const source = p.find.match === "regex" ? p.find.value : p.find.match === "glob" ? p.find.value.split("*").map(escape).join(".*?") : escape(p.find.value);
+    re = new RegExp(source, "g");
+    if (compiled.size > 500) compiled.clear();
+    compiled.set(key, re);
+  }
+  re.lastIndex = 0;
+  return re;
+}
+const entryOf = (is, groups) => is.replace(/\$([1-9])/g, (_, n) => groups[Number(n)] ?? "");
+function callsiteOf(p, entry, line) {
+  if ((0, import_call_entry.callProblem)(entry)) return null;
+  const context = `pattern:${p.id}`;
+  if (entry.startsWith("http:")) {
+    const rest = entry.slice(5);
+    const url = rest.startsWith("/") ? rest : `https://${rest.includes("/") ? rest : `${rest}/`}`;
+    return (0, import_shared.call)(line, p.method ?? "ANY", url, context);
+  }
+  if (entry.startsWith("sql:")) return { kind: "sql_query", protocol: "sql", line, method: "READ", urlPattern: entry.slice(4).toLowerCase(), context };
+  if ((0, import_call_entry.isOwnKind)(entry)) return { kind: "entry", protocol: "entry", line, urlPattern: entry, context, ...p.side ? { method: p.side === "sends" ? "SEND" : "RECEIVE" } : {} };
+  return null;
+}
+function patternCallsites(patterns, relPath, content) {
+  const reading = patterns.filter((p) => (p.in.length === 0 || p.in.some((x) => (0, import_architecture_rule.inPattern)(x, relPath))) && !p.except.some((x) => (0, import_architecture_rule.inPattern)(x, relPath)));
+  if (reading.length === 0) return [];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length && out.length < MAX_PER_FILE; i++) {
+    const text = lines[i].length > MAX_LINE ? lines[i].slice(0, MAX_LINE) : lines[i];
+    for (const p of reading) {
+      for (const m of text.matchAll(finder(p))) {
+        if (m[0] === "") break;
+        const cs = callsiteOf(p, entryOf(p.is, m), i + 1);
+        const key = cs ? `${cs.kind}|${cs.method}|${cs.host ?? ""}|${cs.urlPattern}|${cs.line}` : "";
+        if (cs && !seen.has(key)) {
+          seen.add(key);
+          out.push(cs);
+        }
+      }
+    }
+  }
+  return out;
+}
+function patternCallsitesFor(absFile, content) {
+  try {
+    const root = patternRootOf(absFile);
+    if (!root) return [];
+    const { patterns } = readPatterns(root);
+    if (patterns.length === 0) return [];
+    return patternCallsites(patterns, import_node_path.default.relative(root, import_node_path.default.resolve(absFile)).split(import_node_path.default.sep).join("/"), content);
+  } catch {
+    return [];
+  }
+}
+const patternStamp = (projectRoot) => readPatterns(projectRoot).stamp;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PATTERNS_DIR,
+  forgetPatternRoots,
+  parsePatterns,
+  patternCallsites,
+  patternCallsitesFor,
+  patternRootOf,
+  patternStamp,
+  readPatterns
+});