collective-memory-mcp 0.2.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "collective-memory-mcp",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "A persistent, graph-based memory system for AI agents (MCP Server)",
   "type": "module",
   "main": "src/server.js",
@@ -37,10 +37,6 @@
     "win32"
   ],
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^0.6.0",
-    "better-sqlite3": "^11.0.0"
-  },
-  "devDependencies": {
-    "@types/better-sqlite3": "^7.6.0"
+    "@modelcontextprotocol/sdk": "^0.6.0"
   }
 }

package/src/storage.js

@@ -1,74 +1,84 @@
 /**
- * Storage layer for the Collective Memory System using SQLite.
+ * Storage layer for the Collective Memory System using JSON file.
+ * Pure JavaScript - no native dependencies required.
  */
 
-import Database from "better-sqlite3";
 import { promises as fs } from "fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import path from "path";
 import os from "os";
 import { Entity, Relation } from "./models.js";
 
 const DB_DIR = path.join(os.homedir(), ".collective-memory");
-const DB_PATH = path.join(DB_DIR, "memory.db");
+const DB_PATH = path.join(DB_DIR, "memory.json");
 
 /**
- * SQLite-based storage for the knowledge graph
+ * Simple file-based storage
  */
 export class Storage {
   constructor(dbPath = DB_PATH) {
     this.dbPath = dbPath;
-    this.db = null;
+    this.data = null;
+    // Initialize synchronously
     this.init();
   }
 
   /**
-   * Initialize database and create schema
+   * Initialize storage (synchronous)
    */
   init() {
-    // Ensure directory exists
-    fs.mkdir(path.dirname(this.dbPath), { recursive: true }).catch(() => {});
-
-    this.db = new Database(this.dbPath);
-    this.db.pragma("journal_mode = WAL");
-
-    // Create entities table
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS entities (
-        name TEXT PRIMARY KEY,
-        entity_type TEXT NOT NULL,
-        observations TEXT NOT NULL DEFAULT '[]',
-        created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
-        metadata TEXT NOT NULL DEFAULT '{}'
-      )
-    `);
-
-    // Create relations table
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS relations (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        from_entity TEXT NOT NULL,
-        to_entity TEXT NOT NULL,
-        relation_type TEXT NOT NULL,
-        created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
-        metadata TEXT NOT NULL DEFAULT '{}',
-        UNIQUE(from_entity, to_entity, relation_type)
-      )
-    `);
-
-    // Create indexes
-    this.db.exec(`
-      CREATE INDEX IF NOT EXISTS idx_entities_type ON entities(entity_type);
-      CREATE INDEX IF NOT EXISTS idx_relations_from ON relations(from_entity);
-      CREATE INDEX IF NOT EXISTS idx_relations_to ON relations(to_entity);
-      CREATE INDEX IF NOT EXISTS idx_relations_type ON relations(relation_type);
-    `);
+    try {
+      // Ensure directory exists
+      const dir = path.dirname(this.dbPath);
+      mkdirSync(dir, { recursive: true });
+
+      // Try to load existing data
+      if (existsSync(this.dbPath)) {
+        const content = readFileSync(this.dbPath, "utf-8");
+        this.data = JSON.parse(content);
+      } else {
+        // Create new empty data
+        this.data = {
+          entities: {},
+          relations: [],
+          version: "1.0",
+        };
+        this.saveSync();
+      }
+    } catch (error) {
+      // If anything fails, start with empty data
+      this.data = {
+        entities: {},
+        relations: [],
+        version: "1.0",
+      };
+    }
+  }
+
+  /**
+   * Save data synchronously
+   */
+  saveSync() {
+    try {
+      const dir = path.dirname(this.dbPath);
+      mkdirSync(dir, { recursive: true });
+      writeFileSync(this.dbPath, JSON.stringify(this.data, null, 2), "utf-8");
+    } catch (error) {
+      console.error("Failed to save:", error.message);
+    }
   }
 
   /**
-   * Prepare statement helper
+   * Save data asynchronously
    */
-  prepare(sql) {
-    return this.db.prepare(sql);
+  async save() {
+    const dir = path.dirname(this.dbPath);
+    try {
+      await fs.mkdir(dir, { recursive: true });
+    } catch {
+      // Ignore
+    }
+    await fs.writeFile(this.dbPath, JSON.stringify(this.data, null, 2), "utf-8");
   }
 
   // ========== Entity Operations ==========
@@ -76,40 +86,22 @@ export class Storage {
   /**
    * Create a new entity. Returns true if created, false if duplicate.
    */
-  createEntity(entity) {
-    try {
-      const stmt = this.prepare(`
-        INSERT INTO entities (name, entity_type, observations, created_at, metadata)
-        VALUES (?, ?, ?, ?, ?)
-      `);
-      stmt.run(
-        entity.name,
-        entity.entityType,
-        JSON.stringify(entity.observations),
-        entity.createdAt,
-        JSON.stringify(entity.metadata)
-      );
-      return true;
-    } catch (err) {
-      if (err.code === "SQLITE_CONSTRAINT") return false;
-      throw err;
+  async createEntity(entity) {
+    if (this.data.entities[entity.name]) {
+      return false;
     }
+    this.data.entities[entity.name] = entity.toJSON();
+    await this.save();
+    return true;
   }
 
   /**
    * Get an entity by name
    */
   getEntity(name) {
-    const stmt = this.prepare("SELECT * FROM entities WHERE name = ?");
-    const row = stmt.get(name);
-    if (row) {
-      return new Entity({
-        name: row.name,
-        entityType: row.entity_type,
-        observations: JSON.parse(row.observations),
-        createdAt: row.created_at,
-        metadata: JSON.parse(row.metadata),
-      });
+    const data = this.data.entities[name];
+    if (data) {
+      return new Entity(data);
     }
     return null;
   }
@@ -118,68 +110,60 @@ export class Storage {
    * Get all entities
    */
   getAllEntities() {
-    const stmt = this.prepare("SELECT * FROM entities");
-    const rows = stmt.all();
-    return rows.map(row => new Entity({
-      name: row.name,
-      entityType: row.entity_type,
-      observations: JSON.parse(row.observations),
-      createdAt: row.created_at,
-      metadata: JSON.parse(row.metadata),
-    }));
+    return Object.values(this.data.entities).map(data => new Entity(data));
   }
 
   /**
    * Check if an entity exists
    */
   entityExists(name) {
-    const stmt = this.prepare("SELECT 1 FROM entities WHERE name = ?");
-    return stmt.get(name) !== undefined;
+    return name in this.data.entities;
   }
 
   /**
-   * Update entity observations
+   * Update entity
    */
-  updateEntity(name, { observations, metadata } = {}) {
-    const updates = [];
-    const params = [];
+  async updateEntity(name, { observations, metadata } = {}) {
+    const entity = this.data.entities[name];
+    if (!entity) return false;
 
     if (observations !== undefined) {
-      updates.push("observations = ?");
-      params.push(JSON.stringify(observations));
+      entity.observations = observations;
     }
     if (metadata !== undefined) {
-      updates.push("metadata = ?");
-      params.push(JSON.stringify(metadata));
+      entity.metadata = metadata;
     }
 
-    if (updates.length === 0) return true;
-
-    params.push(name);
-    const stmt = this.prepare(`UPDATE entities SET ${updates.join(", ")} WHERE name = ?`);
-    return stmt.run(...params).changes > 0;
+    await this.save();
+    return true;
   }
 
   /**
    * Delete an entity and its relations
    */
-  deleteEntity(name) {
-    const deleteRelations = this.prepare(
-      "DELETE FROM relations WHERE from_entity = ? OR to_entity = ?"
+  async deleteEntity(name) {
+    if (!this.data.entities[name]) {
+      return false;
+    }
+
+    delete this.data.entities[name];
+
+    // Remove relations involving this entity
+    this.data.relations = this.data.relations.filter(
+      r => r.from !== name && r.to !== name
     );
-    deleteRelations.run(name, name);
 
-    const deleteEntity = this.prepare("DELETE FROM entities WHERE name = ?");
-    return deleteEntity.run(name).changes > 0;
+    await this.save();
+    return true;
   }
 
   /**
    * Delete multiple entities
    */
-  deleteEntities(names) {
+  async deleteEntities(names) {
     let count = 0;
     for (const name of names) {
-      if (this.deleteEntity(name)) count++;
+      if (await this.deleteEntity(name)) count++;
     }
     return count;
   }
@@ -189,91 +173,82 @@ export class Storage {
   /**
    * Create a new relation. Returns true if created, false if duplicate.
    */
-  createRelation(relation) {
-    try {
-      const stmt = this.prepare(`
-        INSERT INTO relations (from_entity, to_entity, relation_type, created_at, metadata)
-        VALUES (?, ?, ?, ?, ?)
-      `);
-      stmt.run(
-        relation.from,
-        relation.to,
-        relation.relationType,
-        relation.createdAt,
-        JSON.stringify(relation.metadata)
-      );
-      return true;
-    } catch (err) {
-      if (err.code === "SQLITE_CONSTRAINT") return false;
-      throw err;
+  async createRelation(relation) {
+    const key = this.relationKey(relation.from, relation.to, relation.relationType);
+    if (this.data.relations.some(r => this.relationKey(r.from, r.to, r.relationType) === key)) {
+      return false;
     }
+
+    this.data.relations.push(relation.toJSON());
+    await this.save();
+    return true;
+  }
+
+  /**
+   * Generate unique key for relation
+   */
+  relationKey(from, to, type) {
+    return `${from}|${to}|${type}`;
   }
 
   /**
    * Get relations with optional filters
    */
   getRelations({ fromEntity, toEntity, relationType } = {}) {
-    let sql = "SELECT * FROM relations WHERE 1=1";
-    const params = [];
+    let results = this.data.relations.map(r => new Relation(r));
 
     if (fromEntity) {
-      sql += " AND from_entity = ?";
-      params.push(fromEntity);
+      results = results.filter(r => r.from === fromEntity);
     }
     if (toEntity) {
-      sql += " AND to_entity = ?";
-      params.push(toEntity);
+      results = results.filter(r => r.to === toEntity);
     }
     if (relationType) {
-      sql += " AND relation_type = ?";
-      params.push(relationType);
+      results = results.filter(r => r.relationType === relationType);
     }
 
-    const stmt = this.prepare(sql);
-    const rows = stmt.all(...params);
-    return rows.map(row => new Relation({
-      from: row.from_entity,
-      to: row.to_entity,
-      relationType: row.relation_type,
-      createdAt: row.created_at,
-      metadata: JSON.parse(row.metadata),
-    }));
+    return results;
   }
 
   /**
    * Get all relations
    */
   getAllRelations() {
-    return this.getRelations();
+    return this.data.relations.map(r => new Relation(r));
   }
 
   /**
    * Check if a relation exists
    */
   relationExists(fromEntity, toEntity, relationType) {
-    const stmt = this.prepare(
-      "SELECT 1 FROM relations WHERE from_entity = ? AND to_entity = ? AND relation_type = ?"
+    return this.data.relations.some(
+      r => r.from === fromEntity && r.to === toEntity && r.relationType === relationType
     );
-    return stmt.get(fromEntity, toEntity, relationType) !== undefined;
   }
 
   /**
    * Delete a specific relation
    */
-  deleteRelation(fromEntity, toEntity, relationType) {
-    const stmt = this.prepare(
-      "DELETE FROM relations WHERE from_entity = ? AND to_entity = ? AND relation_type = ?"
+  async deleteRelation(fromEntity, toEntity, relationType) {
+    const before = this.data.relations.length;
+    this.data.relations = this.data.relations.filter(
+      r => !(r.from === fromEntity && r.to === toEntity && r.relationType === relationType)
     );
-    return stmt.run(fromEntity, toEntity, relationType).changes > 0;
+
+    if (this.data.relations.length < before) {
+      await this.save();
+      return true;
+    }
+    return false;
   }
 
   /**
    * Delete multiple relations
    */
-  deleteRelations(relations) {
+  async deleteRelations(relations) {
     let count = 0;
     for (const [fromEntity, toEntity, relationType] of relations) {
-      if (this.deleteRelation(fromEntity, toEntity, relationType)) count++;
+      if (await this.deleteRelation(fromEntity, toEntity, relationType)) count++;
     }
     return count;
   }
@@ -284,22 +259,13 @@ export class Storage {
    * Search entities by name, type, or observations
    */
   searchEntities(query) {
-    const pattern = `%${query}%`;
-    const stmt = this.prepare(`
-      SELECT DISTINCT e.* FROM entities e
-      WHERE e.name LIKE ?
-         OR e.entity_type LIKE ?
-         OR e.observations LIKE ?
-      ORDER BY e.created_at DESC
-    `);
-    const rows = stmt.all(pattern, pattern, pattern);
-    return rows.map(row => new Entity({
-      name: row.name,
-      entityType: row.entity_type,
-      observations: JSON.parse(row.observations),
-      createdAt: row.created_at,
-      metadata: JSON.parse(row.metadata),
-    }));
+    const lowerQuery = query.toLowerCase();
+    return this.getAllEntities().filter(e => {
+      if (e.name.toLowerCase().includes(lowerQuery)) return true;
+      if (e.entityType.toLowerCase().includes(lowerQuery)) return true;
+      if (e.observations.some(o => o.toLowerCase().includes(lowerQuery))) return true;
+      return false;
+    });
   }
 
   /**
@@ -308,42 +274,38 @@ export class Storage {
   getRelatedEntities(entityName) {
     const result = { connected: [], incoming: [], outgoing: [] };
 
-    // Get connected entity names
-    const outgoingStmt = this.prepare(
-      "SELECT DISTINCT to_entity FROM relations WHERE from_entity = ?"
-    );
-    const incomingStmt = this.prepare(
-      "SELECT DISTINCT from_entity FROM relations WHERE to_entity = ?"
-    );
-
-    const outgoing = outgoingStmt.all(entityName);
-    const incoming = incomingStmt.all(entityName);
-
-    const connectedNames = new Set([
-      ...outgoing.map(r => r.to_entity),
-      ...incoming.map(r => r.from_entity)
-    ]);
+    const connectedNames = new Set();
+
+    for (const rel of this.data.relations) {
+      if (rel.from === entityName) {
+        connectedNames.add(rel.to);
+        result.outgoing.push(rel.to);
+      }
+      if (rel.to === entityName) {
+        connectedNames.add(rel.from);
+        result.incoming.push(rel.from);
+      }
+    }
 
     for (const name of connectedNames) {
       const entity = this.getEntity(name);
-      if (entity) result.connected.push(entity);
+      if (entity) {
+        result.connected.push(entity);
+      }
     }
 
     return result;
   }
 
   /**
-   * Close database connection
+   * Close storage
    */
-  close() {
-    if (this.db) {
-      this.db.close();
-      this.db = null;
-    }
+  async close() {
+    await this.save();
   }
 }
 
-// Export singleton instance
+// Singleton instance
 let storageInstance = null;
 
 export function getStorage(dbPath) {