@coreidentitylabs/open-graph-memory-mcp 1.0.1

package/src/storage/json-store.ts

@@ -0,0 +1,325 @@
+// =============================================================================
+// JSON File Storage Backend
+// =============================================================================
+
+import {
+  writeFileSync,
+  readFileSync,
+  existsSync,
+  mkdirSync,
+  renameSync,
+} from "node:fs";
+import { dirname } from "node:path";
+import type {
+  StorageBackend,
+  MemoryNode,
+  MemoryEdge,
+  ScoredNode,
+  Subgraph,
+  NodeFilter,
+  GraphStats,
+} from "../types.js";
+import { cosineSimilarity } from "../encoding/embedder.js";
+
+interface MemoryFileData {
+  version: string;
+  lastConsolidated?: string;
+  nodes: MemoryNode[];
+  edges: MemoryEdge[];
+}
+
+export class JsonStore implements StorageBackend {
+  private nodes: Map<string, MemoryNode> = new Map();
+  private edges: Map<string, MemoryEdge> = new Map();
+  private lastConsolidated?: string;
+  private filePath: string;
+
+  constructor(filePath: string) {
+    this.filePath = filePath;
+  }
+
+  async initialize(): Promise<void> {
+    if (existsSync(this.filePath)) {
+      const raw = readFileSync(this.filePath, "utf-8");
+      const data: MemoryFileData = JSON.parse(raw);
+      this.lastConsolidated = data.lastConsolidated;
+      for (const node of data.nodes) {
+        this.nodes.set(node.id, node);
+      }
+      for (const edge of data.edges) {
+        this.edges.set(edge.id, edge);
+      }
+      console.error(
+        `[open-memory] Loaded ${this.nodes.size} nodes, ${this.edges.size} edges from ${this.filePath}`,
+      );
+    } else {
+      console.error(
+        `[open-memory] No existing memory file found. Starting fresh at ${this.filePath}`,
+      );
+    }
+  }
+
+  private persist(): void {
+    const data: MemoryFileData = {
+      version: "1.0.0",
+      lastConsolidated: this.lastConsolidated,
+      nodes: Array.from(this.nodes.values()),
+      edges: Array.from(this.edges.values()),
+    };
+    const dir = dirname(this.filePath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    // Atomic write: write to temp file, then rename
+    const tmpPath = this.filePath + ".tmp";
+    writeFileSync(tmpPath, JSON.stringify(data, null, 2), "utf-8");
+    renameSync(tmpPath, this.filePath);
+  }
+
+  // -- Node Operations -------------------------------------------------------
+
+  async addNode(node: MemoryNode): Promise<void> {
+    this.nodes.set(node.id, node);
+    this.persist();
+  }
+
+  async updateNode(
+    id: string,
+    updates: Partial<MemoryNode>,
+  ): Promise<MemoryNode | null> {
+    const existing = this.nodes.get(id);
+    if (!existing) return null;
+    const updated = {
+      ...existing,
+      ...updates,
+      id: existing.id, // prevent ID overwrite
+      updatedAt: new Date().toISOString(),
+    };
+    this.nodes.set(id, updated);
+    this.persist();
+    return updated;
+  }
+
+  async deleteNode(id: string): Promise<boolean> {
+    const existed = this.nodes.delete(id);
+    if (existed) {
+      // Remove all edges connected to this node
+      for (const [edgeId, edge] of this.edges) {
+        if (edge.source === id || edge.target === id) {
+          this.edges.delete(edgeId);
+        }
+      }
+      this.persist();
+    }
+    return existed;
+  }
+
+  async getNode(id: string): Promise<MemoryNode | null> {
+    return this.nodes.get(id) ?? null;
+  }
+
+  async getNodeByName(name: string): Promise<MemoryNode | null> {
+    const nameLower = name.toLowerCase();
+    for (const node of this.nodes.values()) {
+      if (node.name.toLowerCase() === nameLower) {
+        return node;
+      }
+    }
+    return null;
+  }
+
+  async findNodes(filter: NodeFilter): Promise<MemoryNode[]> {
+    let results = Array.from(this.nodes.values());
+
+    if (filter.type) {
+      results = results.filter((n) => n.type === filter.type);
+    }
+    if (filter.source) {
+      results = results.filter((n) => n.source === filter.source);
+    }
+    if (filter.nameContains) {
+      const q = filter.nameContains.toLowerCase();
+      results = results.filter((n) => n.name.toLowerCase().includes(q));
+    }
+    if (filter.createdAfter) {
+      results = results.filter((n) => n.createdAt >= filter.createdAfter!);
+    }
+    if (filter.createdBefore) {
+      results = results.filter((n) => n.createdAt <= filter.createdBefore!);
+    }
+
+    return results;
+  }
+
+  async getAllNodes(
+    limit: number,
+    offset: number,
+  ): Promise<{ nodes: MemoryNode[]; total: number }> {
+    const all = Array.from(this.nodes.values());
+    return {
+      nodes: all.slice(offset, offset + limit),
+      total: all.length,
+    };
+  }
+
+  async findNodesByEmbedding(
+    embedding: number[],
+    topK: number,
+  ): Promise<ScoredNode[]> {
+    const scored: ScoredNode[] = [];
+    for (const node of this.nodes.values()) {
+      if (node.embedding && node.embedding.length > 0) {
+        const score = cosineSimilarity(embedding, node.embedding);
+        scored.push({ node, score, matchType: "semantic" });
+      }
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, topK);
+  }
+
+  // -- Edge Operations --------------------------------------------------------
+
+  async addEdge(edge: MemoryEdge): Promise<void> {
+    this.edges.set(edge.id, edge);
+    this.persist();
+  }
+
+  async updateEdge(
+    id: string,
+    updates: Partial<MemoryEdge>,
+  ): Promise<MemoryEdge | null> {
+    const existing = this.edges.get(id);
+    if (!existing) return null;
+    const updated = {
+      ...existing,
+      ...updates,
+      id: existing.id,
+      updatedAt: new Date().toISOString(),
+    };
+    this.edges.set(id, updated);
+    this.persist();
+    return updated;
+  }
+
+  async deleteEdge(id: string): Promise<boolean> {
+    const existed = this.edges.delete(id);
+    if (existed) this.persist();
+    return existed;
+  }
+
+  async getEdge(id: string): Promise<MemoryEdge | null> {
+    return this.edges.get(id) ?? null;
+  }
+
+  async getEdgesForNode(
+    nodeId: string,
+    direction: "in" | "out" | "both" = "both",
+  ): Promise<MemoryEdge[]> {
+    const results: MemoryEdge[] = [];
+    for (const edge of this.edges.values()) {
+      if (direction === "out" && edge.source === nodeId) results.push(edge);
+      else if (direction === "in" && edge.target === nodeId) results.push(edge);
+      else if (
+        direction === "both" &&
+        (edge.source === nodeId || edge.target === nodeId)
+      )
+        results.push(edge);
+    }
+    return results;
+  }
+
+  async getEdgesBetween(
+    sourceId: string,
+    targetId: string,
+  ): Promise<MemoryEdge[]> {
+    const results: MemoryEdge[] = [];
+    for (const edge of this.edges.values()) {
+      if (
+        (edge.source === sourceId && edge.target === targetId) ||
+        (edge.source === targetId && edge.target === sourceId)
+      ) {
+        results.push(edge);
+      }
+    }
+    return results;
+  }
+
+  // -- Graph Traversal --------------------------------------------------------
+
+  async getNeighborhood(nodeId: string, depth: number): Promise<Subgraph> {
+    const visitedNodes = new Set<string>();
+    const visitedEdges = new Set<string>();
+    const resultNodes: MemoryNode[] = [];
+    const resultEdges: MemoryEdge[] = [];
+
+    const queue: { id: string; currentDepth: number }[] = [
+      { id: nodeId, currentDepth: 0 },
+    ];
+
+    while (queue.length > 0) {
+      const item = queue.shift()!;
+      if (visitedNodes.has(item.id)) continue;
+      visitedNodes.add(item.id);
+
+      const node = this.nodes.get(item.id);
+      if (node) resultNodes.push(node);
+
+      if (item.currentDepth < depth) {
+        for (const edge of this.edges.values()) {
+          if (edge.source === item.id || edge.target === item.id) {
+            if (!visitedEdges.has(edge.id)) {
+              visitedEdges.add(edge.id);
+              resultEdges.push(edge);
+            }
+            const neighborId =
+              edge.source === item.id ? edge.target : edge.source;
+            if (!visitedNodes.has(neighborId)) {
+              queue.push({
+                id: neighborId,
+                currentDepth: item.currentDepth + 1,
+              });
+            }
+          }
+        }
+      }
+    }
+
+    return { nodes: resultNodes, edges: resultEdges };
+  }
+
+  // -- Stats & Lifecycle ------------------------------------------------------
+
+  async getStats(): Promise<GraphStats> {
+    const nodesByType: Record<string, number> = {};
+    for (const node of this.nodes.values()) {
+      nodesByType[node.type] = (nodesByType[node.type] ?? 0) + 1;
+    }
+    return {
+      totalNodes: this.nodes.size,
+      totalEdges: this.edges.size,
+      nodesByType,
+      storageBackend: "json",
+      lastConsolidated: this.lastConsolidated,
+      memoryFilePath: this.filePath,
+    };
+  }
+
+  async close(): Promise<void> {
+    this.persist();
+  }
+
+  // -- Internal helpers for consolidation -------------------------------------
+
+  getNodesMap(): Map<string, MemoryNode> {
+    return this.nodes;
+  }
+
+  getEdgesMap(): Map<string, MemoryEdge> {
+    return this.edges;
+  }
+
+  setLastConsolidated(timestamp: string): void {
+    this.lastConsolidated = timestamp;
+    this.persist();
+  }
+}