ctxloom-pro 1.0.4 → 1.0.6

package/dist/chunk-RE2V3FRF.js

@@ -1,1052 +0,0 @@
-import {
-  collectFiles
-} from "./chunk-ZYDVY7VZ.js";
-import {
-  ASTParser,
-  extractNotebookPythonSource
-} from "./chunk-5CJIMX6D.js";
-import {
-  logger
-} from "./chunk-IHXVD5SO.js";
-
-// src/graph/DependencyGraph.js
-import fs3 from "fs";
-import path3 from "path";
-
-// src/utils/importExtractor.js
-import fs2 from "fs";
-import path2 from "path";
-
-// src/utils/GoModuleResolver.js
-import fs from "fs";
-import path from "path";
-var GoModuleResolver = class {
-  rootDir;
-  modulePath = null;
-  initialized = false;
-  constructor(rootDir) {
-    this.rootDir = rootDir;
-    this.init();
-  }
-  init() {
-    if (this.initialized)
-      return;
-    this.initialized = true;
-    const goModPath = path.join(this.rootDir, "go.mod");
-    if (!fs.existsSync(goModPath))
-      return;
-    try {
-      const content = fs.readFileSync(goModPath, "utf-8");
-      const match = content.match(/^module\s+(\S+)/m);
-      if (match?.[1]) {
-        this.modulePath = match[1];
-      }
-    } catch {
-    }
-  }
-  /** Returns the module path declared in go.mod, or null if no go.mod found. */
-  getModulePath() {
-    return this.modulePath;
-  }
-  /**
-   * Resolve a module-path import (e.g. `github.com/myorg/myapp/internal/auth`)
-   * to a relative project path (e.g. `internal/auth/auth.go`).
-   *
-   * Returns null for:
-   *   - Third-party imports (different module prefix)
-   *   - Relative imports (use resolveRelative() instead)
-   *   - Imports where no .go files are found
-   */
-  resolve(importPath) {
-    if (!this.modulePath)
-      return null;
-    if (importPath.startsWith("."))
-      return null;
-    if (!importPath.startsWith(this.modulePath))
-      return null;
-    const suffix = importPath.slice(this.modulePath.length);
-    if (!suffix)
-      return null;
-    const subPath = suffix.startsWith("/") ? suffix.slice(1) : suffix;
-    const absDir = path.join(this.rootDir, subPath);
-    return this.firstGoFileInDir(absDir, subPath);
-  }
-  /**
-   * Resolve a relative import (`./config`, `../pkg`) from a given Go source file.
-   * Returns the relative project path to the first .go file found, or null.
-   */
-  resolveRelative(fromFile, importSpec) {
-    const fromDir = path.dirname(fromFile);
-    const absTarget = path.resolve(fromDir, importSpec);
-    const subPath = path.relative(this.rootDir, absTarget);
-    return this.firstGoFileInDir(absTarget, subPath);
-  }
-  firstGoFileInDir(absDir, relDir) {
-    if (!fs.existsSync(absDir))
-      return null;
-    let entries;
-    try {
-      entries = fs.readdirSync(absDir);
-    } catch {
-      return null;
-    }
-    const goFiles = entries.filter((f) => f.endsWith(".go")).sort((a, b) => {
-      const aTest = a.endsWith("_test.go") ? 1 : 0;
-      const bTest = b.endsWith("_test.go") ? 1 : 0;
-      return aTest - bTest || a.localeCompare(b);
-    });
-    if (goFiles.length === 0)
-      return null;
-    return path.join(relDir, goFiles[0]).replace(/\\/g, "/");
-  }
-};
-
-// src/utils/importExtractor.js
-var goResolverCache = /* @__PURE__ */ new Map();
-function getGoResolver(rootDir) {
-  let resolver = goResolverCache.get(rootDir);
-  if (!resolver) {
-    resolver = new GoModuleResolver(rootDir);
-    goResolverCache.set(rootDir, resolver);
-  }
-  return resolver;
-}
-function extractImports(filePath, content) {
-  const ext = path2.extname(filePath).toLowerCase();
-  switch (ext) {
-    case ".py":
-      return extractPythonImports(content);
-    case ".rs":
-      return extractRustModules(content);
-    case ".go":
-      return extractGoImports(content);
-    case ".java":
-      return extractJavaImports(content);
-    case ".cs":
-      return extractCSharpImports(content);
-    case ".rb":
-      return extractRubyImports(content);
-    case ".kt":
-    case ".kts":
-      return extractKotlinImports(content);
-    case ".swift":
-      return extractSwiftImports(content);
-    case ".php":
-      return extractPhpImports(content);
-    case ".dart":
-      return extractDartImports(content);
-    case ".ipynb":
-      return extractNotebookImports(filePath, content);
-    case ".vue":
-      return extractVueImports(content);
-    default:
-      return [];
-  }
-}
-function resolveImport(fromAbs, raw, rootDir) {
-  const ext = path2.extname(fromAbs).toLowerCase();
-  const fromDir = path2.dirname(fromAbs);
-  if (ext === ".py")
-    return resolvePythonImport(fromAbs, fromDir, raw, rootDir);
-  if (ext === ".rs")
-    return resolveRustModule(fromDir, raw, rootDir);
-  if (ext === ".go")
-    return resolveGoImportFull(fromAbs, fromDir, raw, rootDir);
-  if (ext === ".java")
-    return resolveJavaImport(fromDir, raw, rootDir);
-  if (ext === ".cs")
-    return resolveCSharpImport(fromDir, raw, rootDir);
-  if (ext === ".rb")
-    return resolveRubyImport(fromDir, raw, rootDir);
-  if (ext === ".kt" || ext === ".kts")
-    return resolveKotlinImport(fromDir, raw, rootDir);
-  if (ext === ".swift")
-    return resolveSwiftImport(fromDir, raw, rootDir);
-  if (ext === ".php")
-    return resolvePhpImport(fromAbs, fromDir, raw, rootDir);
-  if (ext === ".dart")
-    return resolveDartImport(fromAbs, fromDir, raw, rootDir);
-  if (ext === ".ipynb")
-    return resolvePythonImport(fromAbs, fromDir, raw, rootDir);
-  if (ext === ".vue")
-    return resolveVueImport(fromAbs, fromDir, raw, rootDir);
-  return null;
-}
-function extractPythonImports(content) {
-  const results = [];
-  const relFrom = /^from\s+(\.+[\w.]*)\s+import/gm;
-  let m;
-  while ((m = relFrom.exec(content)) !== null) {
-    results.push({ specifier: m[1], isRelative: true });
-  }
-  return results;
-}
-function resolvePythonImport(fromAbs, fromDir, raw, rootDir) {
-  const dotsMatch = raw.specifier.match(/^(\.+)/);
-  const dots = dotsMatch?.[1] ?? ".";
-  const modulePart = raw.specifier.slice(dots.length);
-  let baseDir = fromDir;
-  for (let i = 1; i < dots.length; i++) {
-    baseDir = path2.dirname(baseDir);
-  }
-  const modulePath = modulePart.replace(/\./g, path2.sep);
-  const candidates = modulePath ? [
-    path2.join(baseDir, modulePath + ".py"),
-    path2.join(baseDir, modulePath, "__init__.py")
-  ] : [
-    path2.join(fromDir, "__init__.py"),
-    fromAbs
-    // self — skip below
-  ];
-  for (const c of candidates) {
-    if (c !== fromAbs && fs2.existsSync(c)) {
-      return path2.relative(rootDir, c);
-    }
-  }
-  return null;
-}
-function extractRustModules(content) {
-  const results = [];
-  const modDecl = /^\s*(?:pub(?:\([\w:]+\))?\s+)?mod\s+(\w+)\s*;/gm;
-  let m;
-  while ((m = modDecl.exec(content)) !== null) {
-    results.push({ specifier: m[1], isRelative: true });
-  }
-  return results;
-}
-function resolveRustModule(fromDir, raw, rootDir) {
-  const candidates = [
-    path2.join(fromDir, raw.specifier + ".rs"),
-    path2.join(fromDir, raw.specifier, "mod.rs")
-  ];
-  for (const c of candidates) {
-    if (fs2.existsSync(c)) {
-      return path2.relative(rootDir, c);
-    }
-  }
-  return null;
-}
-function extractGoImports(content) {
-  const results = [];
-  const singleImport = /^import\s+(?:\w+\s+)?"([^"]+)"/gm;
-  let m;
-  while ((m = singleImport.exec(content)) !== null) {
-    const spec = m[1];
-    results.push({ specifier: spec, isRelative: spec.startsWith(".") });
-  }
-  const MAX_BLOCK_LEN = 512 * 1024;
-  const safeContent = content.length > MAX_BLOCK_LEN ? content.slice(0, MAX_BLOCK_LEN) : content;
-  const blockImport = /import\s*\(([^)]{0,4096})\)/gs;
-  while ((m = blockImport.exec(safeContent)) !== null) {
-    const block = m[1];
-    const lineRe = /(?:\w+\s+)?"([^"]+)"/g;
-    let lm;
-    while ((lm = lineRe.exec(block)) !== null) {
-      const spec = lm[1];
-      results.push({ specifier: spec, isRelative: spec.startsWith(".") });
-    }
-  }
-  return results;
-}
-function resolveGoImportFull(fromAbs, fromDir, raw, rootDir) {
-  if (raw.isRelative) {
-    const resolver2 = getGoResolver(rootDir);
-    return resolver2.resolveRelative(fromAbs, raw.specifier);
-  }
-  const resolver = getGoResolver(rootDir);
-  return resolver.resolve(raw.specifier);
-}
-function extractJavaImports(content) {
-  const results = [];
-  const importStmt = /^import\s+(?:static\s+)?([\w.]+)\s*;/gm;
-  let m;
-  while ((m = importStmt.exec(content)) !== null) {
-    results.push({ specifier: m[1], isRelative: false });
-  }
-  return results;
-}
-function resolveJavaImport(fromDir, raw, rootDir) {
-  const filePath = path2.join(rootDir, raw.specifier.replace(/\./g, path2.sep) + ".java");
-  if (fs2.existsSync(filePath)) {
-    return path2.relative(rootDir, filePath);
-  }
-  const localPath = path2.join(fromDir, raw.specifier.split(".").pop() + ".java");
-  if (fs2.existsSync(localPath)) {
-    return path2.relative(rootDir, localPath);
-  }
-  return null;
-}
-function extractCSharpImports(content) {
-  const results = [];
-  const usingRe = /^using\s+(?:static\s+)?([\w.]+)\s*;/gm;
-  let m;
-  while ((m = usingRe.exec(content)) !== null) {
-    results.push({ specifier: m[1], isRelative: false });
-  }
-  return results;
-}
-function resolveCSharpImport(fromDir, raw, rootDir) {
-  const filePath = path2.join(rootDir, raw.specifier.replace(/\./g, path2.sep) + ".cs");
-  if (fs2.existsSync(filePath))
-    return path2.relative(rootDir, filePath);
-  const className = raw.specifier.split(".").pop() ?? raw.specifier;
-  const local = path2.join(fromDir, className + ".cs");
-  if (fs2.existsSync(local))
-    return path2.relative(rootDir, local);
-  return null;
-}
-function extractRubyImports(content) {
-  const results = [];
-  const relRe = /require_relative\s+['"]([^'"]+)['"]/gm;
-  let m;
-  while ((m = relRe.exec(content)) !== null) {
-    results.push({ specifier: m[1], isRelative: true });
-  }
-  return results;
-}
-function resolveRubyImport(fromDir, raw, rootDir) {
-  const candidates = [
-    path2.join(fromDir, raw.specifier + ".rb"),
-    path2.join(fromDir, raw.specifier)
-  ];
-  for (const c of candidates) {
-    if (fs2.existsSync(c))
-      return path2.relative(rootDir, c);
-  }
-  return null;
-}
-function extractKotlinImports(content) {
-  const results = [];
-  const importRe = /^import\s+([\w.]+)/gm;
-  let m;
-  while ((m = importRe.exec(content)) !== null) {
-    results.push({ specifier: m[1], isRelative: false });
-  }
-  return results;
-}
-function resolveKotlinImport(fromDir, raw, rootDir) {
-  const asPath = raw.specifier.replace(/\./g, path2.sep);
-  for (const ext of [".kt", ".kts"]) {
-    const candidate = path2.join(rootDir, asPath + ext);
-    if (fs2.existsSync(candidate))
-      return path2.relative(rootDir, candidate);
-  }
-  const className = raw.specifier.split(".").pop() ?? raw.specifier;
-  const local = path2.join(fromDir, className + ".kt");
-  if (fs2.existsSync(local))
-    return path2.relative(rootDir, local);
-  return null;
-}
-function extractSwiftImports(_content) {
-  return [];
-}
-function resolveSwiftImport(_fromDir, _raw, _rootDir) {
-  return null;
-}
-function extractPhpImports(content) {
-  const results = [];
-  const requireRe = /(?:require|require_once|include|include_once)\s*\(?['"](\.[^'"]+\.php)['"]\)?/gm;
-  let m;
-  while ((m = requireRe.exec(content)) !== null) {
-    results.push({ specifier: m[1], isRelative: true });
-  }
-  const useRe = /^use\s+([\w\\]+)(?:\s+as\s+\w+)?\s*;/gm;
-  while ((m = useRe.exec(content)) !== null) {
-    results.push({ specifier: m[1], isRelative: false });
-  }
-  const groupedRe = /^use\s+([\w\\]+)\\{([^}]+)}/gm;
-  while ((m = groupedRe.exec(content)) !== null) {
-    const prefix = m[1];
-    for (const part of m[2].split(",")) {
-      const name = part.trim().replace(/\s+as\s+\w+$/, "");
-      if (name)
-        results.push({ specifier: `${prefix}\\${name}`, isRelative: false });
-    }
-  }
-  return results;
-}
-function resolvePhpImport(fromAbs, fromDir, raw, rootDir) {
-  void fromAbs;
-  if (raw.isRelative) {
-    const candidate = path2.resolve(fromDir, raw.specifier);
-    const rootResolved = path2.resolve(rootDir);
-    if (!candidate.startsWith(rootResolved + path2.sep) && candidate !== rootResolved)
-      return null;
-    if (fs2.existsSync(candidate))
-      return path2.relative(rootDir, candidate);
-    return null;
-  }
-  const asPath = raw.specifier.replace(/\\/g, path2.sep);
-  const candidates = [
-    path2.join(rootDir, "src", asPath + ".php"),
-    path2.join(rootDir, asPath + ".php"),
-    path2.join(fromDir, asPath.split(path2.sep).pop() + ".php")
-  ];
-  for (const c of candidates) {
-    if (fs2.existsSync(c))
-      return path2.relative(rootDir, c);
-  }
-  return null;
-}
-function extractDartImports(content) {
-  const results = [];
-  const importRe = /^import\s+['"](\.[^'"]+\.dart)['"]/gm;
-  let m;
-  while ((m = importRe.exec(content)) !== null) {
-    results.push({ specifier: m[1], isRelative: true });
-  }
-  return results;
-}
-function resolveDartImport(fromAbs, fromDir, raw, rootDir) {
-  void fromAbs;
-  const candidate = path2.resolve(fromDir, raw.specifier);
-  const rootResolved = path2.resolve(rootDir);
-  if (!candidate.startsWith(rootResolved + path2.sep) && candidate !== rootResolved)
-    return null;
-  if (fs2.existsSync(candidate))
-    return path2.relative(rootDir, candidate);
-  const withoutExt = path2.resolve(fromDir, raw.specifier.replace(/\.dart$/, ""));
-  const withExt = withoutExt + ".dart";
-  if (fs2.existsSync(withExt))
-    return path2.relative(rootDir, withExt);
-  return null;
-}
-function extractNotebookImports(filePath, content) {
-  void filePath;
-  const pythonSource = extractNotebookPythonSource(content);
-  if (!pythonSource)
-    return [];
-  return extractPythonImports(pythonSource);
-}
-function extractVueScriptContent(content) {
-  const match = content.match(/<script(?:\s[^>]*)?>([^]*?)<\/script>/i);
-  return match?.[1] ?? "";
-}
-function extractVueImports(content) {
-  const scriptContent = extractVueScriptContent(content);
-  if (!scriptContent.trim())
-    return [];
-  const results = [];
-  const staticImport = /import\s+(?:[^'"]*from\s+)?['"](\.[^'"]+)['"]/gm;
-  let m;
-  while ((m = staticImport.exec(scriptContent)) !== null) {
-    results.push({ specifier: m[1], isRelative: true });
-  }
-  return results;
-}
-function resolveVueImport(fromAbs, fromDir, raw, rootDir) {
-  void fromAbs;
-  const direct = path2.resolve(fromDir, raw.specifier);
-  const rootResolved = path2.resolve(rootDir);
-  if (!direct.startsWith(rootResolved + path2.sep) && direct !== rootResolved)
-    return null;
-  if (fs2.existsSync(direct))
-    return path2.relative(rootDir, direct);
-  for (const ext of [".ts", ".tsx", ".js", ".jsx", ".vue", "/index.ts", "/index.js"]) {
-    const candidate = path2.resolve(fromDir, raw.specifier.replace(/\.js$/, "") + ext);
-    if (!candidate.startsWith(rootResolved + path2.sep))
-      continue;
-    if (fs2.existsSync(candidate))
-      return path2.relative(rootDir, candidate);
-  }
-  return null;
-}
-
-// src/graph/CallGraphIndex.js
-var CallGraphIndex = class _CallGraphIndex {
-  /** calleeSymbol → Map<"callerFile:callerSymbol", EdgeConfidence> (reverse lookup) */
-  bySite = /* @__PURE__ */ new Map();
-  /** "callerFile:callerSymbol" → Set<calleeSymbol> (forward lookup) */
-  byCallerKey = /* @__PURE__ */ new Map();
-  addEdge(edge) {
-    const { callerFile, callerSymbol, calleeSymbol } = edge;
-    const confidence = edge.confidence ?? "extracted";
-    if (!this.bySite.has(calleeSymbol)) {
-      this.bySite.set(calleeSymbol, /* @__PURE__ */ new Map());
-    }
-    this.bySite.get(calleeSymbol).set(`${callerFile}:${callerSymbol}`, confidence);
-    const callerKey = `${callerFile}:${callerSymbol}`;
-    if (!this.byCallerKey.has(callerKey)) {
-      this.byCallerKey.set(callerKey, /* @__PURE__ */ new Set());
-    }
-    this.byCallerKey.get(callerKey).add(calleeSymbol);
-  }
-  /**
-   * Returns all symbols called by the given function in the given file.
-   */
-  getCallees(callerFile, callerSymbol) {
-    const key = `${callerFile}:${callerSymbol}`;
-    return Array.from(this.byCallerKey.get(key) ?? []);
-  }
-  /**
-   * Returns all files that contain the symbol as a caller (i.e., files where
-   * this symbol has outgoing call edges). Used to resolve callee definition
-   * file when the symbol index has no entry (e.g. in test graphs).
-   */
-  findFilesForCallerSymbol(symbol) {
-    const suffix = `:${symbol}`;
-    const files = [];
-    for (const key of this.byCallerKey.keys()) {
-      if (key.endsWith(suffix)) {
-        files.push(key.slice(0, key.length - suffix.length));
-      }
-    }
-    return files;
-  }
-  /**
-   * Returns all callers of the given symbol across all indexed files.
-   * Optionally filters by confidence tier.
-   */
-  getCallers(symbol, confidenceFilter) {
-    const callerMap = this.bySite.get(symbol);
-    if (!callerMap)
-      return [];
-    const results = [];
-    for (const [key, confidence] of callerMap.entries()) {
-      if (confidenceFilter !== void 0 && confidence !== confidenceFilter) {
-        continue;
-      }
-      const idx = key.indexOf(":");
-      const file = idx >= 0 ? key.slice(0, idx) : key;
-      const symbol_ = idx >= 0 ? key.slice(idx + 1) : "";
-      results.push({ file, symbol: symbol_, callerSymbol: symbol_, confidence });
-    }
-    return results;
-  }
-  /**
-   * Remove all call edges where callerFile is the given file.
-   * Called before re-indexing a file to prevent stale edges.
-   */
-  removeEdgesForFile(callerFile) {
-    const prefix = callerFile + ":";
-    for (const [callee, callerMap] of this.bySite.entries()) {
-      for (const key of callerMap.keys()) {
-        if (key === callerFile || key.startsWith(prefix)) {
-          callerMap.delete(key);
-        }
-      }
-      if (callerMap.size === 0) {
-        this.bySite.delete(callee);
-      }
-    }
-    for (const key of this.byCallerKey.keys()) {
-      if (key === callerFile || key.startsWith(prefix)) {
-        this.byCallerKey.delete(key);
-      }
-    }
-  }
-  /** Total number of distinct caller→callee edges. */
-  size() {
-    let n = 0;
-    for (const m of this.bySite.values())
-      n += m.size;
-    return n;
-  }
-  toJSON() {
-    return {
-      bySite: Object.fromEntries(Array.from(this.bySite.entries()).map(([callee, callerMap]) => [
-        callee,
-        Array.from(callerMap.entries()).map(([callerKey, confidence]) => ({ callerKey, confidence }))
-      ]))
-    };
-  }
-  static fromJSON(data) {
-    const idx = new _CallGraphIndex();
-    if (!data || typeof data !== "object")
-      return idx;
-    const { bySite } = data;
-    if (!bySite || typeof bySite !== "object")
-      return idx;
-    for (const [callee, edges] of Object.entries(bySite)) {
-      if (!Array.isArray(edges))
-        continue;
-      for (const edge of edges) {
-        if (typeof edge === "string") {
-          if (!idx.bySite.has(callee)) {
-            idx.bySite.set(callee, /* @__PURE__ */ new Map());
-          }
-          idx.bySite.get(callee).set(edge, "extracted");
-          if (!idx.byCallerKey.has(edge)) {
-            idx.byCallerKey.set(edge, /* @__PURE__ */ new Set());
-          }
-          idx.byCallerKey.get(edge).add(callee);
-        } else if (edge && typeof edge === "object" && "callerKey" in edge) {
-          const { callerKey, confidence } = edge;
-          if (typeof callerKey !== "string")
-            continue;
-          const resolvedConfidence = confidence === "inferred" || confidence === "ambiguous" ? confidence : "extracted";
-          if (!idx.bySite.has(callee)) {
-            idx.bySite.set(callee, /* @__PURE__ */ new Map());
-          }
-          idx.bySite.get(callee).set(callerKey, resolvedConfidence);
-          if (!idx.byCallerKey.has(callerKey)) {
-            idx.byCallerKey.set(callerKey, /* @__PURE__ */ new Set());
-          }
-          idx.byCallerKey.get(callerKey).add(callee);
-        }
-      }
-    }
-    return idx;
-  }
-};
-
-// src/graph/DependencyGraph.js
-var TS_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".vue"]);
-var AST_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".py", ".go", ".rs", ".java", ".cs", ".rb", ".kt", ".kts", ".swift", ".ipynb", ".php", ".dart"]);
-var DependencyGraph = class {
-  /** file → set of files it imports (forward edges) */
-  forwardEdges = /* @__PURE__ */ new Map();
-  /** file → set of files that import it (reverse edges) */
-  reverseEdges = /* @__PURE__ */ new Map();
-  /** Symbol index: symbolName → { filePath, type, signature, startLine?, endLine? } */
-  symbolIndex = /* @__PURE__ */ new Map();
-  callGraphIndex = new CallGraphIndex();
-  parser = null;
-  rootDir = "";
-  snapshotDir = "";
-  /**
-   * Build the graph from all supported files in rootDir using AST parsing.
-   */
-  async buildFromDirectory(rootDir) {
-    this.rootDir = rootDir;
-    this.snapshotDir = path3.join(rootDir, ".ctxloom");
-    const files = collectFiles(rootDir);
-    if (await this.loadSnapshot(files.length)) {
-      logger.info("Loaded graph from snapshot", { edges: this.edgeCount() });
-      return;
-    }
-    if (!this.parser) {
-      this.parser = new ASTParser();
-      await this.parser.init();
-    }
-    for (const absPath of files) {
-      const relPath = path3.relative(rootDir, absPath);
-      const ext = path3.extname(absPath).toLowerCase();
-      try {
-        if (!this.forwardEdges.has(relPath)) {
-          this.forwardEdges.set(relPath, /* @__PURE__ */ new Set());
-        }
-        if (AST_EXTENSIONS.has(ext)) {
-          const nodes = await this.parser.parse(absPath);
-          if (TS_EXTENSIONS.has(ext)) {
-            const importNodes = nodes.filter((n) => n.type === "import");
-            for (const imp of importNodes) {
-              const src = imp.source ?? "";
-              if (!src.startsWith("."))
-                continue;
-              const resolved = this.resolveImport(absPath, src, rootDir);
-              if (resolved)
-                this.addEdge(relPath, resolved);
-            }
-          } else if (ext === ".go") {
-            const goResolver = new GoModuleResolver(rootDir);
-            const importNodes = nodes.filter((n) => n.type === "import");
-            for (const imp of importNodes) {
-              const spec = imp.source ?? imp.name;
-              const isRelative = spec.startsWith(".");
-              const resolved = isRelative ? goResolver.resolveRelative(absPath, spec) : goResolver.resolve(spec);
-              if (resolved)
-                this.addEdge(relPath, resolved);
-            }
-          } else {
-            const importNodes = nodes.filter((n) => n.type === "import");
-            if (importNodes.length > 0) {
-              for (const imp of importNodes) {
-                const specifier = imp.source ?? imp.name;
-                const isRelative = specifier.startsWith(".");
-                const resolved = resolveImport(absPath, { specifier, isRelative }, rootDir);
-                if (resolved)
-                  this.addEdge(relPath, resolved);
-              }
-            } else {
-              const content = fs3.readFileSync(absPath, "utf-8");
-              const rawImports = extractImports(absPath, content);
-              for (const raw of rawImports) {
-                const resolved = resolveImport(absPath, raw, rootDir);
-                if (resolved)
-                  this.addEdge(relPath, resolved);
-              }
-            }
-          }
-          for (const node of nodes) {
-            if (node.type === "function" || node.type === "class" || node.type === "interface") {
-              const existing = this.symbolIndex.get(node.name) ?? [];
-              existing.push({
-                filePath: relPath,
-                type: node.type,
-                signature: node.signature ?? `${node.type} ${node.name}`,
-                startLine: node.startLine,
-                endLine: node.endLine
-              });
-              this.symbolIndex.set(node.name, existing);
-            }
-          }
-          if (TS_EXTENSIONS.has(ext)) {
-            const callEdges = await this.parser.parseAllCallEdges(absPath);
-            for (const edge of callEdges) {
-              this.callGraphIndex.addEdge({ callerFile: relPath, ...edge });
-            }
-          }
-        } else {
-          const content = fs3.readFileSync(absPath, "utf-8");
-          const rawImports = extractImports(absPath, content);
-          for (const raw of rawImports) {
-            const resolved = resolveImport(absPath, raw, rootDir);
-            if (resolved)
-              this.addEdge(relPath, resolved);
-          }
-        }
-      } catch (err) {
-        logger.error("Failed to parse", { file: relPath, detail: err instanceof Error ? err.message : String(err) });
-      }
-    }
-    await this.saveSnapshot();
-    logger.info("Graph built", { files: files.length, edges: this.edgeCount() });
-  }
-  /**
-   * Set the ASTParser instance (avoids re-initialization).
-   */
-  setParser(parser) {
-    this.parser = parser;
-  }
-  /**
-   * Get files that the given file directly imports.
-   */
-  getImports(fileRel) {
-    return Array.from(this.forwardEdges.get(fileRel) ?? []);
-  }
-  /**
-   * Get files that import the given file.
-   */
-  getImporters(fileRel) {
-    return Array.from(this.reverseEdges.get(fileRel) ?? []);
-  }
-  /**
-   * Look up a symbol by name. Returns all definitions across files.
-   */
-  lookupSymbol(name) {
-    return this.symbolIndex.get(name) ?? [];
-  }
-  /**
-   * Return all symbol names defined in a given file.
-   */
-  lookupSymbolsByFile(fileRel) {
-    const results = [];
-    for (const [name, entries] of this.symbolIndex.entries()) {
-      if (entries.some((e) => e.filePath === fileRel)) {
-        results.push(name);
-      }
-    }
-    return results;
-  }
-  /**
-   * Iterate all symbol entries. Used by ctx_find_large_functions.
-   */
-  symbolEntries() {
-    return this.symbolIndex.entries();
-  }
-  /** Return the pre-built call graph index (TypeScript/TSX only). */
-  getCallGraphIndex() {
-    return this.callGraphIndex;
-  }
-  /**
-   * Traverse the call graph bidirectionally with configurable depth.
-   * direction: 'callers' = reverse edges (who imports me)
-   *            'callees' = forward edges (who do I import)
-   */
-  traverse(startFile, direction, depth = 1) {
-    const MAX_DEPTH = 10;
-    depth = Math.min(depth, MAX_DEPTH);
-    const visited = /* @__PURE__ */ new Set();
-    const queue = [{ file: startFile, currentDepth: 0 }];
-    while (queue.length > 0) {
-      const { file, currentDepth } = queue.shift();
-      if (visited.has(file))
-        continue;
-      visited.add(file);
-      if (currentDepth < depth) {
-        const edges = direction === "callers" ? this.getImporters(file) : this.getImports(file);
-        for (const next of edges) {
-          if (!visited.has(next)) {
-            queue.push({ file: next, currentDepth: currentDepth + 1 });
-          }
-        }
-      }
-    }
-    visited.delete(startFile);
-    return Array.from(visited);
-  }
-  /**
-   * Add a symbol to the index (primarily used for testing and incremental updates).
-   */
-  addSymbol(filePath, symbol) {
-    const existing = this.symbolIndex.get(symbol.name) ?? [];
-    existing.push({
-      filePath,
-      type: symbol.type,
-      signature: symbol.signature,
-      startLine: symbol.startLine,
-      endLine: symbol.endLine
-    });
-    this.symbolIndex.set(symbol.name, existing);
-    if (!this.forwardEdges.has(filePath)) {
-      this.forwardEdges.set(filePath, /* @__PURE__ */ new Set());
-    }
-  }
-  /**
-   * Add a directed edge: fromFile imports toFile.
-   */
-  addEdge(fromFile, toFile) {
-    if (!this.forwardEdges.has(fromFile)) {
-      this.forwardEdges.set(fromFile, /* @__PURE__ */ new Set());
-    }
-    this.forwardEdges.get(fromFile).add(toFile);
-    if (!this.reverseEdges.has(toFile)) {
-      this.reverseEdges.set(toFile, /* @__PURE__ */ new Set());
-    }
-    this.reverseEdges.get(toFile).add(fromFile);
-  }
-  /**
-   * Remove all edges involving a file (used when a file is deleted or re-indexed).
-   */
-  removeFile(fileRel) {
-    const imports = this.forwardEdges.get(fileRel);
-    if (imports) {
-      for (const imp of imports) {
-        this.reverseEdges.get(imp)?.delete(fileRel);
-      }
-      this.forwardEdges.delete(fileRel);
-    }
-    const importers = this.reverseEdges.get(fileRel);
-    if (importers) {
-      for (const imp of importers) {
-        this.forwardEdges.get(imp)?.delete(fileRel);
-      }
-      this.reverseEdges.delete(fileRel);
-    }
-  }
-  /**
-   * Incrementally update the graph for a single changed file.
-   * Removes stale edges, re-parses imports, and rebuilds the symbol index
-   * entries for this file. Saves a new snapshot after the update.
-   */
-  async updateFile(absPath, rootDir) {
-    if (!this.parser) {
-      logger.warn("DependencyGraph.updateFile: no parser set, skipping graph update");
-      return;
-    }
-    const relPath = path3.relative(rootDir, absPath);
-    this.removeFile(relPath);
-    if (!this.forwardEdges.has(relPath)) {
-      this.forwardEdges.set(relPath, /* @__PURE__ */ new Set());
-    }
-    this.callGraphIndex.removeEdgesForFile(relPath);
-    for (const [symbol, entries] of this.symbolIndex.entries()) {
-      const filtered = entries.filter((e) => e.filePath !== relPath);
-      if (filtered.length === 0) {
-        this.symbolIndex.delete(symbol);
-      } else {
-        this.symbolIndex.set(symbol, filtered);
-      }
-    }
-    const ext = path3.extname(absPath).toLowerCase();
-    try {
-      if (AST_EXTENSIONS.has(ext)) {
-        const nodes = await this.parser.parse(absPath);
-        if (TS_EXTENSIONS.has(ext)) {
-          const importNodes = nodes.filter((n) => n.type === "import");
-          for (const importNode of importNodes) {
-            const src = importNode.source ?? "";
-            if (!src.startsWith("."))
-              continue;
-            const resolved = this.resolveImport(absPath, src, rootDir);
-            if (resolved)
-              this.addEdge(relPath, resolved);
-          }
-        } else if (ext === ".go") {
-          const goResolver = new GoModuleResolver(rootDir);
-          const importNodes = nodes.filter((n) => n.type === "import");
-          for (const imp of importNodes) {
-            const spec = imp.source ?? imp.name;
-            const isRelative = spec.startsWith(".");
-            const resolved = isRelative ? goResolver.resolveRelative(absPath, spec) : goResolver.resolve(spec);
-            if (resolved)
-              this.addEdge(relPath, resolved);
-          }
-        } else {
-          const importNodes = nodes.filter((n) => n.type === "import");
-          if (importNodes.length > 0) {
-            for (const imp of importNodes) {
-              const specifier = imp.source ?? imp.name;
-              const isRelative = specifier.startsWith(".");
-              const resolved = resolveImport(absPath, { specifier, isRelative }, rootDir);
-              if (resolved)
-                this.addEdge(relPath, resolved);
-            }
-          } else {
-            const content = fs3.readFileSync(absPath, "utf-8");
-            const rawImports = extractImports(absPath, content);
-            for (const raw of rawImports) {
-              const resolved = resolveImport(absPath, raw, rootDir);
-              if (resolved)
-                this.addEdge(relPath, resolved);
-            }
-          }
-        }
-        for (const node of nodes) {
-          if (node.type === "function" || node.type === "class" || node.type === "interface") {
-            const existing = this.symbolIndex.get(node.name) ?? [];
-            existing.push({
-              filePath: relPath,
-              type: node.type,
-              signature: node.signature ?? `${node.type} ${node.name}`,
-              startLine: node.startLine,
-              endLine: node.endLine
-            });
-            this.symbolIndex.set(node.name, existing);
-          }
-        }
-        if (TS_EXTENSIONS.has(ext)) {
-          const callEdges = await this.parser.parseAllCallEdges(absPath);
-          for (const edge of callEdges) {
-            this.callGraphIndex.addEdge({ callerFile: relPath, ...edge });
-          }
-        }
-      } else {
-        const content = fs3.readFileSync(absPath, "utf-8");
-        const rawImports = extractImports(absPath, content);
-        for (const raw of rawImports) {
-          const resolved = resolveImport(absPath, raw, rootDir);
-          if (resolved)
-            this.addEdge(relPath, resolved);
-        }
-      }
-      logger.info("Graph updated", { file: relPath, edges: this.edgeCount() });
-    } catch (err) {
-      logger.error("Failed to update graph", { file: relPath, detail: err instanceof Error ? err.message : String(err) });
-    }
-    this.saveSnapshot();
-  }
-  /**
-   * Get total number of edges in the graph.
-   */
-  edgeCount() {
-    let count = 0;
-    for (const edges of this.forwardEdges.values()) {
-      count += edges.size;
-    }
-    return count;
-  }
-  /**
-   * Get all files in the graph.
-   */
-  allFiles() {
-    const files = /* @__PURE__ */ new Set();
-    for (const [file] of this.forwardEdges)
-      files.add(file);
-    for (const [file] of this.reverseEdges)
-      files.add(file);
-    return Array.from(files);
-  }
-  // ─── Snapshot persistence ──────────────────────────────────────────────
-  getSnapshotPath() {
-    return path3.join(this.snapshotDir, "graph-snapshot.json");
-  }
-  async saveSnapshot() {
-    if (!this.snapshotDir)
-      return;
-    if (!fs3.existsSync(this.snapshotDir)) {
-      fs3.mkdirSync(this.snapshotDir, { recursive: true });
-    }
-    const data = {
-      version: 1,
-      builtAt: Date.now(),
-      fileCount: this.forwardEdges.size,
-      forwardEdges: Object.fromEntries(Array.from(this.forwardEdges.entries()).map(([k, v]) => [k, Array.from(v)])),
-      reverseEdges: Object.fromEntries(Array.from(this.reverseEdges.entries()).map(([k, v]) => [k, Array.from(v)])),
-      symbolIndex: Object.fromEntries(this.symbolIndex.entries())
-    };
-    const snapshotPath = this.getSnapshotPath();
-    const tmpPath = snapshotPath + ".tmp";
-    fs3.writeFileSync(tmpPath, JSON.stringify(data, null, 2));
-    fs3.renameSync(tmpPath, snapshotPath);
-    const callData = this.callGraphIndex.toJSON();
-    const callPath = path3.join(this.snapshotDir, "call-graph-snapshot.json");
-    const callTmp = callPath + ".tmp";
-    fs3.writeFileSync(callTmp, JSON.stringify(callData));
-    fs3.renameSync(callTmp, callPath);
-  }
-  /** M-2: Validate snapshot shape before hydrating to prevent prototype pollution. */
-  isValidSnapshot(data) {
-    if (!data || typeof data !== "object")
-      return false;
-    const d = data;
-    if (typeof d["version"] !== "number")
-      return false;
-    if (!d["forwardEdges"] || typeof d["forwardEdges"] !== "object")
-      return false;
-    if (!d["reverseEdges"] || typeof d["reverseEdges"] !== "object")
-      return false;
-    for (const v of Object.values(d["forwardEdges"])) {
-      if (!Array.isArray(v) || !v.every((s) => typeof s === "string"))
-        return false;
-    }
-    for (const v of Object.values(d["reverseEdges"])) {
-      if (!Array.isArray(v) || !v.every((s) => typeof s === "string"))
-        return false;
-    }
-    return true;
-  }
-  async loadSnapshot(currentFileCount) {
-    const snapshotPath = this.getSnapshotPath();
-    if (!fs3.existsSync(snapshotPath))
-      return false;
-    try {
-      const raw = JSON.parse(fs3.readFileSync(snapshotPath, "utf-8"));
-      if (!this.isValidSnapshot(raw)) {
-        logger.warn("Graph snapshot failed schema validation, will rebuild");
-        return false;
-      }
-      const data = raw;
-      if (currentFileCount !== void 0 && data.fileCount !== void 0) {
-        if (data.fileCount !== currentFileCount) {
-          logger.info("Graph snapshot stale, rebuilding", { prev: data.fileCount, curr: currentFileCount });
-          return false;
-        }
-      }
-      this.forwardEdges = new Map(Object.entries(data.forwardEdges).map(([k, v]) => [k, new Set(v)]));
-      this.reverseEdges = new Map(Object.entries(data.reverseEdges).map(([k, v]) => [k, new Set(v)]));
-      if (data.symbolIndex) {
-        this.symbolIndex = new Map(Object.entries(data.symbolIndex));
-      }
-      const callPath = path3.join(this.snapshotDir, "call-graph-snapshot.json");
-      if (fs3.existsSync(callPath)) {
-        try {
-          const callRaw = JSON.parse(fs3.readFileSync(callPath, "utf-8"));
-          this.callGraphIndex = CallGraphIndex.fromJSON(callRaw);
-        } catch {
-          this.callGraphIndex = new CallGraphIndex();
-        }
-      }
-      return true;
-    } catch (err) {
-      logger.error("Failed to load graph snapshot, will rebuild", { detail: err instanceof Error ? err.message : String(err) });
-      return false;
-    }
-  }
-  resolveImport(fromAbs, specifier, rootDir) {
-    const dir = path3.dirname(fromAbs);
-    for (const ext of ["", ".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.js"]) {
-      const candidate = path3.resolve(dir, specifier.replace(/\.js$/, "") + ext);
-      if (fs3.existsSync(candidate)) {
-        return path3.relative(rootDir, candidate);
-      }
-    }
-    return null;
-  }
-};
-
-export {
-  DependencyGraph
-};
-//# sourceMappingURL=chunk-RE2V3FRF.js.map