collective-memory-mcp 0.1.0 → 0.3.0

package/src/storage.js

@@ -0,0 +1,442 @@
+/**
+ * Storage layer for the Collective Memory System using JSON file.
+ * Pure JavaScript - no native dependencies required.
+ */
+
+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.json");
+
+/**
+ * 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.lockPath = LOCK_FILE;
+    this.data = null;
+    this.lockRetries = 10;
+    this.lockDelay = 50;
+    this.init();
+  }
+
+  /**
+   * 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
+   */
+  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
+   */
+  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 ==========
+
+  /**
+   * 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;
+    });
+  }
+
+  /**
+   * Get an entity by name
+   */
+  getEntity(name) {
+    const data = this.data.entities[name];
+    if (data) {
+      return new Entity(data);
+    }
+    return null;
+  }
+
+  /**
+   * Get all entities
+   */
+  getAllEntities() {
+    return Object.values(this.data.entities).map(data => new Entity(data));
+  }
+
+  /**
+   * Check if an entity exists
+   */
+  entityExists(name) {
+    return name in this.data.entities;
+  }
+
+  /**
+   * Update entity
+   */
+  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
+   */
+  async deleteEntity(name) {
+    return this.withLock(async () => {
+      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
+      );
+
+      await this.save();
+      return true;
+    });
+  }
+
+  /**
+   * Delete multiple entities
+   */
+  async deleteEntities(names) {
+    let count = 0;
+    for (const name of names) {
+      if (await this.deleteEntity(name)) count++;
+    }
+    return count;
+  }
+
+  // ========== Relation Operations ==========
+
+  /**
+   * 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;
+      }
+
+      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 results = this.data.relations.map(r => new Relation(r));
+
+    if (fromEntity) {
+      results = results.filter(r => r.from === fromEntity);
+    }
+    if (toEntity) {
+      results = results.filter(r => r.to === toEntity);
+    }
+    if (relationType) {
+      results = results.filter(r => r.relationType === relationType);
+    }
+
+    return results;
+  }
+
+  /**
+   * Get all relations
+   */
+  getAllRelations() {
+    return this.data.relations.map(r => new Relation(r));
+  }
+
+  /**
+   * Check if a relation exists
+   */
+  relationExists(fromEntity, toEntity, relationType) {
+    return this.data.relations.some(
+      r => r.from === fromEntity && r.to === toEntity && r.relationType === relationType
+    );
+  }
+
+  /**
+   * 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;
+    });
+  }
+
+  /**
+   * Delete multiple relations
+   */
+  async deleteRelations(relations) {
+    let count = 0;
+    for (const [fromEntity, toEntity, relationType] of relations) {
+      if (await this.deleteRelation(fromEntity, toEntity, relationType)) count++;
+    }
+    return count;
+  }
+
+  // ========== Search ==========
+
+  /**
+   * Search entities by name, type, or observations
+   */
+  searchEntities(query) {
+    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;
+    });
+  }
+
+  /**
+   * Get entities related to a given entity
+   */
+  getRelatedEntities(entityName) {
+    const result = { connected: [], incoming: [], outgoing: [] };
+
+    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);
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Close storage
+   */
+  async close() {
+    await this.save();
+  }
+}
+
+// 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();
+  }
+}

package/index.js

@@ -1,127 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Collective Memory MCP Server - npx Wrapper
- *
- * This wrapper spawns the Python MCP server, making it available via npx:
- *   npx collective-memory-mcp
- *
- * The Python package will be automatically installed on first run.
- */
-
-import { spawn, spawnSync } from 'child_process';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-import { existsSync, readFileSync } from 'fs';
-import { homedir } from 'os';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-// ANSI color codes for better output
-const colors = {
-  reset: '\x1b[0m',
-  red: '\x1b[31m',
-  green: '\x1b[32m',
-  yellow: '\x1b[33m',
-  blue: '\x1b[34m',
-  cyan: '\x1b[36m',
-};
-
-function log(message, color = 'reset') {
-  console.error(`${colors[color]}${message}${colors.reset}`);
-}
-
-function findPython() {
-  // Try different Python commands
-  const pythonCommands = ['python3', 'python', 'python3.12', 'python3.11', 'python3.10'];
-
-  for (const cmd of pythonCommands) {
-    const result = spawnSync(cmd, ['--version'], { stdio: 'pipe' });
-    if (result.status === 0) {
-      return cmd;
-    }
-  }
-
-  return null;
-}
-
-function getDbPath() {
-  // Allow override via environment variable
-  if (process.env.COLLECTIVE_MEMORY_DB_PATH) {
-    return process.env.COLLECTIVE_MEMORY_DB_PATH;
-  }
-
-  // Default to ~/.collective-memory/memory.db
-  return join(homedir(), '.collective-memory', 'memory.db');
-}
-
-async function main() {
-  const pythonCmd = findPython();
-
-  if (!pythonCmd) {
-    log('Error: Python 3.10+ is required but not found.', 'red');
-    log('Please install Python from https://python.org', 'yellow');
-    process.exit(1);
-  }
-
-  // Check if collective_memory module is available
-  const checkModule = spawnSync(pythonCmd, ['-c', 'import collective_memory'], {
-    stdio: 'pipe'
-  });
-
-  if (checkModule.status !== 0) {
-    log('Collective Memory MCP Server not found. Installing...', 'yellow');
-    log('', 'reset');
-
-    const installArgs = ['-m', 'pip', 'install', '-U', 'collective-memory-mcp'];
-    const install = spawn(pythonCmd, installArgs, {
-      stdio: 'inherit'
-    });
-
-    install.on('close', (code) => {
-      if (code !== 0) {
-        log('', 'reset');
-        log('Failed to install collective-memory-mcp Python package.', 'red');
-        log('You can install it manually:', 'yellow');
-        log(`  ${pythonCmd} -m pip install collective-memory-mcp`, 'cyan');
-        process.exit(1);
-      }
-
-      log('', 'reset');
-      log('Installation complete. Starting server...', 'green');
-      startServer(pythonCmd);
-    });
-  } else {
-    startServer(pythonCmd);
-  }
-}
-
-function startServer(pythonCmd) {
-  const dbPath = getDbPath();
-
-  // Spawn the Python MCP server
-  const server = spawn(pythonCmd, ['-m', 'collective_memory'], {
-    stdio: 'inherit',
-    env: {
-      ...process.env,
-      COLLECTIVE_MEMORY_DB_PATH: dbPath,
-      PYTHONUNBUFFERED: '1',
-    }
-  });
-
-  server.on('error', (err) => {
-    log(`Error starting server: ${err.message}`, 'red');
-    process.exit(1);
-  });
-
-  server.on('exit', (code) => {
-    process.exit(code ?? 0);
-  });
-}
-
-// Handle signals
-process.on('SIGINT', () => process.exit(0));
-process.on('SIGTERM', () => process.exit(0));
-
-main();