@yugenlab/vaayu 0.1.8 → 0.1.10

package/chunks/{chunk-S2HDNNC7.js → chunk-OT4G2L46.js}

@@ -17,10 +17,6 @@ import {
   getChitraguptaHome
 } from "./chunk-UZ6OIVEC.js";
 
-// ../chitragupta/packages/smriti/src/graphrag.ts
-import fs from "fs";
-import path from "path";
-
 // ../chitragupta/packages/smriti/src/graphrag-pagerank.ts
 var PAGERANK_DAMPING = 0.85;
 var PAGERANK_EPSILON = 1e-4;
@@ -77,152 +73,12 @@ function computePageRank(graph) {
   return ranks;
 }
 
-// ../chitragupta/packages/smriti/src/graphrag-pagerank-personalized.ts
-function buildTopicBias(nodeIds, nodeContents, topic) {
-  const bias = /* @__PURE__ */ new Map();
-  const n = nodeIds.length;
-  if (!topic || n === 0) {
-    const uniform = 1 / Math.max(n, 1);
-    for (const id of nodeIds) bias.set(id, uniform);
-    return bias;
-  }
-  const queryTerms = tokenizeSimple(topic);
-  const queryTf = termFrequency(queryTerms);
-  let totalSim = 0;
-  const similarities = new Array(n);
-  for (let i = 0; i < n; i++) {
-    const content = nodeContents.get(nodeIds[i]) ?? "";
-    const docTerms = tokenizeSimple(content);
-    const docTf = termFrequency(docTerms);
-    const sim = tfCosineSimilarity(queryTf, docTf);
-    similarities[i] = sim;
-    totalSim += sim;
-  }
-  if (totalSim === 0) {
-    const uniform = 1 / n;
-    for (const id of nodeIds) bias.set(id, uniform);
-    return bias;
-  }
-  for (let i = 0; i < n; i++) {
-    bias.set(nodeIds[i], similarities[i] / totalSim);
-  }
-  return bias;
-}
-function tokenizeSimple(text) {
-  return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((t) => t.length >= 2);
-}
-function termFrequency(tokens) {
-  const tf = /* @__PURE__ */ new Map();
-  for (const t of tokens) {
-    tf.set(t, (tf.get(t) ?? 0) + 1);
-  }
-  return tf;
-}
-function tfCosineSimilarity(a, b) {
-  let dot = 0;
-  let normA = 0;
-  let normB = 0;
-  for (const [term, freqA] of a) {
-    normA += freqA * freqA;
-    const freqB = b.get(term);
-    if (freqB !== void 0) dot += freqA * freqB;
-  }
-  for (const freqB of b.values()) {
-    normB += freqB * freqB;
-  }
-  const denom = Math.sqrt(normA) * Math.sqrt(normB);
-  return denom === 0 ? 0 : dot / denom;
-}
-function computePersonalizedPageRank(graph, topicBias, opts) {
-  const damping = opts?.damping ?? 0.85;
-  const epsilon = opts?.epsilon ?? 1e-6;
-  const maxIter = opts?.maxIterations ?? 150;
-  const useGS = opts?.useGaussSeidel ?? true;
-  const N = graph.nodes.length;
-  if (N === 0) return /* @__PURE__ */ new Map();
-  const nodeIds = graph.nodes.map((n) => n.id);
-  const nodeIdSet = new Set(nodeIds);
-  const outDegree = /* @__PURE__ */ new Map();
-  const inLinks = /* @__PURE__ */ new Map();
-  for (const id of nodeIds) {
-    outDegree.set(id, 0);
-    inLinks.set(id, []);
-  }
-  for (const edge of graph.edges) {
-    if (nodeIdSet.has(edge.source) && nodeIdSet.has(edge.target)) {
-      outDegree.set(edge.source, (outDegree.get(edge.source) ?? 0) + 1);
-      inLinks.get(edge.target).push(edge.source);
-    }
-  }
-  let bias;
-  if (typeof topicBias === "string") {
-    const nodeContents = /* @__PURE__ */ new Map();
-    for (const node of graph.nodes) {
-      nodeContents.set(node.id, node.content);
-    }
-    bias = buildTopicBias(nodeIds, nodeContents, topicBias);
-  } else if (topicBias instanceof Map) {
-    bias = topicBias;
-  } else {
-    const uniform = 1 / N;
-    bias = new Map(nodeIds.map((id) => [id, uniform]));
-  }
-  const ranks = /* @__PURE__ */ new Map();
-  for (const id of nodeIds) {
-    ranks.set(id, 1 / N);
-  }
-  const danglingNodes = [];
-  for (const id of nodeIds) {
-    if ((outDegree.get(id) ?? 0) === 0) danglingNodes.push(id);
-  }
-  for (let iter = 0; iter < maxIter; iter++) {
-    let danglingSum = 0;
-    for (const id of danglingNodes) {
-      danglingSum += ranks.get(id) ?? 0;
-    }
-    const danglingContrib = damping * danglingSum / N;
-    let maxDelta = 0;
-    if (useGS) {
-      for (const id of nodeIds) {
-        const biasVal = bias.get(id) ?? 1 / N;
-        let incomingSum = 0;
-        for (const src of inLinks.get(id) ?? []) {
-          const srcRank = ranks.get(src) ?? 0;
-          const srcOut = outDegree.get(src) ?? 1;
-          incomingSum += srcRank / srcOut;
-        }
-        const newRank = (1 - damping) * biasVal + damping * incomingSum + danglingContrib;
-        const oldRank = ranks.get(id) ?? 0;
-        const delta = Math.abs(newRank - oldRank);
-        if (delta > maxDelta) maxDelta = delta;
-        ranks.set(id, newRank);
-      }
-    } else {
-      const newRanks = /* @__PURE__ */ new Map();
-      for (const id of nodeIds) {
-        const biasVal = bias.get(id) ?? 1 / N;
-        let incomingSum = 0;
-        for (const src of inLinks.get(id) ?? []) {
-          const srcRank = ranks.get(src) ?? 0;
-          const srcOut = outDegree.get(src) ?? 1;
-          incomingSum += srcRank / srcOut;
-        }
-        const newRank = (1 - damping) * biasVal + damping * incomingSum + danglingContrib;
-        newRanks.set(id, newRank);
-        const delta = Math.abs(newRank - (ranks.get(id) ?? 0));
-        if (delta > maxDelta) maxDelta = delta;
-      }
-      for (const [id, rank] of newRanks) ranks.set(id, rank);
-    }
-    if (maxDelta < epsilon) break;
-  }
-  return ranks;
-}
+// ../chitragupta/packages/smriti/src/graphrag-pagerank-incremental.ts
 var IncrementalPageRank = class {
   ranks = /* @__PURE__ */ new Map();
   outDegree = /* @__PURE__ */ new Map();
   inLinks = /* @__PURE__ */ new Map();
-  /** Forward adjacency list: source → Set<target>. Avoids O(E) reverse lookup in getOutNeighbors(). */
+  /** Forward adjacency list: source -> Set<target>. Avoids O(E) reverse lookup in getOutNeighbors(). */
   outLinks = /* @__PURE__ */ new Map();
   nodeSet = /* @__PURE__ */ new Set();
   damping;
@@ -338,7 +194,7 @@ var IncrementalPageRank = class {
   getRanks() {
     return new Map(this.ranks);
   }
-  // ─── Private ──────────────────────────────────────────────────────
+  // --- Private ---------------------------------------------------------
   /**
    * Propagate residuals through the graph until all are below epsilon.
    *
@@ -384,6 +240,148 @@ var IncrementalPageRank = class {
   }
 };
 
+// ../chitragupta/packages/smriti/src/graphrag-pagerank-personalized.ts
+function buildTopicBias(nodeIds, nodeContents, topic) {
+  const bias = /* @__PURE__ */ new Map();
+  const n = nodeIds.length;
+  if (!topic || n === 0) {
+    const uniform = 1 / Math.max(n, 1);
+    for (const id of nodeIds) bias.set(id, uniform);
+    return bias;
+  }
+  const queryTerms = tokenizeSimple(topic);
+  const queryTf = termFrequency(queryTerms);
+  let totalSim = 0;
+  const similarities = new Array(n);
+  for (let i = 0; i < n; i++) {
+    const content = nodeContents.get(nodeIds[i]) ?? "";
+    const docTerms = tokenizeSimple(content);
+    const docTf = termFrequency(docTerms);
+    const sim = tfCosineSimilarity(queryTf, docTf);
+    similarities[i] = sim;
+    totalSim += sim;
+  }
+  if (totalSim === 0) {
+    const uniform = 1 / n;
+    for (const id of nodeIds) bias.set(id, uniform);
+    return bias;
+  }
+  for (let i = 0; i < n; i++) {
+    bias.set(nodeIds[i], similarities[i] / totalSim);
+  }
+  return bias;
+}
+function tokenizeSimple(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((t) => t.length >= 2);
+}
+function termFrequency(tokens) {
+  const tf = /* @__PURE__ */ new Map();
+  for (const t of tokens) {
+    tf.set(t, (tf.get(t) ?? 0) + 1);
+  }
+  return tf;
+}
+function tfCosineSimilarity(a, b) {
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (const [term, freqA] of a) {
+    normA += freqA * freqA;
+    const freqB = b.get(term);
+    if (freqB !== void 0) dot += freqA * freqB;
+  }
+  for (const freqB of b.values()) {
+    normB += freqB * freqB;
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom === 0 ? 0 : dot / denom;
+}
+function computePersonalizedPageRank(graph, topicBias, opts) {
+  const damping = opts?.damping ?? 0.85;
+  const epsilon = opts?.epsilon ?? 1e-6;
+  const maxIter = opts?.maxIterations ?? 150;
+  const useGS = opts?.useGaussSeidel ?? true;
+  const N = graph.nodes.length;
+  if (N === 0) return /* @__PURE__ */ new Map();
+  const nodeIds = graph.nodes.map((n) => n.id);
+  const nodeIdSet = new Set(nodeIds);
+  const outDegree = /* @__PURE__ */ new Map();
+  const inLinks = /* @__PURE__ */ new Map();
+  for (const id of nodeIds) {
+    outDegree.set(id, 0);
+    inLinks.set(id, []);
+  }
+  for (const edge of graph.edges) {
+    if (nodeIdSet.has(edge.source) && nodeIdSet.has(edge.target)) {
+      outDegree.set(edge.source, (outDegree.get(edge.source) ?? 0) + 1);
+      inLinks.get(edge.target).push(edge.source);
+    }
+  }
+  let bias;
+  if (typeof topicBias === "string") {
+    const nodeContents = /* @__PURE__ */ new Map();
+    for (const node of graph.nodes) {
+      nodeContents.set(node.id, node.content);
+    }
+    bias = buildTopicBias(nodeIds, nodeContents, topicBias);
+  } else if (topicBias instanceof Map) {
+    bias = topicBias;
+  } else {
+    const uniform = 1 / N;
+    bias = new Map(nodeIds.map((id) => [id, uniform]));
+  }
+  const ranks = /* @__PURE__ */ new Map();
+  for (const id of nodeIds) {
+    ranks.set(id, 1 / N);
+  }
+  const danglingNodes = [];
+  for (const id of nodeIds) {
+    if ((outDegree.get(id) ?? 0) === 0) danglingNodes.push(id);
+  }
+  for (let iter = 0; iter < maxIter; iter++) {
+    let danglingSum = 0;
+    for (const id of danglingNodes) {
+      danglingSum += ranks.get(id) ?? 0;
+    }
+    const danglingContrib = damping * danglingSum / N;
+    let maxDelta = 0;
+    if (useGS) {
+      for (const id of nodeIds) {
+        const biasVal = bias.get(id) ?? 1 / N;
+        let incomingSum = 0;
+        for (const src of inLinks.get(id) ?? []) {
+          const srcRank = ranks.get(src) ?? 0;
+          const srcOut = outDegree.get(src) ?? 1;
+          incomingSum += srcRank / srcOut;
+        }
+        const newRank = (1 - damping) * biasVal + damping * incomingSum + danglingContrib;
+        const oldRank = ranks.get(id) ?? 0;
+        const delta = Math.abs(newRank - oldRank);
+        if (delta > maxDelta) maxDelta = delta;
+        ranks.set(id, newRank);
+      }
+    } else {
+      const newRanks = /* @__PURE__ */ new Map();
+      for (const id of nodeIds) {
+        const biasVal = bias.get(id) ?? 1 / N;
+        let incomingSum = 0;
+        for (const src of inLinks.get(id) ?? []) {
+          const srcRank = ranks.get(src) ?? 0;
+          const srcOut = outDegree.get(src) ?? 1;
+          incomingSum += srcRank / srcOut;
+        }
+        const newRank = (1 - damping) * biasVal + damping * incomingSum + danglingContrib;
+        newRanks.set(id, newRank);
+        const delta = Math.abs(newRank - (ranks.get(id) ?? 0));
+        if (delta > maxDelta) maxDelta = delta;
+      }
+      for (const [id, rank] of newRanks) ranks.set(id, rank);
+    }
+    if (maxDelta < epsilon) break;
+  }
+  return ranks;
+}
+
 // ../chitragupta/packages/smriti/src/graphrag-extraction.ts
 var CHUNK_TARGET_TOKENS = 350;
 var CHUNK_MIN_TOKENS = 200;
@@ -1120,19 +1118,13 @@ function removeMemoryFromGraph(graph, scope) {
   );
 }
 
-// ../chitragupta/packages/smriti/src/graphrag-leiden.ts
-var DEFAULT_LEIDEN_CONFIG = {
-  resolution: 1,
-  maxIterations: 10,
-  minModularityGain: 1e-6,
-  seed: 42,
-  minCommunitySize: 1
-};
+// ../chitragupta/packages/smriti/src/leiden-algorithm.ts
 var Xorshift32 = class {
   state;
   constructor(seed) {
     this.state = seed | 0 || 1;
   }
+  /** Generate next pseudo-random number in [0, 1). */
   next() {
     let x = this.state;
     x ^= x << 13;
@@ -1143,17 +1135,17 @@ var Xorshift32 = class {
   }
 };
 var AdjacencyGraph = class {
-  /** nodeIndex → Map<neighborIndex, weight> */
+  /** nodeIndex -> Map<neighborIndex, weight> */
   adj;
-  /** nodeIndex → weighted degree (sum of edge weights) */
+  /** nodeIndex -> weighted degree (sum of edge weights) */
   degree;
   /** Total edge weight (2m). */
   totalWeight;
   /** Number of nodes. */
   n;
-  /** Node ID → index mapping. */
+  /** Node ID -> index mapping. */
   idToIndex;
-  /** Index → node ID mapping. */
+  /** Index -> node ID mapping. */
   indexToId;
   constructor(graph) {
     const nodeIds = graph.nodes.map((n) => n.id);
@@ -1329,6 +1321,15 @@ function compactCommunities(assignment, minSize) {
   }
   return assignment.map((c) => remap.get(c) ?? 0);
 }
+
+// ../chitragupta/packages/smriti/src/graphrag-leiden.ts
+var DEFAULT_LEIDEN_CONFIG = {
+  resolution: 1,
+  maxIterations: 10,
+  minModularityGain: 1e-6,
+  seed: 42,
+  minCommunitySize: 1
+};
 function leiden(graph, config) {
   const cfg = { ...DEFAULT_LEIDEN_CONFIG, ...config };
   if (graph.nodes.length === 0) {
@@ -1361,6 +1362,17 @@ function leiden(graph, config) {
     communities.set(g.indexToId[i], compacted[i]);
   }
   const finalModularity = computeModularity(g, compacted, cfg.resolution);
+  const communityList = buildCommunityList(g, compacted, cfg.resolution);
+  communityList.sort((a, b) => b.members.length - a.members.length);
+  return {
+    communities,
+    communityList,
+    modularity: finalModularity,
+    iterations,
+    levels: 1
+  };
+}
+function buildCommunityList(g, compacted, resolution) {
   const communityNodes = /* @__PURE__ */ new Map();
   for (let i = 0; i < g.n; i++) {
     const c = compacted[i];
@@ -1383,11 +1395,9 @@ function leiden(graph, config) {
     const possibleEdges = members.length * (members.length - 1) / 2;
     const density = possibleEdges > 0 ? internalEdges / possibleEdges : 0;
     let ac = 0;
-    for (const mi of memberSet) {
-      ac += g.degree[mi];
-    }
+    for (const mi of memberSet) ac += g.degree[mi];
     const twoM = g.totalWeight;
-    const communityMod = twoM > 0 ? 2 * internalWeight / twoM - cfg.resolution * (ac / twoM) ** 2 : 0;
+    const communityMod = twoM > 0 ? 2 * internalWeight / twoM - resolution * (ac / twoM) ** 2 : 0;
     communityList.push({
       id,
       members,
@@ -1396,14 +1406,7 @@ function leiden(graph, config) {
       level: 0
     });
   }
-  communityList.sort((a, b) => b.members.length - a.members.length);
-  return {
-    communities,
-    communityList,
-    modularity: finalModularity,
-    iterations,
-    levels: 1
-  };
+  return communityList;
 }
 function annotateCommunities(graph, result) {
   for (const node of graph.nodes) {
@@ -1412,50 +1415,318 @@ function annotateCommunities(graph, result) {
       node.metadata.communityId = communityId;
     }
   }
-}
-function communitySummary(graph, communityId, maxLabels = 5) {
-  const members = graph.nodes.filter(
-    (n) => n.metadata.communityId === communityId
-  );
-  const typeCount = {};
-  for (const node of members) {
-    typeCount[node.type] = (typeCount[node.type] ?? 0) + 1;
+}
+function communitySummary(graph, communityId, maxLabels = 5) {
+  const members = graph.nodes.filter(
+    (n) => n.metadata.communityId === communityId
+  );
+  const typeCount = {};
+  for (const node of members) {
+    typeCount[node.type] = (typeCount[node.type] ?? 0) + 1;
+  }
+  const labels = members.filter((n) => n.type === "concept" || n.type === "session").slice(0, maxLabels).map((n) => n.label);
+  return { communityId, labels, nodeTypes: typeCount, size: members.length };
+}
+function filterByCommunity(nodes, communityId) {
+  return nodes.filter((n) => n.metadata.communityId === communityId);
+}
+function findBridgeNodes(graph, result, minCommunities = 2) {
+  const touchedCommunities = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    const ownC = result.communities.get(node.id);
+    if (ownC !== void 0) {
+      touchedCommunities.set(node.id, /* @__PURE__ */ new Set([ownC]));
+    }
+  }
+  for (const edge of graph.edges) {
+    const sc = result.communities.get(edge.source);
+    const tc = result.communities.get(edge.target);
+    if (sc === void 0 || tc === void 0) continue;
+    if (sc === tc) continue;
+    touchedCommunities.get(edge.source)?.add(tc);
+    touchedCommunities.get(edge.target)?.add(sc);
+  }
+  const bridges = [];
+  for (const node of graph.nodes) {
+    const communities = touchedCommunities.get(node.id);
+    if (communities && communities.size >= minCommunities) {
+      bridges.push(node);
+    }
+  }
+  return bridges;
+}
+
+// ../chitragupta/packages/smriti/src/graphrag-persistence.ts
+import fs from "fs";
+import path from "path";
+function getGraphDir() {
+  return path.join(getChitraguptaHome(), "graphrag");
+}
+function getGraphPath() {
+  return path.join(getGraphDir(), "graph.json");
+}
+function getEmbeddingsPath() {
+  return path.join(getGraphDir(), "embeddings.json");
+}
+function getPageRankPath() {
+  return path.join(getGraphDir(), "pagerank.json");
+}
+function getGraphDb(initialized, markInitialized) {
+  try {
+    const dbm = DatabaseManager.instance();
+    if (!initialized) {
+      initGraphSchema(dbm);
+      markInitialized();
+    }
+    return dbm.get("graph");
+  } catch {
+    return null;
+  }
+}
+function upsertNodeToDb(db, node) {
+  db.prepare(`
+    INSERT OR REPLACE INTO nodes (id, type, label, content, metadata, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+  `).run(node.id, node.type, node.label, node.content, JSON.stringify(node.metadata), Date.now(), Date.now());
+}
+function insertEdgeToDb(db, edge) {
+  db.prepare(`
+    INSERT OR IGNORE INTO edges (source, target, relationship, weight, pramana, viveka,
+      valid_from, valid_until, recorded_at, superseded_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    edge.source,
+    edge.target,
+    edge.relationship,
+    edge.weight,
+    null,
+    null,
+    edge.validFrom ? new Date(edge.validFrom).getTime() : Date.now(),
+    edge.validUntil ? new Date(edge.validUntil).getTime() : null,
+    edge.recordedAt ? new Date(edge.recordedAt).getTime() : Date.now(),
+    edge.supersededAt ? new Date(edge.supersededAt).getTime() : null
+  );
+}
+function saveToSqlite(db, graph, pageRankScores, embeddingCache) {
+  db.transaction(() => {
+    db.prepare("DELETE FROM pagerank").run();
+    db.prepare("DELETE FROM edges").run();
+    db.prepare("DELETE FROM nodes").run();
+    for (const node of graph.nodes) upsertNodeToDb(db, node);
+    for (const edge of graph.edges) insertEdgeToDb(db, edge);
+    for (const [nodeId, score] of pageRankScores) {
+      db.prepare("INSERT OR REPLACE INTO pagerank (node_id, score, updated_at) VALUES (?, ?, ?)").run(nodeId, score, Date.now());
+    }
+  })();
+  saveEmbeddingsJson(embeddingCache);
+}
+function loadFromSqlite(db) {
+  const nodeCount = db.prepare("SELECT COUNT(*) as cnt FROM nodes").get().cnt;
+  if (nodeCount === 0) return null;
+  const nodeRows = db.prepare("SELECT * FROM nodes").all();
+  const nodes = nodeRows.map((row) => ({
+    id: row.id,
+    type: row.type,
+    label: row.label,
+    content: row.content ?? "",
+    metadata: (() => {
+      try {
+        return JSON.parse(row.metadata ?? "{}");
+      } catch {
+        return {};
+      }
+    })()
+  }));
+  const edgeRows = db.prepare("SELECT * FROM edges").all();
+  const edges = edgeRows.map((row) => ({
+    source: row.source,
+    target: row.target,
+    relationship: row.relationship,
+    weight: row.weight,
+    validFrom: row.valid_from ? new Date(row.valid_from).toISOString() : void 0,
+    validUntil: row.valid_until ? new Date(row.valid_until).toISOString() : void 0,
+    recordedAt: row.recorded_at ? new Date(row.recorded_at).toISOString() : void 0,
+    supersededAt: row.superseded_at ? new Date(row.superseded_at).toISOString() : void 0
+  }));
+  const pageRankScores = /* @__PURE__ */ new Map();
+  const prRows = db.prepare("SELECT * FROM pagerank").all();
+  for (const row of prRows) {
+    pageRankScores.set(row.node_id, row.score);
+  }
+  return { graph: { nodes, edges }, pageRankScores };
+}
+function migrateInMemoryToSqlite(db, graph, pageRankScores) {
+  db.transaction(() => {
+    for (const node of graph.nodes) upsertNodeToDb(db, node);
+    for (const edge of graph.edges) insertEdgeToDb(db, edge);
+    for (const [nodeId, score] of pageRankScores) {
+      db.prepare("INSERT OR REPLACE INTO pagerank (node_id, score, updated_at) VALUES (?, ?, ?)").run(nodeId, score, Date.now());
+    }
+  })();
+}
+function saveToJson(graph, pageRankScores, embeddingCache) {
+  try {
+    const dir = getGraphDir();
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(getGraphPath(), JSON.stringify(graph, null, "	"), "utf-8");
+    saveEmbeddingsJson(embeddingCache);
+    const pageRankObj = {};
+    for (const [key, value] of pageRankScores) pageRankObj[key] = value;
+    fs.writeFileSync(getPageRankPath(), JSON.stringify(pageRankObj, null, "	"), "utf-8");
+  } catch {
+  }
+}
+function loadFromJson() {
+  let graph = { nodes: [], edges: [] };
+  const pageRankScores = /* @__PURE__ */ new Map();
+  try {
+    const graphPath = getGraphPath();
+    if (fs.existsSync(graphPath)) {
+      graph = JSON.parse(fs.readFileSync(graphPath, "utf-8"));
+    }
+  } catch {
+    graph = { nodes: [], edges: [] };
+  }
+  try {
+    const prPath = getPageRankPath();
+    if (fs.existsSync(prPath)) {
+      const ranks = JSON.parse(fs.readFileSync(prPath, "utf-8"));
+      for (const [key, value] of Object.entries(ranks)) pageRankScores.set(key, value);
+    }
+  } catch {
   }
-  const labels = members.filter((n) => n.type === "concept" || n.type === "session").slice(0, maxLabels).map((n) => n.label);
-  return {
-    communityId,
-    labels,
-    nodeTypes: typeCount,
-    size: members.length
-  };
+  return { graph, pageRankScores };
 }
-function filterByCommunity(nodes, communityId) {
-  return nodes.filter((n) => n.metadata.communityId === communityId);
+function saveEmbeddingsJson(embeddingCache) {
+  try {
+    const dir = getGraphDir();
+    fs.mkdirSync(dir, { recursive: true });
+    const embeddings = {};
+    for (const [key, value] of embeddingCache) embeddings[key] = value;
+    fs.writeFileSync(getEmbeddingsPath(), JSON.stringify(embeddings, null, "	"), "utf-8");
+  } catch {
+  }
 }
-function findBridgeNodes(graph, result, minCommunities = 2) {
-  const touchedCommunities = /* @__PURE__ */ new Map();
-  for (const node of graph.nodes) {
-    const ownC = result.communities.get(node.id);
-    if (ownC !== void 0) {
-      touchedCommunities.set(node.id, /* @__PURE__ */ new Set([ownC]));
+function loadEmbeddingsJson(maxCacheSize) {
+  const cache = /* @__PURE__ */ new Map();
+  try {
+    const embPath = getEmbeddingsPath();
+    if (fs.existsSync(embPath)) {
+      const embeddings = JSON.parse(fs.readFileSync(embPath, "utf-8"));
+      for (const [key, value] of Object.entries(embeddings)) cache.set(key, value);
+      while (cache.size > maxCacheSize) {
+        const oldest = cache.keys().next().value;
+        if (oldest !== void 0) cache.delete(oldest);
+      }
     }
+  } catch {
   }
-  for (const edge of graph.edges) {
-    const sc = result.communities.get(edge.source);
-    const tc = result.communities.get(edge.target);
-    if (sc === void 0 || tc === void 0) continue;
-    if (sc === tc) continue;
-    touchedCommunities.get(edge.source)?.add(tc);
-    touchedCommunities.get(edge.target)?.add(sc);
+  return cache;
+}
+function lookupPramana(db, nodeId) {
+  if (!db) return "shabda";
+  try {
+    const row = db.prepare(`
+      SELECT pramana, COUNT(*) as cnt FROM edges
+      WHERE (source = ? OR target = ?) AND pramana IS NOT NULL
+      GROUP BY pramana ORDER BY cnt DESC LIMIT 1
+    `).get(nodeId, nodeId);
+    if (row?.pramana) return row.pramana;
+  } catch {
   }
-  const bridges = [];
-  for (const node of graph.nodes) {
-    const communities = touchedCommunities.get(node.id);
-    if (communities && communities.size >= minCommunities) {
-      bridges.push(node);
+  return "shabda";
+}
+function lookupPramanaBatch(db, nodeIds) {
+  const result = /* @__PURE__ */ new Map();
+  if (nodeIds.length === 0) return result;
+  if (!db) {
+    for (const id of nodeIds) result.set(id, "shabda");
+    return result;
+  }
+  try {
+    const placeholders = nodeIds.map(() => "?").join(",");
+    const rows = db.prepare(`
+      SELECT node_id, pramana FROM (
+        SELECT source AS node_id, pramana, COUNT(*) AS cnt FROM edges
+        WHERE source IN (${placeholders}) AND pramana IS NOT NULL
+        GROUP BY source, pramana
+        UNION ALL
+        SELECT target AS node_id, pramana, COUNT(*) AS cnt FROM edges
+        WHERE target IN (${placeholders}) AND pramana IS NOT NULL
+        GROUP BY target, pramana
+      ) GROUP BY node_id HAVING cnt = MAX(cnt)
+    `).all(...nodeIds, ...nodeIds);
+    for (const row of rows) result.set(row.node_id, row.pramana);
+  } catch {
+  }
+  for (const id of nodeIds) {
+    if (!result.has(id)) result.set(id, "shabda");
+  }
+  return result;
+}
+function migrateGraphJson() {
+  const graphPath = getGraphPath();
+  const prPath = getPageRankPath();
+  if (!fs.existsSync(graphPath)) return { nodes: 0, edges: 0 };
+  try {
+    const graph = JSON.parse(fs.readFileSync(graphPath, "utf-8"));
+    if (!graph.nodes || graph.nodes.length === 0) return { nodes: 0, edges: 0 };
+    const pageRankScores = /* @__PURE__ */ new Map();
+    try {
+      if (fs.existsSync(prPath)) {
+        const ranks = JSON.parse(fs.readFileSync(prPath, "utf-8"));
+        for (const [key, value] of Object.entries(ranks)) pageRankScores.set(key, value);
+      }
+    } catch {
+    }
+    const dbm = DatabaseManager.instance();
+    initGraphSchema(dbm);
+    const db = dbm.get("graph");
+    db.transaction(() => {
+      const upsertStmt = db.prepare(`
+        INSERT OR REPLACE INTO nodes (id, type, label, content, metadata, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `);
+      const edgeStmt = db.prepare(`
+        INSERT OR IGNORE INTO edges (source, target, relationship, weight, pramana, viveka,
+          valid_from, valid_until, recorded_at, superseded_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+      const prStmt = db.prepare(
+        "INSERT OR REPLACE INTO pagerank (node_id, score, updated_at) VALUES (?, ?, ?)"
+      );
+      const now = Date.now();
+      for (const node of graph.nodes) {
+        upsertStmt.run(node.id, node.type, node.label, node.content, JSON.stringify(node.metadata), now, now);
+      }
+      for (const edge of graph.edges) {
+        edgeStmt.run(
+          edge.source,
+          edge.target,
+          edge.relationship,
+          edge.weight,
+          null,
+          null,
+          edge.validFrom ? new Date(edge.validFrom).getTime() : now,
+          edge.validUntil ? new Date(edge.validUntil).getTime() : null,
+          edge.recordedAt ? new Date(edge.recordedAt).getTime() : now,
+          edge.supersededAt ? new Date(edge.supersededAt).getTime() : null
+        );
+      }
+      for (const [nodeId, score] of pageRankScores) prStmt.run(nodeId, score, now);
+    })();
+    try {
+      fs.renameSync(graphPath, graphPath + ".bak");
+    } catch {
+    }
+    try {
+      if (fs.existsSync(prPath)) fs.renameSync(prPath, prPath + ".bak");
+    } catch {
     }
+    return { nodes: graph.nodes.length, edges: graph.edges.length };
+  } catch {
+    return { nodes: 0, edges: 0 };
   }
-  return bridges;
 }
 
 // ../chitragupta/packages/smriti/src/graphrag.ts
@@ -1464,18 +1735,6 @@ var DEFAULT_CONFIG = {
   model: "nomic-embed-text",
   generationModel: "llama3.2"
 };
-function getGraphDir() {
-  return path.join(getChitraguptaHome(), "graphrag");
-}
-function getGraphPath() {
-  return path.join(getGraphDir(), "graph.json");
-}
-function getEmbeddingsPath() {
-  return path.join(getGraphDir(), "embeddings.json");
-}
-function getPageRankPath() {
-  return path.join(getGraphDir(), "pagerank.json");
-}
 var GraphRAGEngine = class {
   config;
   graph;
@@ -1484,9 +1743,9 @@ var GraphRAGEngine = class {
   maxEmbeddingCacheSize;
   ollamaAvailable = null;
   embeddingService;
-  /** Push-based incremental PageRank engine — avoids full recompute on edge changes. */
+  /** Push-based incremental PageRank engine. */
   incrementalPR = null;
-  /** Whether the graph.db schema has been initialized in this process. */
+  /** Whether graph.db schema has been initialized in this process. */
   _graphDbInitialized = false;
   constructor(config) {
     this.config = { ...DEFAULT_CONFIG, ...config };
@@ -1497,7 +1756,6 @@ var GraphRAGEngine = class {
     this.embeddingService = config?.embeddingService ?? new EmbeddingService();
     this.loadFromDisk();
   }
-  // ─── Ollama Availability (for entity extraction) ──────────────────
   async checkOllamaAvailability() {
     if (this.ollamaAvailable !== null) return this.ollamaAvailable;
     try {
@@ -1511,6 +1769,7 @@ var GraphRAGEngine = class {
     }
     return this.ollamaAvailable;
   }
+  /** Get (or compute and cache) an embedding vector for the given text. */
   async getEmbedding(text) {
     const cached = this.embeddingCache.get(text);
     if (cached) return cached;
@@ -1518,17 +1777,15 @@ var GraphRAGEngine = class {
     this.embeddingCache.set(text, vector);
     if (this.embeddingCache.size > this.maxEmbeddingCacheSize) {
       const oldest = this.embeddingCache.keys().next().value;
-      if (oldest !== void 0) {
-        this.embeddingCache.delete(oldest);
-      }
+      if (oldest !== void 0) this.embeddingCache.delete(oldest);
     }
     return vector;
   }
-  // ─── Cosine Similarity (delegate) ──────────────────────────────────
+  /** Compute cosine similarity between two vectors. */
   cosineSimilarity(a, b) {
     return cosineSimilarity(a, b);
   }
-  // ─── Entity Extraction (delegates) ─────────────────────────────────
+  /** Extract named entities from text using LLM (with keyword + NER fallback). */
   async extractEntities(text) {
     const isAvailable = await this.checkOllamaAvailability();
     let baseEntities;
@@ -1573,46 +1830,27 @@ var GraphRAGEngine = class {
     return baseEntities;
   }
   // ─── Incremental PageRank ────────────────────────────────────────
-  /**
-   * Initialize (or reinitialize) the incremental PageRank engine from
-   * the current graph state. Performs one full Gauss-Seidel computation
-   * internally, then subsequent edge changes are O(1/ε) each via
-   * push-based residual propagation.
-   */
+  /** Initialize incremental PageRank from current graph state. */
   initIncrementalPR() {
     this.incrementalPR = new IncrementalPageRank();
     this.incrementalPR.initialize(this.graph);
     this.pageRankScores = this.incrementalPR.getRanks();
   }
-  /**
-   * Feed removed edges into the incremental PR engine so it can adjust
-   * scores via residual propagation rather than a full recompute.
-   */
+  /** Feed removed edges into incremental PR engine. */
   applyEdgeRemovals(edges) {
     if (!this.incrementalPR || edges.length === 0) return;
-    for (const edge of edges) {
-      this.incrementalPR.removeEdge(edge.source, edge.target);
-    }
+    for (const edge of edges) this.incrementalPR.removeEdge(edge.source, edge.target);
     this.pageRankScores = this.incrementalPR.getRanks();
   }
-  /**
-   * Feed newly added edges into the incremental PR engine.
-   */
+  /** Feed newly added edges into incremental PR engine. */
   applyEdgeAdditions(edges) {
     if (!this.incrementalPR || edges.length === 0) return;
-    for (const edge of edges) {
-      this.incrementalPR.addEdge(edge.source, edge.target);
-    }
+    for (const edge of edges) this.incrementalPR.addEdge(edge.source, edge.target);
     this.pageRankScores = this.incrementalPR.getRanks();
   }
-  // ─── PageRank (delegates) ──────────────────────────────────────────
   /**
-   * Compute PageRank for the given graph (or the internal graph if none provided).
-   *
-   * When called with an explicit graph argument, uses the full power-iteration
-   * algorithm (useful for one-off computations on external graphs and tests).
-   * When called without arguments, initializes the incremental PageRank engine
-   * on the internal graph.
+   * Compute PageRank. With an explicit graph argument uses full power-iteration;
+   * without arguments initializes the incremental engine on the internal graph.
    */
   computePageRank(graph) {
     if (graph) {
@@ -1622,49 +1860,41 @@ var GraphRAGEngine = class {
     this.initIncrementalPR();
     return this.pageRankScores;
   }
+  /** Get the PageRank score for a node. Returns 0 if not computed. */
   getPageRank(nodeId) {
     return this.pageRankScores.get(nodeId) ?? 0;
   }
-  /**
-   * Force a full PageRank recompute from the current graph state.
-   * Reinitializes the incremental engine from scratch. Useful after
-   * graph compaction or any structural change that bypasses the
-   * normal indexSession/indexMemory paths.
-   */
+  /** Force a full PageRank recompute and persist. */
   recomputePageRank() {
     this.initIncrementalPR();
     this.saveToDisk();
   }
   // ─── Graph Building ───────────────────────────────────────────────
+  /** Build a full knowledge graph from sessions and memories. */
   async buildGraph(sessions, memories) {
     const nodes = [];
     const edges = [];
     for (const session of sessions) {
-      const sessionNode = await createSessionNode(this, session);
-      nodes.push(sessionNode);
+      nodes.push(await createSessionNode(this, session));
       await indexSessionTurns(this, session, nodes, edges);
     }
-    for (const memory of memories) {
-      await buildMemoryNodes(this, memory, nodes, edges);
-    }
+    for (const memory of memories) await buildMemoryNodes(this, memory, nodes, edges);
     await extractConceptsFromNodes(this, nodes, edges);
     this.graph = { nodes, edges };
     if (this.graph.nodes.length > 0 && this.graph.edges.length > 0) {
-      const leidenResult = leiden(this.graph);
-      annotateCommunities(this.graph, leidenResult);
+      annotateCommunities(this.graph, leiden(this.graph));
     }
     this.initIncrementalPR();
     this.saveToDisk();
     return this.graph;
   }
   // ─── Hybrid Search ───────────────────────────────────────────────
+  /** Search the knowledge graph using hybrid scoring (cosine + PageRank + BM25). */
   async search(query, graph, topK = 10) {
     const searchGraph = graph ?? this.graph;
     if (searchGraph.nodes.length === 0) return [];
     const queryEmbedding = await this.getEmbedding(query);
-    if (this.pageRankScores.size === 0) {
-      this.computePageRank(searchGraph);
-    }
+    if (this.pageRankScores.size === 0) this.computePageRank(searchGraph);
     let maxPageRank = 0;
     for (const node of searchGraph.nodes) {
       const pr = this.pageRankScores.get(node.id) ?? 0;
@@ -1674,30 +1904,26 @@ var GraphRAGEngine = class {
     for (const node of searchGraph.nodes) {
       let cosineSim = 0;
       if (node.embedding && node.embedding.length > 0) {
-        cosineSim = cosineSimilarity(queryEmbedding, node.embedding);
-        cosineSim = Math.max(0, cosineSim);
+        cosineSim = Math.max(0, cosineSimilarity(queryEmbedding, node.embedding));
       }
-      const rawPageRank = this.pageRankScores.get(node.id) ?? 0;
-      const normalizedPageRank = maxPageRank > 0 ? rawPageRank / maxPageRank : 0;
+      const rawPR = this.pageRankScores.get(node.id) ?? 0;
+      const normPR = maxPageRank > 0 ? rawPR / maxPageRank : 0;
       const textScore = textMatchScore(query, node.content + " " + node.label);
-      const finalScore = ALPHA * cosineSim + BETA * normalizedPageRank + GAMMA * textScore;
-      if (finalScore > 0) {
-        scored.push({ node, score: finalScore });
-      }
+      const finalScore = ALPHA * cosineSim + BETA * normPR + GAMMA * textScore;
+      if (finalScore > 0) scored.push({ node, score: finalScore });
     }
     scored.sort((a, b) => b.score - a.score);
     return scored.slice(0, topK).map((s) => s.node);
   }
   // ─── Incremental Indexing ─────────────────────────────────────────
+  /** Index a single session incrementally. */
   async indexSession(session) {
     const edgesBefore = [...this.graph.edges];
     removeSessionFromGraph(this.graph, session.meta.id);
-    const edgesAfterRemoval = this.graph.edges;
-    const edgesAfterSet = new Set(edgesAfterRemoval);
+    const edgesAfterSet = new Set(this.graph.edges);
     const removedEdges = edgesBefore.filter((e) => !edgesAfterSet.has(e));
     const edgeCountBeforeAdd = this.graph.edges.length;
-    const sessionNode = await createSessionNode(this, session);
-    this.graph.nodes.push(sessionNode);
+    this.graph.nodes.push(await createSessionNode(this, session));
     await indexSessionTurns(this, session, this.graph.nodes, this.graph.edges);
     const newEdges = this.graph.edges.slice(edgeCountBeforeAdd);
     if (!this.incrementalPR) {
@@ -1708,11 +1934,11 @@ var GraphRAGEngine = class {
     }
     this.saveToDisk();
   }
+  /** Index a memory scope incrementally. */
   async indexMemory(scope, content) {
     const edgesBefore = [...this.graph.edges];
     removeMemoryFromGraph(this.graph, scope);
-    const edgesAfterRemoval = this.graph.edges;
-    const edgesAfterSet = new Set(edgesAfterRemoval);
+    const edgesAfterSet = new Set(this.graph.edges);
     const removedEdges = edgesBefore.filter((e) => !edgesAfterSet.has(e));
     const edgeCountBeforeAdd = this.graph.edges.length;
     await buildMemoryNodesFromContent(this, scope, content, this.graph.nodes, this.graph.edges);
@@ -1725,322 +1951,91 @@ var GraphRAGEngine = class {
     }
     this.saveToDisk();
   }
-  // ─── Pramana Lookup ──────────────────────────────────────────────
-  /**
-   * Look up the dominant pramana type for a given node ID.
-   *
-   * Queries the edges table for edges involving this node (as source or target)
-   * and returns the most common non-null pramana value. Falls back to 'shabda'
-   * (testimony/documentation) if no pramana data is found.
-   *
-   * @param nodeId - The graph node ID to look up.
-   * @returns The dominant PramanaType for this node.
-   */
+  // ─── Pramana Lookup (delegates) ──────────────────────────────────
+  /** Look up the dominant pramana type for a given node ID. */
   lookupPramana(nodeId) {
-    const db = this.getGraphDb();
-    if (!db) return "shabda";
-    try {
-      const row = db.prepare(`
-        SELECT pramana, COUNT(*) as cnt
-        FROM edges
-        WHERE (source = ? OR target = ?) AND pramana IS NOT NULL
-        GROUP BY pramana
-        ORDER BY cnt DESC
-        LIMIT 1
-      `).get(nodeId, nodeId);
-      if (row?.pramana) return row.pramana;
-    } catch {
-    }
-    return "shabda";
+    return lookupPramana(this.getGraphDbHandle(), nodeId);
   }
-  /**
-   * Batch look up pramana types for multiple node IDs.
-   *
-   * More efficient than calling lookupPramana() individually for each node.
-   * Returns a Map from node ID to PramanaType. Missing entries default to 'shabda'.
-   *
-   * @param nodeIds - Array of node IDs to look up.
-   * @returns Map from node ID to its dominant PramanaType.
-   */
+  /** Batch look up pramana types for multiple node IDs. */
   lookupPramanaBatch(nodeIds) {
-    const result = /* @__PURE__ */ new Map();
-    if (nodeIds.length === 0) return result;
-    const db = this.getGraphDb();
-    if (!db) {
-      for (const id of nodeIds) result.set(id, "shabda");
-      return result;
-    }
-    try {
-      const placeholders = nodeIds.map(() => "?").join(",");
-      const rows = db.prepare(`
-        SELECT node_id, pramana FROM (
-          SELECT source AS node_id, pramana, COUNT(*) AS cnt
-          FROM edges
-          WHERE source IN (${placeholders}) AND pramana IS NOT NULL
-          GROUP BY source, pramana
-          UNION ALL
-          SELECT target AS node_id, pramana, COUNT(*) AS cnt
-          FROM edges
-          WHERE target IN (${placeholders}) AND pramana IS NOT NULL
-          GROUP BY target, pramana
-        )
-        GROUP BY node_id
-        HAVING cnt = MAX(cnt)
-      `).all(...nodeIds, ...nodeIds);
-      for (const row of rows) {
-        result.set(row.node_id, row.pramana);
-      }
-    } catch {
-    }
-    for (const id of nodeIds) {
-      if (!result.has(id)) result.set(id, "shabda");
-    }
-    return result;
-  }
-  // ─── SQLite Persistence Helpers ─────────────────────────────────
-  /**
-   * Get the graph database handle, initializing the schema on first access.
-   * Returns null if the database layer is unavailable (e.g. mocked fs in tests).
-   */
-  getGraphDb() {
-    try {
-      const dbm = DatabaseManager.instance();
-      if (!this._graphDbInitialized) {
-        initGraphSchema(dbm);
-        this._graphDbInitialized = true;
-      }
-      return dbm.get("graph");
-    } catch {
-      return null;
-    }
-  }
-  /** Insert or replace a node in the SQLite nodes table. */
-  upsertNode(db, node) {
-    db.prepare(`
-      INSERT OR REPLACE INTO nodes (id, type, label, content, metadata, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      node.id,
-      node.type,
-      node.label,
-      node.content,
-      JSON.stringify(node.metadata),
-      Date.now(),
-      Date.now()
-    );
+    return lookupPramanaBatch(this.getGraphDbHandle(), nodeIds);
   }
-  /** Insert an edge into the SQLite edges table (bi-temporal fields mapped). */
-  insertEdge(db, edge) {
-    db.prepare(`
-      INSERT OR IGNORE INTO edges (source, target, relationship, weight, pramana, viveka,
-        valid_from, valid_until, recorded_at, superseded_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      edge.source,
-      edge.target,
-      edge.relationship,
-      edge.weight,
-      null,
-      // pramana — not yet used
-      null,
-      // viveka — not yet used
-      edge.validFrom ? new Date(edge.validFrom).getTime() : Date.now(),
-      edge.validUntil ? new Date(edge.validUntil).getTime() : null,
-      edge.recordedAt ? new Date(edge.recordedAt).getTime() : Date.now(),
-      edge.supersededAt ? new Date(edge.supersededAt).getTime() : null
-    );
+  // ─── Persistence (delegates) ─────────────────────────────────────
+  /** Get graph database handle via persistence layer. */
+  getGraphDbHandle() {
+    return getGraphDb(this._graphDbInitialized, () => {
+      this._graphDbInitialized = true;
+    });
   }
-  // ─── Persistence ──────────────────────────────────────────────────
+  /** Save graph state to SQLite (primary) or JSON (fallback). */
   saveToDisk() {
     try {
-      const db = this.getGraphDb();
+      const db = this.getGraphDbHandle();
       if (db) {
-        db.transaction(() => {
-          db.prepare("DELETE FROM pagerank").run();
-          db.prepare("DELETE FROM edges").run();
-          db.prepare("DELETE FROM nodes").run();
-          for (const node of this.graph.nodes) {
-            this.upsertNode(db, node);
-          }
-          for (const edge of this.graph.edges) {
-            this.insertEdge(db, edge);
-          }
-          for (const [nodeId, score] of this.pageRankScores) {
-            db.prepare(
-              "INSERT OR REPLACE INTO pagerank (node_id, score, updated_at) VALUES (?, ?, ?)"
-            ).run(nodeId, score, Date.now());
-          }
-        })();
-        this.saveEmbeddingsJson();
+        saveToSqlite(db, this.graph, this.pageRankScores, this.embeddingCache);
         return;
       }
     } catch {
     }
-    this.saveToDiskJson();
+    saveToJson(this.graph, this.pageRankScores, this.embeddingCache);
   }
+  /** Load graph state from SQLite (primary) or JSON (fallback). */
   loadFromDisk() {
-    let loadedFromSqlite = false;
+    let loaded = false;
     try {
-      const db = this.getGraphDb();
+      const db = this.getGraphDbHandle();
       if (db) {
-        const nodeCount = db.prepare("SELECT COUNT(*) as cnt FROM nodes").get().cnt;
-        if (nodeCount > 0) {
-          const nodeRows = db.prepare("SELECT * FROM nodes").all();
-          this.graph.nodes = nodeRows.map((row) => ({
-            id: row.id,
-            type: row.type,
-            label: row.label,
-            content: row.content ?? "",
-            metadata: (() => {
-              try {
-                return JSON.parse(row.metadata ?? "{}");
-              } catch {
-                return {};
-              }
-            })()
-            // Note: embedding not stored in nodes table — it's in vectors.db (Phase 0.6)
-          }));
-          const edgeRows = db.prepare("SELECT * FROM edges").all();
-          this.graph.edges = edgeRows.map((row) => ({
-            source: row.source,
-            target: row.target,
-            relationship: row.relationship,
-            weight: row.weight,
-            validFrom: row.valid_from ? new Date(row.valid_from).toISOString() : void 0,
-            validUntil: row.valid_until ? new Date(row.valid_until).toISOString() : void 0,
-            recordedAt: row.recorded_at ? new Date(row.recorded_at).toISOString() : void 0,
-            supersededAt: row.superseded_at ? new Date(row.superseded_at).toISOString() : void 0
-          }));
-          const prRows = db.prepare("SELECT * FROM pagerank").all();
-          for (const row of prRows) {
-            this.pageRankScores.set(row.node_id, row.score);
-          }
-          loadedFromSqlite = true;
+        const sqliteData = loadFromSqlite(db);
+        if (sqliteData) {
+          this.graph = sqliteData.graph;
+          this.pageRankScores = sqliteData.pageRankScores;
         } else {
-          this.loadFromDiskJson();
+          const jsonData = loadFromJson();
+          this.graph = jsonData.graph;
+          this.pageRankScores = jsonData.pageRankScores;
           if (this.graph.nodes.length > 0) {
             try {
-              db.transaction(() => {
-                for (const node of this.graph.nodes) {
-                  this.upsertNode(db, node);
-                }
-                for (const edge of this.graph.edges) {
-                  this.insertEdge(db, edge);
-                }
-                for (const [nodeId, score] of this.pageRankScores) {
-                  db.prepare(
-                    "INSERT OR REPLACE INTO pagerank (node_id, score, updated_at) VALUES (?, ?, ?)"
-                  ).run(nodeId, score, Date.now());
-                }
-              })();
+              migrateInMemoryToSqlite(db, this.graph, this.pageRankScores);
             } catch {
             }
           }
-          loadedFromSqlite = true;
         }
+        loaded = true;
       }
     } catch {
     }
-    if (!loadedFromSqlite) {
-      this.loadFromDiskJson();
-    }
-    this.loadEmbeddingsJson();
-    if (this.graph.edges.length > 0) {
-      this.initIncrementalPR();
-    }
-  }
-  // ─── JSON Fallback Persistence (legacy / migration) ───────────────
-  saveToDiskJson() {
-    try {
-      const dir = getGraphDir();
-      fs.mkdirSync(dir, { recursive: true });
-      fs.writeFileSync(getGraphPath(), JSON.stringify(this.graph, null, "	"), "utf-8");
-      this.saveEmbeddingsJson();
-      const pageRankObj = {};
-      for (const [key, value] of this.pageRankScores) {
-        pageRankObj[key] = value;
-      }
-      fs.writeFileSync(getPageRankPath(), JSON.stringify(pageRankObj, null, "	"), "utf-8");
-    } catch {
-    }
-  }
-  saveEmbeddingsJson() {
-    try {
-      const dir = getGraphDir();
-      fs.mkdirSync(dir, { recursive: true });
-      const embeddings = {};
-      for (const [key, value] of this.embeddingCache) {
-        embeddings[key] = value;
-      }
-      fs.writeFileSync(getEmbeddingsPath(), JSON.stringify(embeddings, null, "	"), "utf-8");
-    } catch {
-    }
-  }
-  loadFromDiskJson() {
-    try {
-      const graphPath = getGraphPath();
-      if (fs.existsSync(graphPath)) {
-        const raw = fs.readFileSync(graphPath, "utf-8");
-        this.graph = JSON.parse(raw);
-      }
-    } catch {
-      this.graph = { nodes: [], edges: [] };
-    }
-    try {
-      const prPath = getPageRankPath();
-      if (fs.existsSync(prPath)) {
-        const raw = fs.readFileSync(prPath, "utf-8");
-        const ranks = JSON.parse(raw);
-        for (const [key, value] of Object.entries(ranks)) {
-          this.pageRankScores.set(key, value);
-        }
-      }
-    } catch {
-      this.pageRankScores = /* @__PURE__ */ new Map();
+    if (!loaded) {
+      const jsonData = loadFromJson();
+      this.graph = jsonData.graph;
+      this.pageRankScores = jsonData.pageRankScores;
     }
-  }
-  loadEmbeddingsJson() {
-    try {
-      const embPath = getEmbeddingsPath();
-      if (fs.existsSync(embPath)) {
-        const raw = fs.readFileSync(embPath, "utf-8");
-        const embeddings = JSON.parse(raw);
-        for (const [key, value] of Object.entries(embeddings)) {
-          this.embeddingCache.set(key, value);
-        }
-        while (this.embeddingCache.size > this.maxEmbeddingCacheSize) {
-          const oldest = this.embeddingCache.keys().next().value;
-          if (oldest !== void 0) {
-            this.embeddingCache.delete(oldest);
-          }
-        }
-      }
-    } catch {
-      this.embeddingCache = /* @__PURE__ */ new Map();
+    for (const [k, v] of loadEmbeddingsJson(this.maxEmbeddingCacheSize)) {
+      this.embeddingCache.set(k, v);
     }
+    if (this.graph.edges.length > 0) this.initIncrementalPR();
   }
+  /** Get the current in-memory knowledge graph. */
   getGraph() {
     return this.graph;
   }
+  /** Clear all graph data, caches, and persisted state. */
   async clear() {
     this.graph = { nodes: [], edges: [] };
     this.embeddingCache = /* @__PURE__ */ new Map();
     this.pageRankScores = /* @__PURE__ */ new Map();
     this.incrementalPR = null;
     try {
-      const db = this.getGraphDb();
-      if (db) {
-        db.exec("DELETE FROM pagerank; DELETE FROM edges; DELETE FROM nodes;");
-      }
+      const db = this.getGraphDbHandle();
+      if (db) db.exec("DELETE FROM pagerank; DELETE FROM edges; DELETE FROM nodes;");
     } catch {
     }
     this.saveToDisk();
   }
+  /** Reset the Ollama availability flag to force re-check. */
   resetAvailability() {
     this.ollamaAvailable = null;
     this.embeddingService.resetAvailability();
   }
-  // ─── Graph Neighbor Queries ───────────────────────────────────────
   /**
    * Get edges connected to a node, optionally filtered by direction.
    * Uses the in-memory graph for fast access.
@@ -2053,94 +2048,10 @@ var GraphRAGEngine = class {
     });
   }
 };
-function migrateGraphJson() {
-  const graphPath = getGraphPath();
-  const prPath = getPageRankPath();
-  if (!fs.existsSync(graphPath)) {
-    return { nodes: 0, edges: 0 };
-  }
-  try {
-    const raw = fs.readFileSync(graphPath, "utf-8");
-    const graph = JSON.parse(raw);
-    if (!graph.nodes || graph.nodes.length === 0) {
-      return { nodes: 0, edges: 0 };
-    }
-    const pageRankScores = /* @__PURE__ */ new Map();
-    try {
-      if (fs.existsSync(prPath)) {
-        const prRaw = fs.readFileSync(prPath, "utf-8");
-        const ranks = JSON.parse(prRaw);
-        for (const [key, value] of Object.entries(ranks)) {
-          pageRankScores.set(key, value);
-        }
-      }
-    } catch {
-    }
-    const dbm = DatabaseManager.instance();
-    initGraphSchema(dbm);
-    const db = dbm.get("graph");
-    db.transaction(() => {
-      const upsertNodeStmt = db.prepare(`
-        INSERT OR REPLACE INTO nodes (id, type, label, content, metadata, created_at, updated_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?)
-      `);
-      const insertEdgeStmt = db.prepare(`
-        INSERT OR IGNORE INTO edges (source, target, relationship, weight, pramana, viveka,
-          valid_from, valid_until, recorded_at, superseded_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `);
-      const upsertPRStmt = db.prepare(
-        "INSERT OR REPLACE INTO pagerank (node_id, score, updated_at) VALUES (?, ?, ?)"
-      );
-      const now = Date.now();
-      for (const node of graph.nodes) {
-        upsertNodeStmt.run(
-          node.id,
-          node.type,
-          node.label,
-          node.content,
-          JSON.stringify(node.metadata),
-          now,
-          now
-        );
-      }
-      for (const edge of graph.edges) {
-        insertEdgeStmt.run(
-          edge.source,
-          edge.target,
-          edge.relationship,
-          edge.weight,
-          null,
-          null,
-          edge.validFrom ? new Date(edge.validFrom).getTime() : now,
-          edge.validUntil ? new Date(edge.validUntil).getTime() : null,
-          edge.recordedAt ? new Date(edge.recordedAt).getTime() : now,
-          edge.supersededAt ? new Date(edge.supersededAt).getTime() : null
-        );
-      }
-      for (const [nodeId, score] of pageRankScores) {
-        upsertPRStmt.run(nodeId, score, now);
-      }
-    })();
-    try {
-      fs.renameSync(graphPath, graphPath + ".bak");
-    } catch {
-    }
-    try {
-      if (fs.existsSync(prPath)) {
-        fs.renameSync(prPath, prPath + ".bak");
-      }
-    } catch {
-    }
-    return { nodes: graph.nodes.length, edges: graph.edges.length };
-  } catch {
-    return { nodes: 0, edges: 0 };
-  }
-}
 
 export {
-  computePersonalizedPageRank,
   IncrementalPageRank,
+  computePersonalizedPageRank,
   NERExtractor,
   createEdge,
   supersedEdge,
@@ -2154,7 +2065,7 @@ export {
   communitySummary,
   filterByCommunity,
   findBridgeNodes,
-  GraphRAGEngine,
-  migrateGraphJson
+  migrateGraphJson,
+  GraphRAGEngine
 };
-//# sourceMappingURL=chunk-S2HDNNC7.js.map
+//# sourceMappingURL=chunk-OT4G2L46.js.map