@yugenlab/vaayu 0.1.0

package/chunks/chunk-S4TBVCL2.js

@@ -0,0 +1,2158 @@
+import {
+  ALPHA,
+  BETA,
+  EmbeddingService,
+  GAMMA,
+  STOP_WORDS,
+  cosineSimilarity,
+  textMatchScore
+} from "./chunk-JAWZ7ANC.js";
+import {
+  DatabaseManager,
+  initGraphSchema
+} from "./chunk-U6OLJ36B.js";
+import {
+  getChitraguptaHome
+} from "./chunk-KC6NRZ7U.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;
+var PAGERANK_MAX_ITERATIONS = 100;
+function computePageRank(graph) {
+  const N = graph.nodes.length;
+  if (N === 0) return /* @__PURE__ */ new Map();
+  const ranks = /* @__PURE__ */ new Map();
+  const nodeIds = /* @__PURE__ */ new Set();
+  for (const node of graph.nodes) {
+    ranks.set(node.id, 1 / N);
+    nodeIds.add(node.id);
+  }
+  const outDegree = /* @__PURE__ */ new Map();
+  const inLinks = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    outDegree.set(node.id, 0);
+    inLinks.set(node.id, []);
+  }
+  for (const edge of graph.edges) {
+    if (nodeIds.has(edge.source) && nodeIds.has(edge.target)) {
+      outDegree.set(edge.source, (outDegree.get(edge.source) ?? 0) + 1);
+      inLinks.get(edge.target).push(edge.source);
+    }
+  }
+  const baseFactor = (1 - PAGERANK_DAMPING) / N;
+  for (let iteration = 0; iteration < PAGERANK_MAX_ITERATIONS; iteration++) {
+    const newRanks = /* @__PURE__ */ new Map();
+    let maxDelta = 0;
+    let danglingRank = 0;
+    for (const node of graph.nodes) {
+      if ((outDegree.get(node.id) ?? 0) === 0) {
+        danglingRank += ranks.get(node.id) ?? 0;
+      }
+    }
+    for (const node of graph.nodes) {
+      let incomingRank = 0;
+      const sources = inLinks.get(node.id) ?? [];
+      for (const source of sources) {
+        const sourceRank = ranks.get(source) ?? 0;
+        const sourceOut = outDegree.get(source) ?? 1;
+        incomingRank += sourceRank / sourceOut;
+      }
+      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;
+    }
+    for (const [id, rank] of newRanks) {
+      ranks.set(id, rank);
+    }
+    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;
+}
+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(). */
+  outLinks = /* @__PURE__ */ new Map();
+  nodeSet = /* @__PURE__ */ new Set();
+  damping;
+  epsilon;
+  constructor(damping = 0.85, epsilon = 1e-6) {
+    this.damping = damping;
+    this.epsilon = epsilon;
+  }
+  /**
+   * Initialize from a knowledge graph. Computes full PageRank once.
+   *
+   * @param graph - Initial knowledge graph.
+   */
+  initialize(graph) {
+    this.nodeSet.clear();
+    this.outDegree.clear();
+    this.inLinks.clear();
+    this.outLinks.clear();
+    for (const node of graph.nodes) {
+      this.nodeSet.add(node.id);
+      this.outDegree.set(node.id, 0);
+      this.inLinks.set(node.id, /* @__PURE__ */ new Set());
+      this.outLinks.set(node.id, /* @__PURE__ */ new Set());
+    }
+    for (const edge of graph.edges) {
+      if (this.nodeSet.has(edge.source) && this.nodeSet.has(edge.target)) {
+        this.outDegree.set(edge.source, (this.outDegree.get(edge.source) ?? 0) + 1);
+        this.inLinks.get(edge.target).add(edge.source);
+        this.outLinks.get(edge.source).add(edge.target);
+      }
+    }
+    this.ranks = computePersonalizedPageRank(graph, void 0, {
+      damping: this.damping,
+      epsilon: this.epsilon
+    });
+  }
+  /**
+   * Incrementally add an edge and update ranks via residual propagation.
+   *
+   * When edge (u -> v) is added:
+   *   - Old contribution from u to each of its neighbors was PR(u)/L_old(u)
+   *   - New contribution is PR(u)/L_new(u) where L_new = L_old + 1
+   *   - Delta at v = +d * PR(u) / L_new(u)
+   *   - Delta at each old neighbor w = -d * PR(u) * (1/L_new - 1/L_old)
+   *
+   * These deltas are injected as residuals and propagated.
+   *
+   * @param source - Source node ID.
+   * @param target - Target node ID.
+   */
+  addEdge(source, target) {
+    if (!this.nodeSet.has(source)) {
+      this.nodeSet.add(source);
+      this.outDegree.set(source, 0);
+      this.inLinks.set(source, /* @__PURE__ */ new Set());
+      this.outLinks.set(source, /* @__PURE__ */ new Set());
+      this.ranks.set(source, 1 / this.nodeSet.size);
+    }
+    if (!this.nodeSet.has(target)) {
+      this.nodeSet.add(target);
+      this.outDegree.set(target, 0);
+      this.inLinks.set(target, /* @__PURE__ */ new Set());
+      this.outLinks.set(target, /* @__PURE__ */ new Set());
+      this.ranks.set(target, 1 / this.nodeSet.size);
+    }
+    const oldDeg = this.outDegree.get(source) ?? 0;
+    const newDeg = oldDeg + 1;
+    this.outDegree.set(source, newDeg);
+    this.inLinks.get(target).add(source);
+    this.outLinks.get(source).add(target);
+    const prU = this.ranks.get(source) ?? 0;
+    const residuals = /* @__PURE__ */ new Map();
+    residuals.set(target, this.damping * prU / newDeg);
+    if (oldDeg > 0) {
+      const shareDelta = prU * (1 / newDeg - 1 / oldDeg);
+      for (const neighbor of this.getOutNeighbors(source)) {
+        if (neighbor === target) continue;
+        const prev = residuals.get(neighbor) ?? 0;
+        residuals.set(neighbor, prev + this.damping * shareDelta);
+      }
+    }
+    this.propagateResiduals(residuals);
+  }
+  /**
+   * Incrementally remove an edge and update ranks via residual propagation.
+   *
+   * @param source - Source node ID.
+   * @param target - Target node ID.
+   */
+  removeEdge(source, target) {
+    if (!this.nodeSet.has(source) || !this.nodeSet.has(target)) return;
+    const inSet = this.inLinks.get(target);
+    if (!inSet || !inSet.has(source)) return;
+    const oldDeg = this.outDegree.get(source) ?? 0;
+    if (oldDeg <= 0) return;
+    const newDeg = oldDeg - 1;
+    this.outDegree.set(source, newDeg);
+    inSet.delete(source);
+    this.outLinks.get(source)?.delete(target);
+    const prU = this.ranks.get(source) ?? 0;
+    const residuals = /* @__PURE__ */ new Map();
+    residuals.set(target, -this.damping * prU / oldDeg);
+    if (newDeg > 0) {
+      const shareDelta = prU * (1 / newDeg - 1 / oldDeg);
+      for (const neighbor of this.getOutNeighbors(source)) {
+        const prev = residuals.get(neighbor) ?? 0;
+        residuals.set(neighbor, prev + this.damping * shareDelta);
+      }
+    }
+    this.propagateResiduals(residuals);
+  }
+  /** Get current rank scores. */
+  getRanks() {
+    return new Map(this.ranks);
+  }
+  // ─── Private ──────────────────────────────────────────────────────
+  /**
+   * Propagate residuals through the graph until all are below epsilon.
+   *
+   * Push-forward scheme: the node with largest absolute residual pushes
+   * its residual to its rank and propagates damped fractions to neighbors.
+   *
+   * Convergence: guaranteed for damping < 1, with total work O(1/epsilon).
+   */
+  propagateResiduals(residuals) {
+    const maxPropagations = this.nodeSet.size * 20;
+    let propagations = 0;
+    while (propagations < maxPropagations) {
+      let maxNode = null;
+      let maxResidual = 0;
+      for (const [node, res2] of residuals) {
+        const absRes = Math.abs(res2);
+        if (absRes > maxResidual) {
+          maxResidual = absRes;
+          maxNode = node;
+        }
+      }
+      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);
+      const outDeg = this.outDegree.get(maxNode) ?? 0;
+      if (outDeg > 0) {
+        const propagated = this.damping * res / outDeg;
+        for (const neighbor of this.getOutNeighbors(maxNode)) {
+          const prevRes = residuals.get(neighbor) ?? 0;
+          residuals.set(neighbor, prevRes + propagated);
+        }
+      }
+      propagations++;
+    }
+  }
+  /**
+   * Get outgoing neighbors of a node.
+   * Uses forward adjacency list for O(degree) lookup instead of O(E).
+   */
+  getOutNeighbors(nodeId) {
+    return [...this.outLinks.get(nodeId) ?? []];
+  }
+};
+
+// ../chitragupta/packages/smriti/src/graphrag-extraction.ts
+var CHUNK_TARGET_TOKENS = 350;
+var CHUNK_MIN_TOKENS = 200;
+var CHUNK_MAX_TOKENS = 500;
+var CHUNK_OVERLAP_TOKENS = 50;
+function splitSentences(text) {
+  const raw = text.split(/(?<=[.!?])\s+(?=[A-Z])|(?<=[.!?])\s*$/);
+  return raw.map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function estimateTokens(text) {
+  return text.split(/\s+/).filter((w) => w.length > 0).length;
+}
+function semanticChunk(text) {
+  const sentences = splitSentences(text);
+  if (sentences.length === 0) return [];
+  const totalTokens = estimateTokens(text);
+  if (totalTokens <= CHUNK_MAX_TOKENS) {
+    return [{ text, startSentence: 0, endSentence: sentences.length - 1 }];
+  }
+  const chunks = [];
+  let startIdx = 0;
+  while (startIdx < sentences.length) {
+    let currentTokens = 0;
+    let endIdx = startIdx;
+    while (endIdx < sentences.length && currentTokens < CHUNK_TARGET_TOKENS) {
+      currentTokens += estimateTokens(sentences[endIdx]);
+      endIdx++;
+    }
+    if (currentTokens < CHUNK_MIN_TOKENS && endIdx < sentences.length) {
+      while (endIdx < sentences.length && currentTokens < CHUNK_MIN_TOKENS) {
+        currentTokens += estimateTokens(sentences[endIdx]);
+        endIdx++;
+      }
+    }
+    const chunkText = sentences.slice(startIdx, endIdx).join(" ");
+    chunks.push({ text: chunkText, startSentence: startIdx, endSentence: endIdx - 1 });
+    let overlapTokens = 0;
+    let overlapStart = endIdx;
+    while (overlapStart > startIdx && overlapTokens < CHUNK_OVERLAP_TOKENS) {
+      overlapStart--;
+      overlapTokens += estimateTokens(sentences[overlapStart]);
+    }
+    startIdx = Math.max(overlapStart, startIdx + 1);
+    if (startIdx >= endIdx) break;
+  }
+  return chunks;
+}
+async function llmExtractEntities(text, endpoint, generationModel) {
+  const truncated = text.slice(0, 4e3);
+  const prompt = `Extract key entities, concepts, and topics from the following text. Return ONLY a valid JSON array of objects, each with "name" (string), "type" (one of: "person", "technology", "concept", "organization", "file", "tool", "decision", "topic"), and "description" (brief string). Do not include any text outside the JSON array.
+
+Text:
+${truncated}
+
+JSON:`;
+  const response = await fetch(`${endpoint}/api/generate`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model: generationModel,
+      prompt,
+      stream: false,
+      options: {
+        temperature: 0.1,
+        num_predict: 2048
+      }
+    }),
+    signal: AbortSignal.timeout(6e4)
+  });
+  if (!response.ok) {
+    throw new Error(`Ollama generation error: ${response.status}`);
+  }
+  const data = await response.json();
+  const responseText = data.response.trim();
+  const jsonMatch = responseText.match(/\[[\s\S]*\]/);
+  if (!jsonMatch) {
+    throw new Error("LLM response did not contain a JSON array");
+  }
+  const parsed = JSON.parse(jsonMatch[0]);
+  const entities = [];
+  for (const item of parsed) {
+    if (typeof item === "object" && item !== null && "name" in item && typeof item.name === "string") {
+      const obj = item;
+      entities.push({
+        name: String(obj.name).toLowerCase().trim(),
+        type: typeof obj.type === "string" ? obj.type : "concept",
+        description: typeof obj.description === "string" ? obj.description : ""
+      });
+    }
+  }
+  return entities;
+}
+function keywordExtractEntities(text) {
+  const words = text.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length > 4 && !STOP_WORDS.has(w));
+  const freq = /* @__PURE__ */ new Map();
+  for (const word of words) {
+    freq.set(word, (freq.get(word) ?? 0) + 1);
+  }
+  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;
+    entities.push({
+      name: word,
+      type: "concept",
+      description: `Keyword appearing ${count} times`
+    });
+  }
+  return entities;
+}
+
+// ../chitragupta/packages/smriti/src/ner-extractor.ts
+var DEFAULT_ENDPOINT = "http://localhost:8501";
+var DEFAULT_MODEL = "gliner-large-v2.1";
+var DEFAULT_MIN_CONFIDENCE = 0.5;
+var DEFAULT_MAX_ENTITIES = 50;
+var GLINER_TIMEOUT_MS = 1e4;
+var GLINER_PROBE_TIMEOUT_MS = 3e3;
+var ALL_ENTITY_TYPES = [
+  "person",
+  "tool",
+  "file",
+  "concept",
+  "decision",
+  "error",
+  "technology",
+  "action",
+  "location",
+  "organization"
+];
+var GLINER_LABEL_MAP = {
+  // Standard NER tags
+  per: "person",
+  person: "person",
+  org: "organization",
+  organization: "organization",
+  loc: "location",
+  location: "location",
+  gpe: "location",
+  // Our custom labels (sent as GLiNER request labels)
+  tool: "tool",
+  file: "file",
+  concept: "concept",
+  decision: "decision",
+  error: "error",
+  technology: "technology",
+  action: "action"
+};
+var HEURISTIC_CONFIDENCE = 0.6;
+var FILE_PATTERN = /(?:^|[\s"'`(])([./][\w/.-]+\.\w{1,10})\b/g;
+var TECHNOLOGY_WORDS = [
+  "angular",
+  "aws",
+  "azure",
+  "bash",
+  "bun",
+  "c\\+\\+",
+  "css",
+  "deno",
+  "docker",
+  "elasticsearch",
+  "express",
+  "fastify",
+  "firebase",
+  "git",
+  "go",
+  "golang",
+  "graphql",
+  "html",
+  "java",
+  "javascript",
+  "jest",
+  "kafka",
+  "kotlin",
+  "kubernetes",
+  "linux",
+  "mongodb",
+  "mysql",
+  "nest",
+  "next\\.js",
+  "nextjs",
+  "node",
+  "node\\.js",
+  "nodejs",
+  "npm",
+  "ollama",
+  "postgres",
+  "postgresql",
+  "prisma",
+  "python",
+  "react",
+  "redis",
+  "rust",
+  "sql",
+  "svelte",
+  "swift",
+  "terraform",
+  "typescript",
+  "vite",
+  "vitest",
+  "vue",
+  "webpack",
+  "yarn",
+  "zod"
+];
+var TECHNOLOGY_PATTERN = new RegExp(
+  `\\b(${TECHNOLOGY_WORDS.join("|")})\\b`,
+  "gi"
+);
+var TOOL_WORDS = [
+  "read",
+  "write",
+  "edit",
+  "bash",
+  "grep",
+  "find",
+  "ls",
+  "diff",
+  "watch",
+  "glob",
+  "notebookedit",
+  "webfetch",
+  "websearch"
+];
+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;
+var CONCEPT_PATTERN = /\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+){1,3})\b/g;
+var NERExtractor = class {
+  endpoint;
+  model;
+  entityTypes;
+  minConfidence;
+  maxEntities;
+  useHeuristic;
+  /** Cached GLiNER2 availability probe result (null = not yet probed). */
+  glinerAvailable = null;
+  constructor(config = {}) {
+    this.endpoint = config.glinerEndpoint ?? DEFAULT_ENDPOINT;
+    this.model = config.glinerModel ?? DEFAULT_MODEL;
+    this.entityTypes = config.entityTypes ?? ALL_ENTITY_TYPES;
+    this.minConfidence = config.minConfidence ?? DEFAULT_MIN_CONFIDENCE;
+    this.maxEntities = config.maxEntities ?? DEFAULT_MAX_ENTITIES;
+    this.useHeuristic = config.useHeuristic ?? true;
+  }
+  // ─── Public API ──────────────────────────────────────────────────────────
+  /**
+   * Extract entities from text.
+   * Tries GLiNER2 first; falls back to heuristic if GLiNER2 is unavailable
+   * and `useHeuristic` is enabled.
+   */
+  async extract(text) {
+    if (!text || text.trim().length === 0) return [];
+    const glinerUp = await this.isGLiNERAvailable();
+    if (glinerUp) {
+      try {
+        const entities = await this.extractViaGLiNER(text);
+        return this.postProcess(entities);
+      } catch {
+      }
+    }
+    if (this.useHeuristic) {
+      const entities = this.extractViaHeuristic(text);
+      return this.postProcess(entities);
+    }
+    return [];
+  }
+  /**
+   * Extract entities from multiple texts in batch.
+   * Each text is processed independently; results are returned in order.
+   */
+  async extractBatch(texts) {
+    return Promise.all(texts.map((t) => this.extract(t)));
+  }
+  /**
+   * Probe whether GLiNER2 is reachable at the configured endpoint.
+   * Caches the result after the first successful probe.
+   */
+  async isGLiNERAvailable() {
+    if (this.glinerAvailable !== null) return this.glinerAvailable;
+    try {
+      const response = await fetch(this.endpoint, {
+        method: "GET",
+        signal: AbortSignal.timeout(GLINER_PROBE_TIMEOUT_MS)
+      });
+      this.glinerAvailable = response.ok;
+    } catch {
+      this.glinerAvailable = false;
+    }
+    return this.glinerAvailable;
+  }
+  // ─── GLiNER2 Integration ─────────────────────────────────────────────────
+  /**
+   * Call GLiNER2's /predict endpoint to extract entities.
+   *
+   * Request format:
+   *   POST /predict { text, labels, model }
+   *
+   * Response format:
+   *   { entities: [{ text, label, score, start, end }] }
+   */
+  async extractViaGLiNER(text) {
+    const response = await fetch(`${this.endpoint}/predict`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        text,
+        labels: this.entityTypes,
+        model: this.model
+      }),
+      signal: AbortSignal.timeout(GLINER_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      throw new Error(`GLiNER2 prediction error: ${response.status}`);
+    }
+    const data = await response.json();
+    if (!data.entities || !Array.isArray(data.entities)) {
+      return [];
+    }
+    return data.entities.map((e) => ({
+      text: e.text,
+      type: this.mapGLiNERLabel(e.label),
+      confidence: e.score,
+      span: [e.start, e.end]
+    }));
+  }
+  /**
+   * Map a GLiNER2 label string to our EntityType enum.
+   * Falls back to "concept" for unknown labels.
+   */
+  mapGLiNERLabel(label) {
+    const normalized = label.toLowerCase().trim();
+    return GLINER_LABEL_MAP[normalized] ?? "concept";
+  }
+  // ─── Heuristic Fallback ──────────────────────────────────────────────────
+  /**
+   * Regex-based NER extraction.
+   * Each pattern extracts entities of a specific type.
+   * All heuristic matches receive a fixed confidence of 0.6.
+   */
+  extractViaHeuristic(text) {
+    const entities = [];
+    const coveredSpans = [];
+    const addMatch = (match, type, groupIndex = 1) => {
+      const captured = match[groupIndex];
+      if (!captured) return;
+      const start = match.index + match[0].indexOf(captured);
+      const end = start + captured.length;
+      if (this.spanOverlaps([start, end], coveredSpans)) return;
+      coveredSpans.push([start, end]);
+      entities.push({
+        text: captured.trim(),
+        type,
+        confidence: HEURISTIC_CONFIDENCE,
+        span: [start, end]
+      });
+    };
+    this.execAll(FILE_PATTERN, text, (m) => addMatch(m, "file"));
+    this.execAll(ERROR_PATTERN, text, (m) => addMatch(m, "error"));
+    this.execAll(TECHNOLOGY_PATTERN, text, (m) => addMatch(m, "technology"));
+    this.execAll(TOOL_PATTERN, text, (m) => addMatch(m, "tool"));
+    this.execAll(DECISION_PATTERN, text, (m) => addMatch(m, "decision"));
+    this.execAll(ACTION_PATTERN, text, (m) => addMatch(m, "action"));
+    this.execAll(CONCEPT_PATTERN, text, (m) => addMatch(m, "concept"));
+    return entities;
+  }
+  // ─── Utilities ───────────────────────────────────────────────────────────
+  /**
+   * Execute a global regex against text, calling `fn` for each match.
+   * Resets the regex lastIndex before and after execution.
+   */
+  execAll(pattern, text, fn) {
+    pattern.lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+      fn(match);
+    }
+    pattern.lastIndex = 0;
+  }
+  /**
+   * Check if a candidate span overlaps with any existing span.
+   */
+  spanOverlaps(candidate, existing) {
+    const [cs, ce] = candidate;
+    return existing.some(([es, ee]) => cs < ee && ce > es);
+  }
+  /**
+   * Post-process extracted entities:
+   * 1. Filter by requested entity types
+   * 2. Filter by minimum confidence
+   * 3. Deduplicate by normalized text
+   * 4. Sort by confidence descending
+   * 5. Cap at maxEntities
+   */
+  postProcess(entities) {
+    const typeSet = new Set(this.entityTypes);
+    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()}`;
+      const existing = seen.get(key);
+      if (!existing || entity.confidence > existing.confidence) {
+        seen.set(key, entity);
+      }
+    }
+    filtered = [...seen.values()];
+    filtered.sort((a, b) => {
+      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
+function nowISO() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+var EPOCH_ISO = "1970-01-01T00:00:00.000Z";
+function createEdge(source, target, relationship, weight, validFrom) {
+  const now = nowISO();
+  return {
+    source,
+    target,
+    relationship,
+    weight,
+    validFrom: validFrom ?? now,
+    recordedAt: now
+  };
+}
+function supersedEdge(existingEdge, newWeight, newRelationship) {
+  const now = nowISO();
+  const superseded = {
+    ...existingEdge,
+    supersededAt: now
+  };
+  const replacement = {
+    source: existingEdge.source,
+    target: existingEdge.target,
+    relationship: newRelationship ?? existingEdge.relationship,
+    weight: newWeight ?? existingEdge.weight,
+    validFrom: now,
+    recordedAt: now
+  };
+  return [superseded, replacement];
+}
+function expireEdge(edge, validUntil) {
+  return {
+    ...edge,
+    validUntil: validUntil ?? nowISO()
+  };
+}
+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 (asOfRecord !== void 0) {
+      const rAt = e.recordedAt ?? EPOCH_ISO;
+      if (rAt > asOfRecord) return false;
+      if (e.supersededAt !== void 0 && e.supersededAt <= asOfRecord) return false;
+    } else {
+      if (e.supersededAt !== void 0) return false;
+    }
+    return true;
+  });
+}
+function getEdgeHistory(edges, source, target) {
+  return edges.filter((e) => e.source === source && e.target === target).sort((a, b) => (a.recordedAt ?? EPOCH_ISO).localeCompare(b.recordedAt ?? EPOCH_ISO));
+}
+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;
+  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;
+    return new Date(e.supersededAt).getTime() > cutoff;
+  });
+}
+
+// ../chitragupta/packages/smriti/src/graphrag-builder.ts
+function scopeToId(scope) {
+  switch (scope.type) {
+    case "global":
+      return "memory-global";
+    case "project":
+      return `memory-project-${scope.path}`;
+    case "agent":
+      return `memory-agent-${scope.agentId}`;
+    case "session":
+      return `memory-session-${scope.sessionId}`;
+  }
+}
+function scopeToLabel(scope) {
+  switch (scope.type) {
+    case "global":
+      return "Global Memory";
+    case "project":
+      return `Project Memory: ${scope.path}`;
+    case "agent":
+      return `Agent Memory: ${scope.agentId}`;
+    case "session":
+      return `Session Memory: ${scope.sessionId}`;
+  }
+}
+async function createSessionNode(ctx, session) {
+  const summaryText = `${session.meta.title} - ${session.meta.tags.join(", ")}`;
+  return {
+    id: session.meta.id,
+    type: "session",
+    label: session.meta.title,
+    content: summaryText,
+    embedding: await ctx.getEmbedding(summaryText),
+    metadata: {
+      agent: session.meta.agent,
+      model: session.meta.model,
+      project: session.meta.project,
+      created: session.meta.created,
+      turnCount: session.turns.length
+    }
+  };
+}
+async function extractConceptsFromNodes(ctx, nodes, edges) {
+  const entityIndex = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    if (!node.content || node.type === "concept") continue;
+    const entities = await ctx.extractEntities(node.content);
+    for (const entity of entities) {
+      const key = entity.name.toLowerCase();
+      const existing = entityIndex.get(key);
+      if (existing) {
+        existing.sourceIds.push(node.id);
+        if (entity.description.length > existing.entity.description.length) {
+          existing.entity = entity;
+        }
+      } else {
+        entityIndex.set(key, { entity, sourceIds: [node.id] });
+      }
+    }
+  }
+  for (const [key, data] of entityIndex) {
+    if (data.sourceIds.length < 2) continue;
+    const conceptId = `concept-${key.replace(/\s+/g, "-")}`;
+    if (nodes.some((n) => n.id === conceptId)) continue;
+    const conceptNode = {
+      id: conceptId,
+      type: "concept",
+      label: data.entity.name,
+      content: data.entity.description || data.entity.name,
+      metadata: {
+        entityType: data.entity.type,
+        sourceCount: data.sourceIds.length
+      }
+    };
+    nodes.push(conceptNode);
+    for (const sourceId of data.sourceIds) {
+      edges.push(createEdge(sourceId, conceptId, "mentions_concept", 0.5));
+    }
+  }
+}
+async function indexSessionTurns(ctx, session, nodes, edges) {
+  for (const turn of session.turns) {
+    const chunks = semanticChunk(turn.content);
+    for (let chunkIdx = 0; chunkIdx < chunks.length; chunkIdx++) {
+      const chunk = chunks[chunkIdx];
+      const chunkId = `${session.meta.id}-turn-${turn.turnNumber}-chunk-${chunkIdx}`;
+      const chunkNode = {
+        id: chunkId,
+        type: "session",
+        label: `Turn ${turn.turnNumber} (${turn.role}) chunk ${chunkIdx + 1}/${chunks.length}`,
+        content: chunk.text,
+        embedding: await ctx.getEmbedding(chunk.text),
+        metadata: {
+          sessionId: session.meta.id,
+          turnNumber: turn.turnNumber,
+          role: turn.role,
+          chunkIndex: chunkIdx,
+          totalChunks: chunks.length,
+          startSentence: chunk.startSentence,
+          endSentence: chunk.endSentence
+        }
+      };
+      nodes.push(chunkNode);
+      edges.push(createEdge(session.meta.id, chunkId, "contains_chunk", 1));
+      if (chunkIdx > 0) {
+        const prevChunkId = `${session.meta.id}-turn-${turn.turnNumber}-chunk-${chunkIdx - 1}`;
+        edges.push(createEdge(prevChunkId, chunkId, "followed_by", 0.7));
+      }
+    }
+    if (turn.toolCalls) {
+      for (let i = 0; i < turn.toolCalls.length; i++) {
+        const tc = turn.toolCalls[i];
+        const toolNodeId = `${session.meta.id}-turn-${turn.turnNumber}-tool-${i}`;
+        const toolNode = {
+          id: toolNodeId,
+          type: "file",
+          label: `Tool: ${tc.name}`,
+          content: tc.input.slice(0, 500),
+          metadata: {
+            toolName: tc.name,
+            isError: tc.isError ?? false
+          }
+        };
+        nodes.push(toolNode);
+        const firstChunkId = `${session.meta.id}-turn-${turn.turnNumber}-chunk-0`;
+        const linkTarget = nodes.some((n) => n.id === firstChunkId) ? firstChunkId : session.meta.id;
+        edges.push(createEdge(linkTarget, toolNodeId, "uses_tool", 0.8));
+      }
+    }
+  }
+  if (session.meta.parent) {
+    edges.push(createEdge(session.meta.parent, session.meta.id, "branched_to", 0.9));
+  }
+}
+async function buildMemoryNodes(ctx, memory, nodes, edges) {
+  const memoryId = scopeToId(memory.scope);
+  const chunks = semanticChunk(memory.content);
+  if (chunks.length <= 1) {
+    const memoryNode = {
+      id: memoryId,
+      type: "memory",
+      label: scopeToLabel(memory.scope),
+      content: memory.content,
+      embedding: await ctx.getEmbedding(memory.content),
+      metadata: { scope: memory.scope }
+    };
+    nodes.push(memoryNode);
+  } else {
+    const memoryNode = {
+      id: memoryId,
+      type: "memory",
+      label: scopeToLabel(memory.scope),
+      content: chunks[0].text,
+      embedding: await ctx.getEmbedding(memory.content.slice(0, 500)),
+      metadata: { scope: memory.scope, totalChunks: chunks.length }
+    };
+    nodes.push(memoryNode);
+    for (let i = 0; i < chunks.length; i++) {
+      const chunkId = `${memoryId}-chunk-${i}`;
+      const chunkNode = {
+        id: chunkId,
+        type: "memory",
+        label: `${scopeToLabel(memory.scope)} chunk ${i + 1}/${chunks.length}`,
+        content: chunks[i].text,
+        embedding: await ctx.getEmbedding(chunks[i].text),
+        metadata: {
+          scope: memory.scope,
+          chunkIndex: i,
+          totalChunks: chunks.length,
+          startSentence: chunks[i].startSentence,
+          endSentence: chunks[i].endSentence
+        }
+      };
+      nodes.push(chunkNode);
+      edges.push(createEdge(memoryId, chunkId, "contains_chunk", 1));
+    }
+  }
+}
+async function buildMemoryNodesFromContent(ctx, scope, content, nodes, edges) {
+  const memoryId = scopeToId(scope);
+  const chunks = semanticChunk(content);
+  if (chunks.length <= 1) {
+    const memoryNode = {
+      id: memoryId,
+      type: "memory",
+      label: scopeToLabel(scope),
+      content,
+      embedding: await ctx.getEmbedding(content),
+      metadata: { scope }
+    };
+    nodes.push(memoryNode);
+  } else {
+    const memoryNode = {
+      id: memoryId,
+      type: "memory",
+      label: scopeToLabel(scope),
+      content: chunks[0].text,
+      embedding: await ctx.getEmbedding(content.slice(0, 500)),
+      metadata: { scope, totalChunks: chunks.length }
+    };
+    nodes.push(memoryNode);
+    for (let i = 0; i < chunks.length; i++) {
+      const chunkId = `${memoryId}-chunk-${i}`;
+      const chunkNode = {
+        id: chunkId,
+        type: "memory",
+        label: `${scopeToLabel(scope)} chunk ${i + 1}/${chunks.length}`,
+        content: chunks[i].text,
+        embedding: await ctx.getEmbedding(chunks[i].text),
+        metadata: {
+          scope,
+          chunkIndex: i,
+          totalChunks: chunks.length,
+          startSentence: chunks[i].startSentence,
+          endSentence: chunks[i].endSentence
+        }
+      };
+      nodes.push(chunkNode);
+      edges.push(createEdge(memoryId, chunkId, "contains_chunk", 1));
+    }
+  }
+}
+function removeSessionFromGraph(graph, sessionId) {
+  const nodeIdsToRemove = /* @__PURE__ */ new Set();
+  for (const node of graph.nodes) {
+    if (node.id === sessionId || node.id.startsWith(`${sessionId}-turn-`)) {
+      nodeIdsToRemove.add(node.id);
+    }
+  }
+  graph.nodes = graph.nodes.filter((n) => !nodeIdsToRemove.has(n.id));
+  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-`)
+  );
+}
+
+// ../chitragupta/packages/smriti/src/graphrag-leiden.ts
+var DEFAULT_LEIDEN_CONFIG = {
+  resolution: 1,
+  maxIterations: 10,
+  minModularityGain: 1e-6,
+  seed: 42,
+  minCommunitySize: 1
+};
+var Xorshift32 = class {
+  state;
+  constructor(seed) {
+    this.state = seed | 0 || 1;
+  }
+  next() {
+    let x = this.state;
+    x ^= x << 13;
+    x ^= x >> 17;
+    x ^= x << 5;
+    this.state = x;
+    return (x >>> 0) / 4294967295;
+  }
+};
+var AdjacencyGraph = class {
+  /** nodeIndex → Map<neighborIndex, weight> */
+  adj;
+  /** nodeIndex → weighted degree (sum of edge weights) */
+  degree;
+  /** Total edge weight (2m). */
+  totalWeight;
+  /** Number of nodes. */
+  n;
+  /** Node ID → index mapping. */
+  idToIndex;
+  /** Index → node ID mapping. */
+  indexToId;
+  constructor(graph) {
+    const nodeIds = graph.nodes.map((n) => n.id);
+    this.n = nodeIds.length;
+    this.idToIndex = new Map(nodeIds.map((id, i) => [id, i]));
+    this.indexToId = nodeIds;
+    this.adj = new Array(this.n);
+    this.degree = new Array(this.n).fill(0);
+    for (let i = 0; i < this.n; i++) {
+      this.adj[i] = /* @__PURE__ */ new Map();
+    }
+    let totalW = 0;
+    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;
+      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);
+      this.degree[s] += w;
+      this.degree[t] += w;
+      totalW += 2 * w;
+    }
+    this.totalWeight = totalW;
+  }
+};
+function computeModularity(g, assignment, resolution) {
+  const twoM = g.totalWeight;
+  if (twoM === 0) return 0;
+  const internalWeight = /* @__PURE__ */ new Map();
+  const communityDegree = /* @__PURE__ */ new Map();
+  for (let i = 0; i < g.n; i++) {
+    const ci = assignment[i];
+    communityDegree.set(ci, (communityDegree.get(ci) ?? 0) + g.degree[i]);
+    for (const [j, w] of g.adj[i]) {
+      if (assignment[j] === ci && j > i) {
+        internalWeight.set(ci, (internalWeight.get(ci) ?? 0) + w);
+      }
+    }
+  }
+  let Q = 0;
+  for (const c of communityDegree.keys()) {
+    const ec = internalWeight.get(c) ?? 0;
+    const ac = communityDegree.get(c) ?? 0;
+    Q += 2 * ec / twoM - resolution * (ac / twoM) ** 2;
+  }
+  return Q;
+}
+function modularityGain(g, i, cNew, assignment, communityDegree, resolution) {
+  const twoM = g.totalWeight;
+  if (twoM === 0) return 0;
+  const cOld = assignment[i];
+  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;
+  }
+  const sigmaTotNew = communityDegree.get(cNew) ?? 0;
+  const sigmaTotOld = communityDegree.get(cOld) ?? 0;
+  const removeGain = -kInOld / twoM + resolution * ki * (sigmaTotOld - ki) / (twoM * twoM);
+  const addGain = kInNew / twoM - resolution * ki * sigmaTotNew / (twoM * twoM);
+  return removeGain + addGain;
+}
+function localNodeMoving(g, assignment, resolution, rng) {
+  const communityDegree = /* @__PURE__ */ new Map();
+  for (let i = 0; i < g.n; i++) {
+    const ci = assignment[i];
+    communityDegree.set(ci, (communityDegree.get(ci) ?? 0) + g.degree[i]);
+  }
+  const order = Array.from({ length: g.n }, (_, i) => i);
+  for (let i = order.length - 1; i > 0; i--) {
+    const j = Math.floor(rng.next() * (i + 1));
+    [order[i], order[j]] = [order[j], order[i]];
+  }
+  let improved = false;
+  for (const i of order) {
+    const cOld = assignment[i];
+    const ki = g.degree[i];
+    const neighborCommunities = /* @__PURE__ */ new Set();
+    for (const [j] of g.adj[i]) {
+      neighborCommunities.add(assignment[j]);
+    }
+    let bestCommunity = cOld;
+    let bestGain = 0;
+    for (const cNew of neighborCommunities) {
+      if (cNew === cOld) continue;
+      const gain = modularityGain(g, i, cNew, assignment, communityDegree, resolution);
+      if (gain > bestGain) {
+        bestGain = gain;
+        bestCommunity = cNew;
+      }
+    }
+    if (bestCommunity !== cOld) {
+      communityDegree.set(cOld, (communityDegree.get(cOld) ?? 0) - ki);
+      communityDegree.set(bestCommunity, (communityDegree.get(bestCommunity) ?? 0) + ki);
+      assignment[i] = bestCommunity;
+      improved = true;
+    }
+  }
+  return improved;
+}
+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, []);
+    communityNodes.get(c).push(i);
+  }
+  let nextCommunityId = Math.max(...assignment) + 1;
+  for (const [_communityId, nodes] of communityNodes) {
+    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;
+      const component = [];
+      const queue = [start];
+      visited.add(start);
+      while (queue.length > 0) {
+        const node = queue.shift();
+        component.push(node);
+        for (const [neighbor] of g.adj[node]) {
+          if (nodeSet.has(neighbor) && !visited.has(neighbor)) {
+            visited.add(neighbor);
+            queue.push(neighbor);
+          }
+        }
+      }
+      components.push(component);
+    }
+    if (components.length > 1) {
+      components.sort((a, b) => b.length - a.length);
+      for (let k = 1; k < components.length; k++) {
+        const newId = nextCommunityId++;
+        for (const node of components[k]) {
+          assignment[node] = newId;
+        }
+      }
+    }
+  }
+}
+function compactCommunities(assignment, minSize) {
+  const sizes = /* @__PURE__ */ new Map();
+  for (const c of assignment) {
+    sizes.set(c, (sizes.get(c) ?? 0) + 1);
+  }
+  let largestCommunity = 0;
+  let largestSize = 0;
+  for (const [c, s] of sizes) {
+    if (s > largestSize) {
+      largestSize = s;
+      largestCommunity = c;
+    }
+  }
+  const remap = /* @__PURE__ */ new Map();
+  let nextId = 0;
+  for (const [c, s] of sizes) {
+    if (s < minSize) {
+      remap.set(c, remap.get(largestCommunity) ?? nextId);
+      if (!remap.has(largestCommunity)) {
+        remap.set(largestCommunity, nextId++);
+      }
+    } else {
+      if (!remap.has(c)) {
+        remap.set(c, nextId++);
+      }
+    }
+  }
+  return assignment.map((c) => remap.get(c) ?? 0);
+}
+function leiden(graph, config) {
+  const cfg = { ...DEFAULT_LEIDEN_CONFIG, ...config };
+  if (graph.nodes.length === 0) {
+    return {
+      communities: /* @__PURE__ */ new Map(),
+      communityList: [],
+      modularity: 0,
+      iterations: 0,
+      levels: 0
+    };
+  }
+  const g = new AdjacencyGraph(graph);
+  const rng = new Xorshift32(cfg.seed ?? Date.now() | 1);
+  const assignment = Array.from({ length: g.n }, (_, i) => i);
+  let prevModularity = -1;
+  let iterations = 0;
+  for (let iter = 0; iter < cfg.maxIterations; iter++) {
+    iterations++;
+    const improved = localNodeMoving(g, assignment, cfg.resolution, rng);
+    refineCommunities(g, assignment);
+    const currentModularity = computeModularity(g, assignment, cfg.resolution);
+    if (!improved || currentModularity - prevModularity < cfg.minModularityGain) {
+      break;
+    }
+    prevModularity = currentModularity;
+  }
+  const compacted = compactCommunities(assignment, cfg.minCommunitySize);
+  const communities = /* @__PURE__ */ new Map();
+  for (let i = 0; i < g.n; i++) {
+    communities.set(g.indexToId[i], compacted[i]);
+  }
+  const finalModularity = computeModularity(g, compacted, cfg.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, []);
+    communityNodes.get(c).push(g.indexToId[i]);
+  }
+  const communityList = [];
+  for (const [id, members] of communityNodes) {
+    let internalEdges = 0;
+    let internalWeight = 0;
+    const memberSet = new Set(members.map((m) => g.idToIndex.get(m)));
+    for (const mi of memberSet) {
+      for (const [j, w] of g.adj[mi]) {
+        if (memberSet.has(j) && j > mi) {
+          internalEdges++;
+          internalWeight += w;
+        }
+      }
+    }
+    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];
+    }
+    const twoM = g.totalWeight;
+    const communityMod = twoM > 0 ? 2 * internalWeight / twoM - cfg.resolution * (ac / twoM) ** 2 : 0;
+    communityList.push({
+      id,
+      members,
+      modularity: communityMod,
+      internalDensity: density,
+      level: 0
+    });
+  }
+  communityList.sort((a, b) => b.members.length - a.members.length);
+  return {
+    communities,
+    communityList,
+    modularity: finalModularity,
+    iterations,
+    levels: 1
+  };
+}
+function annotateCommunities(graph, result) {
+  for (const node of graph.nodes) {
+    const communityId = result.communities.get(node.id);
+    if (communityId !== void 0) {
+      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;
+  }
+  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.ts
+var DEFAULT_CONFIG = {
+  endpoint: process.env.OLLAMA_HOST ?? "http://localhost:11434",
+  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;
+  embeddingCache;
+  pageRankScores;
+  maxEmbeddingCacheSize;
+  ollamaAvailable = null;
+  embeddingService;
+  /** Push-based incremental PageRank engine — avoids full recompute on edge changes. */
+  incrementalPR = null;
+  /** Whether the graph.db schema has been initialized in this process. */
+  _graphDbInitialized = false;
+  constructor(config) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.graph = { nodes: [], edges: [] };
+    this.embeddingCache = /* @__PURE__ */ new Map();
+    this.pageRankScores = /* @__PURE__ */ new Map();
+    this.maxEmbeddingCacheSize = config?.maxEmbeddingCacheSize ?? 1e4;
+    this.embeddingService = config?.embeddingService ?? new EmbeddingService();
+    this.loadFromDisk();
+  }
+  // ─── Ollama Availability (for entity extraction) ──────────────────
+  async checkOllamaAvailability() {
+    if (this.ollamaAvailable !== null) return this.ollamaAvailable;
+    try {
+      const response = await fetch(`${this.config.endpoint}/api/version`, {
+        method: "GET",
+        signal: AbortSignal.timeout(3e3)
+      });
+      this.ollamaAvailable = response.ok;
+    } catch {
+      this.ollamaAvailable = false;
+    }
+    return this.ollamaAvailable;
+  }
+  async getEmbedding(text) {
+    const cached = this.embeddingCache.get(text);
+    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) {
+        this.embeddingCache.delete(oldest);
+      }
+    }
+    return vector;
+  }
+  // ─── Cosine Similarity (delegate) ──────────────────────────────────
+  cosineSimilarity(a, b) {
+    return cosineSimilarity(a, b);
+  }
+  // ─── Entity Extraction (delegates) ─────────────────────────────────
+  async extractEntities(text) {
+    const isAvailable = await this.checkOllamaAvailability();
+    let baseEntities;
+    if (isAvailable) {
+      try {
+        baseEntities = await llmExtractEntities(text, this.config.endpoint, this.config.generationModel);
+      } catch {
+        baseEntities = keywordExtractEntities(text);
+      }
+    } else {
+      baseEntities = keywordExtractEntities(text);
+    }
+    try {
+      const nerExtractor = new NERExtractor({ useHeuristic: true });
+      const nerEntities = await nerExtractor.extract(text);
+      const nerTypeMap = {
+        file: "file",
+        technology: "concept",
+        tool: "tool",
+        error: "concept",
+        decision: "concept",
+        action: "concept",
+        person: "person",
+        organization: "organization",
+        location: "concept",
+        concept: "concept"
+      };
+      const seen = new Set(baseEntities.map((e) => e.name.toLowerCase()));
+      for (const ne of nerEntities) {
+        const normalized = ne.text.toLowerCase().trim();
+        if (!seen.has(normalized) && normalized.length > 0) {
+          baseEntities.push({
+            name: normalized,
+            type: nerTypeMap[ne.type] ?? "concept",
+            description: `NER-detected ${ne.type} (confidence: ${ne.confidence.toFixed(2)})`
+          });
+          seen.add(normalized);
+        }
+      }
+    } catch {
+    }
+    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.
+   */
+  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.
+   */
+  applyEdgeRemovals(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.
+   */
+  applyEdgeAdditions(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.
+   */
+  computePageRank(graph) {
+    if (graph) {
+      this.pageRankScores = computePageRank(graph);
+      return this.pageRankScores;
+    }
+    this.initIncrementalPR();
+    return this.pageRankScores;
+  }
+  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.
+   */
+  recomputePageRank() {
+    this.initIncrementalPR();
+    this.saveToDisk();
+  }
+  // ─── Graph Building ───────────────────────────────────────────────
+  async buildGraph(sessions, memories) {
+    const nodes = [];
+    const edges = [];
+    for (const session of sessions) {
+      const sessionNode = await createSessionNode(this, session);
+      nodes.push(sessionNode);
+      await indexSessionTurns(this, session, 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);
+    }
+    this.initIncrementalPR();
+    this.saveToDisk();
+    return this.graph;
+  }
+  // ─── Hybrid Search ───────────────────────────────────────────────
+  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);
+    }
+    let maxPageRank = 0;
+    for (const node of searchGraph.nodes) {
+      const pr = this.pageRankScores.get(node.id) ?? 0;
+      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);
+      }
+      const rawPageRank = this.pageRankScores.get(node.id) ?? 0;
+      const normalizedPageRank = maxPageRank > 0 ? rawPageRank / 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 });
+      }
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, topK).map((s) => s.node);
+  }
+  // ─── Incremental Indexing ─────────────────────────────────────────
+  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 removedEdges = edgesBefore.filter((e) => !edgesAfterSet.has(e));
+    const edgeCountBeforeAdd = this.graph.edges.length;
+    const sessionNode = await createSessionNode(this, session);
+    this.graph.nodes.push(sessionNode);
+    await indexSessionTurns(this, session, this.graph.nodes, this.graph.edges);
+    const newEdges = this.graph.edges.slice(edgeCountBeforeAdd);
+    if (!this.incrementalPR) {
+      this.initIncrementalPR();
+    } else {
+      this.applyEdgeRemovals(removedEdges);
+      this.applyEdgeAdditions(newEdges);
+    }
+    this.saveToDisk();
+  }
+  async indexMemory(scope, content) {
+    const edgesBefore = [...this.graph.edges];
+    removeMemoryFromGraph(this.graph, scope);
+    const edgesAfterRemoval = this.graph.edges;
+    const edgesAfterSet = new Set(edgesAfterRemoval);
+    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);
+    const newEdges = this.graph.edges.slice(edgeCountBeforeAdd);
+    if (!this.incrementalPR) {
+      this.initIncrementalPR();
+    } else {
+      this.applyEdgeRemovals(removedEdges);
+      this.applyEdgeAdditions(newEdges);
+    }
+    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.
+   */
+  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";
+  }
+  /**
+   * 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.
+   */
+  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()
+    );
+  }
+  /** 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 ──────────────────────────────────────────────────
+  saveToDisk() {
+    try {
+      const db = this.getGraphDb();
+      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();
+        return;
+      }
+    } catch {
+    }
+    this.saveToDiskJson();
+  }
+  loadFromDisk() {
+    let loadedFromSqlite = false;
+    try {
+      const db = this.getGraphDb();
+      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;
+        } else {
+          this.loadFromDiskJson();
+          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());
+                }
+              })();
+            } catch {
+            }
+          }
+          loadedFromSqlite = 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();
+    }
+  }
+  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();
+    }
+  }
+  getGraph() {
+    return this.graph;
+  }
+  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;");
+      }
+    } catch {
+    }
+    this.saveToDisk();
+  }
+  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;
+      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,
+  NERExtractor,
+  createEdge,
+  supersedEdge,
+  expireEdge,
+  queryEdgesAtTime,
+  getEdgeHistory,
+  temporalDecay,
+  compactEdges,
+  leiden,
+  annotateCommunities,
+  communitySummary,
+  filterByCommunity,
+  findBridgeNodes,
+  GraphRAGEngine,
+  migrateGraphJson
+};
+//# sourceMappingURL=chunk-S4TBVCL2.js.map