@esankhan3/code-search-mcp 0.0.2 → 0.1.0

package/dist/core/ast-graph-builder.js

@@ -1,800 +0,0 @@
-import { readFileSync } from "node:fs";
-import { relative, extname, dirname, resolve, basename, join } from "node:path";
-import { walkDir, langFromExt, extractImports, extractNamedImports } from "./file-walker.js";
-function tsEntityPatterns() {
-  return [
-    { regex: /^export\s+function\s+/, type: "function", nameExtractor: (l) => l.match(/^export\s+function\s+(\w+)/)?.[1] },
-    { regex: /^export\s+async\s+function\s+/, type: "function", nameExtractor: (l) => l.match(/^export\s+async\s+function\s+(\w+)/)?.[1] },
-    { regex: /^function\s+/, type: "function", nameExtractor: (l) => l.match(/^function\s+(\w+)/)?.[1] },
-    { regex: /^async\s+function\s+/, type: "function", nameExtractor: (l) => l.match(/^async\s+function\s+(\w+)/)?.[1] },
-    { regex: /^export\s+class\s+/, type: "class", nameExtractor: (l) => l.match(/^export\s+class\s+(\w+)/)?.[1] },
-    { regex: /^class\s+/, type: "class", nameExtractor: (l) => l.match(/^class\s+(\w+)/)?.[1] },
-    { regex: /^export\s+interface\s+/, type: "interface", nameExtractor: (l) => l.match(/^export\s+interface\s+(\w+)/)?.[1] },
-    { regex: /^interface\s+/, type: "interface", nameExtractor: (l) => l.match(/^interface\s+(\w+)/)?.[1] },
-    { regex: /^export\s+type\s+/, type: "type", nameExtractor: (l) => l.match(/^export\s+type\s+(\w+)/)?.[1] },
-    { regex: /^type\s+/, type: "type", nameExtractor: (l) => l.match(/^type\s+(\w+)/)?.[1] },
-    { regex: /^export\s+const\s+/, type: "const", nameExtractor: (l) => l.match(/^export\s+const\s+(\w+)/)?.[1] }
-  ];
-}
-function pyEntityPatterns() {
-  return [
-    { regex: /^def\s+/, type: "function", nameExtractor: (l) => l.match(/^def\s+(\w+)/)?.[1] },
-    { regex: /^async\s+def\s+/, type: "function", nameExtractor: (l) => l.match(/^async\s+def\s+(\w+)/)?.[1] },
-    { regex: /^class\s+/, type: "class", nameExtractor: (l) => l.match(/^class\s+(\w+)/)?.[1] }
-  ];
-}
-function goEntityPatterns() {
-  return [
-    { regex: /^func\s+/, type: "function", nameExtractor: (l) => l.match(/^func\s+(?:\([^)]*\)\s+)?(\w+)/)?.[1] },
-    { regex: /^type\s+\w+\s+struct/, type: "struct", nameExtractor: (l) => l.match(/^type\s+(\w+)\s+struct/)?.[1] },
-    { regex: /^type\s+\w+\s+interface/, type: "interface", nameExtractor: (l) => l.match(/^type\s+(\w+)\s+interface/)?.[1] }
-  ];
-}
-function rsEntityPatterns() {
-  return [
-    { regex: /^(?:pub\s+)?fn\s+/, type: "function", nameExtractor: (l) => l.match(/fn\s+(\w+)/)?.[1] },
-    { regex: /^(?:pub\s+)?struct\s+/, type: "struct", nameExtractor: (l) => l.match(/struct\s+(\w+)/)?.[1] },
-    { regex: /^impl\s+/, type: "impl", nameExtractor: (l) => l.match(/^impl\s+(?:<[^>]+>\s+)?(\w+)/)?.[1] },
-    { regex: /^(?:pub\s+)?trait\s+/, type: "trait", nameExtractor: (l) => l.match(/trait\s+(\w+)/)?.[1] },
-    { regex: /^(?:pub\s+)?enum\s+/, type: "enum", nameExtractor: (l) => l.match(/enum\s+(\w+)/)?.[1] }
-  ];
-}
-function javaEntityPatterns() {
-  return [
-    { regex: /(?:public|private|protected)\s+class\s+/, type: "class", nameExtractor: (l) => l.match(/class\s+(\w+)/)?.[1] },
-    { regex: /(?:public|private|protected)\s+interface\s+/, type: "interface", nameExtractor: (l) => l.match(/interface\s+(\w+)/)?.[1] },
-    { regex: /(?:public|private|protected)\s+(?:static\s+)?(?:void|int|long|boolean|String|[A-Z]\w*)\s+\w+\s*\(/, type: "method", nameExtractor: (l) => l.match(/(?:void|int|long|boolean|String|[A-Z]\w*)\s+(\w+)\s*\(/)?.[1] }
-  ];
-}
-function phpEntityPatterns() {
-  return [
-    { regex: /^(?:abstract\s+)?class\s+/, type: "class", nameExtractor: (l) => l.match(/class\s+(\w+)/)?.[1] },
-    { regex: /^interface\s+/, type: "interface", nameExtractor: (l) => l.match(/interface\s+(\w+)/)?.[1] },
-    { regex: /^trait\s+/, type: "trait", nameExtractor: (l) => l.match(/trait\s+(\w+)/)?.[1] },
-    { regex: /^(?:public|private|protected)\s+(?:static\s+)?function\s+/, type: "method", nameExtractor: (l) => l.match(/function\s+(\w+)/)?.[1] },
-    { regex: /^function\s+/, type: "function", nameExtractor: (l) => l.match(/^function\s+(\w+)/)?.[1] }
-  ];
-}
-function entityPatternsForLang(lang) {
-  switch (lang) {
-    case "typescript":
-    case "javascript":
-      return tsEntityPatterns();
-    case "python":
-      return pyEntityPatterns();
-    case "go":
-      return goEntityPatterns();
-    case "rust":
-      return rsEntityPatterns();
-    case "java":
-      return javaEntityPatterns();
-    case "php":
-      return phpEntityPatterns();
-    default:
-      return tsEntityPatterns();
-  }
-}
-function extractInheritance(line, lang) {
-  const parents = [];
-  if (lang === "typescript" || lang === "javascript") {
-    const ext = line.match(/class\s+\w+\s+extends\s+(\w+)/);
-    if (ext) parents.push(ext[1]);
-    const impl = line.match(/class\s+\w+(?:\s+extends\s+\w+)?\s+implements\s+([\w,\s]+)/);
-    if (impl) parents.push(...impl[1].split(",").map((s) => s.trim()).filter(Boolean));
-  } else if (lang === "python") {
-    const m = line.match(/^class\s+\w+\(([^)]+)\)/);
-    if (m) parents.push(...m[1].split(",").map((s) => s.trim()).filter((s) => s && s !== "object"));
-  } else if (lang === "rust") {
-    const m = line.match(/^impl\s+(\w+)\s+for\s+(\w+)/);
-    if (m) parents.push(m[1]);
-  } else if (lang === "java" || lang === "php") {
-    const ext = line.match(/class\s+\w+\s+extends\s+(\w+)/);
-    if (ext) parents.push(ext[1]);
-    const impl = line.match(/class\s+\w+(?:\s+extends\s+\w+)?\s+implements\s+([\w,\s]+)/);
-    if (impl) parents.push(...impl[1].split(",").map((s) => s.trim()).filter(Boolean));
-  }
-  return parents;
-}
-function extractTypeReferences(body, lang) {
-  const refs = /* @__PURE__ */ new Set();
-  if (lang === "typescript" || lang === "javascript") {
-    for (const m of body.matchAll(/:\s*([A-Z][A-Za-z0-9_]*)/g)) refs.add(m[1]);
-    for (const m of body.matchAll(/<([A-Z][A-Za-z0-9_]*)/g)) refs.add(m[1]);
-    for (const m of body.matchAll(/\bas\s+([A-Z][A-Za-z0-9_]*)/g)) refs.add(m[1]);
-    for (const m of body.matchAll(/\bnew\s+([A-Z][A-Za-z0-9_]*)/g)) refs.add(m[1]);
-  } else if (lang === "python") {
-    for (const m of body.matchAll(/:\s*([A-Z][A-Za-z0-9_]*)/g)) refs.add(m[1]);
-    for (const m of body.matchAll(/->\s*([A-Z][A-Za-z0-9_]*)/g)) refs.add(m[1]);
-  } else if (lang === "go") {
-    for (const m of body.matchAll(/[*\[\]]\s*([A-Z][A-Za-z0-9_]*)/g)) refs.add(m[1]);
-    for (const m of body.matchAll(/\w+\s+([A-Z][A-Za-z0-9_]*)[,)\s]/g)) refs.add(m[1]);
-    for (const m of body.matchAll(/\)\s*(?:\()?([A-Z][A-Za-z0-9_]*)/g)) refs.add(m[1]);
-  } else if (lang === "java" || lang === "php") {
-    for (const m of body.matchAll(/\b([A-Z][A-Za-z0-9_]*)\s+\$?\w+/g)) refs.add(m[1]);
-    for (const m of body.matchAll(/\bnew\s+([A-Z][A-Za-z0-9_]*)/g)) refs.add(m[1]);
-  } else if (lang === "rust") {
-    for (const m of body.matchAll(/[-:]\s*(?:&\s*(?:mut\s+)?)?([A-Z][A-Za-z0-9_]*)/g)) refs.add(m[1]);
-  }
-  const builtins = /* @__PURE__ */ new Set([
-    "String",
-    "Number",
-    "Boolean",
-    "Object",
-    "Array",
-    "Map",
-    "Set",
-    "Promise",
-    "Error",
-    "Date",
-    "RegExp",
-    "Function",
-    "Symbol",
-    "Buffer",
-    "Console",
-    "JSON",
-    "Math",
-    "Uint8Array",
-    "Int32Array",
-    "Float64Array",
-    "None",
-    "True",
-    "False",
-    "Self",
-    "Vec",
-    "Box",
-    "Option",
-    "Result",
-    "HashMap",
-    "HashSet",
-    "Iterator",
-    "Exception",
-    "Throwable"
-  ]);
-  return [...refs].filter((r) => r.length >= 3 && !builtins.has(r));
-}
-const RESOLVE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.js"];
-function extractPackageName(importPath) {
-  if (importPath.startsWith("@")) {
-    const parts = importPath.split("/");
-    return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : importPath;
-  }
-  const slashIdx = importPath.indexOf("/");
-  return slashIdx > 0 ? importPath.slice(0, slashIdx) : importPath;
-}
-function findOwningPackage(relPath, workspaceMap) {
-  let best = null;
-  let bestLen = -1;
-  for (const pkg of workspaceMap.packages) {
-    if (pkg.relativePath === ".") continue;
-    const prefix = pkg.relativePath + "/";
-    if (relPath.startsWith(prefix) && prefix.length > bestLen) {
-      best = pkg;
-      bestLen = prefix.length;
-    }
-  }
-  return best;
-}
-function resolveImportPath(importPath, currentFile, knownFiles, workspaceMap) {
-  if (importPath.startsWith(".")) {
-    const currentDir = dirname(currentFile);
-    const base = resolve("/", currentDir, importPath).slice(1);
-    for (const ext of ["", ...RESOLVE_EXTENSIONS]) {
-      const candidate = base + ext;
-      if (knownFiles.has(candidate)) return candidate;
-    }
-    return null;
-  }
-  if (!workspaceMap) return null;
-  const pkgName = extractPackageName(importPath);
-  const pkg = workspaceMap.nameToPackage.get(pkgName);
-  if (pkg) {
-    if (importPath !== pkgName) {
-      const subPath = importPath.slice(pkgName.length + 1);
-      const fullSub = join(pkg.relativePath, subPath);
-      for (const ext of ["", ...RESOLVE_EXTENSIONS]) {
-        if (knownFiles.has(fullSub + ext)) return fullSub + ext;
-      }
-      const srcSub = join(pkg.relativePath, "src", subPath);
-      for (const ext of ["", ...RESOLVE_EXTENSIONS]) {
-        if (knownFiles.has(srcSub + ext)) return srcSub + ext;
-      }
-    }
-    return `pkg::${pkg.name}`;
-  }
-  for (const [alias, resolvedBase] of workspaceMap.pathAliases) {
-    if (importPath === alias || importPath.startsWith(alias + "/")) {
-      const subPath = importPath === alias ? "" : importPath.slice(alias.length + 1);
-      const mapped = subPath ? join(resolvedBase, subPath) : resolvedBase;
-      for (const ext of ["", ...RESOLVE_EXTENSIONS]) {
-        if (knownFiles.has(mapped + ext)) return mapped + ext;
-      }
-      for (const wsPkg of workspaceMap.packages) {
-        if (resolvedBase.startsWith(wsPkg.relativePath)) {
-          return `pkg::${wsPkg.name}`;
-        }
-      }
-    }
-  }
-  return null;
-}
-function parseGoModulePath(repoPath) {
-  try {
-    const gomod = readFileSync(join(repoPath, "go.mod"), "utf-8");
-    const m = gomod.match(/^module\s+(\S+)/m);
-    return m?.[1] ?? null;
-  } catch {
-    return null;
-  }
-}
-function buildGoPackageMap(repoPath, goModulePath, knownFiles) {
-  const pkgMap = /* @__PURE__ */ new Map();
-  const goDirs = /* @__PURE__ */ new Set();
-  for (const f of knownFiles) {
-    if (f.endsWith(".go")) {
-      goDirs.add(dirname(f));
-    }
-  }
-  for (const dir of goDirs) {
-    const importPath = dir === "." ? goModulePath : `${goModulePath}/${dir}`;
-    pkgMap.set(importPath, dir);
-  }
-  return pkgMap;
-}
-function resolveGoImport(importPath, goModulePath, goPackageMap, knownFiles) {
-  if (!goModulePath || !importPath.startsWith(goModulePath)) return null;
-  const dir = goPackageMap.get(importPath);
-  if (!dir) return null;
-  for (const f of knownFiles) {
-    if (f.startsWith(dir + "/") && f.endsWith(".go") && !f.endsWith("_test.go")) {
-      return dir;
-    }
-  }
-  return dir;
-}
-function parseComposerAutoload(repoPath) {
-  const nsMap = /* @__PURE__ */ new Map();
-  try {
-    const composer = JSON.parse(readFileSync(join(repoPath, "composer.json"), "utf-8"));
-    const psr4 = composer?.autoload?.["psr-4"] ?? {};
-    for (const [ns, path] of Object.entries(psr4)) {
-      nsMap.set(ns, path.replace(/\/+$/, ""));
-    }
-    const devPsr4 = composer?.["autoload-dev"]?.["psr-4"] ?? {};
-    for (const [ns, path] of Object.entries(devPsr4)) {
-      nsMap.set(ns, path.replace(/\/+$/, ""));
-    }
-  } catch {
-  }
-  return nsMap;
-}
-function resolvePhpImport(importPath, phpNamespaceMap, knownFiles) {
-  for (const [prefix, basePath] of phpNamespaceMap) {
-    if (importPath.startsWith(prefix)) {
-      const relPart = importPath.slice(prefix.length).replace(/\\/g, "/");
-      const candidate = basePath + "/" + relPart + ".php";
-      if (knownFiles.has(candidate)) return candidate;
-    }
-  }
-  return null;
-}
-function resolvePythonImport(importPath, currentFile, knownFiles) {
-  if (importPath.startsWith(".")) {
-    const dots = importPath.match(/^(\.+)/)?.[1].length ?? 1;
-    let baseDir = dirname(currentFile);
-    for (let i = 1; i < dots; i++) baseDir = dirname(baseDir);
-    const modulePart = importPath.slice(dots);
-    if (!modulePart) return null;
-    const candidate2 = join(baseDir, modulePart.replace(/\./g, "/"));
-    for (const ext of [".py", "/__init__.py"]) {
-      if (knownFiles.has(candidate2 + ext)) return candidate2 + ext;
-    }
-    return null;
-  }
-  const pathParts = importPath.split(".");
-  const candidate = pathParts.join("/");
-  for (const ext of [".py", "/__init__.py"]) {
-    if (knownFiles.has(candidate + ext)) return candidate + ext;
-  }
-  if (pathParts.length > 1) {
-    const withoutPkg = pathParts.slice(1).join("/");
-    for (const ext of [".py", "/__init__.py"]) {
-      if (knownFiles.has(withoutPkg + ext)) return withoutPkg + ext;
-    }
-  }
-  return null;
-}
-function resolveRustImport(importPath, knownFiles) {
-  if (!importPath.startsWith("crate::")) return null;
-  const parts = importPath.slice(7).split("::");
-  for (let len = parts.length; len > 0; len--) {
-    const candidate = "src/" + parts.slice(0, len).join("/");
-    if (knownFiles.has(candidate + ".rs")) return candidate + ".rs";
-    if (knownFiles.has(candidate + "/mod.rs")) return candidate + "/mod.rs";
-  }
-  return null;
-}
-function resolveJavaImport(importPath, knownFiles) {
-  const filePath = importPath.replace(/\./g, "/") + ".java";
-  for (const prefix of ["src/main/java/", "src/", ""]) {
-    if (knownFiles.has(prefix + filePath)) return prefix + filePath;
-  }
-  return null;
-}
-const SKIP_CALL_NAMES = /* @__PURE__ */ new Set([
-  "if",
-  "else",
-  "for",
-  "while",
-  "switch",
-  "case",
-  "return",
-  "new",
-  "throw",
-  "catch",
-  "try",
-  "await",
-  "yield",
-  "import",
-  "export",
-  "from",
-  "const",
-  "let",
-  "var",
-  "function",
-  "class",
-  "interface",
-  "type",
-  "enum",
-  "struct",
-  "impl",
-  "trait",
-  "fn",
-  "pub",
-  "use",
-  "mod",
-  "def",
-  "self",
-  "super",
-  "this",
-  "true",
-  "false",
-  "null",
-  "undefined",
-  "void",
-  "async",
-  "static",
-  "print",
-  "println",
-  "console",
-  "log",
-  "warn",
-  "error",
-  "info",
-  "debug",
-  "require",
-  "module",
-  "exports",
-  "default",
-  "extends",
-  "implements",
-  "package",
-  "public",
-  "private",
-  "protected",
-  "abstract",
-  "final",
-  "override",
-  "virtual",
-  "delete",
-  "typeof",
-  "instanceof",
-  "len",
-  "str",
-  "int",
-  "float",
-  "bool",
-  "list",
-  "dict",
-  "set",
-  "tuple",
-  "range",
-  "map",
-  "filter",
-  "reduce",
-  "append",
-  "push",
-  "pop",
-  "shift",
-  "fmt",
-  "err",
-  "nil",
-  "make",
-  "close",
-  "open",
-  "read",
-  "write"
-]);
-function resolveCallTarget(calledName, callerFile, callerEntityId, symbolToIds, fileImportTargets) {
-  const candidates = symbolToIds.get(calledName);
-  if (!candidates || candidates.length === 0) return null;
-  if (candidates.length === 1) {
-    if (candidates[0] === callerEntityId) return null;
-    const targetFile = candidates[0].split("::")[0];
-    const confidence = targetFile === callerFile ? 0.9 : 0.8;
-    return { targetId: candidates[0], confidence };
-  }
-  const sameFile = candidates.find((c) => c.startsWith(callerFile + "::") && c !== callerEntityId);
-  if (sameFile) return { targetId: sameFile, confidence: 0.9 };
-  const callerImports = fileImportTargets.get(callerFile);
-  if (callerImports) {
-    const importedCandidate = candidates.find((c) => {
-      const candidateFile = c.split("::")[0];
-      return callerImports.has(candidateFile);
-    });
-    if (importedCandidate) return { targetId: importedCandidate, confidence: 0.85 };
-  }
-  const callerDir = dirname(callerFile);
-  const sameDirCandidates = candidates.filter((c) => {
-    const candidateFile = c.split("::")[0];
-    return dirname(candidateFile) === callerDir && c !== callerEntityId;
-  });
-  if (sameDirCandidates.length === 1) return { targetId: sameDirCandidates[0], confidence: 0.65 };
-  return null;
-}
-function resolveImportFull(importPath, currentFile, lang, knownFiles, workspaceMap, goModulePath, goPackageMap, phpNamespaceMap) {
-  const standard = resolveImportPath(importPath, currentFile, knownFiles, workspaceMap);
-  if (standard) return standard;
-  if (lang === "go") {
-    return resolveGoImport(importPath, goModulePath, goPackageMap, knownFiles);
-  }
-  if (lang === "php") {
-    return resolvePhpImport(importPath, phpNamespaceMap, knownFiles);
-  }
-  if (lang === "python") {
-    return resolvePythonImport(importPath, currentFile, knownFiles);
-  }
-  if (lang === "rust") {
-    return resolveRustImport(importPath, knownFiles);
-  }
-  if (lang === "java") {
-    return resolveJavaImport(importPath, knownFiles);
-  }
-  return null;
-}
-async function buildAstGraph(repoPath, opts) {
-  const files = [];
-  walkDir(repoPath, files);
-  const maxFiles = opts?.maxFiles ?? 5e3;
-  const sourceFiles = files.slice(0, maxFiles);
-  const relPaths = new Set(sourceFiles.map((f) => relative(repoPath, f)));
-  const nodes = [];
-  const edges = [];
-  const entities = [];
-  const symbolToIds = /* @__PURE__ */ new Map();
-  function registerSymbol(name, entityId) {
-    const existing = symbolToIds.get(name);
-    if (existing) {
-      existing.push(entityId);
-    } else {
-      symbolToIds.set(name, [entityId]);
-    }
-  }
-  const wsMap = opts?.workspaceMap;
-  if (wsMap) {
-    for (const pkg of wsMap.packages) {
-      nodes.push({
-        id: `pkg::${pkg.name}`,
-        label: pkg.name,
-        type: "package",
-        file: pkg.relativePath
-      });
-    }
-  }
-  const goModulePath = parseGoModulePath(repoPath);
-  const goPackageMap = goModulePath ? buildGoPackageMap(repoPath, goModulePath, relPaths) : /* @__PURE__ */ new Map();
-  const phpNamespaceMap = parseComposerAutoload(repoPath);
-  const fileImportTargets = /* @__PURE__ */ new Map();
-  for (const filePath of sourceFiles) {
-    let content;
-    try {
-      content = readFileSync(filePath, "utf-8");
-    } catch {
-      continue;
-    }
-    const relPath = relative(repoPath, filePath);
-    const ext = extname(filePath);
-    const lang = langFromExt(ext);
-    const lines = content.split("\n");
-    const patterns = entityPatternsForLang(lang);
-    nodes.push({ id: relPath, label: basename(relPath), type: "module", file: relPath });
-    let currentClassId = null;
-    let currentClassIndent = -1;
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      const trimmed = line.trimStart();
-      const indent = line.length - trimmed.length;
-      if (currentClassId && indent <= currentClassIndent) {
-        currentClassId = null;
-        currentClassIndent = -1;
-      }
-      for (const pat of patterns) {
-        if (!pat.regex.test(trimmed)) continue;
-        const name = pat.nameExtractor(trimmed);
-        if (!name) break;
-        const entityId = `${relPath}::${name}`;
-        const parentNames = extractInheritance(trimmed, lang);
-        nodes.push({ id: entityId, label: name, type: pat.type, file: relPath });
-        const entity = {
-          id: entityId,
-          label: name,
-          type: pat.type,
-          file: relPath,
-          line: i,
-          indent,
-          parents: parentNames
-        };
-        entities.push(entity);
-        registerSymbol(name, entityId);
-        if (currentClassId && indent > currentClassIndent && (pat.type === "function" || pat.type === "method")) {
-          edges.push({ source: currentClassId, target: entityId, type: "contains", confidence: 1 });
-          const className = currentClassId.split("::").pop();
-          if (className) registerSymbol(`${className}.${name}`, entityId);
-        } else {
-          edges.push({ source: relPath, target: entityId, type: "contains", confidence: 1 });
-        }
-        if (pat.type === "class" || pat.type === "struct" || pat.type === "interface" || pat.type === "trait") {
-          currentClassId = entityId;
-          currentClassIndent = indent;
-        }
-        break;
-      }
-    }
-    const importSpecs = extractImports(lines, lang);
-    const importTargetSet = /* @__PURE__ */ new Set();
-    for (const spec of importSpecs) {
-      const resolved = resolveImportFull(spec, relPath, lang, relPaths, wsMap, goModulePath, goPackageMap, phpNamespaceMap);
-      if (resolved) {
-        edges.push({ source: relPath, target: resolved, type: "imports", confidence: 1 });
-        importTargetSet.add(resolved);
-      }
-    }
-    const namedImports = extractNamedImports(lines, lang);
-    for (const ni of namedImports) {
-      const resolved = resolveImportFull(ni.specifier, relPath, lang, relPaths, wsMap, goModulePath, goPackageMap, phpNamespaceMap);
-      if (!resolved) continue;
-      importTargetSet.add(resolved);
-      for (const name of ni.names) {
-        const targetEntityId = `${resolved}::${name}`;
-        const candidates = symbolToIds.get(name);
-        if (candidates?.includes(targetEntityId)) {
-          edges.push({ source: relPath, target: targetEntityId, type: "uses", confidence: 0.95 });
-        } else if (candidates && candidates.length === 1) {
-          edges.push({ source: relPath, target: candidates[0], type: "uses", confidence: 0.85 });
-        }
-      }
-    }
-    fileImportTargets.set(relPath, importTargetSet);
-  }
-  const entityByFile = /* @__PURE__ */ new Map();
-  for (const e of entities) {
-    const list = entityByFile.get(e.file) || [];
-    list.push(e);
-    entityByFile.set(e.file, list);
-  }
-  for (const filePath of sourceFiles) {
-    const relPath = relative(repoPath, filePath);
-    const fileEntities = entityByFile.get(relPath);
-    if (!fileEntities || fileEntities.length === 0) continue;
-    let content;
-    try {
-      content = readFileSync(filePath, "utf-8");
-    } catch {
-      continue;
-    }
-    const lines = content.split("\n");
-    const lang = langFromExt(extname(filePath));
-    for (let ei = 0; ei < fileEntities.length; ei++) {
-      const entity = fileEntities[ei];
-      const startLine = entity.line;
-      const endLine = ei + 1 < fileEntities.length ? fileEntities[ei + 1].line : lines.length;
-      const body = lines.slice(startLine, Math.min(startLine + 30, endLine)).join("\n");
-      const typeRefs = extractTypeReferences(body, lang);
-      for (const typeName of typeRefs) {
-        const resolved = resolveCallTarget(typeName, entity.file, entity.id, symbolToIds, fileImportTargets);
-        if (resolved) {
-          edges.push({ source: entity.id, target: resolved.targetId, type: "type-ref", confidence: Math.min(resolved.confidence, 0.85) });
-        }
-      }
-    }
-  }
-  for (const filePath of sourceFiles) {
-    const relPath = relative(repoPath, filePath);
-    const fileEntities = entityByFile.get(relPath);
-    if (!fileEntities || fileEntities.length === 0) continue;
-    let content;
-    try {
-      content = readFileSync(filePath, "utf-8");
-    } catch {
-      continue;
-    }
-    const lines = content.split("\n");
-    for (let ei = 0; ei < fileEntities.length; ei++) {
-      const entity = fileEntities[ei];
-      const startLine = entity.line;
-      const endLine = ei + 1 < fileEntities.length ? fileEntities[ei + 1].line : lines.length;
-      const body = lines.slice(startLine, endLine).join("\n");
-      const callRegex = /\b([a-zA-Z_]\w*)\s*\(/g;
-      let match;
-      const seenCalls = /* @__PURE__ */ new Set();
-      while ((match = callRegex.exec(body)) !== null) {
-        const calledName = match[1];
-        if (calledName.length < 3) continue;
-        if (SKIP_CALL_NAMES.has(calledName)) continue;
-        if (seenCalls.has(calledName)) continue;
-        seenCalls.add(calledName);
-        const resolved = resolveCallTarget(calledName, entity.file, entity.id, symbolToIds, fileImportTargets);
-        if (resolved) {
-          edges.push({ source: entity.id, target: resolved.targetId, type: "calls", confidence: resolved.confidence });
-        }
-      }
-    }
-  }
-  for (const entity of entities) {
-    for (const parent of entity.parents) {
-      const candidates = symbolToIds.get(parent);
-      if (!candidates || candidates.length === 0) continue;
-      if (candidates.length === 1) {
-        edges.push({ source: entity.id, target: candidates[0], type: "inherits", confidence: 0.95 });
-      } else {
-        const resolved = resolveCallTarget(parent, entity.file, entity.id, symbolToIds, fileImportTargets);
-        if (resolved) {
-          edges.push({ source: entity.id, target: resolved.targetId, type: "inherits", confidence: resolved.confidence });
-        }
-      }
-    }
-  }
-  if (wsMap) {
-    for (const relPath of relPaths) {
-      const owning = findOwningPackage(relPath, wsMap);
-      if (owning) {
-        edges.push({ source: `pkg::${owning.name}`, target: relPath, type: "contains", confidence: 1 });
-      }
-    }
-  }
-  return { nodes, links: edges };
-}
-function generateGraphReport(repoName, graph) {
-  const sections = [];
-  sections.push(`# Knowledge Graph Report: ${repoName}`);
-  sections.push(`
-> Auto-generated by Anvil AST graph builder.
-`);
-  const nodeCount = graph.nodes.length;
-  const edgeCount = graph.links.length;
-  const fileNodes = graph.nodes.filter((n) => n.type === "module");
-  sections.push(`## Overview
-`);
-  sections.push(`- **Files:** ${fileNodes.length}`);
-  sections.push(`- **Entities:** ${nodeCount - fileNodes.length}`);
-  sections.push(`- **Total nodes:** ${nodeCount}`);
-  sections.push(`- **Total edges:** ${edgeCount}`);
-  const edgeTypeCounts = /* @__PURE__ */ new Map();
-  for (const e of graph.links) {
-    const t = e.type || "unknown";
-    edgeTypeCounts.set(t, (edgeTypeCounts.get(t) || 0) + 1);
-  }
-  sections.push(`
-### Edge Types
-`);
-  sections.push("| Type | Count | Avg Confidence |");
-  sections.push("|------|-------|----------------|");
-  for (const [type, count] of [...edgeTypeCounts.entries()].sort((a, b) => b[1] - a[1])) {
-    const edgesOfType = graph.links.filter((e) => e.type === type);
-    const avgConf = edgesOfType.reduce((sum, e) => sum + (e.confidence ?? 0), 0) / edgesOfType.length;
-    sections.push(`| ${type} | ${count} | ${avgConf.toFixed(2)} |`);
-  }
-  const entityTypeCounts = /* @__PURE__ */ new Map();
-  for (const n of graph.nodes) {
-    const t = n.type || "unknown";
-    entityTypeCounts.set(t, (entityTypeCounts.get(t) || 0) + 1);
-  }
-  sections.push(`
-### Entity Types
-`);
-  sections.push("| Type | Count |");
-  sections.push("|------|-------|");
-  for (const [type, count] of [...entityTypeCounts.entries()].sort((a, b) => b[1] - a[1])) {
-    sections.push(`| ${type} | ${count} |`);
-  }
-  const degreeMap = /* @__PURE__ */ new Map();
-  for (const e of graph.links) {
-    degreeMap.set(e.source, (degreeMap.get(e.source) || 0) + 1);
-    degreeMap.set(e.target, (degreeMap.get(e.target) || 0) + 1);
-  }
-  const topNodes = [...degreeMap.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10);
-  if (topNodes.length > 0) {
-    sections.push(`
-### Hotspots (Top 10 by edge degree)
-`);
-    sections.push("| Node | Degree | Type |");
-    sections.push("|------|--------|------|");
-    for (const [nodeId, degree] of topNodes) {
-      const node = graph.nodes.find((n) => n.id === nodeId);
-      sections.push(`| ${nodeId} | ${degree} | ${node?.type || "-"} |`);
-    }
-  }
-  const importEdges = graph.links.filter((e) => e.type === "imports" || e.type === "uses");
-  const importCounts = /* @__PURE__ */ new Map();
-  for (const e of importEdges) {
-    importCounts.set(e.source, (importCounts.get(e.source) || 0) + 1);
-  }
-  const topImporters = [...importCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10);
-  if (topImporters.length > 0) {
-    sections.push(`
-### Top Importers
-`);
-    sections.push("| File | Import Count |");
-    sections.push("|------|-------------|");
-    for (const [file, count] of topImporters) {
-      sections.push(`| ${file} | ${count} |`);
-    }
-  }
-  return sections.join("\n");
-}
-async function incrementalGraphUpdate(existingGraph, changedFiles, deletedFiles, repoPath, opts) {
-  const totalFiles = new Set(existingGraph.nodes.filter((n) => n.file).map((n) => n.file)).size;
-  const changedCount = changedFiles.length + deletedFiles.length;
-  if (totalFiles === 0 || changedCount / totalFiles > 0.3) {
-    return buildAstGraph(repoPath, opts);
-  }
-  try {
-    const filesToRemove = /* @__PURE__ */ new Set([...changedFiles, ...deletedFiles]);
-    const removedNodeIds = /* @__PURE__ */ new Set();
-    for (const node of existingGraph.nodes) {
-      if (node.file && filesToRemove.has(node.file)) {
-        removedNodeIds.add(node.id);
-      }
-    }
-    for (const node of existingGraph.nodes) {
-      if (node.type === "module" && node.file && filesToRemove.has(node.file)) {
-        removedNodeIds.add(node.id);
-      }
-    }
-    const keptNodes = existingGraph.nodes.filter((n) => !removedNodeIds.has(n.id));
-    const keptEdges = existingGraph.links.filter(
-      (e) => !removedNodeIds.has(e.source) && !removedNodeIds.has(e.target)
-    );
-    if (changedFiles.length === 0) {
-      return { nodes: keptNodes, links: keptEdges };
-    }
-    const freshGraph = await buildAstGraph(repoPath, opts);
-    const changedFileSet = new Set(changedFiles);
-    const newNodes = freshGraph.nodes.filter((n) => n.file && changedFileSet.has(n.file));
-    const newNodeIds = new Set(newNodes.map((n) => n.id));
-    const keptNodeIds = new Set(keptNodes.map((n) => n.id));
-    const newEdges = freshGraph.links.filter((e) => {
-      const sourceIsNew = newNodeIds.has(e.source);
-      const targetIsNew = newNodeIds.has(e.target);
-      const sourceExists = keptNodeIds.has(e.source) || newNodeIds.has(e.source);
-      const targetExists = keptNodeIds.has(e.target) || newNodeIds.has(e.target);
-      return sourceExists && targetExists && (sourceIsNew || targetIsNew);
-    });
-    const updatedEdges = freshGraph.links.filter((e) => {
-      const sourceKept = keptNodeIds.has(e.source);
-      const targetNew = newNodeIds.has(e.target);
-      return sourceKept && targetNew;
-    });
-    return {
-      nodes: [...keptNodes, ...newNodes],
-      links: [...keptEdges, ...newEdges, ...updatedEdges]
-    };
-  } catch (err) {
-    console.warn(`[ast-graph] Incremental update failed, falling back to full rebuild: ${err}`);
-    return buildAstGraph(repoPath, opts);
-  }
-}
-export {
-  buildAstGraph,
-  generateGraphReport,
-  incrementalGraphUpdate
-};