toon-memory 1.0.1 → 1.0.2

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "toon-memory",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Persistent memory system for OpenCode AI agent using TOON format (40% fewer tokens than JSON)",
   "type": "module",
   "bin": {
-    "toon-memory": "./bin/setup.js"
+    "toon-memory": "./bin/setup.js",
+    "toon-memory-mcp": "./src/mcp/server.ts"
   },
   "files": [
     "src/",
@@ -12,13 +13,16 @@
     "skills/"
   ],
   "dependencies": {
-    "@toon-format/toon": "^2.3.0"
+    "@modelcontextprotocol/server": "^2.0.0-beta.3",
+    "@toon-format/toon": "^2.3.0",
+    "zod": "^4.4.3"
   },
   "keywords": [
     "opencode",
     "ai-agent",
     "memory",
     "toon",
+    "mcp",
     "llm",
     "token-efficiency"
   ],

package/src/mcp/server.ts

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+
+import { McpServer } from "@modelcontextprotocol/server"
+import { serveStdio } from "@modelcontextprotocol/server/stdio"
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs"
+import * as path from "path"
+import { encode, decode } from "@toon-format/toon"
+import { randomUUID } from "crypto"
+import * as z from "zod/v4"
+
+// ── Memory storage ──────────────────────────────
+
+const MEMORY_DIR = path.join(process.cwd(), ".opencode", "memory")
+const MEMORY_FILE = path.join(MEMORY_DIR, "data.toon")
+
+interface MemoryEntry {
+  id: string
+  category: "decision" | "pattern" | "bug" | "knowledge"
+  key: string
+  content: string
+  file: string
+  tags: string
+  date: string
+}
+
+interface MemoryData {
+  version: number
+  entries: MemoryEntry[]
+  summaries: Record<string, string>
+}
+
+function defaultData(): MemoryData {
+  return { version: 1, entries: [], summaries: {} }
+}
+
+function ensureDir() {
+  if (!existsSync(MEMORY_DIR)) mkdirSync(MEMORY_DIR, { recursive: true })
+}
+
+function readMemory(): MemoryData {
+  ensureDir()
+  if (!existsSync(MEMORY_FILE)) return defaultData()
+  try {
+    const raw = readFileSync(MEMORY_FILE, "utf-8")
+    const parsed = decode(raw) as MemoryData
+    if (!parsed || typeof parsed !== "object") return defaultData()
+    if (!Array.isArray(parsed.entries)) parsed.entries = []
+    if (!parsed.summaries || typeof parsed.summaries !== "object") parsed.summaries = {}
+    return parsed
+  } catch {
+    return defaultData()
+  }
+}
+
+function writeMemory(data: MemoryData): void {
+  ensureDir()
+  const toon = encode(data, { delimiter: "|", indent: 2 })
+  writeFileSync(MEMORY_FILE, toon, "utf-8")
+}
+
+function genId(): string {
+  return randomUUID().slice(0, 8)
+}
+
+// ── MCP Server ──────────────────────────────────
+
+serveStdio(() => {
+  const server = new McpServer({
+    name: "toon-memory",
+    version: "1.0.1",
+  })
+
+  // Tool: memory_remember
+  server.registerTool(
+    "memory_remember",
+    {
+      title: "Save to Memory",
+      description:
+        "Guarda un hecho en la memoria persistente del proyecto (decisiones, patrones, bugs, conocimiento). Se recuerda entre sesiones.",
+      inputSchema: z.object({
+        category: z
+          .enum(["decision", "pattern", "bug", "knowledge"])
+          .describe("Categoría del hecho"),
+        key: z
+          .string()
+          .describe("Título corto en kebab-case (ej: risk-engine-prioridad)"),
+        content: z.string().describe("Contenido detallado del hecho"),
+        file: z
+          .string()
+          .describe("Archivo o línea relacionada (ej: spec.md:145)")
+          .default(""),
+        tags: z
+          .string()
+          .describe("Tags separados por punto y coma (ej: risk;spec)")
+          .default(""),
+      }),
+    },
+    async ({ category, key, content, file, tags }) => {
+      const state = readMemory()
+      const existing = state.entries.find(
+        (e) => e.category === category && e.key === key,
+      )
+      const entry: MemoryEntry = {
+        id: existing?.id || genId(),
+        category,
+        key,
+        content,
+        file,
+        tags,
+        date: new Date().toISOString().slice(0, 10),
+      }
+      if (existing) {
+        const idx = state.entries.indexOf(existing)
+        state.entries[idx] = entry
+      } else {
+        state.entries.push(entry)
+      }
+      writeMemory(state)
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `${existing ? "🧠 Actualizado" : "🧠 Guardado"}: ${category}/${key} (${entry.id})\n${content}`,
+          },
+        ],
+      }
+    },
+  )
+
+  // Tool: memory_recall
+  server.registerTool(
+    "memory_recall",
+    {
+      title: "Search Memory",
+      description:
+        "Busca en la memoria persistente del proyecto. Devuelve entradas relevantes. Usar ANTES de leer archivos.",
+      inputSchema: z.object({
+        query: z.string().describe("Texto a buscar"),
+        category: z
+          .string()
+          .describe("Filtrar por categoría (vacío = todos)")
+          .default(""),
+      }),
+    },
+    async ({ query, category }) => {
+      const state = readMemory()
+      const q = query.toLowerCase()
+      let results = state.entries.filter((e) => {
+        const matchText =
+          e.key.toLowerCase().includes(q) ||
+          e.content.toLowerCase().includes(q) ||
+          e.tags.toLowerCase().includes(q)
+        const matchCat = category ? e.category === category : true
+        return matchText && matchCat
+      })
+      results = results.slice(0, 10)
+
+      if (results.length === 0) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `No encontré nada para "${query}"${category ? ` en "${category}"` : ""}.`,
+            },
+          ],
+        }
+      }
+
+      const output = results
+        .map(
+          (e) =>
+            `[${e.category}] ${e.key} (${e.id})\n  ${e.content}\n  File: ${e.file || "N/A"} | Tags: ${e.tags || "N/A"} | Date: ${e.date}`,
+        )
+        .join("\n\n")
+
+      return { content: [{ type: "text" as const, text: output }] }
+    },
+  )
+
+  // Tool: memory_forget
+  server.registerTool(
+    "memory_forget",
+    {
+      title: "Delete from Memory",
+      description: "Elimina una entrada de la memoria por su key o id.",
+      inputSchema: z.object({
+        key: z.string().describe("Key o id de la entrada a eliminar"),
+      }),
+    },
+    async ({ key }) => {
+      const state = readMemory()
+      const before = state.entries.length
+      state.entries = state.entries.filter(
+        (e) => e.key !== key && e.id !== key,
+      )
+      if (state.entries.length === before) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `No encontré "${key}" en la memoria.`,
+            },
+          ],
+        }
+      }
+      writeMemory(state)
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `"${key}" eliminado. Quedan ${state.entries.length} entradas.`,
+          },
+        ],
+      }
+    },
+  )
+
+  // Tool: memory_stats
+  server.registerTool(
+    "memory_stats",
+    {
+      title: "Memory Stats",
+      description: "Muestra estadísticas de la memoria del proyecto.",
+      inputSchema: z.object({}),
+    },
+    async () => {
+      const state = readMemory()
+      const byCategory: Record<string, number> = {}
+      for (const e of state.entries) {
+        byCategory[e.category] = (byCategory[e.category] || 0) + 1
+      }
+      const catStr = Object.entries(byCategory)
+        .map(([k, v]) => `  ${k}: ${v}`)
+        .join("\n")
+      const recent = state.entries
+        .slice(-5)
+        .reverse()
+        .map((e) => `  [${e.category}] ${e.key} (${e.date})`)
+        .join("\n")
+
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: [
+              `Entradas totales: ${state.entries.length}`,
+              `Resúmenes de archivos: ${Object.keys(state.summaries).length}`,
+              "",
+              "Por categoría:",
+              catStr || "  (vacío)",
+              "",
+              "Últimas 5:",
+              recent || "  (ninguna)",
+            ].join("\n"),
+          },
+        ],
+      }
+    },
+  )
+
+  // Tool: memory_summary
+  server.registerTool(
+    "memory_summary",
+    {
+      title: "File Summary",
+      description:
+        "Guarda o recupera un resumen de un archivo grande para ahorrar tokens.",
+      inputSchema: z.object({
+        action: z.enum(["get", "set"]).describe("get para leer, set para guardar"),
+        file: z.string().describe("Ruta del archivo"),
+        summary: z
+          .string()
+          .describe("Resumen del archivo (solo para set)")
+          .default(""),
+      }),
+    },
+    async ({ action, file, summary }) => {
+      const state = readMemory()
+      if (action === "get") {
+        const s = state.summaries[file]
+        if (!s) {
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: `No hay resumen para "${file}".`,
+              },
+            ],
+          }
+        }
+        return { content: [{ type: "text" as const, text: s }] }
+      }
+      state.summaries[file] = summary
+      writeMemory(state)
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `${file} actualizado.`,
+          },
+        ],
+      }
+    },
+  )
+
+  return server
+})