@yugenlab/vaayu 0.1.9 → 0.1.11

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

@@ -6,28 +6,25 @@ import {
   STOP_WORDS,
   cosineSimilarity,
   textMatchScore
-} from "./chunk-JAWZ7ANC.js";
+} from "./chunk-A3HOZBC5.js";
 import {
   initGraphSchema
-} from "./chunk-YJRXLRTE.js";
+} from "./chunk-V2ZIKDN4.js";
 import {
   DatabaseManager
-} from "./chunk-U62ABYKD.js";
+} from "./chunk-67DXWEKG.js";
 import {
   getChitraguptaHome
-} from "./chunk-UZ6OIVEC.js";
+} from "./chunk-2OBLQJYJ.js";
 
-// ../chitragupta/packages/smriti/src/graphrag.ts
-import fs from "fs";
-import path from "path";
-
-// ../chitragupta/packages/smriti/src/graphrag-pagerank.ts
+// ../chitragupta/packages/smriti/dist/graphrag-pagerank.js
 var PAGERANK_DAMPING = 0.85;
 var PAGERANK_EPSILON = 1e-4;
 var PAGERANK_MAX_ITERATIONS = 100;
 function computePageRank(graph) {
   const N = graph.nodes.length;
-  if (N === 0) return /* @__PURE__ */ new Map();
+  if (N === 0)
+    return /* @__PURE__ */ new Map();
   const ranks = /* @__PURE__ */ new Map();
   const nodeIds = /* @__PURE__ */ new Set();
   for (const node of graph.nodes) {
@@ -67,162 +64,24 @@ function computePageRank(graph) {
       const rank = baseFactor + PAGERANK_DAMPING * (incomingRank + danglingRank / N);
       newRanks.set(node.id, rank);
       const delta = Math.abs(rank - (ranks.get(node.id) ?? 0));
-      if (delta > maxDelta) maxDelta = delta;
+      if (delta > maxDelta)
+        maxDelta = delta;
     }
     for (const [id, rank] of newRanks) {
       ranks.set(id, rank);
     }
-    if (maxDelta < PAGERANK_EPSILON) break;
+    if (maxDelta < PAGERANK_EPSILON)
+      break;
   }
   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/dist/graphrag-pagerank-incremental.js
 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;
@@ -299,7 +158,8 @@ var IncrementalPageRank = class {
     if (oldDeg > 0) {
       const shareDelta = prU * (1 / newDeg - 1 / oldDeg);
       for (const neighbor of this.getOutNeighbors(source)) {
-        if (neighbor === target) continue;
+        if (neighbor === target)
+          continue;
         const prev = residuals.get(neighbor) ?? 0;
         residuals.set(neighbor, prev + this.damping * shareDelta);
       }
@@ -313,11 +173,14 @@ var IncrementalPageRank = class {
    * @param target - Target node ID.
    */
   removeEdge(source, target) {
-    if (!this.nodeSet.has(source) || !this.nodeSet.has(target)) return;
+    if (!this.nodeSet.has(source) || !this.nodeSet.has(target))
+      return;
     const inSet = this.inLinks.get(target);
-    if (!inSet || !inSet.has(source)) return;
+    if (!inSet || !inSet.has(source))
+      return;
     const oldDeg = this.outDegree.get(source) ?? 0;
-    if (oldDeg <= 0) return;
+    if (oldDeg <= 0)
+      return;
     const newDeg = oldDeg - 1;
     this.outDegree.set(source, newDeg);
     inSet.delete(source);
@@ -338,7 +201,7 @@ var IncrementalPageRank = class {
   getRanks() {
     return new Map(this.ranks);
   }
-  // ─── Private ──────────────────────────────────────────────────────
+  // --- Private ---------------------------------------------------------
   /**
    * Propagate residuals through the graph until all are below epsilon.
    *
@@ -360,7 +223,8 @@ var IncrementalPageRank = class {
           maxNode = node;
         }
       }
-      if (maxNode === null || maxResidual < this.epsilon) break;
+      if (maxNode === null || maxResidual < this.epsilon)
+        break;
       const res = residuals.get(maxNode);
       this.ranks.set(maxNode, (this.ranks.get(maxNode) ?? 0) + res);
       residuals.delete(maxNode);
@@ -384,7 +248,158 @@ var IncrementalPageRank = class {
   }
 };
 
-// ../chitragupta/packages/smriti/src/graphrag-extraction.ts
+// ../chitragupta/packages/smriti/dist/graphrag-pagerank-personalized.js
+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/dist/graphrag-extraction.js
 var CHUNK_TARGET_TOKENS = 350;
 var CHUNK_MIN_TOKENS = 200;
 var CHUNK_MAX_TOKENS = 500;
@@ -398,7 +413,8 @@ function estimateTokens(text) {
 }
 function semanticChunk(text) {
   const sentences = splitSentences(text);
-  if (sentences.length === 0) return [];
+  if (sentences.length === 0)
+    return [];
   const totalTokens = estimateTokens(text);
   if (totalTokens <= CHUNK_MAX_TOKENS) {
     return [{ text, startSentence: 0, endSentence: sentences.length - 1 }];
@@ -427,7 +443,8 @@ function semanticChunk(text) {
       overlapTokens += estimateTokens(sentences[overlapStart]);
     }
     startIdx = Math.max(overlapStart, startIdx + 1);
-    if (startIdx >= endIdx) break;
+    if (startIdx >= endIdx)
+      break;
   }
   return chunks;
 }
@@ -485,8 +502,10 @@ function keywordExtractEntities(text) {
   const entities = [];
   const sorted = [...freq.entries()].sort((a, b) => b[1] - a[1]);
   for (const [word, count] of sorted) {
-    if (count < 2) break;
-    if (entities.length >= 20) break;
+    if (count < 2)
+      break;
+    if (entities.length >= 20)
+      break;
     entities.push({
       name: word,
       type: "concept",
@@ -496,7 +515,7 @@ function keywordExtractEntities(text) {
   return entities;
 }
 
-// ../chitragupta/packages/smriti/src/ner-extractor.ts
+// ../chitragupta/packages/smriti/dist/ner-extractor.js
 var DEFAULT_ENDPOINT = "http://localhost:8501";
 var DEFAULT_MODEL = "gliner-large-v2.1";
 var DEFAULT_MIN_CONFIDENCE = 0.5;
@@ -590,10 +609,7 @@ var TECHNOLOGY_WORDS = [
   "yarn",
   "zod"
 ];
-var TECHNOLOGY_PATTERN = new RegExp(
-  `\\b(${TECHNOLOGY_WORDS.join("|")})\\b`,
-  "gi"
-);
+var TECHNOLOGY_PATTERN = new RegExp(`\\b(${TECHNOLOGY_WORDS.join("|")})\\b`, "gi");
 var TOOL_WORDS = [
   "read",
   "write",
@@ -609,10 +625,7 @@ var TOOL_WORDS = [
   "webfetch",
   "websearch"
 ];
-var TOOL_PATTERN = new RegExp(
-  `\\b(${TOOL_WORDS.join("|")})\\b`,
-  "gi"
-);
+var TOOL_PATTERN = new RegExp(`\\b(${TOOL_WORDS.join("|")})\\b`, "gi");
 var ERROR_PATTERN = /\b((?:[A-Z]\w*Error)\b|(?:ENOENT|EACCES|ECONNREFUSED|ETIMEDOUT|EPERM)\b|(?:failed\s+to\s+\w+)|(?:error:\s*\S+))/gi;
 var DECISION_PATTERN = /\b((?:decided|chose|selected|opted|switched|migrated|moved)\s+to\s+\w[\w\s]{0,30})/gi;
 var ACTION_PATTERN = /\b((?:created|deleted|removed|modified|updated|installed|uninstalled|deployed|fixed|refactored|renamed|merged|rebased|reverted|committed|pushed|pulled)\s+\w[\w\s]{0,30})/gi;
@@ -641,7 +654,8 @@ var NERExtractor = class {
    * and `useHeuristic` is enabled.
    */
   async extract(text) {
-    if (!text || text.trim().length === 0) return [];
+    if (!text || text.trim().length === 0)
+      return [];
     const glinerUp = await this.isGLiNERAvailable();
     if (glinerUp) {
       try {
@@ -668,7 +682,8 @@ var NERExtractor = class {
    * Caches the result after the first successful probe.
    */
   async isGLiNERAvailable() {
-    if (this.glinerAvailable !== null) return this.glinerAvailable;
+    if (this.glinerAvailable !== null)
+      return this.glinerAvailable;
     try {
       const response = await fetch(this.endpoint, {
         method: "GET",
@@ -734,10 +749,12 @@ var NERExtractor = class {
     const coveredSpans = [];
     const addMatch = (match, type, groupIndex = 1) => {
       const captured = match[groupIndex];
-      if (!captured) return;
+      if (!captured)
+        return;
       const start = match.index + match[0].indexOf(captured);
       const end = start + captured.length;
-      if (this.spanOverlaps([start, end], coveredSpans)) return;
+      if (this.spanOverlaps([start, end], coveredSpans))
+        return;
       coveredSpans.push([start, end]);
       entities.push({
         text: captured.trim(),
@@ -785,9 +802,7 @@ var NERExtractor = class {
    */
   postProcess(entities) {
     const typeSet = new Set(this.entityTypes);
-    let filtered = entities.filter(
-      (e) => typeSet.has(e.type) && e.confidence >= this.minConfidence
-    );
+    let filtered = entities.filter((e) => typeSet.has(e.type) && e.confidence >= this.minConfidence);
     const seen = /* @__PURE__ */ new Map();
     for (const entity of filtered) {
       const key = `${entity.type}::${entity.text.toLowerCase().trim()}`;
@@ -798,14 +813,15 @@ var NERExtractor = class {
     }
     filtered = [...seen.values()];
     filtered.sort((a, b) => {
-      if (b.confidence !== a.confidence) return b.confidence - a.confidence;
+      if (b.confidence !== a.confidence)
+        return b.confidence - a.confidence;
       return a.span[0] - b.span[0];
     });
     return filtered.slice(0, this.maxEntities);
   }
 };
 
-// ../chitragupta/packages/smriti/src/bitemporal.ts
+// ../chitragupta/packages/smriti/dist/bitemporal.js
 function nowISO() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
@@ -846,14 +862,19 @@ function expireEdge(edge, validUntil) {
 function queryEdgesAtTime(edges, asOfValid, asOfRecord) {
   return edges.filter((e) => {
     const vFrom = e.validFrom ?? EPOCH_ISO;
-    if (vFrom > asOfValid) return false;
-    if (e.validUntil !== void 0 && e.validUntil <= asOfValid) return false;
+    if (vFrom > asOfValid)
+      return false;
+    if (e.validUntil !== void 0 && e.validUntil <= asOfValid)
+      return false;
     if (asOfRecord !== void 0) {
       const rAt = e.recordedAt ?? EPOCH_ISO;
-      if (rAt > asOfRecord) return false;
-      if (e.supersededAt !== void 0 && e.supersededAt <= asOfRecord) return false;
+      if (rAt > asOfRecord)
+        return false;
+      if (e.supersededAt !== void 0 && e.supersededAt <= asOfRecord)
+        return false;
     } else {
-      if (e.supersededAt !== void 0) return false;
+      if (e.supersededAt !== void 0)
+        return false;
     }
     return true;
   });
@@ -864,19 +885,21 @@ function getEdgeHistory(edges, source, target) {
 function temporalDecay(edge, now, halfLifeMs) {
   const referenceTime = edge.validUntil !== void 0 ? new Date(edge.validUntil).getTime() : new Date(edge.validFrom ?? EPOCH_ISO).getTime();
   const elapsed = now - referenceTime;
-  if (elapsed <= 0) return edge.weight;
+  if (elapsed <= 0)
+    return edge.weight;
   const decay = Math.exp(-Math.LN2 * elapsed / halfLifeMs);
   return edge.weight * decay;
 }
 function compactEdges(edges, retentionMs) {
   const cutoff = Date.now() - retentionMs;
   return edges.filter((e) => {
-    if (e.supersededAt === void 0) return true;
+    if (e.supersededAt === void 0)
+      return true;
     return new Date(e.supersededAt).getTime() > cutoff;
   });
 }
 
-// ../chitragupta/packages/smriti/src/graphrag-builder.ts
+// ../chitragupta/packages/smriti/dist/graphrag-builder.js
 function scopeToId(scope) {
   switch (scope.type) {
     case "global":
@@ -921,7 +944,8 @@ async function createSessionNode(ctx, session) {
 async function extractConceptsFromNodes(ctx, nodes, edges) {
   const entityIndex = /* @__PURE__ */ new Map();
   for (const node of nodes) {
-    if (!node.content || node.type === "concept") continue;
+    if (!node.content || node.type === "concept")
+      continue;
     const entities = await ctx.extractEntities(node.content);
     for (const entity of entities) {
       const key = entity.name.toLowerCase();
@@ -937,9 +961,11 @@ async function extractConceptsFromNodes(ctx, nodes, edges) {
     }
   }
   for (const [key, data] of entityIndex) {
-    if (data.sourceIds.length < 2) continue;
+    if (data.sourceIds.length < 2)
+      continue;
     const conceptId = `concept-${key.replace(/\s+/g, "-")}`;
-    if (nodes.some((n) => n.id === conceptId)) continue;
+    if (nodes.some((n) => n.id === conceptId))
+      continue;
     const conceptNode = {
       id: conceptId,
       type: "concept",
@@ -1106,33 +1132,21 @@ function removeSessionFromGraph(graph, sessionId) {
     }
   }
   graph.nodes = graph.nodes.filter((n) => !nodeIdsToRemove.has(n.id));
-  graph.edges = graph.edges.filter(
-    (e) => !nodeIdsToRemove.has(e.source) && !nodeIdsToRemove.has(e.target)
-  );
+  graph.edges = graph.edges.filter((e) => !nodeIdsToRemove.has(e.source) && !nodeIdsToRemove.has(e.target));
 }
 function removeMemoryFromGraph(graph, scope) {
   const memoryId = scopeToId(scope);
-  graph.nodes = graph.nodes.filter(
-    (n) => n.id !== memoryId && !n.id.startsWith(`${memoryId}-chunk-`)
-  );
-  graph.edges = graph.edges.filter(
-    (e) => e.source !== memoryId && e.target !== memoryId && !e.source.startsWith(`${memoryId}-chunk-`) && !e.target.startsWith(`${memoryId}-chunk-`)
-  );
+  graph.nodes = graph.nodes.filter((n) => n.id !== memoryId && !n.id.startsWith(`${memoryId}-chunk-`));
+  graph.edges = graph.edges.filter((e) => e.source !== memoryId && e.target !== memoryId && !e.source.startsWith(`${memoryId}-chunk-`) && !e.target.startsWith(`${memoryId}-chunk-`));
 }
 
-// ../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/dist/leiden-algorithm.js
 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 +1157,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);
@@ -1169,8 +1183,10 @@ var AdjacencyGraph = class {
     for (const edge of graph.edges) {
       const s = this.idToIndex.get(edge.source);
       const t = this.idToIndex.get(edge.target);
-      if (s === void 0 || t === void 0) continue;
-      if (s === t) continue;
+      if (s === void 0 || t === void 0)
+        continue;
+      if (s === t)
+        continue;
       const w = edge.weight ?? 1;
       this.adj[s].set(t, (this.adj[s].get(t) ?? 0) + w);
       this.adj[t].set(s, (this.adj[t].get(s) ?? 0) + w);
@@ -1183,7 +1199,8 @@ var AdjacencyGraph = class {
 };
 function computeModularity(g, assignment, resolution) {
   const twoM = g.totalWeight;
-  if (twoM === 0) return 0;
+  if (twoM === 0)
+    return 0;
   const internalWeight = /* @__PURE__ */ new Map();
   const communityDegree = /* @__PURE__ */ new Map();
   for (let i = 0; i < g.n; i++) {
@@ -1205,15 +1222,19 @@ function computeModularity(g, assignment, resolution) {
 }
 function modularityGain(g, i, cNew, assignment, communityDegree, resolution) {
   const twoM = g.totalWeight;
-  if (twoM === 0) return 0;
+  if (twoM === 0)
+    return 0;
   const cOld = assignment[i];
-  if (cOld === cNew) return 0;
+  if (cOld === cNew)
+    return 0;
   const ki = g.degree[i];
   let kInNew = 0;
   let kInOld = 0;
   for (const [j, w] of g.adj[i]) {
-    if (assignment[j] === cNew) kInNew += w;
-    if (assignment[j] === cOld) kInOld += w;
+    if (assignment[j] === cNew)
+      kInNew += w;
+    if (assignment[j] === cOld)
+      kInOld += w;
   }
   const sigmaTotNew = communityDegree.get(cNew) ?? 0;
   const sigmaTotOld = communityDegree.get(cOld) ?? 0;
@@ -1243,7 +1264,8 @@ function localNodeMoving(g, assignment, resolution, rng) {
     let bestCommunity = cOld;
     let bestGain = 0;
     for (const cNew of neighborCommunities) {
-      if (cNew === cOld) continue;
+      if (cNew === cOld)
+        continue;
       const gain = modularityGain(g, i, cNew, assignment, communityDegree, resolution);
       if (gain > bestGain) {
         bestGain = gain;
@@ -1263,17 +1285,20 @@ function refineCommunities(g, assignment) {
   const communityNodes = /* @__PURE__ */ new Map();
   for (let i = 0; i < g.n; i++) {
     const c = assignment[i];
-    if (!communityNodes.has(c)) communityNodes.set(c, []);
+    if (!communityNodes.has(c))
+      communityNodes.set(c, []);
     communityNodes.get(c).push(i);
   }
   let nextCommunityId = Math.max(...assignment) + 1;
   for (const [_communityId, nodes] of communityNodes) {
-    if (nodes.length <= 1) continue;
+    if (nodes.length <= 1)
+      continue;
     const nodeSet = new Set(nodes);
     const visited = /* @__PURE__ */ new Set();
     const components = [];
     for (const start of nodes) {
-      if (visited.has(start)) continue;
+      if (visited.has(start))
+        continue;
       const component = [];
       const queue = [start];
       visited.add(start);
@@ -1329,6 +1354,15 @@ function compactCommunities(assignment, minSize) {
   }
   return assignment.map((c) => remap.get(c) ?? 0);
 }
+
+// ../chitragupta/packages/smriti/dist/graphrag-leiden.js
+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,10 +1395,22 @@ 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];
-    if (!communityNodes.has(c)) communityNodes.set(c, []);
+    if (!communityNodes.has(c))
+      communityNodes.set(c, []);
     communityNodes.get(c).push(g.indexToId[i]);
   }
   const communityList = [];
@@ -1383,11 +1429,10 @@ 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) {
+    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 +1441,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) {
@@ -1414,20 +1452,13 @@ function annotateCommunities(graph, result) {
   }
 }
 function communitySummary(graph, communityId, maxLabels = 5) {
-  const members = graph.nodes.filter(
-    (n) => n.metadata.communityId === communityId
-  );
+  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
-  };
+  return { communityId, labels, nodeTypes: typeCount, size: members.length };
 }
 function filterByCommunity(nodes, communityId) {
   return nodes.filter((n) => n.metadata.communityId === communityId);
@@ -1443,8 +1474,10 @@ function findBridgeNodes(graph, result, minCommunities = 2) {
   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;
+    if (sc === void 0 || tc === void 0)
+      continue;
+    if (sc === tc)
+      continue;
     touchedCommunities.get(edge.source)?.add(tc);
     touchedCommunities.get(edge.target)?.add(sc);
   }
@@ -1458,12 +1491,9 @@ function findBridgeNodes(graph, result, minCommunities = 2) {
   return bridges;
 }
 
-// ../chitragupta/packages/smriti/src/graphrag.ts
-var DEFAULT_CONFIG = {
-  endpoint: process.env.OLLAMA_HOST ?? "http://localhost:11434",
-  model: "nomic-embed-text",
-  generationModel: "llama3.2"
-};
+// ../chitragupta/packages/smriti/dist/graphrag-persistence.js
+import fs from "fs";
+import path from "path";
 function getGraphDir() {
   return path.join(getChitraguptaHome(), "graphrag");
 }
@@ -1476,6 +1506,267 @@ function getEmbeddingsPath() {
 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 {
+  }
+  return { graph, pageRankScores };
+}
+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 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 {
+  }
+  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 {
+  }
+  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 };
+  }
+}
+
+// ../chitragupta/packages/smriti/dist/graphrag.js
+var DEFAULT_CONFIG = {
+  endpoint: process.env.OLLAMA_HOST ?? "http://localhost:11434",
+  model: "nomic-embed-text",
+  generationModel: "llama3.2"
+};
 var GraphRAGEngine = class {
   config;
   graph;
@@ -1484,9 +1775,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,9 +1788,9 @@ 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;
+    if (this.ollamaAvailable !== null)
+      return this.ollamaAvailable;
     try {
       const response = await fetch(`${this.config.endpoint}/api/version`, {
         method: "GET",
@@ -1511,24 +1802,25 @@ 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;
+    if (cached)
+      return cached;
     const vector = await this.embeddingService.getEmbedding(text);
     this.embeddingCache.set(text, vector);
     if (this.embeddingCache.size > this.maxEmbeddingCacheSize) {
       const oldest = this.embeddingCache.keys().next().value;
-      if (oldest !== void 0) {
+      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 +1865,31 @@ 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) {
+    if (!this.incrementalPR || edges.length === 0)
+      return;
+    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) {
+    if (!this.incrementalPR || edges.length === 0)
+      return;
+    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,82 +1899,75 @@ 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) {
+    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 [];
+    if (searchGraph.nodes.length === 0)
+      return [];
     const queryEmbedding = await this.getEmbedding(query);
-    if (this.pageRankScores.size === 0) {
+    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;
-      if (pr > maxPageRank) maxPageRank = pr;
+      if (pr > maxPageRank)
+        maxPageRank = pr;
     }
     const scored = [];
     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) {
+      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 +1978,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,422 +1995,111 @@ 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;
+    return lookupPramanaBatch(this.getGraphDbHandle(), nodeIds);
   }
-  // ─── 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()
-    );
-  }
-  /** 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 ──────────────────────────────────────────────────
+  // ─── Persistence (delegates) ─────────────────────────────────────
+  /** Get graph database handle via persistence layer. */
+  getGraphDbHandle() {
+    return getGraphDb(this._graphDbInitialized, () => {
+      this._graphDbInitialized = true;
+    });
+  }
+  /** 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) {
+      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.
    */
   getNeighbors(nodeId, direction = "both") {
     return this.graph.edges.filter((edge) => {
-      if (direction === "out") return edge.source === nodeId;
-      if (direction === "in") return edge.target === nodeId;
+      if (direction === "out")
+        return edge.source === nodeId;
+      if (direction === "in")
+        return edge.target === nodeId;
       return edge.source === nodeId || edge.target === nodeId;
     });
   }
 };
-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 +2113,7 @@ export {
   communitySummary,
   filterByCommunity,
   findBridgeNodes,
-  GraphRAGEngine,
-  migrateGraphJson
+  migrateGraphJson,
+  GraphRAGEngine
 };
-//# sourceMappingURL=chunk-S2HDNNC7.js.map
+//# sourceMappingURL=chunk-LJUEMPLG.js.map