@remnic/coding-graph 9.6.23 → 9.6.25

package/README.md

@@ -4,8 +4,7 @@
 engine: web-tree-sitter grammars, per-language symbol extractors, and the
 neutral `FileIR` intermediate representation that the graph store consumes.
 
-> Part of #1548 (Track B, Phase 1). Package and core wiring for PR1 (#1551
-> step 1 + step 2). The real backend lands in PR2 (#1551 step 3+).
+> Part of Remnic's coding-knowledge layer (issue #1548).
 
 ## Install
 
@@ -15,23 +14,21 @@ npm install @remnic/coding-graph
 pnpm add @remnic/coding-graph
 ```
 
-## Status (PR1)
-
-This package's public surface is **scaffolded only**:
-
-- `ENGINE_VERSION = "0.1.0-pr1"` constant
-- `TIER_1_LANGUAGES` (15 languages)
-- `CodingGraphError` tagged error class (`code: "not_implemented" | "module_load_failed"`)
-- `CodingGraphEngine` interface — the full PR2 contract, no implementation
-- `createCodingGraphEngine()` — throws `CodingGraphError("not_implemented", …)`
-
-Calling `createCodingGraphEngine()` *always* throws a tagged error. There
-is no silent stub and there is no half-working fallback. The runtime
-contract is observable today; PR2 fills the implementation.
-
-`web-tree-sitter` is declared as the parser engine; grammar `.wasm` assets
-will ship in PR2 via the `grammars/` directory listed in the package's
-`files` manifest.
+## What it provides
+
+- `createCodingGraphEngine()` — returns a working engine backed by a
+  WASM tree-sitter parser. It parses source files into the neutral `FileIR`
+  (symbols plus import edges) for the 15 tier-1 languages.
+- `TIER_1_LANGUAGES` — the supported tier-1 language list.
+- `ENGINE_VERSION` / `CODING_GRAPH_ENGINE_VERSION` — the engine version
+  string. The single source of truth lives in `@remnic/core`; this package
+  re-exports it so every consumer stays in lockstep.
+- `CodingGraphEngine` interface and the `CodingGraphError` tagged error class.
+
+A per-file parse failure surfaces as a tagged `{ ok: false, code: "parse_failed" }`
+result rather than a thrown exception, so one unparseable file never bricks a
+whole index run. Grammar `.wasm` assets ship in the `grammars/` directory listed
+in the package's `files` manifest.
 
 ## How `@remnic/core` loads this
 

package/dist/{chunk-CPYJACC5.js → chunk-ABDBWCXU.js}

@@ -207,6 +207,80 @@ var GraphStore = class _GraphStore {
     }
     return this.queue.schedule(() => this.runUpsertEdges(edges));
   }
+  /**
+   * Retire stale LSP-provenance edges for a file (issue #1895).
+   *
+   * The LSP resolution pass re-derives edges from the CURRENT source on each
+   * run. After writing the new `lsp` edges for a file, this method deletes
+   * prior `lsp`-provenance edges owned by that file's nodes whose
+   * `(src, dst, type)` key is NOT in the asserted set. This is the LSP
+   * layer's side of the provenance-lifecycle contract: each layer owns its
+   * own stale-edge retirement (#1894 established that reindex's heuristic
+   * scope never touches `lsp` rows).
+   *
+   * Heuristic, trace, and semantic edges are never touched.
+   *
+   * @returns the number of retired edges.
+   */
+  reconcileLspEdges(filePath, assertedEdges) {
+    if (this.closed) return 0;
+    try {
+      const fileRow = expectRow(
+        this.db.prepare("SELECT id FROM files WHERE path = ?").get(filePath),
+        ["id"]
+      );
+      if (!fileRow) return 0;
+      const nodes = expectRows(
+        this.db.prepare("SELECT id, qualified_name FROM nodes WHERE file_id = ?").all(fileRow.id),
+        ["id", "qualified_name"]
+      );
+      if (nodes.length === 0) return 0;
+      const nameCount = /* @__PURE__ */ new Map();
+      for (const n of nodes) nameCount.set(n.qualified_name, (nameCount.get(n.qualified_name) ?? 0) + 1);
+      const srcMap = /* @__PURE__ */ new Map();
+      for (const n of nodes) {
+        if (nameCount.get(n.qualified_name) === 1) srcMap.set(n.qualified_name, n.id);
+      }
+      const nodeIds = nodes.map((n) => n.id);
+      const assertedKeys = /* @__PURE__ */ new Set();
+      for (const e of assertedEdges) {
+        const srcId = srcMap.get(e.srcQualifiedName);
+        if (!srcId) continue;
+        const dstId = resolveNodeId(e.dstQualifiedName, /* @__PURE__ */ new Map(), this.db);
+        if (!dstId) continue;
+        assertedKeys.add(`${srcId}\0${dstId}\0${e.type}`);
+      }
+      const placeholders = nodeIds.map(() => "?").join(", ");
+      const priorEdges = expectRows(
+        this.db.prepare(
+          `SELECT src, dst, type FROM edges
+              WHERE src IN (${placeholders}) AND provenance = 'lsp'`
+        ).all(...nodeIds),
+        ["src", "dst", "type"]
+      );
+      let deleted = 0;
+      const toDelete = [];
+      for (const e of priorEdges) {
+        const key = `${e.src}\0${e.dst}\0${e.type}`;
+        if (!assertedKeys.has(key)) toDelete.push([e.src, e.dst, e.type]);
+      }
+      if (toDelete.length > 0) {
+        const SQLITE_VARIABLE_LIMIT2 = 32766;
+        const PARAMS_PER_TUPLE = 3;
+        const MAX_TUPLES = Math.floor(SQLITE_VARIABLE_LIMIT2 / PARAMS_PER_TUPLE);
+        for (let i = 0; i < toDelete.length; i += MAX_TUPLES) {
+          const chunk = toDelete.slice(i, i + MAX_TUPLES);
+          const ph = chunk.map(() => "(?, ?, ?)").join(", ");
+          const r = this.db.prepare(`DELETE FROM edges WHERE (src, dst, type) IN (${ph})`).run(...chunk.flat());
+          deleted += r.changes;
+        }
+      }
+      return deleted;
+    } catch (error) {
+      logWriteFailure(error);
+      return 0;
+    }
+  }
   /** Wait for pending writes to drain — test seam. */
   async drain() {
     await this.queue.drain();
@@ -748,11 +822,12 @@ var GraphStore = class _GraphStore {
       }
       const srcId = qualifiedNameToId.get(edge.srcQualifiedName);
       if (!srcId) continue;
-      const dstId = resolveNodeId(
+      const dstId = edge.dstPathHint ? resolveNodeIdWithPathHint(
         edge.dstQualifiedName,
-        qualifiedNameToId,
-        this.db
-      );
+        edge.dstPathHint,
+        this.db,
+        edge.dstImporterLanguage
+      ) : resolveNodeId(edge.dstQualifiedName, qualifiedNameToId, this.db);
       if (!dstId) continue;
       const key = `${srcId}\0${dstId}\0${edge.type}`;
       assertedKeys.add(key);
@@ -769,12 +844,13 @@ var GraphStore = class _GraphStore {
     );
     const priorByKey = /* @__PURE__ */ new Map();
     const staleSrcDstTypes = [];
+    const scoped = ir.assertedEdgeProvenances && ir.assertedEdgeProvenances.length > 0 ? ir.assertedEdgeProvenances : void 0;
     for (const p of priorEdges) {
       const key = `${p.src}\0${p.dst}\0${p.type}`;
       priorByKey.set(key, { confidence: p.confidence, provenance: p.provenance });
-      if (!assertedKeys.has(key)) {
-        staleSrcDstTypes.push({ src: p.src, dst: p.dst, type: p.type });
-      }
+      if (assertedKeys.has(key)) continue;
+      if (scoped && !scoped.includes(p.provenance)) continue;
+      staleSrcDstTypes.push({ src: p.src, dst: p.dst, type: p.type });
     }
     const SQLITE_VARIABLE_LIMIT2 = 32766;
     const PARAMS_PER_TUPLE = 3;
@@ -805,6 +881,9 @@ var GraphStore = class _GraphStore {
       if (prior && prior.confidence === edge.confidence && prior.provenance === edge.provenance) {
         continue;
       }
+      if (prior && scoped && (!scoped.includes(prior.provenance) || prior.provenance === "lsp" && edge.provenance === "heuristic")) {
+        continue;
+      }
       const r = insertEdge.run(srcId, dstId, edge.type, edge.confidence, edge.provenance);
       edgeCount += r.changes;
     }
@@ -1734,6 +1813,65 @@ function resolveNodeId(qualifiedName, inBatch, db) {
   }
   return rows[0]?.id;
 }
+var LANG_FAMILY_EXTENSIONS = {
+  js: /* @__PURE__ */ new Set(["ts", "tsx", "js", "jsx", "mjs", "cjs", "mts", "cts"]),
+  python: /* @__PURE__ */ new Set(["py", "pyi"]),
+  ruby: /* @__PURE__ */ new Set(["rb"]),
+  go: /* @__PURE__ */ new Set(["go"]),
+  rust: /* @__PURE__ */ new Set(["rs"]),
+  php: /* @__PURE__ */ new Set(["php"]),
+  java: /* @__PURE__ */ new Set(["java"]),
+  csharp: /* @__PURE__ */ new Set(["cs"]),
+  cpp: /* @__PURE__ */ new Set(["cc", "cpp", "cxx", "c", "hh", "hpp", "hxx", "h"]),
+  kotlin: /* @__PURE__ */ new Set(["kt"]),
+  swift: /* @__PURE__ */ new Set(["swift"]),
+  bash: /* @__PURE__ */ new Set(["sh", "bash"])
+};
+var IMPORTER_LANG_FAMILY = {
+  typescript: "js",
+  tsx: "js",
+  javascript: "js",
+  python: "python",
+  ruby: "ruby",
+  go: "go",
+  rust: "rust",
+  php: "php",
+  java: "java",
+  csharp: "csharp",
+  c: "cpp",
+  cpp: "cpp",
+  kotlin: "kotlin",
+  swift: "swift",
+  bash: "bash"
+};
+function resolveNodeIdWithPathHint(qualifiedName, pathHint, db, importerLanguage) {
+  const family = importerLanguage ? IMPORTER_LANG_FAMILY[importerLanguage] : void 0;
+  const allowedExts = family ? LANG_FAMILY_EXTENSIONS[family] : void 0;
+  const rows = expectRows(
+    db.prepare(
+      `SELECT n.id, f.path FROM nodes n JOIN files f ON n.file_id = f.id
+          WHERE n.qualified_name = ?
+          ORDER BY f.path, n.id`
+    ).all(qualifiedName),
+    ["id", "path"]
+  );
+  const matches = rows.filter((row) => {
+    if (row.path === pathHint) {
+      if (allowedExts) {
+        return false;
+      }
+      return true;
+    }
+    if (!row.path.startsWith(pathHint)) return false;
+    const rest = row.path.slice(pathHint.length);
+    const m = /^(?:\.([^./]+)|\/(?:index|__init__)\.([^./]+))$/.exec(rest);
+    if (!m) return false;
+    const ext = m[1] ?? m[2];
+    return !allowedExts || allowedExts.has(ext);
+  });
+  if (matches.length !== 1) return void 0;
+  return matches[0]?.id;
+}
 function resolveByNodeId(stmt, nodeId, qualifiedName) {
   const row = expectRow(stmt.get(nodeId), ["qualified_name"]);
   if (!row) return void 0;
@@ -1835,4 +1973,4 @@ export {
   GraphStore,
   nodeIdFor
 };
-//# sourceMappingURL=chunk-CPYJACC5.js.map
+//# sourceMappingURL=chunk-ABDBWCXU.js.map