collective-memory-mcp 0.2.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "collective-memory-mcp",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "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,123 @@
 /**
- * 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 path from "path";
 import os from "os";
+import { createHash } from "crypto";
 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
+ * Lock file to prevent concurrent writes
+ */
+const LOCK_FILE = path.join(DB_DIR, "memory.lock");
+
+/**
+ * Simple file-based storage with locking
  */
 export class Storage {
   constructor(dbPath = DB_PATH) {
     this.dbPath = dbPath;
-    this.db = null;
+    this.lockPath = LOCK_FILE;
+    this.data = null;
+    this.lockRetries = 10;
+    this.lockDelay = 50;
     this.init();
   }
 
   /**
-   * Initialize database and create schema
+   * Initialize storage
+   */
+  async init() {
+    await this.ensureDir();
+    await this.load();
+  }
+
+  /**
+   * Ensure data directory exists
+   */
+  async ensureDir() {
+    try {
+      await fs.mkdir(path.dirname(this.dbPath), { recursive: true });
+    } catch {
+      // Ignore if exists
+    }
+  }
+
+  /**
+   * Load data from file
+   */
+  async load() {
+    try {
+      const content = await fs.readFile(this.dbPath, "utf-8");
+      this.data = JSON.parse(content);
+    } catch {
+      // File doesn't exist or is invalid - create new
+      this.data = {
+        entities: {},
+        relations: [],
+        version: "1.0",
+      };
+      await this.save();
+    }
+  }
+
+  /**
+   * Save data to file
    */
-  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);
-    `);
+  async save() {
+    const dir = path.dirname(this.dbPath);
+    await fs.mkdir(dir, { recursive: true });
+    const tempPath = path.join(dir, ".memory.tmp");
+    await fs.writeFile(tempPath, JSON.stringify(this.data, null, 2), "utf-8");
+    await fs.rename(tempPath, this.dbPath);
   }
 
   /**
-   * Prepare statement helper
+   * Acquire lock
    */
-  prepare(sql) {
-    return this.db.prepare(sql);
+  async acquireLock() {
+    for (let i = 0; i < this.lockRetries; i++) {
+      try {
+        await fs.writeFile(
+          this.lockPath,
+          process.pid.toString(),
+          { flag: "wx" }
+        );
+        return;
+      } catch {
+        await new Promise(r => setTimeout(r, this.lockDelay));
+      }
+    }
+    // If we can't get lock, just proceed (it's a simple file lock)
+  }
+
+  /**
+   * Release lock
+   */
+  async releaseLock() {
+    try {
+      await fs.unlink(this.lockPath);
+    } catch {
+      // Ignore
+    }
+  }
+
+  /**
+   * Execute operation with lock
+   */
+  async withLock(fn) {
+    await this.acquireLock();
+    try {
+      return await fn();
+    } finally {
+      await this.releaseLock();
+    }
   }
 
   // ========== Entity Operations ==========
@@ -76,40 +125,24 @@ 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)
-      );
+  async createEntity(entity) {
+    return this.withLock(async () => {
+      if (this.data.entities[entity.name]) {
+        return false;
+      }
+      this.data.entities[entity.name] = entity.toJSON();
+      await this.save();
       return true;
-    } catch (err) {
-      if (err.code === "SQLITE_CONSTRAINT") return false;
-      throw err;
-    }
+    });
   }
 
   /**
    * 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 +151,64 @@ 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 = [];
-
-    if (observations !== undefined) {
-      updates.push("observations = ?");
-      params.push(JSON.stringify(observations));
-    }
-    if (metadata !== undefined) {
-      updates.push("metadata = ?");
-      params.push(JSON.stringify(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;
+  async updateEntity(name, { observations, metadata } = {}) {
+    return this.withLock(async () => {
+      const entity = this.data.entities[name];
+      if (!entity) return false;
+
+      if (observations !== undefined) {
+        entity.observations = observations;
+      }
+      if (metadata !== undefined) {
+        entity.metadata = metadata;
+      }
+
+      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 = ?"
-    );
-    deleteRelations.run(name, name);
+  async deleteEntity(name) {
+    return this.withLock(async () => {
+      if (!this.data.entities[name]) {
+        return false;
+      }
+
+      delete this.data.entities[name];
 
-    const deleteEntity = this.prepare("DELETE FROM entities WHERE name = ?");
-    return deleteEntity.run(name).changes > 0;
+      // Remove relations involving this entity
+      this.data.relations = this.data.relations.filter(
+        r => r.from !== name && r.to !== name
+      );
+
+      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 +218,86 @@ 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)
-      );
+  async createRelation(relation) {
+    return this.withLock(async () => {
+      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;
-    } catch (err) {
-      if (err.code === "SQLITE_CONSTRAINT") return false;
-      throw err;
-    }
+    });
+  }
+
+  /**
+   * 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 = ?"
-    );
-    return stmt.run(fromEntity, toEntity, relationType).changes > 0;
+  async deleteRelation(fromEntity, toEntity, relationType) {
+    return this.withLock(async () => {
+      const before = this.data.relations.length;
+      this.data.relations = this.data.relations.filter(
+        r => !(r.from === fromEntity && r.to === toEntity && r.relationType === relationType)
+      );
+
+      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 +308,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,47 +323,120 @@ 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
+// Sync wrapper for async operations
 let storageInstance = null;
 
 export function getStorage(dbPath) {
   if (!storageInstance) {
     storageInstance = new Storage(dbPath);
+    // Initialize asynchronously but don't wait
+    storageInstance.init().catch(console.error);
   }
   return storageInstance;
 }
+
+// Synchronous methods for compatibility
+export class SyncStorage {
+  constructor(dbPath = DB_PATH) {
+    this.storage = new Storage(dbPath);
+  }
+
+  async init() {
+    await this.storage.init();
+  }
+
+  createEntity(entity) {
+    return this.storage.createEntity(entity);
+  }
+
+  getEntity(name) {
+    return this.storage.getEntity(name);
+  }
+
+  getAllEntities() {
+    return this.storage.getAllEntities();
+  }
+
+  entityExists(name) {
+    return this.storage.entityExists(name);
+  }
+
+  updateEntity(name, data) {
+    return this.storage.updateEntity(name, data);
+  }
+
+  deleteEntity(name) {
+    return this.storage.deleteEntity(name);
+  }
+
+  deleteEntities(names) {
+    return this.storage.deleteEntities(names);
+  }
+
+  createRelation(relation) {
+    return this.storage.createRelation(relation);
+  }
+
+  getRelations(filters) {
+    return this.storage.getRelations(filters);
+  }
+
+  getAllRelations() {
+    return this.storage.getAllRelations();
+  }
+
+  relationExists(from, to, type) {
+    return this.storage.relationExists(from, to, type);
+  }
+
+  deleteRelation(from, to, type) {
+    return this.storage.deleteRelation(from, to, type);
+  }
+
+  deleteRelations(relations) {
+    return this.storage.deleteRelations(relations);
+  }
+
+  searchEntities(query) {
+    return this.storage.searchEntities(query);
+  }
+
+  getRelatedEntities(name) {
+    return this.storage.getRelatedEntities(name);
+  }
+
+  close() {
+    return this.storage.close();
+  }
+}