depgraph-core 1.9.1 → 1.9.2

package/depgraph-mcp.js

@@ -3263,8 +3263,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path8) {
-      let input = path8;
+    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 path8 = queryIndex === -1 ? wsComponent.resourceName : wsComponent.resourceName.slice(0, queryIndex);
-        wsComponent.path = path8 && path8 !== "/" ? path8 : 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: path8, errorMaps, issueData } = params;
-  const fullPath = [...path8, ...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, path8, key) {
+  constructor(parent, value, path9, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path8;
+    this._path = path9;
     this._key = key;
   }
   get path() {
@@ -11435,10 +11435,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path8) {
-  if (!path8)
+function getElementAtPath(obj, path9) {
+  if (!path9)
     return obj;
-  return path8.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(path8, issues) {
+function prefixIssues(path9, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path8);
+    iss.path.unshift(path9);
     return iss;
   });
 }
@@ -15173,11 +15173,11 @@ function normalizeObjectSchema(schema) {
   }
   return void 0;
 }
-function getDotPath(path8) {
-  if (path8.length === 0) {
+function getDotPath(path9) {
+  if (path9.length === 0) {
     return "object root";
   }
-  return path8.reduce((acc, seg, index) => {
+  return path9.reduce((acc, seg, index) => {
     if (index === 0) {
       return String(seg);
     }
@@ -21546,7 +21546,8 @@ var SUPPORTED_EXTS = /* @__PURE__ */ new Set([
   ".svelte",
   ".dart",
   ".rs",
-  ".sql"
+  ".sql",
+  ".prisma"
 ]);
 var MAX_FILE_SIZE = 3e5;
 var MAX_BFS_DEPTH = 10;
@@ -23711,6 +23712,24 @@ function collectCteNames(text) {
   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 = [];
@@ -23816,17 +23835,55 @@ function extractEntities12(code, filePath) {
   }
   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 imports = [];
   const fileBase = import_path3.default.basename(_currentFile, import_path3.default.extname(_currentFile));
-  if (!fileBase) return imports;
-  const ctes = collectCteNames(masked);
-  for (const ref of collectFkRefs(masked)) {
-    imports.push({ source: fileBase, names: [ref.name], isLocal: true });
-  }
-  for (const ref of collectTableRefs(masked, ctes)) {
-    imports.push({ source: fileBase, names: [ref.name], isLocal: true });
+  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;
 }
@@ -23858,9 +23915,94 @@ var SqlParser = {
 };
 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_path4 = __toESM(require("path"));
+var import_path5 = __toESM(require("path"));
 function collectFiles(dir) {
   const results = [];
   function walk(currentDir) {
@@ -23872,7 +24014,7 @@ function collectFiles(dir) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = import_path4.default.join(currentDir, entry);
+      const fullPath = import_path5.default.join(currentDir, entry);
       let stat;
       try {
         stat = import_fs.default.statSync(fullPath);
@@ -23886,7 +24028,7 @@ function collectFiles(dir) {
         }
         continue;
       }
-      const ext = import_path4.default.extname(entry);
+      const ext = import_path5.default.extname(entry);
       if (SUPPORTED_EXTS.has(ext) && stat.size < MAX_FILE_SIZE) {
         results.push(fullPath);
       }
@@ -23898,7 +24040,7 @@ function collectFiles(dir) {
 
 // src/stages/parser.ts
 var import_fs2 = __toESM(require("fs"));
-var import_path5 = __toESM(require("path"));
+var import_path6 = __toESM(require("path"));
 function parseFile(filePath) {
   let code;
   try {
@@ -23907,7 +24049,7 @@ function parseFile(filePath) {
     console.warn(`\u26A0 Cannot read file: ${filePath}`);
     return null;
   }
-  const ext = import_path5.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);
@@ -23939,12 +24081,12 @@ function parseFiles(filePaths) {
 }
 
 // src/stages/graph.ts
-var import_path6 = __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_path6.default.basename(file.filePath, import_path6.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;
@@ -23968,7 +24110,7 @@ function buildGraph(parsedFiles) {
     fileMap.set(file.filePath, file);
   }
   for (const file of parsedFiles) {
-    const fileBase = import_path6.default.basename(file.filePath, import_path6.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);
@@ -23978,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_path6.default.basename(resolvedPath, import_path6.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_path6.default.basename(resolvedPath)}`
+            type: edgeType,
+            description: `${fromEntity.name} ${edgeType} ${importedName}`
           });
           const fromNode = nodes.get(fromId);
           const toNode = nodes.get(toId);
@@ -24016,7 +24159,7 @@ function makeId(name, fileBase) {
   return `${cleanName}__${cleanBase}`;
 }
 function resolvePath(fromFile, importSource, allFiles) {
-  const fromDir = import_path6.default.dirname(fromFile);
+  const fromDir = import_path7.default.dirname(fromFile);
   let normalizedSource = importSource;
   if (normalizedSource.startsWith("crate::")) {
     normalizedSource = normalizedSource.slice(7).replace(/::/g, "/");
@@ -24025,7 +24168,7 @@ function resolvePath(fromFile, importSource, allFiles) {
   } else if (normalizedSource.startsWith("self::")) {
     normalizedSource = "./" + normalizedSource.slice(6).replace(/::/g, "/");
   }
-  const base = import_path6.default.join(fromDir, normalizedSource);
+  const base = import_path7.default.join(fromDir, normalizedSource);
   const candidates = [
     base,
     `${base}.ts`,
@@ -24036,14 +24179,15 @@ function resolvePath(fromFile, importSource, allFiles) {
     `${base}/index.js`,
     `${base}.dart`,
     `${base}.rs`,
-    `${base}.sql`
+    `${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_path6.default.dirname(base);
+  const parentBase = import_path7.default.dirname(base);
   if (parentBase && parentBase !== base) {
     const parentCandidates = [
       `${parentBase}.rs`,
@@ -24233,7 +24377,7 @@ function emptyReport(targetName, changeDescription, reason) {
 
 // src/stages/gitdiff.ts
 var import_child_process = require("child_process");
-var import_path7 = __toESM(require("path"));
+var import_path8 = __toESM(require("path"));
 function getChangedEntities(options) {
   const diff = runGitDiff(options);
   if (!diff) return [];
@@ -24325,7 +24469,7 @@ function parseDiff(diff, projectDir) {
   return entities;
 }
 function extractEntityFromContext(context, file) {
-  const ext = import_path7.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) {