npm - @vheins/local-memory-mcp - Versions diffs - 0.18.13 → 0.19.0 - Mend

@vheins/local-memory-mcp 0.18.13 → 0.19.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (23) hide show

package/README.id.md +9 -1
package/README.md +32 -17
package/dist/{chunk-BK2QIQXS.js → chunk-AKFMCVQ4.js} +857 -680
package/dist/dashboard/public/assets/{index-wAYh22Zy.css → index-CtKekPIh.css} +1 -1
package/dist/dashboard/public/assets/index-DsmurBbn.js +150 -0
package/dist/dashboard/public/index.html +2 -2
package/dist/dashboard/server.js +227 -171
package/dist/mcp/server.js +1919 -727
package/dist/prompts/create-task.md +10 -2
package/dist/prompts/documentation-sync.md +1 -1
package/dist/prompts/learning-retrospective.md +1 -1
package/dist/prompts/memory-agent-core.md +8 -2
package/dist/prompts/project-briefing.md +2 -2
package/dist/prompts/review-and-audit.md +2 -2
package/dist/prompts/review-and-post-issue.md +3 -3
package/dist/prompts/scrum-master.md +1 -1
package/dist/prompts/sentinel-issue-resolver.md +1 -1
package/dist/prompts/server/instructions.md +10 -2
package/dist/prompts/session-planner.md +1 -1
package/dist/prompts/task-memory-executor.md +2 -2
package/dist/prompts/tool-usage-guidelines.md +9 -2
package/package.json +5 -1
package/dist/dashboard/public/assets/index-DWRMdSsg.js +0 -150

package/dist/dashboard/public/index.html CHANGED Viewed

@@ -8,8 +8,8 @@
   <link rel="preconnect" href="https://fonts.googleapis.com">
   <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
   <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet">
-  <script type="module" crossorigin src="/assets/index-DWRMdSsg.js"></script>
-  <link rel="stylesheet" crossorigin href="/assets/index-wAYh22Zy.css">
+  <script type="module" crossorigin src="/assets/index-DsmurBbn.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-CtKekPIh.css">
 </head>
 <body>
   <div id="app"></div>

package/dist/dashboard/server.js CHANGED Viewed

@@ -1,6 +1,5 @@
 #!/usr/bin/env node
 import {
-  MCP_PROTOCOL_VERSION,
   PROMPTS,
   RealVectorStore,
   SQLiteStore,
@@ -16,7 +15,7 @@ import {
   handleTaskClaim,
   listResources,
   logger
-} from "../chunk-BK2QIQXS.js";
+} from "../chunk-AKFMCVQ4.js";
 // src/dashboard/server.ts
 import express from "express";
@@ -25,191 +24,60 @@ import fs3 from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
 // src/mcp/client.ts
-import { spawn } from "child_process";
-import { createInterface } from "readline";
 import path from "path";
 import fs from "fs";
 import { fileURLToPath } from "url";
+import { Client } from "@modelcontextprotocol/client";
+import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
 var __dirname = path.dirname(fileURLToPath(import.meta.url));
-var RETRY_DELAYS = [1e3, 2e3, 4e3];
-var MAX_RETRIES = 3;
-var MAX_RESTARTS = 3;
-var REQUEST_TIMEOUT_MS = 1e4;
 var MCPClient = class {
-  process = null;
-  starting = null;
-  requestId = 0;
-  pendingRequests = /* @__PURE__ */ new Map();
-  isInitialized = false;
+  client;
+  transport = null;
+  _connected = false;
   serverPathOverride;
-  restartCount = 0;
   constructor(serverPath) {
     this.serverPathOverride = serverPath;
+    this.client = new Client(
+      { name: "mcp-client", version: "1.0.0" },
+      {
+        enforceStrictCapabilities: false
+      }
+    );
   }
   async start() {
-    if (this.isInitialized && this.process) return;
-    if (this.starting) return this.starting;
-    this.starting = this.startInternal();
-    try {
-      await this.starting;
-    } finally {
-      this.starting = null;
-    }
-  }
-  async startInternal() {
-    if (this.process) return;
+    if (this._connected) return;
     const serverPath = this.serverPathOverride || (fs.existsSync(path.join(__dirname, "../mcp/server.js")) ? path.join(__dirname, "../mcp/server.js") : path.join(__dirname, "./server.js"));
-    this.process = spawn("node", [serverPath], {
-      stdio: ["pipe", "pipe", "inherit"]
-    });
-    if (!this.process.stdout || !this.process.stdin) {
-      throw new Error("Failed to spawn MCP server");
-    }
-    this.process.on("close", (code) => {
-      if (this.process === null) {
-        return;
-      }
-      logger.error("MCP server process closed unexpectedly", { code, restartCount: this.restartCount });
-      this.process = null;
-      this.isInitialized = false;
-      this.starting = null;
-      if (this.restartCount < MAX_RESTARTS) {
-        this.restartCount++;
-        logger.info("Attempting to restart MCP server", { attempt: this.restartCount });
-        this.start().catch((err) => {
-          logger.error("Failed to restart MCP server", { error: String(err) });
-        });
-      } else {
-        logger.error("Max restart attempts reached, giving up", { maxRestarts: MAX_RESTARTS });
-      }
-    });
-    const rl = createInterface({
-      input: this.process.stdout,
-      crlfDelay: Infinity
-    });
-    rl.on("line", (line) => {
-      try {
-        const response = JSON.parse(line);
-        if (!response.id) return;
-        const pending = this.pendingRequests.get(response.id);
-        if (pending) {
-          this.pendingRequests.delete(response.id);
-          if (response.error) {
-            pending.reject(new Error(response.error.message));
-          } else {
-            pending.resolve(response.result);
-          }
-        }
-      } catch (err) {
-        logger.error("Failed to parse MCP response", { error: String(err), rawLine: line });
-      }
-    });
-    await this.callWithRetry("initialize", {
-      protocolVersion: MCP_PROTOCOL_VERSION,
-      capabilities: {},
-      clientInfo: { name: "mcp-client", version: "1.0.0" }
-    });
-    if (this.process?.stdin) {
-      this.process.stdin.write(
-        JSON.stringify({
-          jsonrpc: "2.0",
-          method: "notifications/initialized"
-        }) + "\n"
-      );
-    }
-    this.isInitialized = true;
-  }
-  /**
-   * Send a single request without retry. Returns a Promise that rejects on timeout.
-   */
-  callOnce(method, params = {}) {
-    if (!this.process || !this.process.stdin) {
-      return Promise.reject(new Error("MCP server not started"));
-    }
-    const id = ++this.requestId;
-    const request = { jsonrpc: "2.0", id, method, params };
-    return new Promise((resolve, reject) => {
-      this.pendingRequests.set(id, { resolve, reject });
-      const timer = setTimeout(() => {
-        if (this.pendingRequests.has(id)) {
-          this.pendingRequests.delete(id);
-          reject(new Error("Request timeout"));
-        }
-      }, REQUEST_TIMEOUT_MS);
-      if (timer.unref) timer.unref();
-      this.process.stdin.write(JSON.stringify(request) + "\n");
+    this.transport = new StdioClientTransport({
+      command: "node",
+      args: [serverPath]
     });
-  }
-  /**
-   * Call with retry on timeout — up to MAX_RETRIES retries with exponential backoff.
-   * Req 18.1: retry up to 3x with delays 1s, 2s, 4s.
-   */
-  async callWithRetry(method, params = {}) {
-    let lastError;
-    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-      try {
-        return await this.callOnce(method, params);
-      } catch (err) {
-        lastError = err;
-        const isTimeout = err instanceof Error && err.message === "Request timeout";
-        if (!isTimeout || attempt === MAX_RETRIES) {
-          logger.error("MCP request failed", {
-            method,
-            attempt,
-            error: String(err)
-          });
-          throw err;
-        }
-        const delay = RETRY_DELAYS[attempt];
-        logger.warn("MCP request timed out, retrying", {
-          method,
-          attempt: attempt + 1,
-          delayMs: delay
-        });
-        await sleep(delay);
-      }
-    }
-    throw lastError;
+    await this.client.connect(this.transport);
+    this._connected = true;
   }
   async call(method, params = {}) {
-    return this.callWithRetry(method, params);
+    return this.client.request({ method, params });
   }
   async callTool(toolName, args) {
-    return this.call("tools/call", { name: toolName, arguments: args });
+    return this.client.callTool({
+      name: toolName,
+      arguments: args
+    });
   }
   async readResource(uri) {
-    return this.call("resources/read", { uri });
+    return this.client.readResource({ uri });
   }
-  /**
-   * Stop the client: reject all pending requests, then kill the process.
-   * Req 18.3: reject all pending requests with "Client stopped".
-   */
-  stop() {
-    for (const [id, pending] of this.pendingRequests) {
-      pending.reject(new Error("Client stopped"));
-      this.pendingRequests.delete(id);
-    }
-    if (this.process) {
-      const proc = this.process;
-      this.process = null;
-      this.isInitialized = false;
-      proc.kill();
-    }
+  async stop() {
+    this._connected = false;
+    await this.client.close();
+    this.transport = null;
   }
   isConnected() {
-    return this.isInitialized && this.process !== null;
+    return this._connected;
   }
-  /**
-   * Returns the number of requests currently awaiting a response.
-   * Req 18.5
-   */
   getPendingCount() {
-    return this.pendingRequests.size;
+    return 0;
   }
 };
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
 // src/dashboard/lib/context.ts
 var db = await SQLiteStore.create();
@@ -221,7 +89,7 @@ vectors.initialize().catch((err) => {
 });
 // src/dashboard/routes/index.ts
-import { Router as Router6 } from "express";
+import { Router as Router7 } from "express";
 // src/dashboard/routes/system.routes.ts
 import { Router } from "express";
@@ -1298,14 +1166,202 @@ router5.get("/claims", CoordinationController.listClaims);
 router5.post("/claims/release", CoordinationController.releaseClaim);
 var coordination_routes_default = router5;
-// src/dashboard/routes/index.ts
+// src/dashboard/routes/kg.routes.ts
+import { Router as Router6 } from "express";
+// src/dashboard/controllers/KGController.ts
+var KGController = class {
+  static async listEntities(req, res) {
+    try {
+      await db.refresh();
+      const repo = req.query.repo;
+      if (!repo) return res.status(400).json(jsonApiError("repo is required", 400));
+      const type = req.query.type;
+      const search = req.query.search;
+      let sql = "SELECT * FROM entities WHERE repo = ?";
+      const params = [repo];
+      if (type) {
+        sql += " AND type = ?";
+        params.push(type);
+      }
+      if (search) {
+        sql += " AND name LIKE ?";
+        params.push(`%${search}%`);
+      }
+      sql += " ORDER BY name";
+      const items = db.db.prepare(sql).all(...params);
+      res.json(jsonApiRes(items, "entity"));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      res.status(500).json(jsonApiError(message));
+    }
+  }
+  static async getEntity(req, res) {
+    try {
+      await db.refresh();
+      const name = req.params.name;
+      const entity = db.db.prepare("SELECT * FROM entities WHERE name = ?").get(name);
+      if (!entity) return res.status(404).json(jsonApiError("Entity not found", 404));
+      const relations = db.db.prepare("SELECT * FROM relations WHERE from_entity = ? OR to_entity = ? ORDER BY relation_type").all(name, name);
+      const observations = db.db.prepare("SELECT * FROM observations WHERE entity_name = ? ORDER BY created_at DESC").all(name);
+      res.json(jsonApiRes({ id: entity.name, entity, relations, observations }, "entity"));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      res.status(500).json(jsonApiError(message));
+    }
+  }
+  static async listRelations(req, res) {
+    try {
+      await db.refresh();
+      const repo = req.query.repo;
+      if (!repo) return res.status(400).json(jsonApiError("repo is required", 400));
+      const items = db.db.prepare("SELECT * FROM relations WHERE repo = ? ORDER BY from_entity, to_entity").all(repo);
+      res.json(jsonApiRes(items, "relation"));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      res.status(500).json(jsonApiError(message));
+    }
+  }
+  static async listGraph(req, res) {
+    try {
+      await db.refresh();
+      const repo = req.query.repo;
+      if (!repo) return res.status(400).json(jsonApiError("repo is required", 400));
+      const nodes = db.db.prepare(
+        `SELECT e.name, e.type, e.description, COUNT(o.id) as memoryCount
+					 FROM entities e
+					 LEFT JOIN observations o ON o.entity_name = e.name
+					 WHERE e.repo = ?
+					 GROUP BY e.name
+					 ORDER BY e.name`
+      ).all(repo);
+      const edges = db.db.prepare(
+        "SELECT from_entity as source, to_entity as target, relation_type FROM relations WHERE repo = ? ORDER BY from_entity, to_entity"
+      ).all(repo);
+      res.json(jsonApiRes({ id: `graph-${repo}`, nodes, edges }, "graph"));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      res.status(500).json(jsonApiError(message));
+    }
+  }
+  static async createEntity(req, res) {
+    try {
+      await db.refresh();
+      const attributes = getAttributes(req);
+      const { name, type, description, repo, owner } = attributes;
+      if (!name) return res.status(400).json(jsonApiError("name is required", 400));
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      db.db.prepare(
+        `INSERT INTO entities (name, type, description, repo, owner, created_at, updated_at)
+					 VALUES (?, ?, ?, ?, ?, ?, ?)`
+      ).run(name, type || "unknown", description || null, repo || "", owner || "", now, now);
+      const entity = db.db.prepare("SELECT * FROM entities WHERE name = ?").get(name);
+      res.json(jsonApiRes(entity, "entity"));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      res.status(500).json(jsonApiError(message));
+    }
+  }
+  static async deleteEntity(req, res) {
+    try {
+      await db.refresh();
+      const name = req.params.name;
+      const existing = db.db.prepare("SELECT name FROM entities WHERE name = ?").get(name);
+      if (!existing) return res.status(404).json(jsonApiError("Entity not found", 404));
+      db.db.prepare("DELETE FROM entities WHERE name = ?").run(name);
+      res.json(jsonApiRes({ message: "Deleted", name }, "status"));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      res.status(500).json(jsonApiError(message));
+    }
+  }
+  static async createRelation(req, res) {
+    try {
+      await db.refresh();
+      const attributes = getAttributes(req);
+      const { from_entity, to_entity, relation_type, repo, owner } = attributes;
+      if (!from_entity || !to_entity || !relation_type) {
+        return res.status(400).json(jsonApiError("from_entity, to_entity, and relation_type are required", 400));
+      }
+      const fromExists = db.db.prepare("SELECT 1 FROM entities WHERE name = ?").get(from_entity);
+      if (!fromExists) {
+        return res.status(400).json(jsonApiError(`Source entity '${from_entity}' not found`, 400));
+      }
+      const toExists = db.db.prepare("SELECT 1 FROM entities WHERE name = ?").get(to_entity);
+      if (!toExists) {
+        return res.status(400).json(jsonApiError(`Target entity '${to_entity}' not found`, 400));
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      db.db.prepare(
+        `INSERT INTO relations (from_entity, to_entity, relation_type, repo, owner, created_at)
+					 VALUES (?, ?, ?, ?, ?, ?)`
+      ).run(from_entity, to_entity, relation_type, repo || "", owner || "", now);
+      res.json(jsonApiRes({ from_entity, to_entity, relation_type }, "relation"));
+    } catch (err) {
+      const sqlerr = err;
+      if (sqlerr.code === "SQLITE_CONSTRAINT_PRIMARYKEY") {
+        return res.status(409).json(jsonApiError("Relation already exists", 409));
+      }
+      const message = err instanceof Error ? err.message : "Internal server error";
+      res.status(500).json(jsonApiError(message));
+    }
+  }
+  static async deleteRelation(req, res) {
+    try {
+      await db.refresh();
+      const attributes = getAttributes(req);
+      const { from_entity, to_entity, relation_type } = attributes;
+      if (!from_entity || !to_entity || !relation_type) {
+        return res.status(400).json(jsonApiError("from_entity, to_entity, and relation_type are required", 400));
+      }
+      const result = db.db.prepare("DELETE FROM relations WHERE from_entity = ? AND to_entity = ? AND relation_type = ?").run(from_entity, to_entity, relation_type);
+      if (result.changes === 0) {
+        return res.status(404).json(jsonApiError("Relation not found", 404));
+      }
+      res.json(jsonApiRes({ message: "Deleted" }, "status"));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      res.status(500).json(jsonApiError(message));
+    }
+  }
+  static async deleteObservation(req, res) {
+    try {
+      await db.refresh();
+      const id = req.params.id;
+      const result = db.db.prepare("DELETE FROM observations WHERE id = ?").run(id);
+      if (result.changes === 0) {
+        return res.status(404).json(jsonApiError("Observation not found", 404));
+      }
+      res.json(jsonApiRes({ message: "Deleted", id }, "status"));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      res.status(500).json(jsonApiError(message));
+    }
+  }
+};
+// src/dashboard/routes/kg.routes.ts
 var router6 = Router6();
-router6.use("/", system_routes_default);
-router6.use("/memories", memory_routes_default);
-router6.use("/tasks", task_routes_default);
-router6.use("/standards", standard_routes_default);
-router6.use("/coordination", coordination_routes_default);
-var routes_default = router6;
+router6.get("/kg/entities", KGController.listEntities);
+router6.get("/kg/entities/:name", KGController.getEntity);
+router6.post("/kg/entities", KGController.createEntity);
+router6.delete("/kg/entities/:name", KGController.deleteEntity);
+router6.get("/kg/relations", KGController.listRelations);
+router6.post("/kg/relations", KGController.createRelation);
+router6.delete("/kg/relations", KGController.deleteRelation);
+router6.delete("/kg/observations/:id", KGController.deleteObservation);
+router6.get("/kg/graph", KGController.listGraph);
+var kg_routes_default = router6;
+// src/dashboard/routes/index.ts
+var router7 = Router7();
+router7.use("/", system_routes_default);
+router7.use("/memories", memory_routes_default);
+router7.use("/tasks", task_routes_default);
+router7.use("/standards", standard_routes_default);
+router7.use("/coordination", coordination_routes_default);
+router7.use("/", kg_routes_default);
+var routes_default = router7;
 // src/dashboard/server.ts
 var __dirname3 = path3.dirname(fileURLToPath3(import.meta.url));
@@ -1414,7 +1470,7 @@ app.use((req, res, next) => {
     `);
   }
 });
-app.use((err, req, res, next) => {
+app.use((err, req, res, _next) => {
   if (err.status === 404) return res.status(404).end();
   logger.error("Unhandled error", { error: err.message });
   res.status(500).end();