depgraph-core 1.9.0 → 1.9.2

package/depgraph-mcp.js

@@ -3263,8 +3263,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path7) {
-      let input = path7;
+    function removeDotSegments(path9) {
+      let input = path9;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -3673,8 +3673,8 @@ var require_schemes = __commonJS({
       }
       if (wsComponent.resourceName) {
         const queryIndex = wsComponent.resourceName.indexOf("?");
-        const path7 = queryIndex === -1 ? wsComponent.resourceName : wsComponent.resourceName.slice(0, queryIndex);
-        wsComponent.path = path7 && path7 !== "/" ? path7 : void 0;
+        const path9 = queryIndex === -1 ? wsComponent.resourceName : wsComponent.resourceName.slice(0, queryIndex);
+        wsComponent.path = path9 && path9 !== "/" ? path9 : void 0;
         wsComponent.query = queryIndex === -1 ? void 0 : wsComponent.resourceName.slice(queryIndex + 1);
         wsComponent.resourceName = void 0;
       }
@@ -7677,8 +7677,8 @@ function getErrorMap() {
 
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path7, errorMaps, issueData } = params;
-  const fullPath = [...path7, ...issueData.path || []];
+  const { data, path: path9, errorMaps, issueData } = params;
+  const fullPath = [...path9, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -7794,11 +7794,11 @@ var errorUtil;
 
 // node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path7, key) {
+  constructor(parent, value, path9, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path7;
+    this._path = path9;
     this._key = key;
   }
   get path() {
@@ -11435,10 +11435,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path7) {
-  if (!path7)
+function getElementAtPath(obj, path9) {
+  if (!path9)
     return obj;
-  return path7.reduce((acc, key) => acc?.[key], obj);
+  return path9.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -11758,11 +11758,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path7, issues) {
+function prefixIssues(path9, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path7);
+    iss.path.unshift(path9);
     return iss;
   });
 }
@@ -15173,11 +15173,11 @@ function normalizeObjectSchema(schema) {
   }
   return void 0;
 }
-function getDotPath(path7) {
-  if (path7.length === 0) {
+function getDotPath(path9) {
+  if (path9.length === 0) {
     return "object root";
   }
-  return path7.reduce((acc, seg, index) => {
+  return path9.reduce((acc, seg, index) => {
     if (index === 0) {
       return String(seg);
     }
@@ -21545,7 +21545,9 @@ var SUPPORTED_EXTS = /* @__PURE__ */ new Set([
   ".vue",
   ".svelte",
   ".dart",
-  ".rs"
+  ".rs",
+  ".sql",
+  ".prisma"
 ]);
 var MAX_FILE_SIZE = 3e5;
 var MAX_BFS_DEPTH = 10;
@@ -23592,9 +23594,415 @@ var RustParser = {
 };
 registerParser(RustParser);
 
+// src/languages/sql/helpers.ts
+var NAME_PART = '(?:"(?:[^"\\n]|"")*"|`(?:[^`\\n]|``)*`|\\[(?:[^\\]\\n]|\\]\\])*\\]|[\\w$]+)';
+var QUAL_NAME = `${NAME_PART}(?:\\s*\\.\\s*${NAME_PART})*`;
+var ROUTINE_RECOVERY_RX = new RegExp(
+  `\\bCREATE\\s+(?:OR\\s+(?:REPLACE|ALTER)\\s+)?(?:FUNCTION|PROC(?:EDURE)?)\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?(${QUAL_NAME})`,
+  "gi"
+);
+function lineOf(text, offset) {
+  return text.slice(0, offset).split("\n").length;
+}
+function normIdent(name) {
+  return name.split(".").map((p) => {
+    const s = p.trim();
+    if (s.length >= 2 && (s[0] === s[s.length - 1] && (s[0] === '"' || s[0] === "`") || s[0] === "[" && s[s.length - 1] === "]")) {
+      return s.slice(1, -1).toLowerCase();
+    }
+    return s.toLowerCase();
+  }).join(".");
+}
+function maskSqlComments(text) {
+  const out = [];
+  let i = 0;
+  const n = text.length;
+  function blank(upto) {
+    for (const ch of text.slice(i, upto)) out.push(ch === "\n" ? "\n" : " ");
+    return upto;
+  }
+  while (i < n) {
+    const c = text[i];
+    if (c === "'") {
+      let j = i + 1;
+      while (j < n && text[j] !== "\n") {
+        if (text[j] === "'") {
+          if (j + 1 < n && text[j + 1] === "'") {
+            j += 2;
+            continue;
+          }
+          j++;
+          break;
+        }
+        j++;
+      }
+      i = blank(j);
+    } else if (c === '"' || c === "`" || c === "[") {
+      const closer = c === "[" ? "]" : c;
+      let j = i + 1;
+      let closed = false;
+      while (j < n && text[j] !== "\n") {
+        if (text[j] === closer) {
+          if (j + 1 < n && text[j + 1] === closer) {
+            j += 2;
+            continue;
+          }
+          j++;
+          closed = true;
+          break;
+        }
+        j++;
+      }
+      const span = text.slice(i, j);
+      if (closed && !span.includes("--") && !span.includes("/*")) {
+        out.push(span);
+        i = j;
+      } else {
+        let eol = text.indexOf("\n", i);
+        if (eol === -1) eol = n;
+        i = blank(eol);
+      }
+    } else if (c === "-" && i + 1 < n && text[i + 1] === "-") {
+      let j = i;
+      while (j < n && text[j] !== "\n") j++;
+      i = blank(j);
+    } else if (c === "/" && i + 1 < n && text[i + 1] === "*") {
+      let depth = 1;
+      let j = i + 2;
+      while (j < n && depth > 0) {
+        if (text[j] === "/" && j + 1 < n && text[j + 1] === "*") {
+          depth++;
+          j += 2;
+        } else if (text[j] === "*" && j + 1 < n && text[j + 1] === "/") {
+          depth--;
+          j += 2;
+        } else j++;
+      }
+      i = blank(j);
+    } else {
+      out.push(c);
+      i++;
+    }
+  }
+  return out.join("");
+}
+var NON_TABLES = /* @__PURE__ */ new Set([
+  "select",
+  "where",
+  "set",
+  "dual",
+  "null",
+  "true",
+  "false",
+  "first",
+  "skip",
+  "rows",
+  "next",
+  "only",
+  "lateral",
+  "values",
+  "inserted",
+  "deleted",
+  "new",
+  "old"
+]);
+function collectCteNames(text) {
+  const ctes = /* @__PURE__ */ new Set();
+  const rx = /\bWITH\s+(?:RECURSIVE\s+)?([\w$]+)\s*(?:\([^()]*\))?\s+AS\s*\(/gi;
+  for (const m of text.matchAll(rx)) ctes.add(normIdent(m[1]));
+  return ctes;
+}
+function findMatchingParen(text, openIdx) {
+  let depth = 0;
+  for (let i = openIdx; i < text.length; i++) {
+    if (text[i] === "(") depth++;
+    else if (text[i] === ")") {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  return text.length;
+}
+function findStatementEnd(text, start) {
+  const slice = text.slice(start);
+  const match = slice.match(/(?:^|\n)\s*CREATE\s/i);
+  if (!match || match.index == null) return text.length;
+  const offset = match.index === 0 ? 0 : match.index + 1;
+  return start + offset;
+}
+function collectTableRefs(masked, extraNonTables = /* @__PURE__ */ new Set()) {
+  const skip = /* @__PURE__ */ new Set([...NON_TABLES, ...extraNonTables]);
+  const refs = [];
+  const seen = /* @__PURE__ */ new Set();
+  const rx = new RegExp(
+    `\\b(?:FROM|JOIN|INTO|UPDATE)\\s+(${QUAL_NAME})`,
+    "gi"
+  );
+  for (const m of masked.matchAll(rx)) {
+    const raw = m[1];
+    const key = normIdent(raw);
+    if (skip.has(key) || seen.has(key)) continue;
+    seen.add(key);
+    refs.push({ name: raw, line: lineOf(masked, m.index ?? 0) });
+  }
+  return refs;
+}
+function collectFkRefs(masked) {
+  const refs = [];
+  const seen = /* @__PURE__ */ new Set();
+  const rx = new RegExp(`\\bREFERENCES\\s+(${QUAL_NAME})`, "gi");
+  for (const m of masked.matchAll(rx)) {
+    const raw = m[1];
+    const key = normIdent(raw);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    refs.push({ name: raw, line: lineOf(masked, m.index ?? 0) });
+  }
+  return refs;
+}
+
+// src/languages/sql/patterns.ts
+var sqlEntityPatterns = [
+  {
+    regex: new RegExp(
+      `\\bCREATE\\s+(?:TEMP(?:ORARY)?\\s+)?TABLE\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?(${QUAL_NAME})`,
+      "gi"
+    ),
+    type: "table"
+  },
+  {
+    regex: new RegExp(
+      `\\bCREATE\\s+(?:OR\\s+(?:REPLACE|ALTER)\\s+)?(?:MATERIALIZED\\s+)?VIEW\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?(${QUAL_NAME})`,
+      "gi"
+    ),
+    type: "view"
+  },
+  {
+    regex: new RegExp(
+      `\\bCREATE\\s+(?:OR\\s+(?:REPLACE|ALTER)\\s+)?FUNCTION\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?(${QUAL_NAME})`,
+      "gi"
+    ),
+    type: "function"
+  },
+  {
+    regex: new RegExp(
+      `\\bCREATE\\s+(?:OR\\s+(?:REPLACE|ALTER)\\s+)?PROC(?:EDURE)?\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?(${QUAL_NAME})`,
+      "gi"
+    ),
+    type: "procedure"
+  },
+  {
+    regex: new RegExp(
+      `\\bCREATE\\s+(?:OR\\s+(?:REPLACE|ALTER)\\s+)?TRIGGER\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?(${QUAL_NAME})`,
+      "gi"
+    ),
+    type: "trigger"
+  },
+  {
+    regex: new RegExp(
+      `\\bCREATE\\s+(?:UNIQUE\\s+)?INDEX\\s+(?:CONCURRENTLY\\s+)?(?:IF\\s+NOT\\s+EXISTS\\s+)?(${QUAL_NAME})\\s+ON\\b`,
+      "gi"
+    ),
+    type: "index"
+  }
+];
+
+// src/languages/sql/extractor.ts
+var import_path3 = __toESM(require("path"));
+var _currentFile = "";
+function extractEntities12(code, filePath) {
+  _currentFile = filePath;
+  const masked = maskSqlComments(code);
+  const entities = [];
+  const seenNames = /* @__PURE__ */ new Set();
+  for (const { regex, type } of sqlEntityPatterns) {
+    regex.lastIndex = 0;
+    for (const m of masked.matchAll(regex)) {
+      const raw = m[1].trim();
+      const key = normIdent(raw);
+      if (seenNames.has(key)) continue;
+      seenNames.add(key);
+      entities.push({ name: raw, type, line: lineOf(code, m.index ?? 0), complexity: "low" });
+    }
+  }
+  ROUTINE_RECOVERY_RX.lastIndex = 0;
+  for (const m of masked.matchAll(ROUTINE_RECOVERY_RX)) {
+    const raw = m[1].trim();
+    const key = normIdent(raw);
+    if (seenNames.has(key)) continue;
+    seenNames.add(key);
+    entities.push({ name: `${raw}()`, type: "procedure", line: lineOf(code, m.index ?? 0), complexity: "low" });
+  }
+  return entities;
+}
+var TABLE_HEADER_RX = new RegExp(
+  `\\bCREATE\\s+(?:TEMP(?:ORARY)?\\s+)?TABLE\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?(${QUAL_NAME})`,
+  "gi"
+);
+var VIEW_HEADER_RX = new RegExp(
+  `\\bCREATE\\s+(?:OR\\s+(?:REPLACE|ALTER)\\s+)?(?:MATERIALIZED\\s+)?VIEW\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?(${QUAL_NAME})`,
+  "gi"
+);
+var ROUTINE_HEADER_RX = new RegExp(
+  `\\bCREATE\\s+(?:OR\\s+(?:REPLACE|ALTER)\\s+)?(?:FUNCTION|PROC(?:EDURE)?)\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?(${QUAL_NAME})`,
+  "gi"
+);
+function extractImports12(code) {
+  const masked = maskSqlComments(code);
+  const fileBase = import_path3.default.basename(_currentFile, import_path3.default.extname(_currentFile));
+  if (!fileBase) return [];
+  const imports = [];
+  function emit(fromEntity, name, relationType) {
+    if (normIdent(name) === normIdent(fromEntity)) return;
+    imports.push({ source: fileBase, names: [name], isLocal: true, fromEntity, relationType });
+  }
+  TABLE_HEADER_RX.lastIndex = 0;
+  for (const m of masked.matchAll(TABLE_HEADER_RX)) {
+    const tableName = m[1].trim();
+    const afterHeader = m.index + m[0].length;
+    let pi = afterHeader;
+    while (pi < masked.length && masked[pi] !== "(" && masked[pi] !== ";") pi++;
+    if (masked[pi] !== "(") continue;
+    const bodyEnd = findMatchingParen(masked, pi);
+    const body = masked.slice(pi + 1, bodyEnd);
+    for (const ref of collectFkRefs(body)) emit(tableName, ref.name, "references");
+  }
+  VIEW_HEADER_RX.lastIndex = 0;
+  for (const m of masked.matchAll(VIEW_HEADER_RX)) {
+    const viewName = m[1].trim();
+    const afterHeader = m.index + m[0].length;
+    const bodyEnd = findStatementEnd(masked, afterHeader);
+    const body = masked.slice(afterHeader, bodyEnd);
+    const ctes = collectCteNames(body);
+    for (const ref of collectTableRefs(body, ctes)) emit(viewName, ref.name, "reads_from");
+  }
+  ROUTINE_HEADER_RX.lastIndex = 0;
+  for (const m of masked.matchAll(ROUTINE_HEADER_RX)) {
+    const routineName = m[1].trim();
+    const afterHeader = m.index + m[0].length;
+    const bodyEnd = findStatementEnd(masked, afterHeader);
+    const body = masked.slice(afterHeader, bodyEnd);
+    const ctes = collectCteNames(body);
+    for (const ref of collectTableRefs(body, ctes)) emit(routineName, ref.name, "reads_from");
+  }
+  return imports;
+}
+function extractExports12(code) {
+  const masked = maskSqlComments(code);
+  const names = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const { regex } of sqlEntityPatterns) {
+    regex.lastIndex = 0;
+    for (const m of masked.matchAll(regex)) {
+      const key = normIdent(m[1].trim());
+      if (!seen.has(key)) {
+        seen.add(key);
+        names.push(m[1].trim());
+      }
+    }
+  }
+  return names;
+}
+
+// src/languages/sql/index.ts
+var SqlParser = {
+  lang: "sql",
+  extensions: [".sql"],
+  extractEntities: extractEntities12,
+  extractImports: extractImports12,
+  extractExports: extractExports12,
+  entityPatterns: sqlEntityPatterns
+};
+registerParser(SqlParser);
+
+// src/languages/prisma/extractor.ts
+var import_path4 = __toESM(require("path"));
+var PRISMA_SCALARS = /* @__PURE__ */ new Set([
+  "string",
+  "int",
+  "float",
+  "boolean",
+  "datetime",
+  "json",
+  "bytes",
+  "decimal",
+  "bigint",
+  "unsupported"
+]);
+function isScalar(typeName) {
+  return PRISMA_SCALARS.has(typeName.toLowerCase());
+}
+function baseType(t) {
+  return t.replace(/[\[\]?]/g, "").trim();
+}
+var _currentFile2 = "";
+function extractEntities13(code, filePath) {
+  _currentFile2 = filePath;
+  const entities = [];
+  const modelRx = /^model\s+(\w+)\s*\{/gm;
+  for (const m of code.matchAll(modelRx)) {
+    const line = code.slice(0, m.index).split("\n").length;
+    entities.push({ name: m[1], type: "model", line, complexity: "low" });
+  }
+  const enumRx = /^enum\s+(\w+)\s*\{/gm;
+  for (const m of code.matchAll(enumRx)) {
+    const line = code.slice(0, m.index).split("\n").length;
+    entities.push({ name: m[1], type: "enum", line, complexity: "low" });
+  }
+  return entities;
+}
+function extractImports13(code) {
+  const fileBase = import_path4.default.basename(_currentFile2, import_path4.default.extname(_currentFile2));
+  if (!fileBase) return [];
+  const imports = [];
+  const modelBlockRx = /^model\s+(\w+)\s*\{([^}]*)\}/gms;
+  for (const block of code.matchAll(modelBlockRx)) {
+    const modelName = block[1];
+    const body = block[2];
+    const fieldRx = /^\s*(\w+)\s+(\w[\w[\]?]*)/gm;
+    const seen = /* @__PURE__ */ new Set();
+    for (const field of body.matchAll(fieldRx)) {
+      const rawType = field[2];
+      const typeName = baseType(rawType);
+      if (isScalar(typeName)) continue;
+      if (typeName === modelName) continue;
+      if (seen.has(typeName)) continue;
+      seen.add(typeName);
+      imports.push({
+        source: fileBase,
+        names: [typeName],
+        isLocal: true,
+        fromEntity: modelName,
+        relationType: "relation"
+      });
+    }
+  }
+  return imports;
+}
+function extractExports13(code) {
+  const names = [];
+  for (const m of code.matchAll(/^(?:model|enum)\s+(\w+)/gm)) names.push(m[1]);
+  return names;
+}
+
+// src/languages/prisma/index.ts
+var prismaEntityPatterns = [
+  { regex: /^model\s+(\w+)\s*\{/gm, type: "model" },
+  { regex: /^enum\s+(\w+)\s*\{/gm, type: "enum" }
+];
+var PrismaParser = {
+  lang: "prisma",
+  extensions: [".prisma"],
+  extractEntities: extractEntities13,
+  extractImports: extractImports13,
+  extractExports: extractExports13,
+  entityPatterns: prismaEntityPatterns
+};
+registerParser(PrismaParser);
+
 // src/stages/collector.ts
 var import_fs = __toESM(require("fs"));
-var import_path3 = __toESM(require("path"));
+var import_path5 = __toESM(require("path"));
 function collectFiles(dir) {
   const results = [];
   function walk(currentDir) {
@@ -23606,7 +24014,7 @@ function collectFiles(dir) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = import_path3.default.join(currentDir, entry);
+      const fullPath = import_path5.default.join(currentDir, entry);
       let stat;
       try {
         stat = import_fs.default.statSync(fullPath);
@@ -23620,7 +24028,7 @@ function collectFiles(dir) {
         }
         continue;
       }
-      const ext = import_path3.default.extname(entry);
+      const ext = import_path5.default.extname(entry);
       if (SUPPORTED_EXTS.has(ext) && stat.size < MAX_FILE_SIZE) {
         results.push(fullPath);
       }
@@ -23632,7 +24040,7 @@ function collectFiles(dir) {
 
 // src/stages/parser.ts
 var import_fs2 = __toESM(require("fs"));
-var import_path4 = __toESM(require("path"));
+var import_path6 = __toESM(require("path"));
 function parseFile(filePath) {
   let code;
   try {
@@ -23641,7 +24049,7 @@ function parseFile(filePath) {
     console.warn(`\u26A0 Cannot read file: ${filePath}`);
     return null;
   }
-  const ext = import_path4.default.extname(filePath).toLowerCase();
+  const ext = import_path6.default.extname(filePath).toLowerCase();
   const parser = getLanguageParser(ext);
   if (!parser) return null;
   const isHashCommentLang = [".py", ".rb", ".sh", ".bash", ".ps1"].includes(ext);
@@ -23673,12 +24081,12 @@ function parseFiles(filePaths) {
 }
 
 // src/stages/graph.ts
-var import_path5 = __toESM(require("path"));
+var import_path7 = __toESM(require("path"));
 function buildGraph(parsedFiles) {
   const nodes = /* @__PURE__ */ new Map();
   const edges = [];
   for (const file of parsedFiles) {
-    const fileBase = import_path5.default.basename(file.filePath, import_path5.default.extname(file.filePath));
+    const fileBase = import_path7.default.basename(file.filePath, import_path7.default.extname(file.filePath));
     for (const entity of file.entities) {
       const id = makeId(entity.name, fileBase);
       if (nodes.has(id)) continue;
@@ -23702,7 +24110,7 @@ function buildGraph(parsedFiles) {
     fileMap.set(file.filePath, file);
   }
   for (const file of parsedFiles) {
-    const fileBase = import_path5.default.basename(file.filePath, import_path5.default.extname(file.filePath));
+    const fileBase = import_path7.default.basename(file.filePath, import_path7.default.extname(file.filePath));
     for (const imp of file.imports) {
       if (!imp.isLocal) continue;
       const resolvedPath = resolvePath(file.filePath, imp.source, parsedFiles);
@@ -23712,23 +24120,24 @@ function buildGraph(parsedFiles) {
       for (const importedName of imp.names) {
         const targetEntity = targetFile.entities.find((e) => e.name === importedName);
         if (!targetEntity) continue;
-        const targetBase = import_path5.default.basename(resolvedPath, import_path5.default.extname(resolvedPath));
+        const targetBase = import_path7.default.basename(resolvedPath, import_path7.default.extname(resolvedPath));
         const toId = makeId(importedName, targetBase);
         if (!nodes.has(toId)) continue;
-        const fromEntities = file.entities.length > 0 ? file.entities : [{ name: fileBase, type: "file", line: 0, complexity: "low" }];
+        const edgeType = imp.relationType ?? "imports";
+        const fromEntities = imp.fromEntity ? file.entities.filter((e) => e.name === imp.fromEntity) : file.entities.length > 0 ? file.entities : [{ name: fileBase, type: "file", line: 0, complexity: "low" }];
         for (const fromEntity of fromEntities) {
           const fromId = makeId(fromEntity.name, fileBase);
           if (!nodes.has(fromId)) continue;
           if (fromId === toId) continue;
           const alreadyExists = edges.some(
-            (e) => e.from === fromId && e.to === toId && e.type === "imports"
+            (e) => e.from === fromId && e.to === toId && e.type === edgeType
           );
           if (alreadyExists) continue;
           edges.push({
             from: fromId,
             to: toId,
-            type: "imports",
-            description: `${fromEntity.name} imports ${importedName} from ${import_path5.default.basename(resolvedPath)}`
+            type: edgeType,
+            description: `${fromEntity.name} ${edgeType} ${importedName}`
           });
           const fromNode = nodes.get(fromId);
           const toNode = nodes.get(toId);
@@ -23750,7 +24159,7 @@ function makeId(name, fileBase) {
   return `${cleanName}__${cleanBase}`;
 }
 function resolvePath(fromFile, importSource, allFiles) {
-  const fromDir = import_path5.default.dirname(fromFile);
+  const fromDir = import_path7.default.dirname(fromFile);
   let normalizedSource = importSource;
   if (normalizedSource.startsWith("crate::")) {
     normalizedSource = normalizedSource.slice(7).replace(/::/g, "/");
@@ -23759,7 +24168,7 @@ function resolvePath(fromFile, importSource, allFiles) {
   } else if (normalizedSource.startsWith("self::")) {
     normalizedSource = "./" + normalizedSource.slice(6).replace(/::/g, "/");
   }
-  const base = import_path5.default.join(fromDir, normalizedSource);
+  const base = import_path7.default.join(fromDir, normalizedSource);
   const candidates = [
     base,
     `${base}.ts`,
@@ -23769,14 +24178,16 @@ function resolvePath(fromFile, importSource, allFiles) {
     `${base}/index.ts`,
     `${base}/index.js`,
     `${base}.dart`,
-    `${base}.rs`
+    `${base}.rs`,
+    `${base}.sql`,
+    `${base}.prisma`
   ];
   for (const candidate of candidates) {
     const normalized = candidate.replace(/\\/g, "/");
     const found = allFiles.find((f) => f.filePath.replace(/\\/g, "/") === normalized);
     if (found) return found.filePath;
   }
-  const parentBase = import_path5.default.dirname(base);
+  const parentBase = import_path7.default.dirname(base);
   if (parentBase && parentBase !== base) {
     const parentCandidates = [
       `${parentBase}.rs`,
@@ -23966,7 +24377,7 @@ function emptyReport(targetName, changeDescription, reason) {
 
 // src/stages/gitdiff.ts
 var import_child_process = require("child_process");
-var import_path6 = __toESM(require("path"));
+var import_path8 = __toESM(require("path"));
 function getChangedEntities(options) {
   const diff = runGitDiff(options);
   if (!diff) return [];
@@ -24058,7 +24469,7 @@ function parseDiff(diff, projectDir) {
   return entities;
 }
 function extractEntityFromContext(context, file) {
-  const ext = import_path6.default.extname(file).toLowerCase();
+  const ext = import_path8.default.extname(file).toLowerCase();
   const parser = getLanguageParser(ext);
   if (parser?.entityPatterns) {
     for (const { regex, type } of parser.entityPatterns) {