toon-memory 1.0.4 → 1.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toon-memory",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Persistent memory system for OpenCode AI agent using TOON format (40% fewer tokens than JSON)",
   "type": "module",
   "bin": {

package/skills/toon-memory.md

@@ -14,6 +14,40 @@ A persistent memory system for the OpenCode AI agent. It remembers decisions, pa
 | `memory_stats` | View memory state |
 | `memory_summary` | Save/retrieve file summaries |
 
+## Installation
+
+### Option 1: Global MCP Server (recommended)
+
+Add to `~/.config/opencode/opencode.json`:
+
+```json
+{
+  "mcp": {
+    "toon-memory": {
+      "type": "local",
+      "command": ["npx", "-y", "toon-memory", "mcp"],
+      "enabled": true
+    }
+  }
+}
+```
+
+### Option 2: Project-level MCP Server
+
+Add to `.opencode/opencode.json`:
+
+```json
+{
+  "mcp": {
+    "toon-memory": {
+      "type": "local",
+      "command": ["npx", "-y", "toon-memory", "mcp"],
+      "enabled": true
+    }
+  }
+}
+```
+
 ## How to use
 
 ### At the START of every session

package/src/mcp/server.ts

@@ -1,307 +1,251 @@
-#!/usr/bin/env node
-
 import { McpServer } from "@modelcontextprotocol/server"
-import { serveStdio } from "@modelcontextprotocol/server/stdio"
+import { StdioServerTransport } from "@modelcontextprotocol/server/stdio"
+import { z } from "zod"
 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
-}
+import { dirname, join } from "path"
+import { fileURLToPath } from "url"
+import { randomBytes } from "crypto"
 
-interface MemoryData {
-  version: number
-  entries: MemoryEntry[]
-  summaries: Record<string, string>
-}
-
-function defaultData(): MemoryData {
-  return { version: 1, entries: [], summaries: {} }
-}
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const MEMORY_DIR = join(process.cwd(), ".opencode", "memory")
+const MEMORY_FILE = join(MEMORY_DIR, "data.toon")
 
-function ensureDir() {
+function ensureMemoryFile() {
   if (!existsSync(MEMORY_DIR)) mkdirSync(MEMORY_DIR, { recursive: true })
+  if (!existsSync(MEMORY_FILE)) {
+    writeFileSync(MEMORY_FILE, "version: 1\nentries[0|]{id|category|key|content|file|tags|date}:\n")
+  }
 }
 
-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 readMemory() {
+  ensureMemoryFile()
+  return readFileSync(MEMORY_FILE, "utf-8")
 }
 
-function writeMemory(data: MemoryData): void {
-  ensureDir()
-  const toon = encode(data, { delimiter: "|", indent: 2 })
-  writeFileSync(MEMORY_FILE, toon, "utf-8")
+function writeMemory(content: string) {
+  ensureMemoryFile()
+  writeFileSync(MEMORY_FILE, content)
 }
 
-function genId(): string {
-  return randomUUID().slice(0, 8)
+function generateId(): string {
+  return randomBytes(4).toString("hex")
 }
 
-// ── 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(""),
-      }),
+const server = new McpServer(
+  { name: "toon-memory", version: "1.0.5" },
+  { capabilities: { tools: { listChanged: true } } }
+)
+
+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: {
+      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().optional().default("").describe("Archivo o línea relacionada (ej: spec.md:145)"),
+      tags: z.string().optional().default("").describe("Tags separados por punto y coma (ej: risk;spec)"),
     },
-    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 ({ category, key, content, file, tags }) => {
+    const data = readMemory()
+    const id = generateId()
+    const date = new Date().toISOString().split("T")[0]
+    const lines = data.split("\n")
+
+    let headerIdx = lines.findIndex((l) => l.startsWith("entries["))
+    if (headerIdx === -1) {
+      lines.push(`entries[0|]{id|category|key|content|file|tags|date}:`)
+      headerIdx = lines.length - 1
+    }
+
+    const match = lines[headerIdx].match(/entries\[(\d+)\|/)
+    const count = match ? parseInt(match[1]) : 0
+    const newEntry = `${id}|${category}|${key}|${content}|${file || ""}|${tags || ""}|${date}`
+
+    lines.splice(headerIdx + 1, 0, `  ${newEntry}`)
+    lines[headerIdx] = lines[headerIdx].replace(/entries\[\d+\|/, `[${count + 1}|`)
+
+    writeMemory(lines.join("\n"))
+    return {
+      content: [{ type: "text" as const, text: `🧠 Guardado: ${category}/${key} (${id})\n${content}` }],
+    }
+  }
+)
+
+server.registerTool(
+  "memory_recall",
+  {
+    title: "Search Memory",
+    description: "Busca en la memoria persistente del proyecto. Devuelve entradas relevantes. Usar ANTES de leer archivos.",
+    inputSchema: {
+      query: z.string().describe("Texto a buscar"),
+      category: z.string().optional().default("").describe("Filtrar por categoría (vacío = todos)"),
     },
-    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
+  },
+  async ({ query, category }) => {
+    const data = readMemory()
+    const lines = data.split("\n").filter((l) => l.startsWith("  ") && l.includes("|"))
+    const queryLower = query.toLowerCase()
+
+    const results = lines
+      .map((line) => {
+        const trimmed = line.trim()
+        const parts = trimmed.split("|")
+        if (parts.length < 7) return null
+        const [id, cat, key, content, file, tags, date] = parts
+        if (category && cat !== category) return null
+        const searchStr = `${id} ${cat} ${key} ${content} ${file} ${tags}`.toLowerCase()
+        if (!searchStr.includes(queryLower)) return null
+        return { id, cat, key, content, file, tags, date }
       })
-      results = results.slice(0, 10)
-
-      if (results.length === 0) {
-        return {
-          content: [
-            {
-              type: "text" as const,
-              text: `No encontré nada para "${query}"${category ? ` en "${category}"` : ""}.`,
-            },
-          ],
-        }
-      }
+      .filter(Boolean)
 
-      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")
+    if (results.length === 0) {
+      return { content: [{ type: "text" as const, text: `No se encontraron resultados para "${query}"` }] }
+    }
 
-      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"),
-          },
-        ],
-      }
+    const formatted = results
+      .map((r) => `[${r!.cat}] ${r!.key} (${r!.id})\n  ${r!.content}\n  File: ${r!.file} | Tags: ${r!.tags} | Date: ${r!.date}`)
+      .join("\n\n")
+
+    return { content: [{ type: "text" as const, text: formatted }] }
+  }
+)
+
+server.registerTool(
+  "memory_forget",
+  {
+    title: "Delete from Memory",
+    description: "Elimina una entrada de la memoria por su key o id.",
+    inputSchema: {
+      key: z.string().describe("Key o id de la entrada a eliminar"),
     },
-  )
-
-  // 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 ({ key }) => {
+    const data = readMemory()
+    const lines = data.split("\n")
+    const headerIdx = lines.findIndex((l) => l.startsWith("entries["))
+
+    if (headerIdx === -1) {
+      return { content: [{ type: "text" as const, text: "No hay entradas en memoria" }] }
+    }
+
+    const entryLines = lines.slice(headerIdx + 1).filter((l) => l.trim().length > 0)
+    const filtered = entryLines.filter((l) => {
+      const parts = l.trim().split("|")
+      return parts[0] !== key && parts[2] !== key
+    })
+
+    const removed = entryLines.length - filtered.length
+    const match = lines[headerIdx].match(/entries\[(\d+)\|/)
+    const count = match ? parseInt(match[1]) : 0
+    lines[headerIdx] = lines[headerIdx].replace(/entries\[\d+\|/, `[${count - removed}|`)
+    lines.splice(headerIdx + 1, entryLines.length, ...filtered.map((l) => `  ${l.trim()}`))
+
+    writeMemory(lines.join("\n"))
+    return {
+      content: [{ type: "text" as const, text: `"${key}" eliminado. Quedan ${count - removed} entradas.` }],
+    }
+  }
+)
+
+server.registerTool(
+  "memory_stats",
+  {
+    title: "Memory Stats",
+    description: "Muestra estadísticas de la memoria del proyecto.",
+    inputSchema: {},
+  },
+  async () => {
+    const data = readMemory()
+    const lines = data.split("\n").filter((l) => l.startsWith("  ") && l.includes("|"))
+    const entries = lines.map((l) => {
+      const parts = l.trim().split("|")
+      return { category: parts[1] || "unknown" }
+    })
+
+    const byCategory: Record<string, number> = {}
+    for (const e of entries) {
+      byCategory[e.category] = (byCategory[e.category] || 0) + 1
+    }
+
+    const summaryLines = data.split("\n").filter((l) => l.includes(":") && !l.startsWith("  ") && !l.startsWith("version") && !l.startsWith("entries"))
+    const stats = [
+      `Entradas totales: ${entries.length}`,
+      `Resúmenes de archivos: ${summaryLines.length}`,
+      "",
+      "Por categoría:",
+      ...Object.entries(byCategory).map(([k, v]) => `  ${k}: ${v}`),
+      "",
+      `Últimas 5 entradas:`,
+      ...lines.slice(-5).map((l) => {
+        const parts = l.trim().split("|")
+        return `  [${parts[1]}] ${parts[2]} (${parts[0]})`
       }),
+    ]
+
+    return { content: [{ type: "text" as const, text: stats.join("\n") }] }
+  }
+)
+
+server.registerTool(
+  "memory_summary",
+  {
+    title: "File Summary",
+    description: "Guarda o recupera un resumen de un archivo grande para ahorrar tokens.",
+    inputSchema: {
+      action: z.enum(["get", "set"]).describe("get para leer, set para guardar"),
+      file: z.string().describe("Ruta del archivo"),
+      summary: z.string().optional().default("").describe("Resumen del archivo (solo para set)"),
     },
-    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 }] }
+  },
+  async ({ action, file, summary }) => {
+    const data = readMemory()
+
+    if (action === "get") {
+      const lines = data.split("\n")
+      const summaryIdx = lines.findIndex((l) => l.trim().startsWith("summaries:"))
+      if (summaryIdx === -1) {
+        return { content: [{ type: "text" as const, text: `No hay resúmenes guardados para "${file}"` }] }
       }
-      state.summaries[file] = summary
-      writeMemory(state)
-      return {
-        content: [
-          {
-            type: "text" as const,
-            text: `${file} actualizado.`,
-          },
-        ],
+
+      const summaryLines = lines.slice(summaryIdx + 1).filter((l) => l.includes(":"))
+      const match = summaryLines.find((l) => l.startsWith(`  ${file}:`))
+      if (!match) {
+        return { content: [{ type: "text" as const, text: `No hay resumen para "${file}"` }] }
       }
-    },
-  )
 
-  return server
-})
+      const summaryText = match.replace(`  ${file}: `, "")
+      return { content: [{ type: "text" as const, text: summaryText }] }
+    }
+
+    const lines = data.split("\n")
+    let summaryIdx = lines.findIndex((l) => l.trim().startsWith("summaries:"))
+
+    if (summaryIdx === -1) {
+      lines.push("", "summaries:")
+      summaryIdx = lines.length - 1
+    }
+
+    const summaryLines = lines.slice(summaryIdx + 1).filter((l) => l.includes(":"))
+    const existingIdx = summaryLines.findIndex((l) => l.startsWith(`  ${file}:`))
+
+    if (existingIdx !== -1) {
+      summaryLines[existingIdx] = `  ${file}: ${summary}`
+    } else {
+      summaryLines.push(`  ${file}: ${summary}`)
+    }
+
+    lines.splice(summaryIdx + 1, lines.length - summaryIdx - 1, ...summaryLines)
+    writeMemory(lines.join("\n"))
+    return {
+      content: [{ type: "text" as const, text: `📝 Resumen guardado para ${file}` }],
+    }
+  }
+)
+
+const transport = new StdioServerTransport()
+await server.connect(transport)