ctxloom-pro 1.5.6 → 1.7.0

package/dist/{chunk-FPMNXF4D.js → chunk-FFCLVZCO.js}

@@ -1,10 +1,11 @@
 import {
   VectorStore
-} from "./chunk-JULFFD7O.js";
+} from "./chunk-7S2ELKNU.js";
 import {
+  INDEXER_IGNORED_DIRS,
   collectFiles,
   generateEmbedding
-} from "./chunk-WDX4PJGL.js";
+} from "./chunk-6FGTNOCP.js";
 import {
   diskSink,
   readEvents
@@ -503,6 +504,13 @@ var ASTParser = class {
   extractTSNodes(rootNode, _filePath, lines) {
     const nodes = [];
     const processedIds = /* @__PURE__ */ new Set();
+    const hasCallableRight = (n) => {
+      const right = n.childForFieldName?.("right") ?? n.children[n.children.length - 1];
+      if (!right) return false;
+      if (right.type === "function" || right.type === "function_expression" || right.type === "arrow_function" || right.type === "function_declaration") return true;
+      if (right.type === "assignment_expression") return hasCallableRight(right);
+      return false;
+    };
     const walk = (node) => {
       if (processedIds.has(node.id)) return;
       switch (node.type) {
@@ -674,6 +682,56 @@ var ASTParser = class {
           processedIds.add(node.id);
           return;
         }
+        // ─── Prototype / object method assignments ──────────────────────
+        // CommonJS libraries (and pre-class-syntax ES) attach their public
+        // API via assignment expressions:
+        //
+        //   res.send = function send(body) { ... }
+        //   res.json = function (obj) { ... }
+        //   res.contentType = res.type = function (type) { ... }    // chained
+        //   exports.foo = function foo() { ... }
+        //   MyClass.prototype.bar = function () { ... }
+        //
+        // Without this case, none of those names enter the symbol index,
+        // so `lookupSymbolsByFile()` returns empty for libraries like
+        // express, and any downstream tool that wants to attribute callers
+        // to a file (blast-radius symbolCallers, ctx_get_definition, etc.)
+        // falls flat. The call graph itself already records callers of
+        // `send`/`json`/etc. — this case bridges the gap so we can match
+        // them back to the file that defines them.
+        //
+        // Heuristic:
+        //   - left  = member_expression  → use the FINAL property as symbol
+        //   - right = function | arrow_function | function_expression
+        //   - right = assignment_expression → recurse for chained pattern
+        // Anything else (constants, identifiers being aliased) is skipped
+        // intentionally — those aren't callable API surface.
+        case "assignment_expression": {
+          const left = node.childForFieldName?.("left") ?? node.children.find(
+            (c) => c?.type === "member_expression" || c?.type === "identifier"
+          );
+          const right = node.childForFieldName?.("right") ?? node.children[node.children.length - 1];
+          if (left?.type === "member_expression" && right) {
+            const prop = left.childForFieldName?.("property") ?? left.children[left.children.length - 1];
+            const propName = prop?.text;
+            if (right.type === "assignment_expression") {
+              walk(right);
+            }
+            const rightIsCallable = right.type === "function" || right.type === "function_expression" || right.type === "arrow_function" || right.type === "function_declaration" || right.type === "assignment_expression" && hasCallableRight(right);
+            if (propName && rightIsCallable && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(propName)) {
+              const sig = lines[node.startPosition.row] ?? "";
+              nodes.push({
+                type: "method",
+                name: propName,
+                signature: sig.trim().slice(0, 200),
+                startLine: node.startPosition.row + 1,
+                endLine: node.endPosition.row + 1
+              });
+            }
+          }
+          processedIds.add(node.id);
+          return;
+        }
         // ─── Lexical declarations (const fn = () => {}) ────────────────
         case "lexical_declaration": {
           for (const child of node.children) {
@@ -780,10 +838,34 @@ var ASTParser = class {
         }
         case "import_from_statement": {
           const moduleNode = node.children.find((c) => c?.type === "dotted_name" || c?.type === "relative_import");
+          const sourceText = moduleNode?.text ?? "";
+          const importedNames = [];
+          let pastImportKeyword = false;
+          for (const child of node.children) {
+            if (!child) continue;
+            if (child.text === "import" && (child.type === "import" || child.children.length === 0)) {
+              pastImportKeyword = true;
+              continue;
+            }
+            if (!pastImportKeyword) continue;
+            if (child.type === "wildcard_import") continue;
+            if (child.type === "dotted_name") {
+              importedNames.push(child.text);
+            } else if (child.type === "aliased_import") {
+              const alias = child.childForFieldName?.("alias");
+              const aliasName = alias?.text;
+              if (aliasName) importedNames.push(aliasName);
+              else {
+                const name = child.childForFieldName?.("name")?.text;
+                if (name) importedNames.push(name);
+              }
+            }
+          }
           nodes.push({
             type: "import",
-            name: moduleNode?.text ?? "",
-            source: moduleNode?.text ?? "",
+            name: sourceText,
+            source: sourceText,
+            importedNames: importedNames.length > 0 ? importedNames : void 0,
             startLine: node.startPosition.row + 1,
             endLine: node.endPosition.row + 1
           });
@@ -1653,6 +1735,78 @@ var ASTParser = class {
       tree.delete();
     }
   }
+  /**
+   * Extract all call edges in a Python (.py / .ipynb) file. Mirrors
+   * `parseAllCallEdges` but uses tree-sitter-python node types.
+   *
+   * Tree-sitter-python relevant shapes:
+   *   - call.function = identifier "foo"         → callee = "foo"
+   *   - call.function = attribute (obj.method)   → callee = "method"
+   *   - call.function = call (chained)           → recurse into inner
+   *
+   * Enclosing-context tracking follows the same pattern: track the
+   * innermost `function_definition`. Methods inside a class are also
+   * function_definitions, so the same handler covers them.
+   */
+  async parseAllPythonCallEdges(filePath) {
+    if (!this.pyLang) await this.loadPython();
+    if (!this.pyLang) return [];
+    const parser = this.getParser(this.pyLang);
+    let source;
+    try {
+      const raw = fs2.readFileSync(filePath, "utf-8");
+      source = filePath.endsWith(".ipynb") ? extractNotebookPythonSource(raw) : raw;
+    } catch {
+      return [];
+    }
+    if (!source.trim()) return [];
+    const tree = parser.parse(source);
+    if (!tree) return [];
+    const results = [];
+    const extractCalleeName = (fn) => {
+      if (fn.type === "identifier") return fn.text;
+      if (fn.type === "attribute") {
+        const right = fn.childForFieldName?.("attribute") ?? fn.children[fn.children.length - 1];
+        return right?.text ?? "";
+      }
+      if (fn.type === "call") {
+        const innerFn = fn.childForFieldName?.("function");
+        return innerFn ? extractCalleeName(innerFn) : "";
+      }
+      return "";
+    };
+    const walk = (node, contextStack) => {
+      let newStack = contextStack;
+      if (node.type === "function_definition") {
+        const nameNode = node.childForFieldName?.("name");
+        if (nameNode?.text) {
+          newStack = [...contextStack, nameNode.text];
+        }
+      }
+      if (node.type === "call") {
+        const fn = node.childForFieldName?.("function") ?? node.children.find((c) => c?.type === "identifier" || c?.type === "attribute" || c?.type === "call");
+        if (fn) {
+          const name = extractCalleeName(fn);
+          if (name && name.length > 0) {
+            results.push({
+              callerSymbol: newStack[newStack.length - 1] ?? "",
+              calleeSymbol: name,
+              line: node.startPosition.row + 1
+            });
+          }
+        }
+      }
+      for (const child of node.children) {
+        if (child) walk(child, newStack);
+      }
+    };
+    try {
+      walk(tree.rootNode, []);
+      return results;
+    } finally {
+      tree.delete();
+    }
+  }
   /**
    * Extract all call edges in a TypeScript/TSX file.
    * Tracks the enclosing function/method context for each call site.
@@ -1735,48 +1889,100 @@ var GoModuleResolver = class {
   }
   /**
    * Resolve a module-path import (e.g. `github.com/myorg/myapp/internal/auth`)
-   * to a relative project path (e.g. `internal/auth/auth.go`).
+   * to the FIRST 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
+   *
+   * NOTE: A Go import imports a PACKAGE (a directory of .go files), not a
+   * single file. Use `resolveAll()` to get every file in the package — that
+   * matches Go's compile-unit semantics and is what the graph wants for
+   * accurate reachability. `resolve()` is kept for back-compat callers
+   * that only need a representative file.
    */
   resolve(importPath) {
-    if (!this.modulePath) return null;
-    if (importPath.startsWith(".")) return null;
-    if (!importPath.startsWith(this.modulePath)) return null;
+    const all = this.resolveAll(importPath);
+    return all[0] ?? null;
+  }
+  /**
+   * Resolve a module-path import to ALL non-test .go files in the target
+   * package directory. This matches Go's compile-unit semantics: a single
+   * `import "github.com/foo/bar/pkg"` statement brings the entire `pkg/`
+   * directory into the dependency graph — every exported symbol from
+   * every .go file in that directory is accessible to the caller.
+   *
+   * Pre-fix the resolver returned only ONE file per import, which made
+   * gin's `binding/` package (~20 files) appear to be a single file from
+   * the graph's perspective. The bench's graphReachability on gin
+   * collapsed to 0.32 because PRs that touched 4 files in `binding/`
+   * had only ONE of them in the graph reach of the entry-point file.
+   * Returning ALL package files fixes the structural model.
+   *
+   * Test files (_test.go) are intentionally excluded — they're not part
+   * of a package's public API and aren't imported by callers. The
+   * test↔source link is handled separately by per-directory sibling
+   * edges (see DependencyGraph's Go intra-package pass).
+   */
+  resolveAll(importPath) {
+    if (!this.modulePath) return [];
+    if (importPath.startsWith(".")) return [];
+    if (!importPath.startsWith(this.modulePath)) return [];
     const suffix = importPath.slice(this.modulePath.length);
-    if (!suffix) return null;
+    if (!suffix) return [];
     const subPath = suffix.startsWith("/") ? suffix.slice(1) : suffix;
     const absDir = path3.join(this.rootDir, subPath);
-    return this.firstGoFileInDir(absDir, subPath);
+    return this.allGoFilesInDir(
+      absDir,
+      subPath,
+      /* includeTests */
+      false
+    );
   }
   /**
    * 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.
+   * Kept for back-compat — most callers should prefer `resolveRelativeAll()`.
    */
   resolveRelative(fromFile, importSpec) {
+    const all = this.resolveRelativeAll(fromFile, importSpec);
+    return all[0] ?? null;
+  }
+  /**
+   * Resolve a relative import to ALL non-test .go files in the target
+   * package directory. See `resolveAll()` for rationale.
+   */
+  resolveRelativeAll(fromFile, importSpec) {
     const fromDir = path3.dirname(fromFile);
     const absTarget = path3.resolve(fromDir, importSpec);
     const subPath = path3.relative(this.rootDir, absTarget);
-    return this.firstGoFileInDir(absTarget, subPath);
+    return this.allGoFilesInDir(
+      absTarget,
+      subPath,
+      /* includeTests */
+      false
+    );
   }
-  firstGoFileInDir(absDir, relDir) {
-    if (!fs3.existsSync(absDir)) return null;
+  /**
+   * Enumerate every .go file in a directory, returning project-relative
+   * paths sorted with non-test files first. Used by both the single-file
+   * and all-files resolvers.
+   */
+  allGoFilesInDir(absDir, relDir, includeTests) {
+    if (!fs3.existsSync(absDir)) return [];
     let entries;
     try {
       entries = fs3.readdirSync(absDir);
     } catch {
-      return null;
+      return [];
     }
-    const goFiles = entries.filter((f) => f.endsWith(".go")).sort((a, b) => {
+    const goFiles = entries.filter((f) => f.endsWith(".go")).filter((f) => includeTests || !f.endsWith("_test.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 path3.join(relDir, goFiles[0]).replace(/\\/g, "/");
+    return goFiles.map((f) => path3.join(relDir, f).replace(/\\/g, "/"));
   }
 };
 
@@ -1818,6 +2024,24 @@ function extractImports(filePath, content) {
       return extractNotebookImports(filePath, content);
     case ".vue":
       return extractVueImports(content);
+    case ".c":
+    case ".cc":
+    case ".cpp":
+    case ".cxx":
+    case ".h":
+    case ".hh":
+    case ".hpp":
+    case ".hxx":
+      return extractCppImports(content);
+    case ".scala":
+      return extractScalaImports(content);
+    case ".lua":
+      return extractLuaImports(content);
+    case ".ex":
+    case ".exs":
+      return extractElixirImports(content);
+    case ".zig":
+      return extractZigImports(content);
     default:
       return [];
   }
@@ -1837,8 +2061,14 @@ function resolveImport(fromAbs, 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);
+  if (CPP_EXTENSIONS.has(ext)) return resolveCppImport(fromDir, raw, rootDir);
+  if (ext === ".scala") return resolveScalaImport(fromDir, raw, rootDir);
+  if (ext === ".lua") return resolveLuaImport(fromDir, raw, rootDir);
+  if (ext === ".ex" || ext === ".exs") return resolveElixirImport(fromDir, raw, rootDir);
+  if (ext === ".zig") return resolveZigImport(fromAbs, fromDir, raw, rootDir);
   return null;
 }
+var CPP_EXTENSIONS = /* @__PURE__ */ new Set([".c", ".cc", ".cpp", ".cxx", ".h", ".hh", ".hpp", ".hxx"]);
 function extractPythonImports(content) {
   const results = [];
   let m;
@@ -2125,6 +2355,124 @@ function resolveVueImport(fromAbs, fromDir, raw, rootDir) {
   }
   return null;
 }
+function extractCppImports(content) {
+  const results = [];
+  const localInclude = /^\s*#\s*include\s+"([^"]+)"/gm;
+  let m;
+  while ((m = localInclude.exec(content)) !== null) {
+    results.push({ specifier: m[1], isRelative: true });
+  }
+  return results;
+}
+function resolveCppImport(fromDir, raw, rootDir) {
+  const rootResolved = path4.resolve(rootDir);
+  const candidates = [
+    path4.resolve(fromDir, raw.specifier),
+    path4.resolve(rootDir, raw.specifier)
+  ];
+  for (const c of candidates) {
+    if (!c.startsWith(rootResolved + path4.sep) && c !== rootResolved) continue;
+    if (fs4.existsSync(c)) return path4.relative(rootDir, c);
+  }
+  return null;
+}
+function extractScalaImports(content) {
+  const results = [];
+  const importRe = /^\s*import\s+((?:\w+\.)*\w+)(?:\.\{[^}]+\})?/gm;
+  let m;
+  while ((m = importRe.exec(content)) !== null) {
+    results.push({ specifier: m[1], isRelative: false });
+  }
+  return results;
+}
+function resolveScalaImport(fromDir, raw, rootDir) {
+  const asPath = raw.specifier.replace(/\./g, path4.sep);
+  const candidates = [
+    path4.join(rootDir, "src", "main", "scala", asPath + ".scala"),
+    path4.join(rootDir, asPath + ".scala")
+  ];
+  for (const c of candidates) {
+    if (fs4.existsSync(c)) return path4.relative(rootDir, c);
+  }
+  const className = raw.specifier.split(".").pop() ?? raw.specifier;
+  const local = path4.join(fromDir, className + ".scala");
+  if (fs4.existsSync(local)) return path4.relative(rootDir, local);
+  return null;
+}
+function extractLuaImports(content) {
+  const results = [];
+  const requireRe = /\brequire\s*\(?\s*['"]([^'"]+)['"]/g;
+  let m;
+  while ((m = requireRe.exec(content)) !== null) {
+    results.push({ specifier: m[1], isRelative: false });
+  }
+  return results;
+}
+function resolveLuaImport(fromDir, raw, rootDir) {
+  const asPath = raw.specifier.replace(/\./g, path4.sep);
+  const candidates = [
+    path4.join(fromDir, asPath + ".lua"),
+    path4.join(rootDir, asPath + ".lua"),
+    // Lua's package convention also supports init.lua as a directory
+    // entry point — analogous to Python's __init__.py.
+    path4.join(rootDir, asPath, "init.lua")
+  ];
+  for (const c of candidates) {
+    if (fs4.existsSync(c)) return path4.relative(rootDir, c);
+  }
+  return null;
+}
+function extractElixirImports(content) {
+  const results = [];
+  const re = /^\s*(?:alias|import|use|require)\s+([A-Z][\w.]*)/gm;
+  let m;
+  while ((m = re.exec(content)) !== null) {
+    results.push({ specifier: m[1], isRelative: false });
+  }
+  return results;
+}
+function resolveElixirImport(fromDir, raw, rootDir) {
+  const segments = raw.specifier.split(".").map(
+    (s) => s.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase()
+  );
+  const asPath = segments.join(path4.sep);
+  const candidates = [
+    path4.join(rootDir, "lib", asPath + ".ex"),
+    path4.join(rootDir, "lib", asPath + ".exs"),
+    path4.join(rootDir, asPath + ".ex"),
+    path4.join(rootDir, asPath + ".exs")
+  ];
+  for (const c of candidates) {
+    if (fs4.existsSync(c)) return path4.relative(rootDir, c);
+  }
+  const tail = segments[segments.length - 1];
+  const local = path4.join(fromDir, tail + ".ex");
+  if (fs4.existsSync(local)) return path4.relative(rootDir, local);
+  return null;
+}
+function extractZigImports(content) {
+  const results = [];
+  const importRe = /@import\s*\(\s*"([^"]+)"\s*\)/g;
+  let m;
+  while ((m = importRe.exec(content)) !== null) {
+    const spec = m[1];
+    if (spec.endsWith(".zig")) {
+      const isRelative = spec.startsWith(".") || !spec.includes("/");
+      results.push({ specifier: spec, isRelative });
+    }
+  }
+  return results;
+}
+function resolveZigImport(fromAbs, fromDir, raw, rootDir) {
+  void fromAbs;
+  const rootResolved = path4.resolve(rootDir);
+  const candidate = path4.resolve(fromDir, raw.specifier);
+  if (!candidate.startsWith(rootResolved + path4.sep) && candidate !== rootResolved) {
+    return null;
+  }
+  if (fs4.existsSync(candidate)) return path4.relative(rootDir, candidate);
+  return null;
+}
 
 // packages/core/src/utils/TsConfigPathsResolver.ts
 import fs5 from "fs";
@@ -2355,6 +2703,7 @@ var CallGraphIndex = class _CallGraphIndex {
 
 // packages/core/src/graph/DependencyGraph.ts
 var TS_EXTENSIONS2 = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".vue"]);
+var PY_EXTENSIONS = /* @__PURE__ */ new Set([".py", ".ipynb"]);
 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) */
@@ -2364,6 +2713,31 @@ var DependencyGraph = class {
   /** Symbol index: symbolName → { filePath, type, signature, startLine?, endLine? } */
   symbolIndex = /* @__PURE__ */ new Map();
   callGraphIndex = new CallGraphIndex();
+  /**
+   * Re-export tracing (v1.6.x):
+   *   reExportMap[barrelFile][symbol] = sourceFile
+   *
+   * Built during graph construction from `from .submodule import Name`
+   * statements (Python). When file C imports `from <barrel> import Name`,
+   * the import resolver consults this map and emits a parallel edge
+   * C → sourceFile so blast-radius queries against sourceFile can find
+   * C as a transitive consumer through the barrel.
+   *
+   * Concrete fastapi case:
+   *   tests/test_routing.py has `from fastapi import APIRouter`
+   *   fastapi/__init__.py has `from .routing import APIRouter`
+   *   → reExportMap['fastapi/__init__.py']['APIRouter'] = 'fastapi/routing.py'
+   *   → emit edge tests/test_routing.py → fastapi/routing.py
+   */
+  reExportMap = /* @__PURE__ */ new Map();
+  /**
+   * Pending re-export queries. Populated during pass 1 (parse all
+   * files, extract their imports); resolved in pass 2 once the
+   * reExportMap is fully built. Required because file ordering would
+   * otherwise miss re-exports whose source files are parsed AFTER the
+   * consumer file.
+   */
+  pendingReExportQueries = [];
   parser = null;
   rootDir = "";
   snapshotDir = "";
@@ -2418,8 +2792,10 @@ var DependencyGraph = class {
             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);
+              const resolvedAll = isRelative ? goResolver.resolveRelativeAll(absPath, spec) : goResolver.resolveAll(spec);
+              for (const resolved of resolvedAll) {
+                this.addEdge(relPath, resolved);
+              }
             }
           } else {
             const importNodes = nodes.filter((n) => n.type === "import");
@@ -2428,7 +2804,26 @@ var DependencyGraph = class {
                 const specifier = imp.source ?? imp.name;
                 const isRelative = specifier.startsWith(".");
                 const resolved = resolveImport(absPath, { specifier, isRelative }, rootDir);
-                if (resolved) this.addEdge(relPath, resolved);
+                if (resolved) {
+                  this.addEdge(relPath, resolved);
+                  if (ext === ".py" && imp.importedNames && imp.importedNames.length > 0) {
+                    if (isRelative) {
+                      let map = this.reExportMap.get(relPath);
+                      if (!map) {
+                        map = /* @__PURE__ */ new Map();
+                        this.reExportMap.set(relPath, map);
+                      }
+                      for (const name of imp.importedNames) {
+                        map.set(name, resolved);
+                      }
+                    }
+                    this.pendingReExportQueries.push({
+                      caller: relPath,
+                      barrel: resolved,
+                      symbols: imp.importedNames
+                    });
+                  }
+                }
               }
             } else {
               const content = fs6.readFileSync(absPath, "utf-8");
@@ -2440,7 +2835,7 @@ var DependencyGraph = class {
             }
           }
           for (const node of nodes) {
-            if (node.type === "function" || node.type === "class" || node.type === "interface") {
+            if (node.type === "function" || node.type === "class" || node.type === "interface" || node.type === "method") {
               const existing = this.symbolIndex.get(node.name) ?? [];
               existing.push({
                 filePath: relPath,
@@ -2457,6 +2852,11 @@ var DependencyGraph = class {
             for (const edge of callEdges) {
               this.callGraphIndex.addEdge({ callerFile: relPath, ...edge });
             }
+          } else if (PY_EXTENSIONS.has(ext)) {
+            const callEdges = await this.parser.parseAllPythonCallEdges(absPath);
+            for (const edge of callEdges) {
+              this.callGraphIndex.addEdge({ callerFile: relPath, ...edge });
+            }
           }
         } else {
           const content = fs6.readFileSync(absPath, "utf-8");
@@ -2470,6 +2870,49 @@ var DependencyGraph = class {
         logger.error("Failed to parse", { file: relPath, detail: err instanceof Error ? err.message : String(err) });
       }
     }
+    let reExportEdgesAdded = 0;
+    for (const { caller, barrel, symbols } of this.pendingReExportQueries) {
+      const map = this.reExportMap.get(barrel);
+      if (!map) continue;
+      for (const sym of symbols) {
+        const source = map.get(sym);
+        if (source && source !== caller && source !== barrel) {
+          this.addEdge(caller, source);
+          reExportEdgesAdded += 1;
+        }
+      }
+    }
+    this.pendingReExportQueries = [];
+    if (reExportEdgesAdded > 0) {
+      logger.info("Re-export tracing added parallel edges", { count: reExportEdgesAdded });
+    }
+    let goTestEdgesAdded = 0;
+    for (const relPath of this.forwardEdges.keys()) {
+      if (!relPath.endsWith("_test.go")) continue;
+      const dir = path6.dirname(relPath);
+      const base = path6.basename(relPath, "_test.go");
+      const namesake = path6.join(dir, base + ".go").replace(/\\/g, "/");
+      if (this.forwardEdges.has(namesake)) {
+        this.addEdge(relPath, namesake);
+        this.addEdge(namesake, relPath);
+        goTestEdgesAdded += 2;
+        continue;
+      }
+      const absDir = path6.join(this.rootDir, dir);
+      try {
+        const siblings = fs6.readdirSync(absDir).filter((f) => f.endsWith(".go") && !f.endsWith("_test.go"));
+        for (const sib of siblings) {
+          const sibRel = path6.join(dir, sib).replace(/\\/g, "/");
+          this.addEdge(relPath, sibRel);
+          this.addEdge(sibRel, relPath);
+          goTestEdgesAdded += 2;
+        }
+      } catch {
+      }
+    }
+    if (goTestEdgesAdded > 0) {
+      logger.info("Go test\u2194source linkage added edges", { count: goTestEdgesAdded });
+    }
     await this.saveSnapshot();
     logger.info("Graph built", { files: files.length, edges: this.edgeCount() });
     if (options?.afterReady) {
@@ -2662,8 +3105,10 @@ var DependencyGraph = class {
           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);
+            const resolvedAll = isRelative ? goResolver.resolveRelativeAll(absPath, spec) : goResolver.resolveAll(spec);
+            for (const resolved of resolvedAll) {
+              this.addEdge(relPath, resolved);
+            }
           }
         } else {
           const importNodes = nodes.filter((n) => n.type === "import");
@@ -2684,7 +3129,7 @@ var DependencyGraph = class {
           }
         }
         for (const node of nodes) {
-          if (node.type === "function" || node.type === "class" || node.type === "interface") {
+          if (node.type === "function" || node.type === "class" || node.type === "interface" || node.type === "method") {
             const existing = this.symbolIndex.get(node.name) ?? [];
             existing.push({
               filePath: relPath,
@@ -2701,6 +3146,11 @@ var DependencyGraph = class {
           for (const edge of callEdges) {
             this.callGraphIndex.addEdge({ callerFile: relPath, ...edge });
           }
+        } else if (PY_EXTENSIONS.has(ext)) {
+          const callEdges = await this.parser.parseAllPythonCallEdges(absPath);
+          for (const edge of callEdges) {
+            this.callGraphIndex.addEdge({ callerFile: relPath, ...edge });
+          }
         }
       } else {
         const content = fs6.readFileSync(absPath, "utf-8");
@@ -6133,7 +6583,7 @@ function buildHistoricalCouplingEntries(changedFiles, staticSet, overlay) {
   const now = Math.floor(Date.now() / 1e3);
   const coupling = [];
   for (const seedFile of changedFiles) {
-    const coupled = overlay.coChange.topFor({ node: seedFile, limit: 10, minConfidence: 0.2 });
+    const coupled = overlay.coChange.topFor({ node: seedFile, limit: 25, minConfidence: 0.1 });
     for (const hit of coupled) {
       const sibling = hit.nodeA === seedFile ? hit.nodeB : hit.nodeA;
       if (!staticSet.has(sibling) && !coupling.some((h) => h.node === sibling)) {
@@ -6150,25 +6600,143 @@ function buildHistoricalCouplingEntries(changedFiles, staticSet, overlay) {
   coupling.splice(10);
   return coupling;
 }
+function collectImportees(changedFiles, graph) {
+  const changedSet = new Set(changedFiles);
+  const importees = /* @__PURE__ */ new Set();
+  for (const file of changedFiles) {
+    for (const imp of graph.getImports(file)) {
+      if (!changedSet.has(imp)) importees.add(imp);
+    }
+  }
+  return importees;
+}
+var SYMBOL_CALLERS_TOP_K = 25;
+var PATH_PROXIMITY_BONUS = 1;
+var SYMBOL_CALLERS_MIN_SCORE = 1;
+function pathProximityScore(callerFile, seedFile) {
+  const lastSlash = seedFile.lastIndexOf("/");
+  const lastDot = seedFile.lastIndexOf(".");
+  const stem = seedFile.slice(
+    lastSlash + 1,
+    lastDot > lastSlash ? lastDot : seedFile.length
+  );
+  if (stem.length < 3) return 0;
+  const shortPrefix = stem.slice(0, 3);
+  const tokens = stem === shortPrefix ? [stem] : [stem, shortPrefix];
+  const caller = callerFile.toLowerCase();
+  for (const t of tokens) {
+    const token = t.toLowerCase();
+    const re = new RegExp(`(?:^|[/_.\\-])${token}(?:[/_.\\-]|$)`);
+    if (re.test(caller)) return PATH_PROXIMITY_BONUS;
+  }
+  return 0;
+}
+function collectSymbolCallers(changedFiles, graph) {
+  const changedSet = new Set(changedFiles);
+  const callGraph = graph.getCallGraphIndex();
+  const callerScores = /* @__PURE__ */ new Map();
+  const callersWithProximityApplied = /* @__PURE__ */ new Set();
+  for (const file of changedFiles) {
+    const symbols = graph.lookupSymbolsByFile(file);
+    for (const sym of symbols) {
+      const defs = graph.lookupSymbol(sym);
+      const definedInSeed = defs.some((d) => changedSet.has(d.filePath));
+      if (!definedInSeed) continue;
+      const specificity = 1 / defs.length;
+      const seenForSym = /* @__PURE__ */ new Set();
+      for (const caller of callGraph.getCallers(sym)) {
+        if (changedSet.has(caller.file)) continue;
+        if (seenForSym.has(caller.file)) continue;
+        seenForSym.add(caller.file);
+        const prev = callerScores.get(caller.file) ?? 0;
+        const next = prev + specificity;
+        callerScores.set(caller.file, next);
+      }
+    }
+    for (const callerFile of callerScores.keys()) {
+      if (callersWithProximityApplied.has(callerFile)) continue;
+      const bonus = pathProximityScore(callerFile, file);
+      if (bonus > 0) {
+        callerScores.set(callerFile, (callerScores.get(callerFile) ?? 0) + bonus);
+      }
+      callersWithProximityApplied.add(callerFile);
+    }
+  }
+  const ranked = Array.from(callerScores.entries()).filter(([, score]) => score >= SYMBOL_CALLERS_MIN_SCORE).sort((a, b) => {
+    if (b[1] !== a[1]) return b[1] - a[1];
+    return a[0].localeCompare(b[0]);
+  });
+  return new Set(ranked.slice(0, SYMBOL_CALLERS_TOP_K).map(([file]) => file));
+}
+var SEMANTIC_TOP_K = 10;
+var SEMANTIC_DIST_THRESHOLD = 0.5;
+async function computeSemanticSimilar(changedFiles, vectorStore, staticSet) {
+  return collectSemanticSimilar(changedFiles, vectorStore, staticSet);
+}
+async function collectSemanticSimilar(changedFiles, vectorStore, staticSet) {
+  const changedSet = new Set(changedFiles);
+  const scores = /* @__PURE__ */ new Map();
+  for (const seedFile of changedFiles) {
+    let embedding;
+    try {
+      embedding = await vectorStore.findEmbeddingByPath(seedFile);
+    } catch {
+      continue;
+    }
+    if (embedding === null) continue;
+    let results;
+    try {
+      results = await vectorStore.search(embedding, SEMANTIC_TOP_K + 5);
+    } catch {
+      continue;
+    }
+    for (const r of results) {
+      if (changedSet.has(r.filePath)) continue;
+      if (staticSet.has(r.filePath)) continue;
+      if (r.score >= SEMANTIC_DIST_THRESHOLD) continue;
+      const prev = scores.get(r.filePath);
+      if (prev === void 0 || r.score < prev) {
+        scores.set(r.filePath, r.score);
+      }
+    }
+  }
+  return Array.from(scores.entries()).sort((a, b) => a[1] - b[1]).slice(0, SEMANTIC_TOP_K).map(([node, score]) => ({ node, score }));
+}
 function getImpactRadius(input) {
-  const { graph, overlay, changedFiles, depth = 3 } = input;
+  const {
+    graph,
+    overlay,
+    changedFiles,
+    depth = 3,
+    includeImportees = false,
+    includeSymbolCallers = false
+  } = input;
   const { directImporters, allReachable } = traverseImporters(changedFiles, graph, depth);
   const transitiveImporters = [];
   for (const file of allReachable) {
     if (!directImporters.has(file)) transitiveImporters.push(file);
   }
+  const importeesSet = includeImportees ? collectImportees(changedFiles, graph) : /* @__PURE__ */ new Set();
+  const directImportees = Array.from(importeesSet);
+  const symbolCallersSet = includeSymbolCallers ? collectSymbolCallers(changedFiles, graph) : /* @__PURE__ */ new Set();
+  const symbolCallers = Array.from(symbolCallersSet);
   const staticSet = /* @__PURE__ */ new Set([
     ...changedFiles,
     ...directImporters,
-    ...transitiveImporters
+    ...transitiveImporters,
+    ...directImportees,
+    ...symbolCallers
   ]);
   const historicalCoupling = overlay !== void 0 ? buildHistoricalCouplingEntries(changedFiles, staticSet, overlay) : [];
-  const totalImpacted = directImporters.size + transitiveImporters.length;
+  const totalImpacted = directImporters.size + transitiveImporters.length + directImportees.length + symbolCallers.length;
   return {
     seedFiles: [...changedFiles],
     directImporters: Array.from(directImporters),
     transitiveImporters,
+    directImportees,
+    symbolCallers,
     historicalCoupling,
+    semanticSimilar: [],
     totalImpacted
   };
 }
@@ -8072,7 +8640,7 @@ function registerFullTextSearchTool(registry, ctx) {
       };
       if (mode === "semantic") {
         try {
-          const { generateEmbedding: generateEmbedding2 } = await import("./embedder-3AE4CSR7.js");
+          const { generateEmbedding: generateEmbedding2 } = await import("./embedder-2JWDJUE2.js");
           const store = await ctx.getStore(project_root);
           const embedding = await generateEmbedding2(query);
           const results = await store.search(embedding, limit);
@@ -8109,7 +8677,7 @@ function registerFullTextSearchTool(registry, ctx) {
       let merged = keywordResults.slice(0, limit);
       if (mode === "hybrid") {
         try {
-          const { generateEmbedding: generateEmbedding2 } = await import("./embedder-3AE4CSR7.js");
+          const { generateEmbedding: generateEmbedding2 } = await import("./embedder-2JWDJUE2.js");
           const store = await ctx.getStore(project_root);
           const embedding = await generateEmbedding2(query);
           const vectorResults = await store.search(embedding, Math.ceil(limit / 2));
@@ -9981,16 +10549,14 @@ var PathValidator = class {
 
 // packages/core/src/watcher/FileWatcher.ts
 import chokidar from "chokidar";
-var IGNORED = [
-  "**/node_modules/**",
-  "**/.git/**",
-  "**/dist/**",
-  "**/build/**",
-  "**/.ctxloom/**",
-  "**/coverage/**",
-  "**/.next/**",
-  "**/.cache/**"
-];
+function isIgnoredPath(absPath) {
+  const segments = absPath.split(/[\\/]/);
+  for (const seg of segments) {
+    if (INDEXER_IGNORED_DIRS.has(seg)) return true;
+  }
+  return false;
+}
+var IGNORED = isIgnoredPath;
 var FileWatcher = class {
   root;
   onChange;
@@ -10346,10 +10912,10 @@ var TELEMETRY_DISABLED = TELEMETRY_LEVEL === "off";
 function getTelemetryLevel() {
   return TELEMETRY_LEVEL;
 }
-var CTXLOOM_VERSION = "1.5.6".length > 0 ? "1.5.6" : "dev";
+var CTXLOOM_VERSION = "1.7.0".length > 0 ? "1.7.0" : "dev";
 var POSTHOG_HOST = "https://eu.i.posthog.com";
 var POSTHOG_KEY = process.env["POSTHOG_API_KEY"] ?? (true ? "phc_CiDkmFLcZ2K6uCpcoSUQLmFrnnUvsyXGhSxopX5TVKE6" : "");
-var SENTRY_DSN = process.env["SENTRY_DSN"] ?? (true ? "https://81c94a0f04a8e242dee493ac1e17f733@o4508531702497280.ingest.de.sentry.io/4511256875368528\u2028" : "");
+var SENTRY_DSN = process.env["SENTRY_DSN"] ?? (true ? "https://81c94a0f04a8e242dee493ac1e17f733@o4508531702497280.ingest.de.sentry.io/4511256875368528" : "");
 var cachedDistinctId = null;
 function resolveDistinctId() {
   if (cachedDistinctId) return cachedDistinctId;
@@ -10984,6 +11550,27 @@ The graph is faster, cheaper (fewer tokens), and gives you
 structural context (callers, dependents, test coverage) that file
 scanning cannot.
 
+### Operating principles
+
+ctxloom's tools exist to operationalize four principles for working
+with an AI coding agent. They're the *why* behind every tool below.
+Adapted from Karpathy's LLM-coding-pitfalls notes
+(<https://github.com/multica-ai/andrej-karpathy-skills>, MIT).
+
+1. **Think before coding** \u2014 read the relevant graph slice before
+   editing. \`ctx_blast_radius\`, \`ctx_get_call_graph\`,
+   \`ctx_get_review_context\` are how you do this without re-reading
+   whole files.
+2. **Simplicity first** \u2014 prefer the smallest viable change. Use
+   \`ctx_refactor_preview\` to see the full diff *before* applying;
+   if the preview is sprawling, the plan is too big.
+3. **Surgical changes** \u2014 every changed line should trace directly
+   to the user's request. \`ctx_detect_changes\` after each edit
+   confirms scope hasn't drifted.
+4. **Goal-driven execution** \u2014 stop when the goal is met. Don't
+   "polish" beyond the request. \`ctx_knowledge_gaps\` flags real
+   risk surfaces; everything else is yak-shaving.
+
 ### Start every workflow with \`ctx_get_minimal_context\`
 
 The first MCP call into ctxloom should always be
@@ -11229,9 +11816,18 @@ description: Orient yourself to an unfamiliar codebase using ctxloom's structura
 
 # Explore Codebase
 
+**Principle: Think Before Coding.** Exploration is "think" with a
+budget. The trap is reading every file in sight; the discipline is
+to read the *graph*, then the few files the graph nominates. This
+skill caps you at 5 tool calls and 2000 tokens \u2014 enough to ground
+the next edit, not enough to procrastinate.
+
 Use this when you need to understand a codebase you haven't worked in
 before, or when re-orienting after time away.
 
+**Skip when:** you already know which files matter \u2014 just open them.
+Reserve this skill for "I don't know where to start" situations.
+
 ## Steps
 
 1. **Orientation anchor**: call \`ctx_get_minimal_context(task="explore this codebase")\`.
@@ -11280,9 +11876,17 @@ argument-hint: "<symbol-name | file-path>"
 
 # Blast Radius
 
+**Principle: Think Before Coding.** You can't make a surgical change
+if you don't know who depends on the symbol. This skill is the
+"think" phase \u2014 read the graph slice before editing anything.
+
 Use this before any change to a public function, type, or file
 where you're not sure who depends on it.
 
+**Skip when:** the change is purely internal to a private helper
+with no callers outside the file, OR you've already run this skill
+for the same symbol in the current task.
+
 ## Inputs
 
 - \`$ARGUMENTS\` \u2014 the symbol name (e.g. \`emitTelemetry\`) or file
@@ -11331,9 +11935,18 @@ argument-hint: "<old-name> <new-name>"
 
 # Refactor Safely
 
+**Principle: Surgical Changes.** A rename touches every call site \u2014
+done blindly it's the opposite of surgical. This skill enforces
+"see the full diff before applying" so the change stays scoped to
+the user's request and doesn't accidentally rewrite tangents.
+
 Use this for renames, signature changes, or function moves. The
 skill enforces preview-before-apply.
 
+**Skip when:** the symbol is local to a single file (just edit it),
+OR the user wants a behavior change, not a rename (use the regular
+edit flow with \`ctx_blast_radius\` for impact awareness).
+
 ## Inputs
 
 - \`$1\` \u2014 current symbol name (e.g. \`emitTelemetry\`)
@@ -11386,9 +11999,18 @@ description: Identify code that lacks test coverage, prioritized by caller frequ
 
 # Coverage Gap Analysis
 
+**Principle: Goal-Driven Execution.** "Add tests everywhere" is
+yak-shaving. The goal is to add tests where they pay back the
+investment: high-caller, high-churn, low-coverage code. This skill
+ranks gaps so you write tests with intent, not by reflex.
+
 Use this to find untested code that genuinely matters \u2014 the
 intersection of "no tests" + "many callers" + "high risk score."
 
+**Skip when:** the user asked for tests on a specific symbol \u2014
+write them directly. Reserve this skill for "where should we
+invest in tests next?" queries.
+
 ## Steps
 
 1. **Orientation**: call \`ctx_get_minimal_context(task="check test coverage")\`.
@@ -11436,10 +12058,20 @@ argument-hint: "<PR number | branch name>"
 
 # Review PR
 
+**Principle: Think Before Coding.** A code review *is* the "think"
+phase for the author and the reviewer alike. This skill structures
+that thinking around graph slices rather than naive file-by-file
+reading, so you spot blast-radius and coverage risks the diff alone
+hides.
+
 Comprehensive PR review using ctxloom's graph. Mirrors the
 multi-agent review the ctxloom-bot posts automatically \u2014 useful
 when reviewing manually or when the bot isn't wired up.
 
+**Skip when:** the PR is one-file, \u226430 lines, with full test
+coverage \u2014 read the diff directly. Reserve this skill for changes
+where the structural impact isn't obvious from the diff.
+
 ## Inputs
 
 - \`$ARGUMENTS\` \u2014 PR number (e.g. \`142\`) or branch name (e.g. \`feat/foo\`).
@@ -11527,6 +12159,11 @@ description: Inspect ctxloom's per-tool budget telemetry \u2014 fallback distrib
 
 # Budget Stats
 
+**Principle: Simplicity First.** Don't guess what \`DEFAULT_MAX_RESPONSE_TOKENS\`
+should be \u2014 measure. This skill turns real telemetry into the
+simplest viable constant: the p75 of actual usage. Tune what hurts;
+leave the rest alone.
+
 Wrapper around \`ctxloom budget-stats\` for inline use inside a
 Claude Code session. Useful when:
 
@@ -11535,6 +12172,10 @@ Claude Code session. Useful when:
 - Diagnosing why a tool keeps falling back to skeleton mode
 - Understanding which tools dominate the user's token budget
 
+**Skip when:** there's no budget complaint to investigate \u2014 telemetry
+exists for tuning, not browsing. Reserve this skill for "this tool
+keeps hitting the budget" or scheduled tuning passes.
+
 ## Steps
 
 1. **Orientation**: call \`ctx_get_minimal_context(task="inspect budget telemetry")\`.
@@ -11862,6 +12503,7 @@ export {
   emitTaskBudgetBreached,
   ToolRegistry,
   detectChanges,
+  computeSemanticSimilar,
   getImpactRadius,
   buildBlastRadiusXml,
   validateAlias,
@@ -11946,4 +12588,4 @@ export {
   skillFilePath,
   installHarness
 };
-//# sourceMappingURL=chunk-FPMNXF4D.js.map
+//# sourceMappingURL=chunk-FFCLVZCO.js.map