@remnic/coding-graph 9.6.23 → 9.6.24

package/dist/cypher/query-parser.js

@@ -4,8 +4,8 @@ import {
   executeAst,
   executeCypher,
   parseCypher
-} from "../chunk-5I2DBHOQ.js";
-import "../chunk-CPYJACC5.js";
+} from "../chunk-7DI5P62Q.js";
+import "../chunk-ZLCF3XQK.js";
 import "../chunk-ZVCMIM4T.js";
 export {
   CYPHER_LABEL_TO_DB_LABEL,

package/dist/graph-store.d.ts

@@ -50,6 +50,23 @@ interface EdgeIR {
     readonly srcNodeId?: string;
     /** Optional content-derived destination node id — see {@link EdgeIR.srcNodeId}. */
     readonly dstNodeId?: string;
+    /**
+     * Repo-relative, extension-stripped path the dst must live in (issue
+     * #1894 review): derived from a relative import's module specifier. A
+     * hinted edge resolves ONLY among nodes whose file path matches the
+     * hint (`<hint>`, `<hint>.<ext>`, `<hint>/index.<ext>`, or
+     * `<hint>/__init__.<ext>`) — never via
+     * the global bare-name fallback — so `import { foo } from "./missing"`
+     * can never bind an unrelated same-named symbol elsewhere in the repo.
+     */
+    readonly dstPathHint?: string;
+    /**
+     * Language of the importing file (issue #1894 round 13): constrains the
+     * hinted dst's file extension to that language's module-resolution set
+     * so a polyglot repo cannot cross-bind a JS import to a same-named .py
+     * file.
+     */
+    readonly dstImporterLanguage?: string;
 }
 /**
  * Store input — the subset of @remnic/core's `FileIR` the store reads,
@@ -74,6 +91,16 @@ interface StoreFileIR {
     readonly symbols: readonly SymbolIR[];
     /** Store-specific edges derived from the IR by the caller. */
     readonly edges?: readonly EdgeIR[];
+    /**
+     * When present, the stale-edge delete in `upsertFileEdges` is scoped to
+     * edges whose provenance is in this list: prior src-owned edges of OTHER
+     * provenances survive un-asserted (issue #1891). The reindex pipeline
+     * asserts `["heuristic"]` because a fresh parse says nothing about
+     * `trace`/`lsp` edges; deleting them on every re-ingest would destroy
+     * state the parse never contradicted (rule 25). Absent = legacy
+     * behavior: every stale src-owned edge is deleted.
+     */
+    readonly assertedEdgeProvenances?: readonly EdgeProvenance[];
     /**
      * Per-file export list (mirrors core FileIR.exports). When present,
      * the write pipeline marks every node in this file whose `name`

package/dist/graph-store.js

@@ -4,7 +4,7 @@ import {
   GraphStore,
   MAX_TRAVERSE_PATHS_HOPS,
   nodeIdFor
-} from "./chunk-CPYJACC5.js";
+} from "./chunk-ZLCF3XQK.js";
 import "./chunk-ZVCMIM4T.js";
 export {
   DEAD_CODE_EXCLUSION,

package/dist/index.js

@@ -3,14 +3,14 @@ import {
   executeAst,
   executeCypher,
   parseCypher
-} from "./chunk-5I2DBHOQ.js";
+} from "./chunk-7DI5P62Q.js";
 import {
   DEAD_CODE_EXCLUSION,
   DEFAULT_TRAVERSE_PATHS_MAX,
   GraphStore,
   MAX_TRAVERSE_PATHS_HOPS,
   nodeIdFor
-} from "./chunk-CPYJACC5.js";
+} from "./chunk-ZLCF3XQK.js";
 import {
   CODING_GRAPH_SCHEMA_VERSION,
   EDGE_PROVENANCE_VALUES,
@@ -175,15 +175,25 @@ var JS_FAMILY_DEFINITIONS = `
 var JS_IMPORTS = `
 (import_statement
   source: (string (string_fragment) @import.module)) @__import.stmt
+; Default and namespace imports bind LOCAL aliases whose exported symbol
+; is unknowable to Phase A (issue #1894 round 12): they appear in
+; importedNames (informational) but never in bindings (call-bindable).
 (import_statement
-  (import_clause (identifier) @import.name)
+  (import_clause (identifier) @import.unboundName)
   source: (string (string_fragment) @import.module)) @__import.stmt
 (import_statement
-  (import_clause (namespace_import (identifier) @import.name))
+  (import_clause (namespace_import (identifier) @import.unboundName))
   source: (string (string_fragment) @import.module)) @__import.stmt
 (import_statement
   (import_clause (named_imports (import_specifier name: (identifier) @import.name)))
   source: (string (string_fragment) @import.module)) @__import.stmt
+; Aliased named import (issue #1894 review): import { foo as bar } \u2014 the
+; local binding is the alias; the exported name stays the binding target.
+(import_statement
+  (import_clause (named_imports (import_specifier
+    name: (identifier) @import.aliasExported
+    alias: (identifier) @import.aliasLocal)))
+  source: (string (string_fragment) @import.module)) @__import.stmt
 
 ; CommonJS require("...") \u2014 capture the module specifier so dependency
 ; edges exist for Node/CommonJS codebases, not just ES-module imports.
@@ -242,7 +252,10 @@ var JS_EXPORTS = `
 `.trim();
 var JS_CALLS = `
 (call_expression function: (identifier) @call.callee)
-(call_expression function: (member_expression property: (property_identifier) @call.callee))
+; Member calls are captured separately (issue #1894 review): obj.save()'s
+; \`save\` must never bind a bare visible symbol \u2014 method dispatch is
+; Phase B (LSP) territory. The emit layer marks these memberAccess: true.
+(call_expression function: (member_expression property: (property_identifier) @call.member))
 `.trim();
 var JS_ROUTES = `
 ; Unified route pattern: captures verb + path + the arguments node.
@@ -290,6 +303,17 @@ var PYTHON_EXTRACTOR = {
   importsQuery: `
 (import_statement (dotted_name) @import.module) @__import.stmt
 (import_from_statement module_name: (dotted_name) @import.module) @__import.stmt
+; Imported names (issue #1894 review round 7): without these captures,
+; extractImports emits importedNames: [] and the heuristic resolver's
+; import bindings never fire for real Python parses.
+(import_from_statement
+  module_name: (dotted_name) @import.module
+  name: (dotted_name) @import.name) @__import.stmt
+(import_from_statement
+  module_name: (dotted_name) @import.module
+  name: (aliased_import
+    name: (dotted_name) @import.aliasExported
+    alias: (identifier) @import.aliasLocal)) @__import.stmt
 ; Python relative imports: from .models import User / from ..parent import X
 ; tree-sitter-python wraps the module inside a relative_import node, so the
 ; module_name field is NOT set. Capture the relative_import node itself so
@@ -297,11 +321,19 @@ var PYTHON_EXTRACTOR = {
 ; relative levels must not collapse to the same module name
 ; (chatgpt-codex-connector #1688 P2: 'Preserve dots in Python relative imports').
 (import_from_statement (relative_import) @import.module) @__import.stmt
+(import_from_statement
+  (relative_import) @import.module
+  name: (dotted_name) @import.name) @__import.stmt
+(import_from_statement
+  (relative_import) @import.module
+  name: (aliased_import
+    name: (dotted_name) @import.aliasExported
+    alias: (identifier) @import.aliasLocal)) @__import.stmt
 `.trim(),
   exportsQuery: ``,
   callSitesQuery: `
 (call function: (identifier) @call.callee)
-(call function: (attribute attribute: (identifier) @call.callee))
+(call function: (attribute attribute: (identifier) @call.member))
 `.trim(),
   routesQuery: `
 (decorated_definition
@@ -337,7 +369,7 @@ var GO_EXTRACTOR = {
   exportsQuery: ``,
   callSitesQuery: `
 (call_expression function: (identifier) @call.callee)
-(call_expression function: (selector_expression field: (field_identifier) @call.callee))
+(call_expression function: (selector_expression field: (field_identifier) @call.member))
 `.trim(),
   routesQuery: ``
 };
@@ -372,7 +404,7 @@ var RUST_EXTRACTOR = {
   exportsQuery: ``,
   callSitesQuery: `
 (call_expression function: (identifier) @call.callee)
-(call_expression function: (field_expression field: (field_identifier) @call.callee))
+(call_expression function: (field_expression field: (field_identifier) @call.member))
 (call_expression function: (scoped_identifier) @call.callee)
 `.trim(),
   routesQuery: ``
@@ -391,7 +423,8 @@ var JAVA_EXTRACTOR = {
 `.trim(),
   exportsQuery: ``,
   callSitesQuery: `
-(method_invocation name: (identifier) @call.callee)
+(method_invocation !object name: (identifier) @call.callee)
+(method_invocation object: (_) name: (identifier) @call.member)
 `.trim(),
   routesQuery: ``
 };
@@ -429,7 +462,7 @@ var CPP_EXTRACTOR = {
   exportsQuery: ``,
   callSitesQuery: `
 (call_expression function: (identifier) @call.callee)
-(call_expression function: (field_expression field: (field_identifier) @call.callee))
+(call_expression function: (field_expression field: (field_identifier) @call.member))
 `.trim(),
   routesQuery: ``
 };
@@ -448,7 +481,7 @@ var CSHARP_EXTRACTOR = {
   exportsQuery: ``,
   callSitesQuery: `
 (invocation_expression function: (identifier) @call.callee)
-(invocation_expression function: (member_access_expression name: (identifier) @call.callee))
+(invocation_expression function: (member_access_expression name: (identifier) @call.member))
 `.trim(),
   routesQuery: ``
 };
@@ -467,7 +500,8 @@ var RUBY_EXTRACTOR = {
 `.trim(),
   exportsQuery: ``,
   callSitesQuery: `
-(call method: (identifier) @call.callee)
+(call !receiver method: (identifier) @call.callee)
+(call receiver: (_) method: (identifier) @call.member)
 `.trim(),
   routesQuery: ``
 };
@@ -485,7 +519,7 @@ var PHP_EXTRACTOR = {
   exportsQuery: ``,
   callSitesQuery: `
 (function_call_expression function: (name) @call.callee)
-(member_call_expression (name) @call.callee)
+(member_call_expression (name) @call.member)
 `.trim(),
   routesQuery: ``
 };
@@ -691,11 +725,20 @@ function extractImports(root, language, lang) {
       let stmtStart = -1;
       let stmtEnd = -1;
       const names = [];
+      const unboundNames = [];
+      let aliasExported = "";
+      let aliasLocal = "";
       for (const cap of match.captures) {
         if (cap.name === "import.module") {
           moduleText = cleanModuleSpecifier(cap.node.text);
         } else if (cap.name === "import.name") {
           names.push(cap.node.text);
+        } else if (cap.name === "import.unboundName") {
+          unboundNames.push(cap.node.text);
+        } else if (cap.name === "import.aliasExported") {
+          aliasExported = cap.node.text;
+        } else if (cap.name === "import.aliasLocal") {
+          aliasLocal = cap.node.text;
         } else if (cap.name === "__import.stmt") {
           stmtStart = cap.node.startIndex;
           stmtEnd = cap.node.endIndex;
@@ -711,21 +754,34 @@ function extractImports(root, language, lang) {
         }
       }
       const key = `${stmtStart}:${moduleText}`;
-      const existing = groups.get(key);
-      if (existing) {
-        for (const n of names) existing.names.add(n);
-      } else {
-        groups.set(key, {
+      let group = groups.get(key);
+      if (!group) {
+        group = {
           module: moduleText,
-          names: new Set(names),
+          names: /* @__PURE__ */ new Set(),
+          bindings: /* @__PURE__ */ new Map(),
           startByte: stmtStart,
           endByte: stmtEnd
-        });
+        };
+        groups.set(key, group);
+      }
+      for (const n of names) {
+        group.names.add(n);
+        if (!group.bindings.has(n)) group.bindings.set(n, n);
+      }
+      for (const n of unboundNames) {
+        group.names.add(n);
+      }
+      if (aliasExported && aliasLocal) {
+        group.names.add(aliasExported);
+        group.bindings.delete(aliasExported);
+        group.bindings.set(aliasLocal, aliasExported);
       }
     }
     return Array.from(groups.values()).map((g) => ({
       module: g.module,
       importedNames: Array.from(g.names).sort(),
+      bindings: Array.from(g.bindings.entries()).map(([local, exported]) => ({ exported, local })).sort((a, b) => a.local.localeCompare(b.local)),
       span: { startByte: g.startByte, endByte: g.endByte }
     })).sort((a, b) => a.span.startByte - b.span.startByte || a.module.localeCompare(b.module));
   } finally {
@@ -786,6 +842,12 @@ function extractCallSites(root, language, lang) {
           calleeNameCandidates: [cap.node.text],
           span: { startByte: cap.node.startIndex, endByte: cap.node.endIndex }
         });
+      } else if (cap.name === "call.member") {
+        callSites.push({
+          calleeNameCandidates: [cap.node.text],
+          memberAccess: true,
+          span: { startByte: cap.node.startIndex, endByte: cap.node.endIndex }
+        });
       }
     }
     return callSites.sort(
@@ -1101,6 +1163,219 @@ function createCodingGraphEngine(_options = {}) {
 // src/reindex.ts
 import { readFile as fsReadFile, realpath as fsRealpath } from "fs/promises";
 import path2 from "path";
+
+// src/heuristic-resolution.ts
+import { posix } from "path";
+var EXPLICIT_RECEIVER_LANGUAGES = /* @__PURE__ */ new Set([
+  "typescript",
+  "tsx",
+  "javascript",
+  "python",
+  // PHP method dispatch requires $this->/self:: — both arrive as
+  // member_call_expression (memberAccess) — so a bare helper() inside a
+  // method never means a sibling method (codex review round 12).
+  "php"
+]);
+var HEURISTIC_CONFIDENCE_SAME_FILE = 0.9;
+var HEURISTIC_CONFIDENCE_IMPORT_BOUND = 0.8;
+var HEURISTIC_PROVENANCE_SCOPE = ["heuristic"];
+function deriveHeuristicEdges(batch) {
+  let callSites = 0;
+  let resolved = 0;
+  let skippedUnresolved = 0;
+  let skippedAmbiguous = 0;
+  let skippedNoEnclosingSymbol = 0;
+  let skippedMemberAccess = 0;
+  const files = [];
+  for (const ir of batch) {
+    const parentOf = /* @__PURE__ */ new Map();
+    const kindOf = /* @__PURE__ */ new Map();
+    for (const sym of ir.symbols) kindOf.set(sym.qualifiedName, sym.kind);
+    for (const sym of ir.symbols) {
+      let parent;
+      for (const other of ir.symbols) {
+        if (other === sym) continue;
+        const contains = other.span.startByte <= sym.span.startByte && sym.span.endByte <= other.span.endByte;
+        const identical = other.span.startByte === sym.span.startByte && other.span.endByte === sym.span.endByte;
+        if (!contains || identical) continue;
+        const size = other.span.endByte - other.span.startByte;
+        if (!parent || size < parent.size) {
+          parent = { qualifiedName: other.qualifiedName, size };
+        }
+      }
+      parentOf.set(sym.qualifiedName, parent ? parent.qualifiedName : "");
+    }
+    const scopeByName = /* @__PURE__ */ new Map();
+    for (const sym of ir.symbols) {
+      const level = parentOf.get(sym.qualifiedName) ?? "";
+      let names = scopeByName.get(level);
+      if (!names) {
+        names = /* @__PURE__ */ new Map();
+        scopeByName.set(level, names);
+      }
+      const prior = names.get(sym.name);
+      if (prior) {
+        prior.count += 1;
+      } else {
+        names.set(sym.name, { qualifiedName: sym.qualifiedName, count: 1 });
+      }
+    }
+    const importBindings = /* @__PURE__ */ new Map();
+    for (const imp of ir.imports) {
+      let specifier;
+      if (imp.module.startsWith("./") || imp.module.startsWith("../")) {
+        specifier = imp.module;
+      } else if (ir.language === "python" && imp.module.startsWith(".")) {
+        const dots = /^\.+/.exec(imp.module)?.[0].length ?? 1;
+        const rest = imp.module.slice(dots).replace(/\./g, "/");
+        specifier = `${"../".repeat(dots - 1)}${rest}` || ".";
+      }
+      if (specifier === void 0) continue;
+      const joined = posix.join(posix.dirname(ir.path), specifier);
+      const hint = joined.replace(/\/+$/, "").replace(/\.[cm]?[jt]sx?$/, "");
+      if (hint.startsWith("../")) continue;
+      const bindings = imp.bindings ?? imp.importedNames.map((name) => ({ exported: name, local: name }));
+      let enclosing;
+      for (const sym of ir.symbols) {
+        if (sym.span.startByte > imp.span.startByte || imp.span.endByte > sym.span.endByte) continue;
+        const size = sym.span.endByte - sym.span.startByte;
+        if (!enclosing || size < enclosing.size) {
+          enclosing = { qualifiedName: sym.qualifiedName, size };
+        }
+      }
+      const enclosingKind = enclosing === void 0 ? void 0 : kindOf.get(enclosing.qualifiedName);
+      const visible = enclosingKind === void 0 || enclosingKind !== "class" && enclosingKind !== "interface" && enclosingKind !== "enum";
+      for (const b of bindings) {
+        const list = importBindings.get(b.local) ?? [];
+        list.push({
+          exported: b.exported,
+          hint,
+          enclosing: visible ? enclosing?.qualifiedName : void 0,
+          // A class-body import is genuinely invisible: store it with a
+          // sentinel that can never match an ancestor chain.
+          invisible: !visible
+        });
+        importBindings.set(b.local, list);
+      }
+    }
+    const edges = [];
+    const seenKeys = /* @__PURE__ */ new Set();
+    for (const site of ir.callSites) {
+      callSites += 1;
+      if (site.memberAccess === true) {
+        skippedMemberAccess += 1;
+        continue;
+      }
+      let src;
+      for (const sym of ir.symbols) {
+        if (sym.span.startByte > site.span.startByte || site.span.endByte > sym.span.endByte) continue;
+        const size = sym.span.endByte - sym.span.startByte;
+        if (!src || size < src.size) {
+          src = { qualifiedName: sym.qualifiedName, size };
+        }
+      }
+      if (!src) {
+        skippedNoEnclosingSymbol += 1;
+        continue;
+      }
+      const excludeClassScopes = EXPLICIT_RECEIVER_LANGUAGES.has(ir.language);
+      const scopeLevels = [src.qualifiedName];
+      const ancestorChain = /* @__PURE__ */ new Set([src.qualifiedName]);
+      let cursor = src.qualifiedName;
+      while (cursor !== void 0 && cursor !== "") {
+        cursor = parentOf.get(cursor) ?? "";
+        if (cursor !== "") ancestorChain.add(cursor);
+        if (excludeClassScopes) {
+          const kind = cursor === "" ? void 0 : kindOf.get(cursor);
+          if (kind === "class" || kind === "interface" || kind === "enum") continue;
+        }
+        scopeLevels.push(cursor);
+      }
+      let dstQualifiedName;
+      let dstPathHint;
+      let confidence = 0;
+      let sawAmbiguous = false;
+      for (const candidate of site.calleeNameCandidates) {
+        let candidateAmbiguous = false;
+        for (const level of scopeLevels) {
+          const match = scopeByName.get(level)?.get(candidate);
+          if (!match) continue;
+          if (match.count === 1) {
+            dstQualifiedName = match.qualifiedName;
+            confidence = HEURISTIC_CONFIDENCE_SAME_FILE;
+          } else {
+            candidateAmbiguous = true;
+          }
+          break;
+        }
+        if (dstQualifiedName !== void 0) break;
+        if (candidateAmbiguous) {
+          sawAmbiguous = true;
+          continue;
+        }
+        const candidates = importBindings.get(candidate);
+        if (candidates !== void 0) {
+          let chosen;
+          let chosenDepth = -1;
+          for (const c of candidates) {
+            if (c.invisible) continue;
+            if (c.enclosing === void 0) {
+              if (chosenDepth < 0) {
+                chosen = c;
+                chosenDepth = 0;
+              }
+              continue;
+            }
+            if (ancestorChain.has(c.enclosing)) {
+              const depth = [...ancestorChain].indexOf(c.enclosing);
+              if (chosenDepth < 0 || depth < chosenDepth) {
+                chosen = c;
+                chosenDepth = depth;
+              }
+            }
+          }
+          if (chosen) {
+            dstQualifiedName = chosen.exported;
+            dstPathHint = chosen.hint;
+            confidence = HEURISTIC_CONFIDENCE_IMPORT_BOUND;
+            break;
+          }
+        }
+      }
+      if (dstQualifiedName === void 0) {
+        if (sawAmbiguous) skippedAmbiguous += 1;
+        else skippedUnresolved += 1;
+        continue;
+      }
+      resolved += 1;
+      const key = `${src.qualifiedName}\0${dstQualifiedName}\0${dstPathHint ?? ""}`;
+      if (seenKeys.has(key)) continue;
+      seenKeys.add(key);
+      edges.push({
+        srcQualifiedName: src.qualifiedName,
+        dstQualifiedName,
+        type: "CALLS",
+        confidence,
+        provenance: "heuristic",
+        ...dstPathHint !== void 0 ? { dstPathHint, dstImporterLanguage: ir.language } : {}
+      });
+    }
+    files.push({ ...ir, edges });
+  }
+  return {
+    files,
+    stats: {
+      callSites,
+      resolved,
+      skippedUnresolved,
+      skippedAmbiguous,
+      skippedNoEnclosingSymbol,
+      skippedMemberAccess
+    }
+  };
+}
+
+// src/reindex.ts
 var META_KEY_LAST_HEAD = "last_indexed_head";
 var META_KEY_PENDING_PARSE_FAILURES = "pending_parse_failures";
 function planReindex(lastState, facts) {
@@ -1467,7 +1742,7 @@ function computeNextPending(args) {
   return [...next];
 }
 async function ingestFiles(store, repoRoot, parseFile, readFile2, paths, deletePaths = []) {
-  const batch = [];
+  const parsed = [];
   const parseFailedPaths = [];
   for (const relPath of paths) {
     if (!isCanonicalRelativePath(relPath)) {
@@ -1488,8 +1763,13 @@ async function ingestFiles(store, repoRoot, parseFile, readFile2, paths, deleteP
       parseFailedPaths.push(relPath);
       continue;
     }
-    batch.push(parseResult.ir);
+    parsed.push(parseResult.ir);
   }
+  const derived = deriveHeuristicEdges(parsed);
+  const batch = derived.files.map((file) => ({
+    ...file,
+    assertedEdgeProvenances: HEURISTIC_PROVENANCE_SCOPE
+  }));
   const upsertResult = await store.upsertFileBatch(batch, deletePaths);
   if (!upsertResult.ok) {
     return {