collective-memory-mcp 0.1.0 → 0.2.0

package/src/storage.js

@@ -0,0 +1,354 @@
+/**
+ * Storage layer for the Collective Memory System using SQLite.
+ */
+
+import Database from "better-sqlite3";
+import { promises as fs } 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");
+
+/**
+ * SQLite-based storage for the knowledge graph
+ */
+export class Storage {
+  constructor(dbPath = DB_PATH) {
+    this.dbPath = dbPath;
+    this.db = null;
+    this.init();
+  }
+
+  /**
+   * Initialize database and create schema
+   */
+  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);
+    `);
+  }
+
+  /**
+   * Prepare statement helper
+   */
+  prepare(sql) {
+    return this.db.prepare(sql);
+  }
+
+  // ========== Entity Operations ==========
+
+  /**
+   * 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;
+    }
+  }
+
+  /**
+   * 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),
+      });
+    }
+    return null;
+  }
+
+  /**
+   * 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),
+    }));
+  }
+
+  /**
+   * Check if an entity exists
+   */
+  entityExists(name) {
+    const stmt = this.prepare("SELECT 1 FROM entities WHERE name = ?");
+    return stmt.get(name) !== undefined;
+  }
+
+  /**
+   * Update entity observations
+   */
+  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;
+  }
+
+  /**
+   * 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);
+
+    const deleteEntity = this.prepare("DELETE FROM entities WHERE name = ?");
+    return deleteEntity.run(name).changes > 0;
+  }
+
+  /**
+   * Delete multiple entities
+   */
+  deleteEntities(names) {
+    let count = 0;
+    for (const name of names) {
+      if (this.deleteEntity(name)) count++;
+    }
+    return count;
+  }
+
+  // ========== Relation Operations ==========
+
+  /**
+   * 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;
+    }
+  }
+
+  /**
+   * Get relations with optional filters
+   */
+  getRelations({ fromEntity, toEntity, relationType } = {}) {
+    let sql = "SELECT * FROM relations WHERE 1=1";
+    const params = [];
+
+    if (fromEntity) {
+      sql += " AND from_entity = ?";
+      params.push(fromEntity);
+    }
+    if (toEntity) {
+      sql += " AND to_entity = ?";
+      params.push(toEntity);
+    }
+    if (relationType) {
+      sql += " AND relation_type = ?";
+      params.push(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),
+    }));
+  }
+
+  /**
+   * Get all relations
+   */
+  getAllRelations() {
+    return this.getRelations();
+  }
+
+  /**
+   * 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 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;
+  }
+
+  /**
+   * Delete multiple relations
+   */
+  deleteRelations(relations) {
+    let count = 0;
+    for (const [fromEntity, toEntity, relationType] of relations) {
+      if (this.deleteRelation(fromEntity, toEntity, relationType)) count++;
+    }
+    return count;
+  }
+
+  // ========== Search ==========
+
+  /**
+   * 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),
+    }));
+  }
+
+  /**
+   * Get entities related to a given entity
+   */
+  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)
+    ]);
+
+    for (const name of connectedNames) {
+      const entity = this.getEntity(name);
+      if (entity) result.connected.push(entity);
+    }
+
+    return result;
+  }
+
+  /**
+   * Close database connection
+   */
+  close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+}
+
+// Export singleton instance
+let storageInstance = null;
+
+export function getStorage(dbPath) {
+  if (!storageInstance) {
+    storageInstance = new Storage(dbPath);
+  }
+  return storageInstance;
+}

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();