@remnic/coding-graph 9.3.759

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@remnic/coding-graph",
+  "version": "9.3.759",
+  "description": "Web-tree-sitter powered symbol-extraction engine + SQLite knowledge-graph store for codebase memory (Tier 1: TypeScript, TSX, JavaScript, Python, Go, Rust, Java, C, C++, C#, Ruby, PHP, Kotlin, Swift, Bash). Optional companion of @remnic/core — install only when coding-graph features are needed.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "remnic-source": "./src/index.ts",
+      "import": "./dist/index.js"
+    },
+    "./graph-schema": {
+      "types": "./dist/graph-schema.d.ts",
+      "remnic-source": "./src/graph-schema.ts",
+      "import": "./dist/graph-schema.js"
+    },
+    "./graph-store": {
+      "types": "./dist/graph-store.d.ts",
+      "remnic-source": "./src/graph-store.ts",
+      "import": "./dist/graph-store.js"
+    },
+    "./cypher": {
+      "types": "./dist/cypher/query-parser.d.ts",
+      "remnic-source": "./src/cypher/query-parser.ts",
+      "import": "./dist/cypher/query-parser.js"
+    }
+  },
+  "files": [
+    "src",
+    "dist",
+    "grammars"
+  ],
+  "scripts": {
+    "prebuild": "node ../../scripts/ensure-bench-build-deps.mjs",
+    "build": "tsup --config tsup.config.ts",
+    "precheck-types": "node ../../scripts/ensure-bench-build-deps.mjs",
+    "check-types": "tsc --noEmit",
+    "test": "NODE_OPTIONS=\"${NODE_OPTIONS:+$NODE_OPTIONS }--conditions=remnic-source\" tsx --test 'src/**/*.test.ts'",
+    "prepublishOnly": "npm run build"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "better-sqlite3": "^12.6.2",
+    "web-tree-sitter": "^0.25.0"
+  },
+  "peerDependencies": {
+    "@remnic/core": "^9.3.759"
+  },
+  "devDependencies": {
+    "@remnic/core": "workspace:*",
+    "@types/node": "^22.10.0",
+    "tsup": "^8.5.1",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/joshuaswarren/remnic.git",
+    "directory": "packages/coding-graph"
+  },
+  "keywords": [
+    "remnic",
+    "memory",
+    "codebase",
+    "coding-graph",
+    "knowledge-graph",
+    "sqlite",
+    "tree-sitter",
+    "wasm",
+    "symbols",
+    "extraction"
+  ]
+}

package/src/co-change.test.ts

@@ -0,0 +1,175 @@
+/**
+ * Co-change mining tests (issue #1553).
+ *
+ * mineCoChangeEdges: pure function over commit→files entries.
+ * Tests: support/confidence thresholds, idempotency, byte-stability.
+ */
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { GraphStore } from "./graph-store.js";
+import {
+  mineCoChangeEdges,
+  mineAndStoreCoChanges,
+  DEFAULT_CO_CHANGE_CONFIG,
+  type CoChangeConfig,
+} from "./co-change.js";
+import type { CodingGitInvoker, LogFilesEntry } from "./git-invoker.js";
+
+// ──────────────────────────────────────────────────────────────────────────
+// Pure mining tests
+// ──────────────────────────────────────────────────────────────────────────
+
+const COMMIT_A = "a".repeat(40);
+const COMMIT_B = "b".repeat(40);
+const COMMIT_C = "c".repeat(40);
+const COMMIT_D = "d".repeat(40);
+
+test("mineCoChangeEdges: basic — two files co-changed 3 times", () => {
+  const entries: LogFilesEntry[] = [
+    { sha: COMMIT_A, files: ["src/a.ts", "src/b.ts"] },
+    { sha: COMMIT_B, files: ["src/a.ts", "src/b.ts"] },
+    { sha: COMMIT_C, files: ["src/a.ts", "src/b.ts"] },
+  ];
+  const edges = mineCoChangeEdges(entries, {
+    maxCommits: 500,
+    minSupport: 3,
+    minConfidence: 0.3,
+  });
+  assert.equal(edges.length, 1);
+  assert.equal(edges[0]!.fileA, "src/a.ts");
+  assert.equal(edges[0]!.fileB, "src/b.ts");
+  assert.equal(edges[0]!.support, 3);
+  assert.equal(edges[0]!.confidence, 1.0); // 3/3 = 1.0
+});
+
+test("mineCoChangeEdges: below support threshold → no edge", () => {
+  const entries: LogFilesEntry[] = [
+    { sha: COMMIT_A, files: ["src/a.ts", "src/b.ts"] },
+    { sha: COMMIT_B, files: ["src/a.ts", "src/b.ts"] },
+  ];
+  const edges = mineCoChangeEdges(entries, DEFAULT_CO_CHANGE_CONFIG);
+  // support=2 < minSupport=3 → no edge.
+  assert.equal(edges.length, 0);
+});
+
+test("mineCoChangeEdges: below confidence threshold → no edge", () => {
+  // a.ts changed 10 times, b.ts changed 10 times, co-changed 3 times.
+  // confidence = 3/10 = 0.3 — exactly at threshold (minConfidence=0.3).
+  // With minConfidence=0.31 → no edge.
+  const entries: LogFilesEntry[] = [
+    { sha: COMMIT_A, files: ["src/a.ts", "src/b.ts"] },
+    { sha: COMMIT_B, files: ["src/a.ts", "src/b.ts"] },
+    { sha: COMMIT_C, files: ["src/a.ts", "src/b.ts"] },
+    // a.ts changed alone 7 more times.
+    ...Array.from({ length: 7 }, (_, i) => ({
+      sha: `${i}${"x".repeat(39)}`,
+      files: ["src/a.ts"],
+    })),
+    // b.ts changed alone 7 more times.
+    ...Array.from({ length: 7 }, (_, i) => ({
+      sha: `${i + 7}${"y".repeat(39)}`,
+      files: ["src/b.ts"],
+    })),
+  ];
+  const config: CoChangeConfig = {
+    maxCommits: 500,
+    minSupport: 3,
+    minConfidence: 0.31,
+  };
+  const edges = mineCoChangeEdges(entries, config);
+  assert.equal(edges.length, 0);
+});
+
+test("mineCoChangeEdges: idempotent — same input, same output", () => {
+  const entries: LogFilesEntry[] = [
+    { sha: COMMIT_A, files: ["src/a.ts", "src/b.ts", "src/c.ts"] },
+    { sha: COMMIT_B, files: ["src/a.ts", "src/b.ts"] },
+    { sha: COMMIT_C, files: ["src/b.ts", "src/c.ts"] },
+    { sha: COMMIT_D, files: ["src/a.ts", "src/c.ts"] },
+  ];
+  const e1 = mineCoChangeEdges(entries, DEFAULT_CO_CHANGE_CONFIG);
+  const e2 = mineCoChangeEdges(entries, DEFAULT_CO_CHANGE_CONFIG);
+  assert.deepEqual(e1, e2);
+});
+
+test("mineCoChangeEdges: byte-stable sort order", () => {
+  const entries: LogFilesEntry[] = [
+    { sha: COMMIT_A, files: ["src/z.ts", "src/a.ts"] },
+    { sha: COMMIT_B, files: ["src/z.ts", "src/a.ts"] },
+    { sha: COMMIT_C, files: ["src/z.ts", "src/a.ts"] },
+  ];
+  const edges = mineCoChangeEdges(entries, DEFAULT_CO_CHANGE_CONFIG);
+  // Sorted by fileA then fileB — a.ts before z.ts.
+  assert.equal(edges[0]!.fileA, "src/a.ts");
+  assert.equal(edges[0]!.fileB, "src/z.ts");
+});
+
+test("mineCoChangeEdges: empty input → empty output", () => {
+  const edges = mineCoChangeEdges([], DEFAULT_CO_CHANGE_CONFIG);
+  assert.equal(edges.length, 0);
+});
+
+// ──────────────────────────────────────────────────────────────────────────
+// mineAndStoreCoChanges — integration with GraphStore
+// ──────────────────────────────────────────────────────────────────────────
+
+function mockGitForLog(entries: LogFilesEntry[]): CodingGitInvoker {
+  return {
+    revParseHead: () => ({ ok: true, head: COMMIT_A }),
+    isReachable: () => ({ ok: true, reachable: true }),
+    diffNameStatus: () => ({ ok: true, entries: [] }),
+    diffHunks: () => ({ ok: true, hunks: [] }),
+    logFiles: () => ({ ok: true, entries }),
+    listTrackedFiles: () => ({ ok: true, paths: [] }),  };
+}
+
+async function tempStore(): Promise<{ store: GraphStore; dir: string }> {
+  const dir = await mkdtemp(path.join(tmpdir(), "cochange-test-"));
+  const store = await GraphStore.open({
+    dbPath: path.join(dir, "graph.sqlite"),
+    repoRoot: dir,
+  });
+  return { store, dir };
+}
+
+async function dispose(store: GraphStore, dir: string): Promise<void> {
+  await store.close();
+  await rm(dir, { recursive: true, force: true });
+}
+
+test("mineAndStoreCoChanges: stores edges + idempotent re-run", async () => {
+  const { store, dir } = await tempStore();
+  try {
+    const entries: LogFilesEntry[] = [
+      { sha: COMMIT_A, files: ["src/a.ts", "src/b.ts"] },
+      { sha: COMMIT_B, files: ["src/a.ts", "src/b.ts"] },
+      { sha: COMMIT_C, files: ["src/a.ts", "src/b.ts"] },
+    ];
+    const git = mockGitForLog(entries);
+
+    const r1 = await mineAndStoreCoChanges({ store, git, repoRoot: dir });
+    assert.equal(r1.ok, true);
+    if (!r1.ok) return;
+    assert.equal(r1.edges.length, 1);
+
+    // Verify edges persisted.
+    const coForA = store.readCoChanges("src/a.ts");
+    assert.equal(coForA.ok, true);
+    if (!coForA.ok) return;
+    assert.equal(coForA.edges.length, 1);
+    assert.equal(coForA.edges[0]!.fileB, "src/b.ts");
+
+    // Re-run: idempotent (clear + repopulate).
+    const r2 = await mineAndStoreCoChanges({ store, git, repoRoot: dir });
+    assert.equal(r2.ok, true);
+    const coForA2 = store.readCoChanges("src/a.ts");
+    assert.equal(coForA2.ok, true);
+    assert.equal(coForA2.ok ? coForA2.edges.length : -1, 1);
+  } finally {
+    await dispose(store, dir);
+  }
+});

package/src/co-change.ts

@@ -0,0 +1,167 @@
+/**
+ * FILE_CHANGES_WITH co-change edge mining (issue #1553).
+ *
+ * Mines co-change relationships from `git log --name-only` over a bounded
+ * window (default 500 commits). An edge between two files is written when:
+ *   - support (co-change count) ≥ `minSupport`
+ *   - confidence (co-change / total changes of the less-changed file) ≥
+ *     `minConfidence`
+ *
+ * Deterministic given the same history — re-running on unchanged history
+ * is idempotent (same edges, same confidence).
+ *
+ * Co-change edges are stored in a dedicated `co_changes` table (file-level,
+ * not symbol-level — the existing `edges` table is between symbol nodes).
+ * The table is additive to schema v1 (CREATE TABLE IF NOT EXISTS — same
+ * pattern as `node_attributes` in PR2).
+ */
+import type { CodingGitInvoker, GitFailure, LogFilesEntry } from "./git-invoker.js";
+import type { GraphStore } from "./graph-store.js";
+
+// ──────────────────────────────────────────────────────────────────────────
+// Public types
+// ──────────────────────────────────────────────────────────────────────────
+
+/** A mined co-change edge between two files. */
+export interface CoChangeEdge {
+  readonly fileA: string;
+  readonly fileB: string;
+  /** Number of commits where both files changed together. */
+  readonly support: number;
+  /** Confidence: support / min(totalChangesA, totalChangesB). */
+  readonly confidence: number;
+}
+
+/** Result of co-change mining. */
+export type MineCoChangesResult =
+  | { readonly ok: true; readonly edges: readonly CoChangeEdge[] }
+  | GitFailure
+  | { readonly ok: false; readonly code: "store_closed" | "db_error" };
+
+/** Configuration for co-change mining. */
+export interface CoChangeConfig {
+  /** Maximum commits to scan (default 500). */
+  readonly maxCommits: number;
+  /** Minimum co-change count to write an edge (default 3). */
+  readonly minSupport: number;
+  /** Minimum confidence to write an edge (default 0.3). */
+  readonly minConfidence: number;
+}
+
+export const DEFAULT_CO_CHANGE_CONFIG: CoChangeConfig = {
+  maxCommits: 500,
+  minSupport: 3,
+  minConfidence: 0.3,
+};
+
+// ──────────────────────────────────────────────────────────────────────────
+// Pure mining logic — unit-testable without git or SQLite
+// ──────────────────────────────────────────────────────────────────────────
+
+/**
+ * Compute co-change edges from a list of commit→files entries.
+ *
+ * Algorithm:
+ *   1. Count total changes per file (how many commits touched it).
+ *   2. For each unordered file pair, count how many commits changed both.
+ *   3. Confidence = coChangeCount / min(totalA, totalB).
+ *   4. Keep edges where support ≥ minSupport AND confidence ≥ minConfidence.
+ *
+ * Deterministic: the same input always produces the same output, sorted
+ * by (fileA, fileB) for byte-stability.
+ *
+ * Half-open time windows (rule 35): each commit is a discrete point; a
+ * pair is "co-changed" in a commit iff both files are in that commit's
+ * file list. No off-by-one — a file that appears once in a commit counts
+ * once (deduped by the git-invoker's parser).
+ */
+export function mineCoChangeEdges(
+  entries: readonly LogFilesEntry[],
+  config: CoChangeConfig = DEFAULT_CO_CHANGE_CONFIG,
+): CoChangeEdge[] {
+  // Step 1: total changes per file.
+  const totalChanges = new Map<string, number>();
+  for (const entry of entries) {
+    for (const file of entry.files) {
+      totalChanges.set(file, (totalChanges.get(file) ?? 0) + 1);
+    }
+  }
+
+  // Step 2: co-change counts per unordered pair.
+  // Key: "fileA\x00fileB" where fileA < fileB lexicographically.
+  const coChangeCounts = new Map<string, { a: string; b: string; count: number }>();
+  for (const entry of entries) {
+    const files = entry.files;
+    // Only consider pairs within the same commit.
+    for (let i = 0; i < files.length; i += 1) {
+      for (let j = i + 1; j < files.length; j += 1) {
+        const [a, b] = files[i]! < files[j]! ? [files[i]!, files[j]!] : [files[j]!, files[i]!];
+        const key = `${a}\u0000${b}`;
+        const existing = coChangeCounts.get(key);
+        if (existing) {
+          existing.count += 1;
+        } else {
+          coChangeCounts.set(key, { a, b, count: 1 });
+        }
+      }
+    }
+  }
+
+  // Step 3+4: filter by support + confidence thresholds.
+  const edges: CoChangeEdge[] = [];
+  for (const { a, b, count } of coChangeCounts.values()) {
+    if (count < config.minSupport) continue;
+    const totalA = totalChanges.get(a) ?? 0;
+    const totalB = totalChanges.get(b) ?? 0;
+    const minTotal = Math.min(totalA, totalB);
+    if (minTotal === 0) continue;
+    const confidence = count / minTotal;
+    if (confidence < config.minConfidence) continue;
+    edges.push({ fileA: a, fileB: b, support: count, confidence });
+  }
+
+  // Sort for byte-stability (deterministic output).
+  edges.sort((x, y) => {
+    const cmp = x.fileA.localeCompare(y.fileA);
+    if (cmp !== 0) return cmp;
+    return x.fileB.localeCompare(y.fileB);
+  });
+
+  return edges;
+}
+
+// ──────────────────────────────────────────────────────────────────────────
+// Executor — fetch git log, mine, persist to store
+// ──────────────────────────────────────────────────────────────────────────
+
+/**
+ * Mine co-change edges from git history and persist them to the store's
+ * `co_changes` table. Idempotent: re-running on unchanged history produces
+ * the same edges (the table is cleared + repopulated each run, so stale
+ * edges from history changes are pruned automatically).
+ */
+export async function mineAndStoreCoChanges(options: {
+  readonly store: GraphStore;
+  readonly git: CodingGitInvoker;
+  readonly repoRoot: string;
+  readonly config?: CoChangeConfig;
+}): Promise<MineCoChangesResult> {
+  const { store, git, repoRoot } = options;
+  const config = options.config ?? DEFAULT_CO_CHANGE_CONFIG;
+
+  const logResult = git.logFiles(repoRoot, config.maxCommits);
+  if (!logResult.ok) return logResult;
+
+  const edges = mineCoChangeEdges(logResult.entries, config);
+
+  // Persist: clear + repopulate in one transaction. Propagate a
+  // store_closed failure so the caller does not believe mining
+  // succeeded while nothing was persisted (cursor Bugbot: 'Co-change
+  // store reports false success').
+  const persistResult = await store.upsertCoChanges(edges);
+  if (!persistResult.ok) {
+    return { ok: false, code: persistResult.code };
+  }
+
+  return { ok: true, edges };
+}