@remnic/coding-graph 9.6.24 → 9.6.26

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-ZLCF3XQK.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();
@@ -1899,4 +1973,4 @@ export {
   GraphStore,
   nodeIdFor
 };
-//# sourceMappingURL=chunk-ZLCF3XQK.js.map
+//# sourceMappingURL=chunk-ABDBWCXU.js.map