collective-memory-mcp 0.3.0 → 0.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "collective-memory-mcp",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "A persistent, graph-based memory system for AI agents (MCP Server)",
   "type": "module",
   "main": "src/server.js",

package/src/server.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 /**
  * Collective Memory MCP Server
  * A persistent, graph-based memory system for AI agents.

package/src/storage.js

@@ -4,120 +4,81 @@
  */
 
 import { promises as fs } from "fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } 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.json");
 
 /**
- * Lock file to prevent concurrent writes
- */
-const LOCK_FILE = path.join(DB_DIR, "memory.lock");
-
-/**
- * Simple file-based storage with locking
+ * Simple file-based storage
  */
 export class Storage {
   constructor(dbPath = DB_PATH) {
     this.dbPath = dbPath;
-    this.lockPath = LOCK_FILE;
     this.data = null;
-    this.lockRetries = 10;
-    this.lockDelay = 50;
+    // Initialize synchronously
     this.init();
   }
 
   /**
-   * Initialize storage
-   */
-  async init() {
-    await this.ensureDir();
-    await this.load();
-  }
-
-  /**
-   * Ensure data directory exists
+   * Initialize storage (synchronous)
    */
-  async ensureDir() {
+  init() {
     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
+      // 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",
       };
-      await this.save();
     }
   }
 
   /**
-   * Save data to file
-   */
-  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);
-  }
-
-  /**
-   * Acquire lock
+   * Save data synchronously
    */
-  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));
-      }
+  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);
     }
-    // If we can't get lock, just proceed (it's a simple file lock)
   }
 
   /**
-   * Release lock
+   * Save data asynchronously
    */
-  async releaseLock() {
+  async save() {
+    const dir = path.dirname(this.dbPath);
     try {
-      await fs.unlink(this.lockPath);
+      await fs.mkdir(dir, { recursive: true });
     } catch {
       // Ignore
     }
-  }
-
-  /**
-   * Execute operation with lock
-   */
-  async withLock(fn) {
-    await this.acquireLock();
-    try {
-      return await fn();
-    } finally {
-      await this.releaseLock();
-    }
+    await fs.writeFile(this.dbPath, JSON.stringify(this.data, null, 2), "utf-8");
   }
 
   // ========== Entity Operations ==========
@@ -126,14 +87,12 @@ export class Storage {
    * Create a new entity. Returns true if created, false if duplicate.
    */
   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;
-    });
+    if (this.data.entities[entity.name]) {
+      return false;
+    }
+    this.data.entities[entity.name] = entity.toJSON();
+    await this.save();
+    return true;
   }
 
   /**
@@ -165,41 +124,37 @@ export class Storage {
    * Update entity
    */
   async updateEntity(name, { observations, metadata } = {}) {
-    return this.withLock(async () => {
-      const entity = this.data.entities[name];
-      if (!entity) return false;
+    const entity = this.data.entities[name];
+    if (!entity) return false;
 
-      if (observations !== undefined) {
-        entity.observations = observations;
-      }
-      if (metadata !== undefined) {
-        entity.metadata = metadata;
-      }
+    if (observations !== undefined) {
+      entity.observations = observations;
+    }
+    if (metadata !== undefined) {
+      entity.metadata = metadata;
+    }
 
-      await this.save();
-      return true;
-    });
+    await this.save();
+    return true;
   }
 
   /**
    * Delete an entity and its relations
    */
   async deleteEntity(name) {
-    return this.withLock(async () => {
-      if (!this.data.entities[name]) {
-        return false;
-      }
+    if (!this.data.entities[name]) {
+      return false;
+    }
 
-      delete this.data.entities[name];
+    delete this.data.entities[name];
 
-      // Remove relations involving this entity
-      this.data.relations = this.data.relations.filter(
-        r => r.from !== name && r.to !== name
-      );
+    // Remove relations involving this entity
+    this.data.relations = this.data.relations.filter(
+      r => r.from !== name && r.to !== name
+    );
 
-      await this.save();
-      return true;
-    });
+    await this.save();
+    return true;
   }
 
   /**
@@ -219,16 +174,14 @@ export class Storage {
    * Create a new relation. Returns true if created, false if duplicate.
    */
   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;
-      }
+    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;
-    });
+    this.data.relations.push(relation.toJSON());
+    await this.save();
+    return true;
   }
 
   /**
@@ -277,18 +230,16 @@ export class Storage {
    * Delete a specific relation
    */
   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;
-    });
+    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;
   }
 
   /**
@@ -354,89 +305,12 @@ export class Storage {
   }
 }
 
-// Sync wrapper for async operations
+// Singleton instance
 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();
-  }
-}