ctxloom-pro 1.5.6 → 1.7.0

package/apps/dashboard/dist/server/index.js

@@ -79,6 +79,27 @@ var init_logger = __esm({
 // ../../packages/core/src/indexer/embedder.ts
 import fs3 from "fs";
 import path3 from "path";
+function resolveEmbeddingModel(env = process.env) {
+  const envModel = env.CTXLOOM_EMBEDDING_MODEL?.trim();
+  if (!envModel) return MODEL_REGISTRY.minilm;
+  const registered = MODEL_REGISTRY[envModel];
+  if (registered) return registered;
+  const envDim = env.CTXLOOM_EMBEDDING_DIM ? Number.parseInt(env.CTXLOOM_EMBEDDING_DIM, 10) : NaN;
+  if (!Number.isFinite(envDim) || envDim <= 0) {
+    throw new Error(
+      `CTXLOOM_EMBEDDING_MODEL=${envModel} is not a known alias. Either use one of [${Object.keys(MODEL_REGISTRY).join(", ")}] or set CTXLOOM_EMBEDDING_DIM=<vector-length> alongside a raw HF id.`
+    );
+  }
+  return {
+    hfId: envModel,
+    dim: envDim,
+    // Without a known artifact size we can't enforce the truncated-download
+    // guard. Use 1 MB as the minimum; the worst case is a redundant retry
+    // rather than a hung process.
+    minBytes: 1024 * 1024,
+    description: `User-supplied model: ${envModel} (${envDim}-dim)`
+  };
+}
 function collectFiles(dir, results = []) {
   const IGNORED_DIRS = /* @__PURE__ */ new Set([
     // Build artifacts + dependency caches
@@ -144,12 +165,37 @@ function collectFiles(dir, results = []) {
   }
   return results;
 }
-var MIN_MODEL_BYTES;
+var MODEL_REGISTRY, ACTIVE_MODEL, EMBEDDING_DIMENSION, MODEL_ID, MIN_MODEL_BYTES;
 var init_embedder = __esm({
   "../../packages/core/src/indexer/embedder.ts"() {
     "use strict";
     init_logger();
-    MIN_MODEL_BYTES = 80 * 1024 * 1024;
+    MODEL_REGISTRY = {
+      // The historical default. General English, 384-dim, ~90 MB.
+      // Kept as the free-tier default so existing users see zero change.
+      minilm: {
+        hfId: "sentence-transformers/all-MiniLM-L6-v2",
+        dim: 384,
+        minBytes: 80 * 1024 * 1024,
+        description: "General-purpose English sentence embedder (2020). 384-dim. The legacy default."
+      },
+      // Code-specific embedding model (Jina AI). 768-dim, ~140 MB.
+      // Empirically 20-40% better recall on code-similarity queries than
+      // MiniLM — the upgrade path recommended in the v1.7.0 analysis.
+      // Runs through the same @huggingface/transformers pipeline so the
+      // privacy story (fully local, no network at inference time) is
+      // preserved.
+      "jina-code": {
+        hfId: "jinaai/jina-embeddings-v2-base-code",
+        dim: 768,
+        minBytes: 130 * 1024 * 1024,
+        description: "Code-specific embedder (Jina, 2024). 768-dim. Better recall on code-similarity tasks."
+      }
+    };
+    ACTIVE_MODEL = resolveEmbeddingModel();
+    EMBEDDING_DIMENSION = ACTIVE_MODEL.dim;
+    MODEL_ID = ACTIVE_MODEL.hfId;
+    MIN_MODEL_BYTES = ACTIVE_MODEL.minBytes;
   }
 });
 
@@ -160,6 +206,7 @@ var init_VectorStore = __esm({
   "../../packages/core/src/db/VectorStore.ts"() {
     "use strict";
     init_logger();
+    init_embedder();
   }
 });
 
@@ -657,6 +704,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) {
@@ -828,6 +882,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) {
@@ -934,10 +1038,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
           });
@@ -1807,6 +1935,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.
@@ -1893,48 +2093,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 = path4.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 = path4.dirname(fromFile);
     const absTarget = path4.resolve(fromDir, importSpec);
     const subPath = path4.relative(this.rootDir, absTarget);
-    return this.firstGoFileInDir(absTarget, subPath);
+    return this.allGoFilesInDir(
+      absTarget,
+      subPath,
+      /* includeTests */
+      false
+    );
   }
-  firstGoFileInDir(absDir, relDir) {
-    if (!fs4.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 (!fs4.existsSync(absDir)) return [];
     let entries;
     try {
       entries = fs4.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 path4.join(relDir, goFiles[0]).replace(/\\/g, "/");
+    return goFiles.map((f) => path4.join(relDir, f).replace(/\\/g, "/"));
   }
 };
 
@@ -1976,6 +2228,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 [];
   }
@@ -1995,8 +2265,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;
@@ -2283,6 +2559,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 = path5.resolve(rootDir);
+  const candidates = [
+    path5.resolve(fromDir, raw.specifier),
+    path5.resolve(rootDir, raw.specifier)
+  ];
+  for (const c of candidates) {
+    if (!c.startsWith(rootResolved + path5.sep) && c !== rootResolved) continue;
+    if (fs5.existsSync(c)) return path5.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, path5.sep);
+  const candidates = [
+    path5.join(rootDir, "src", "main", "scala", asPath + ".scala"),
+    path5.join(rootDir, asPath + ".scala")
+  ];
+  for (const c of candidates) {
+    if (fs5.existsSync(c)) return path5.relative(rootDir, c);
+  }
+  const className = raw.specifier.split(".").pop() ?? raw.specifier;
+  const local = path5.join(fromDir, className + ".scala");
+  if (fs5.existsSync(local)) return path5.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, path5.sep);
+  const candidates = [
+    path5.join(fromDir, asPath + ".lua"),
+    path5.join(rootDir, asPath + ".lua"),
+    // Lua's package convention also supports init.lua as a directory
+    // entry point — analogous to Python's __init__.py.
+    path5.join(rootDir, asPath, "init.lua")
+  ];
+  for (const c of candidates) {
+    if (fs5.existsSync(c)) return path5.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(path5.sep);
+  const candidates = [
+    path5.join(rootDir, "lib", asPath + ".ex"),
+    path5.join(rootDir, "lib", asPath + ".exs"),
+    path5.join(rootDir, asPath + ".ex"),
+    path5.join(rootDir, asPath + ".exs")
+  ];
+  for (const c of candidates) {
+    if (fs5.existsSync(c)) return path5.relative(rootDir, c);
+  }
+  const tail = segments[segments.length - 1];
+  const local = path5.join(fromDir, tail + ".ex");
+  if (fs5.existsSync(local)) return path5.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 = path5.resolve(rootDir);
+  const candidate = path5.resolve(fromDir, raw.specifier);
+  if (!candidate.startsWith(rootResolved + path5.sep) && candidate !== rootResolved) {
+    return null;
+  }
+  if (fs5.existsSync(candidate)) return path5.relative(rootDir, candidate);
+  return null;
+}
 
 // ../../packages/core/src/utils/TsConfigPathsResolver.ts
 import fs6 from "fs";
@@ -2513,6 +2907,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) */
@@ -2522,6 +2917,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 = "";
@@ -2576,8 +2996,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");
@@ -2586,7 +3008,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 map2 = this.reExportMap.get(relPath);
+                      if (!map2) {
+                        map2 = /* @__PURE__ */ new Map();
+                        this.reExportMap.set(relPath, map2);
+                      }
+                      for (const name of imp.importedNames) {
+                        map2.set(name, resolved);
+                      }
+                    }
+                    this.pendingReExportQueries.push({
+                      caller: relPath,
+                      barrel: resolved,
+                      symbols: imp.importedNames
+                    });
+                  }
+                }
               }
             } else {
               const content = fs7.readFileSync(absPath, "utf-8");
@@ -2598,7 +3039,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,
@@ -2615,6 +3056,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 = fs7.readFileSync(absPath, "utf-8");
@@ -2628,6 +3074,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 map2 = this.reExportMap.get(barrel);
+      if (!map2) continue;
+      for (const sym of symbols) {
+        const source = map2.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 = path7.dirname(relPath);
+      const base = path7.basename(relPath, "_test.go");
+      const namesake = path7.join(dir, base + ".go").replace(/\\/g, "/");
+      if (this.forwardEdges.has(namesake)) {
+        this.addEdge(relPath, namesake);
+        this.addEdge(namesake, relPath);
+        goTestEdgesAdded += 2;
+        continue;
+      }
+      const absDir = path7.join(this.rootDir, dir);
+      try {
+        const siblings = fs7.readdirSync(absDir).filter((f) => f.endsWith(".go") && !f.endsWith("_test.go"));
+        for (const sib of siblings) {
+          const sibRel = path7.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) {
@@ -2820,8 +3309,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");
@@ -2842,7 +3333,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,
@@ -2859,6 +3350,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 = fs7.readFileSync(absPath, "utf-8");
@@ -11511,6 +12007,7 @@ var MAX_FILE_SIZE = 5 * 1024 * 1024;
 init_logger();
 
 // ../../packages/core/src/watcher/FileWatcher.ts
+init_embedder();
 init_logger();
 
 // ../../packages/core/src/license/LicenseStore.ts
@@ -11597,10 +12094,10 @@ function resolveTelemetryLevel() {
 }
 var TELEMETRY_LEVEL = resolveTelemetryLevel();
 var TELEMETRY_DISABLED = TELEMETRY_LEVEL === "off";
-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;
@@ -11765,6 +12262,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