devsh-memory-mcp 0.1.0 → 0.2.0

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   runServer
-} from "./chunk-PI6DAQTW.js";
+} from "./chunk-YTXBZTQ2.js";
 
 // src/cli.ts
 function parseArgs() {

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   createMemoryMcpServer,
   runServer
-} from "./chunk-PI6DAQTW.js";
+} from "./chunk-YTXBZTQ2.js";
 export {
   createMemoryMcpServer,
   runServer

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "devsh-memory-mcp",
-  "version": "0.1.0",
-  "description": "MCP server for devsh/cmux agent memory - enables Claude Desktop and external clients to access sandbox memory",
+  "version": "0.2.0",
+  "description": "MCP server for devsh/cmux agent memory - enables Claude Desktop and external clients to access sandbox memory and orchestrate multi-agent workflows",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -33,15 +33,17 @@
     "claude",
     "memory",
     "agent",
+    "orchestration",
+    "multi-agent",
     "model-context-protocol",
     "claude-desktop"
   ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/karlorz/cmux.git",
-    "directory": "packages/cmux-memory-mcp"
+    "directory": "packages/devsh-memory-mcp"
   },
-  "homepage": "https://github.com/karlorz/cmux/tree/main/packages/cmux-memory-mcp#readme",
+  "homepage": "https://github.com/karlorz/cmux/tree/main/packages/devsh-memory-mcp#readme",
   "bugs": {
     "url": "https://github.com/karlorz/cmux/issues"
   },

package/dist/chunk-PI6DAQTW.js

@@ -1,655 +0,0 @@
-// src/index.ts
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema
-} from "@modelcontextprotocol/sdk/types.js";
-import * as fs from "fs";
-import * as path from "path";
-import * as crypto from "crypto";
-var DEFAULT_MEMORY_DIR = "/root/lifecycle/memory";
-function createMemoryMcpServer(config) {
-  const memoryDir = config?.memoryDir ?? DEFAULT_MEMORY_DIR;
-  const agentName = config?.agentName ?? process.env.CMUX_AGENT_NAME ?? "external-client";
-  const knowledgeDir = path.join(memoryDir, "knowledge");
-  const dailyDir = path.join(memoryDir, "daily");
-  const orchestrationDir = path.join(memoryDir, "orchestration");
-  const mailboxPath = path.join(memoryDir, "MAILBOX.json");
-  const tasksPath = path.join(memoryDir, "TASKS.json");
-  const planPath = path.join(orchestrationDir, "PLAN.json");
-  const agentsPath = path.join(orchestrationDir, "AGENTS.json");
-  const eventsPath = path.join(orchestrationDir, "EVENTS.jsonl");
-  function readFile(filePath) {
-    try {
-      if (!fs.existsSync(filePath)) return null;
-      return fs.readFileSync(filePath, "utf-8");
-    } catch {
-      return null;
-    }
-  }
-  function writeFile(filePath, content) {
-    try {
-      fs.writeFileSync(filePath, content, "utf-8");
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  function readTasks() {
-    const content = readFile(tasksPath);
-    if (!content) return { version: 1, tasks: [] };
-    try {
-      return JSON.parse(content);
-    } catch {
-      return { version: 1, tasks: [] };
-    }
-  }
-  function writeTasks(tasks) {
-    return writeFile(tasksPath, JSON.stringify(tasks, null, 2));
-  }
-  function generateTaskId() {
-    return "task_" + crypto.randomUUID().replace(/-/g, "").slice(0, 12);
-  }
-  function getTodayDateString() {
-    const iso = (/* @__PURE__ */ new Date()).toISOString();
-    return iso.slice(0, iso.indexOf("T"));
-  }
-  function ensureDir(dirPath) {
-    if (!fs.existsSync(dirPath)) {
-      fs.mkdirSync(dirPath, { recursive: true });
-    }
-  }
-  function readPlan() {
-    const content = readFile(planPath);
-    if (!content) return null;
-    try {
-      return JSON.parse(content);
-    } catch {
-      return null;
-    }
-  }
-  function writePlan(plan) {
-    ensureDir(orchestrationDir);
-    plan.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    return writeFile(planPath, JSON.stringify(plan, null, 2));
-  }
-  function appendEvent(event) {
-    ensureDir(orchestrationDir);
-    const line = JSON.stringify(event) + "\n";
-    try {
-      fs.appendFileSync(eventsPath, line, "utf-8");
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  function readMailbox() {
-    const content = readFile(mailboxPath);
-    if (!content) return { version: 1, messages: [] };
-    try {
-      return JSON.parse(content);
-    } catch {
-      return { version: 1, messages: [] };
-    }
-  }
-  function writeMailbox(mailbox) {
-    return writeFile(mailboxPath, JSON.stringify(mailbox, null, 2));
-  }
-  function generateMessageId() {
-    return "msg_" + crypto.randomUUID().replace(/-/g, "").slice(0, 12);
-  }
-  function listDailyLogs() {
-    try {
-      if (!fs.existsSync(dailyDir)) return [];
-      const files = fs.readdirSync(dailyDir);
-      return files.filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", "")).sort().reverse();
-    } catch {
-      return [];
-    }
-  }
-  function searchMemory(query) {
-    const results = [];
-    const lowerQuery = query.toLowerCase();
-    const knowledge = readFile(path.join(knowledgeDir, "MEMORY.md"));
-    if (knowledge?.toLowerCase().includes(lowerQuery)) {
-      const lines = knowledge.split("\n");
-      for (let i = 0; i < lines.length; i++) {
-        if (lines[i].toLowerCase().includes(lowerQuery)) {
-          results.push({
-            source: "knowledge/MEMORY.md",
-            line: i + 1,
-            content: lines[i].trim()
-          });
-        }
-      }
-    }
-    const tasks = readFile(tasksPath);
-    if (tasks?.toLowerCase().includes(lowerQuery)) {
-      results.push({ source: "TASKS.json", content: "Match found in tasks file" });
-    }
-    const mailbox = readFile(mailboxPath);
-    if (mailbox?.toLowerCase().includes(lowerQuery)) {
-      results.push({ source: "MAILBOX.json", content: "Match found in mailbox file" });
-    }
-    const dailyLogs = listDailyLogs();
-    for (const date of dailyLogs.slice(0, 7)) {
-      const logContent = readFile(path.join(dailyDir, `${date}.md`));
-      if (logContent?.toLowerCase().includes(lowerQuery)) {
-        const lines = logContent.split("\n");
-        for (let i = 0; i < lines.length; i++) {
-          if (lines[i].toLowerCase().includes(lowerQuery)) {
-            results.push({
-              source: `daily/${date}.md`,
-              line: i + 1,
-              content: lines[i].trim()
-            });
-          }
-        }
-      }
-    }
-    return results;
-  }
-  const server = new Server(
-    {
-      name: "devsh-memory",
-      version: "0.1.0"
-    },
-    {
-      capabilities: {
-        tools: {}
-      }
-    }
-  );
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: [
-      {
-        name: "read_memory",
-        description: 'Read a memory file. Type can be "knowledge", "tasks", or "mailbox".',
-        inputSchema: {
-          type: "object",
-          properties: {
-            type: {
-              type: "string",
-              enum: ["knowledge", "tasks", "mailbox"],
-              description: "The type of memory to read"
-            }
-          },
-          required: ["type"]
-        }
-      },
-      {
-        name: "list_daily_logs",
-        description: "List available daily log dates (newest first).",
-        inputSchema: {
-          type: "object",
-          properties: {}
-        }
-      },
-      {
-        name: "read_daily_log",
-        description: "Read a specific daily log by date (YYYY-MM-DD format).",
-        inputSchema: {
-          type: "object",
-          properties: {
-            date: {
-              type: "string",
-              description: "The date in YYYY-MM-DD format"
-            }
-          },
-          required: ["date"]
-        }
-      },
-      {
-        name: "search_memory",
-        description: "Search across all memory files for a query string.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            query: {
-              type: "string",
-              description: "The search query"
-            }
-          },
-          required: ["query"]
-        }
-      },
-      {
-        name: "send_message",
-        description: 'Send a message to another agent on the same task. Use "*" to broadcast to all agents.',
-        inputSchema: {
-          type: "object",
-          properties: {
-            to: {
-              type: "string",
-              description: 'Recipient agent name (e.g., "claude/opus-4.5") or "*" for broadcast'
-            },
-            message: {
-              type: "string",
-              description: "The message content"
-            },
-            type: {
-              type: "string",
-              enum: ["handoff", "request", "status"],
-              description: "Message type: handoff (work transfer), request (ask to do something), status (progress update)"
-            }
-          },
-          required: ["to", "message"]
-        }
-      },
-      {
-        name: "get_my_messages",
-        description: "Get all messages addressed to this agent (including broadcasts). Returns unread messages first.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            includeRead: {
-              type: "boolean",
-              description: "Include messages already marked as read (default: false)"
-            }
-          }
-        }
-      },
-      {
-        name: "mark_read",
-        description: "Mark a message as read by its ID.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            messageId: {
-              type: "string",
-              description: "The message ID to mark as read"
-            }
-          },
-          required: ["messageId"]
-        }
-      },
-      // Write tools
-      {
-        name: "append_daily_log",
-        description: "Append content to today's daily log. Creates the file if it doesn't exist.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            content: {
-              type: "string",
-              description: "Content to append to the daily log"
-            }
-          },
-          required: ["content"]
-        }
-      },
-      {
-        name: "update_knowledge",
-        description: "Update a specific priority section in the knowledge file (MEMORY.md). Appends a new entry with today's date.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            section: {
-              type: "string",
-              enum: ["P0", "P1", "P2"],
-              description: "Priority section to update (P0=Core, P1=Active, P2=Reference)"
-            },
-            content: {
-              type: "string",
-              description: "Content to add to the section (will be prefixed with today's date)"
-            }
-          },
-          required: ["section", "content"]
-        }
-      },
-      {
-        name: "add_task",
-        description: "Add a new task to the TASKS.json file.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            subject: {
-              type: "string",
-              description: "Brief title for the task"
-            },
-            description: {
-              type: "string",
-              description: "Detailed description of what needs to be done"
-            }
-          },
-          required: ["subject", "description"]
-        }
-      },
-      {
-        name: "update_task",
-        description: "Update the status of an existing task in TASKS.json.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            taskId: {
-              type: "string",
-              description: "The ID of the task to update"
-            },
-            status: {
-              type: "string",
-              enum: ["pending", "in_progress", "completed"],
-              description: "New status for the task"
-            }
-          },
-          required: ["taskId", "status"]
-        }
-      },
-      // Orchestration tools
-      {
-        name: "read_orchestration",
-        description: "Read an orchestration file (PLAN.json, AGENTS.json, or EVENTS.jsonl).",
-        inputSchema: {
-          type: "object",
-          properties: {
-            type: {
-              type: "string",
-              enum: ["plan", "agents", "events"],
-              description: "Type of orchestration file to read"
-            }
-          },
-          required: ["type"]
-        }
-      },
-      {
-        name: "append_event",
-        description: "Append an orchestration event to EVENTS.jsonl.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            event: {
-              type: "string",
-              description: "Event type (e.g., agent_spawned, agent_completed, message_sent)"
-            },
-            message: {
-              type: "string",
-              description: "Human-readable message describing the event"
-            },
-            agentName: {
-              type: "string",
-              description: "Agent name associated with the event (optional)"
-            },
-            taskRunId: {
-              type: "string",
-              description: "Task run ID associated with the event (optional)"
-            }
-          },
-          required: ["event", "message"]
-        }
-      },
-      {
-        name: "update_plan_task",
-        description: "Update the status of a task in the orchestration PLAN.json.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            taskId: {
-              type: "string",
-              description: "The ID of the orchestration task to update"
-            },
-            status: {
-              type: "string",
-              description: "New status (pending, assigned, running, completed, failed, cancelled)"
-            },
-            result: {
-              type: "string",
-              description: "Result message (for completed tasks)"
-            },
-            errorMessage: {
-              type: "string",
-              description: "Error message (for failed tasks)"
-            }
-          },
-          required: ["taskId", "status"]
-        }
-      }
-    ]
-  }));
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    switch (name) {
-      case "read_memory": {
-        const type = args.type;
-        let content = null;
-        if (type === "knowledge") {
-          content = readFile(path.join(knowledgeDir, "MEMORY.md"));
-        } else if (type === "tasks") {
-          content = readFile(tasksPath);
-        } else if (type === "mailbox") {
-          content = readFile(mailboxPath);
-        }
-        return {
-          content: [{ type: "text", text: content ?? `No ${type} content found.` }]
-        };
-      }
-      case "list_daily_logs": {
-        const dates = listDailyLogs();
-        return {
-          content: [{ type: "text", text: dates.length > 0 ? dates.join("\n") : "No daily logs found." }]
-        };
-      }
-      case "read_daily_log": {
-        const date = args.date;
-        const content = readFile(path.join(dailyDir, `${date}.md`));
-        return {
-          content: [{ type: "text", text: content ?? `No log found for ${date}.` }]
-        };
-      }
-      case "search_memory": {
-        const query = args.query;
-        const results = searchMemory(query);
-        if (results.length === 0) {
-          return { content: [{ type: "text", text: `No results found for "${query}".` }] };
-        }
-        const formatted = results.map((r) => `[${r.source}${r.line ? `:${r.line}` : ""}] ${r.content}`).join("\n");
-        return { content: [{ type: "text", text: formatted }] };
-      }
-      case "send_message": {
-        const { to, message, type } = args;
-        const mailbox = readMailbox();
-        const newMessage = {
-          id: generateMessageId(),
-          from: agentName,
-          to,
-          type: type ?? "request",
-          message,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          read: false
-        };
-        mailbox.messages.push(newMessage);
-        writeMailbox(mailbox);
-        return { content: [{ type: "text", text: `Message sent successfully. ID: ${newMessage.id}` }] };
-      }
-      case "get_my_messages": {
-        const includeRead = args.includeRead ?? false;
-        const mailbox = readMailbox();
-        const myMessages = mailbox.messages.filter(
-          (m) => m.to === agentName || m.to === "*"
-        );
-        const filtered = includeRead ? myMessages : myMessages.filter((m) => !m.read);
-        if (filtered.length === 0) {
-          return { content: [{ type: "text", text: "No messages for you." }] };
-        }
-        const formatted = filtered.map((m) => `[${m.id}] ${m.type ?? "message"} from ${m.from}: ${m.message}`).join("\n\n");
-        return { content: [{ type: "text", text: formatted }] };
-      }
-      case "mark_read": {
-        const messageId = args.messageId;
-        const mailbox = readMailbox();
-        const message = mailbox.messages.find((m) => m.id === messageId);
-        if (!message) {
-          return { content: [{ type: "text", text: `Message ${messageId} not found.` }] };
-        }
-        message.read = true;
-        writeMailbox(mailbox);
-        return { content: [{ type: "text", text: `Message ${messageId} marked as read.` }] };
-      }
-      // Write tool handlers
-      case "append_daily_log": {
-        const { content } = args;
-        const today = getTodayDateString();
-        ensureDir(dailyDir);
-        const logPath = path.join(dailyDir, `${today}.md`);
-        const existing = readFile(logPath) ?? `# Daily Log: ${today}
-
-> Session-specific observations. Temporary notes go here.
-
----
-`;
-        const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[1].split(".")[0];
-        const newContent = existing + `
-- [${timestamp}] ${content}`;
-        if (writeFile(logPath, newContent)) {
-          return { content: [{ type: "text", text: `Appended to daily/${today}.md` }] };
-        }
-        return { content: [{ type: "text", text: `Failed to append to daily log` }] };
-      }
-      case "update_knowledge": {
-        const { section, content } = args;
-        ensureDir(knowledgeDir);
-        const knowledgePath = path.join(knowledgeDir, "MEMORY.md");
-        let existing = readFile(knowledgePath);
-        if (!existing) {
-          existing = `# Project Knowledge
-
-> Curated insights organized by priority. Add date tags for TTL tracking.
-
-## P0 - Core (Never Expires)
-<!-- Fundamental project facts, configuration, invariants -->
-
-## P1 - Active (90-day TTL)
-<!-- Ongoing work context, current strategies, recent decisions -->
-
-## P2 - Reference (30-day TTL)
-<!-- Temporary findings, debug notes, one-off context -->
-
----
-*Priority guide: P0 = permanent truth, P1 = active context, P2 = temporary reference*
-*Format: - [YYYY-MM-DD] Your insight here*
-`;
-        }
-        const today = getTodayDateString();
-        const newEntry = `- [${today}] ${content}`;
-        const sectionHeaders = {
-          P0: "## P0 - Core (Never Expires)",
-          P1: "## P1 - Active (90-day TTL)",
-          P2: "## P2 - Reference (30-day TTL)"
-        };
-        const header = sectionHeaders[section];
-        const headerIndex = existing.indexOf(header);
-        if (headerIndex === -1) {
-          return { content: [{ type: "text", text: `Section ${section} not found in MEMORY.md` }] };
-        }
-        const afterHeader = existing.slice(headerIndex + header.length);
-        const nextSectionMatch = afterHeader.match(/\n## /);
-        const insertPoint = nextSectionMatch ? headerIndex + header.length + (nextSectionMatch.index ?? afterHeader.length) : existing.length;
-        const commentEndMatch = afterHeader.match(/<!--[^>]*-->\n/);
-        const commentEnd = commentEndMatch ? headerIndex + header.length + (commentEndMatch.index ?? 0) + commentEndMatch[0].length : headerIndex + header.length + 1;
-        const actualInsertPoint = Math.min(commentEnd, insertPoint);
-        const updated = existing.slice(0, actualInsertPoint) + newEntry + "\n" + existing.slice(actualInsertPoint);
-        if (writeFile(knowledgePath, updated)) {
-          return { content: [{ type: "text", text: `Added entry to ${section} section in MEMORY.md` }] };
-        }
-        return { content: [{ type: "text", text: `Failed to update MEMORY.md` }] };
-      }
-      case "add_task": {
-        const { subject, description } = args;
-        const tasks = readTasks();
-        const now = (/* @__PURE__ */ new Date()).toISOString();
-        const newTask = {
-          id: generateTaskId(),
-          subject,
-          description,
-          status: "pending",
-          createdAt: now,
-          updatedAt: now
-        };
-        tasks.tasks.push(newTask);
-        if (writeTasks(tasks)) {
-          return { content: [{ type: "text", text: `Task created with ID: ${newTask.id}` }] };
-        }
-        return { content: [{ type: "text", text: `Failed to create task` }] };
-      }
-      case "update_task": {
-        const { taskId, status } = args;
-        const tasks = readTasks();
-        const task = tasks.tasks.find((t) => t.id === taskId);
-        if (!task) {
-          return { content: [{ type: "text", text: `Task ${taskId} not found` }] };
-        }
-        task.status = status;
-        task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-        if (writeTasks(tasks)) {
-          return { content: [{ type: "text", text: `Task ${taskId} updated to status: ${status}` }] };
-        }
-        return { content: [{ type: "text", text: `Failed to update task` }] };
-      }
-      // Orchestration tool handlers
-      case "read_orchestration": {
-        const type = args.type;
-        let content = null;
-        if (type === "plan") {
-          content = readFile(planPath);
-        } else if (type === "agents") {
-          content = readFile(agentsPath);
-        } else if (type === "events") {
-          content = readFile(eventsPath);
-        }
-        return {
-          content: [{ type: "text", text: content ?? `No ${type} file found in orchestration directory.` }]
-        };
-      }
-      case "append_event": {
-        const { event, message, agentName: agentName2, taskRunId } = args;
-        const eventObj = {
-          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-          event,
-          message
-        };
-        if (agentName2) eventObj.agentName = agentName2;
-        if (taskRunId) eventObj.taskRunId = taskRunId;
-        if (appendEvent(eventObj)) {
-          return { content: [{ type: "text", text: `Event appended to EVENTS.jsonl` }] };
-        }
-        return { content: [{ type: "text", text: `Failed to append event` }] };
-      }
-      case "update_plan_task": {
-        const { taskId, status, result, errorMessage } = args;
-        const plan = readPlan();
-        if (!plan) {
-          return { content: [{ type: "text", text: `No PLAN.json found in orchestration directory` }] };
-        }
-        const task = plan.tasks.find((t) => t.id === taskId);
-        if (!task) {
-          return { content: [{ type: "text", text: `Task ${taskId} not found in PLAN.json` }] };
-        }
-        task.status = status;
-        if (result !== void 0) task.result = result;
-        if (errorMessage !== void 0) task.errorMessage = errorMessage;
-        if (status === "running" && !task.startedAt) {
-          task.startedAt = (/* @__PURE__ */ new Date()).toISOString();
-        }
-        if (status === "completed" || status === "failed" || status === "cancelled") {
-          task.completedAt = (/* @__PURE__ */ new Date()).toISOString();
-        }
-        if (writePlan(plan)) {
-          return { content: [{ type: "text", text: `Plan task ${taskId} updated to status: ${status}` }] };
-        }
-        return { content: [{ type: "text", text: `Failed to update plan task` }] };
-      }
-      default:
-        return { content: [{ type: "text", text: `Unknown tool: ${name}` }] };
-    }
-  });
-  return server;
-}
-async function runServer(config) {
-  const server = createMemoryMcpServer(config);
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-}
-
-export {
-  createMemoryMcpServer,
-  runServer
-};