toon-memory 1.0.4 → 1.0.6

package/src/memory.ts

@@ -1,244 +1,237 @@
 import { tool } from "@opencode-ai/plugin"
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs"
-import * as path from "path"
-import { encode, decode } from "@toon-format/toon"
-import { randomUUID } from "crypto"
-
-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>
-}
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs"
+import { dirname, join } from "path"
+import { fileURLToPath } from "url"
+import { randomBytes } from "crypto"
 
-function defaultData(): MemoryData {
-  return { version: 1, entries: [], summaries: {} }
-}
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const MEMORY_DIR = join(__dirname, "..", "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")
 }
 
-export const memory_remember = tool({
-  description:
-    "Guarda un hecho en la memoria persistente del proyecto (decisiones, patrones, bugs, conocimiento). Se recuerda entre sesiones. Usar cuando el agente tome una decisión importante, resuelva un bug, o observe un patrón.",
+export const memoryRemember = tool({
+  description: "Guarda un hecho en la memoria persistente del proyecto (decisiones, patrones, bugs, conocimiento). Se recuerda entre sesiones.",
   args: {
-    category: tool.schema
-      .enum(["decision", "pattern", "bug", "knowledge"])
-      .describe("Categoría: decision (diseño), pattern (código), bug (resolución), knowledge (general)"),
-    key: tool.schema
-      .string()
-      .describe("Título corto en kebab-case (ej: risk-engine-prioridad)"),
-    content: tool.schema
-      .string()
-      .describe("Contenido detallado del hecho"),
-    file: tool.schema
-      .string()
-      .describe("Archivo o línea relacionada (ej: spec.md:145)")
-      .default(""),
-    tags: tool.schema
-      .string()
-      .describe("Tags separados por punto y coma (ej: risk;spec)")
-      .default(""),
+    category: tool.schema.enum({
+      description: "Categoría del hecho",
+      options: ["decision", "pattern", "bug", "knowledge"],
+    }),
+    key: tool.schema.string({
+      description: "Título corto en kebab-case (ej: risk-engine-prioridad)",
+    }),
+    content: tool.schema.string({
+      description: "Contenido detallado del hecho",
+    }),
+    file: tool.schema.string({
+      description: "Archivo o línea relacionada (ej: spec.md:145)",
+    }),
+    tags: tool.schema.string({
+      description: "Tags separados por punto y coma (ej: risk;spec)",
+    }),
   },
-  async execute({ 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 {
-      title: existing ? "🧠 Actualizado" : "🧠 Guardado",
-      output: `${category}/${key} (${entry.id})\n${content}`,
+  async execute(args) {
+    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}|${args.category}|${args.key}|${args.content}|${args.file || ""}|${args.tags || ""}|${date}`
+
+    lines.splice(headerIdx + 1, 0, `  ${newEntry}`)
+    lines[headerIdx] = lines[headerIdx].replace(/entries\[\d+\|/, `[${count + 1}|`)
+
+    writeMemory(lines.join("\n"))
+    return `🧠 Guardado: ${args.category}/${args.key} (${id})\n${args.content}`
   },
 })
 
-export const memory_recall = tool({
-  description:
-    "Busca en la memoria persistente del proyecto. Devuelve entradas relevantes por categoría, tag, o texto libre. Usar ANTES de leer archivos para evitar re-investigar.",
+export const memoryRecall = tool({
+  description: "Busca en la memoria persistente del proyecto. Devuelve entradas relevantes por categoría, tag, o texto libre. Usar ANTES de leer archivos para evitar re-investigar.",
   args: {
-    query: tool.schema
-      .string()
-      .describe("Texto a buscar (busca en key, content, tags)"),
-    category: tool.schema
-      .string()
-      .describe("Filtrar por categoría (decision|pattern|bug|knowledge). Vacío = todos.")
-      .default(""),
+    query: tool.schema.string({
+      description: "Texto a buscar (busca en key, content, tags)",
+    }),
+    category: tool.schema.string({
+      description: "Filtrar por categoría (decision|pattern|bug|knowledge). Vacío = todos.",
+    }),
   },
-  async execute({ 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)
+  async execute(args) {
+    const data = readMemory()
+    const lines = data.split("\n").filter((l) => l.startsWith("  ") && l.includes("|"))
+    const queryLower = args.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 (args.category && cat !== args.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 }
+      })
+      .filter(Boolean)
+
     if (results.length === 0) {
-      return {
-        title: "🔍 Sin resultados",
-        output: `No encontré nada para "${query}"${category ? ` en categoría "${category}"` : ""}.`,
-      }
+      return `No se encontraron resultados para "${args.query}"`
     }
-    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}`,
-      )
+
+    return 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 { title: `🔍 ${results.length} resultados`, output }
   },
 })
 
-export const memory_forget = tool({
+export const memoryForget = tool({
   description: "Elimina una entrada de la memoria por su key o id.",
   args: {
-    key: tool.schema
-      .string()
-      .describe("Key o id de la entrada a eliminar"),
+    key: tool.schema.string({
+      description: "Key o id de la entrada a eliminar",
+    }),
   },
-  async execute({ 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 {
-        title: "⚠️ No encontrado",
-        output: `No encontré "${key}" en la memoria.`,
-      }
-    }
-    writeMemory(state)
-    return {
-      title: "🗑️ Eliminado",
-      output: `"${key}" eliminado. Quedan ${state.entries.length} entradas.`,
+  async execute(args) {
+    const data = readMemory()
+    const lines = data.split("\n")
+    const headerIdx = lines.findIndex((l) => l.startsWith("entries["))
+
+    if (headerIdx === -1) {
+      return "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] !== args.key && parts[2] !== args.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 `"${args.key}" eliminado. Quedan ${count - removed} entradas.`
   },
 })
 
-export const memory_stats = tool({
-  description:
-    "Muestra estadísticas de la memoria: total entradas, por categoría, y resúmenes de archivos.",
+export const memoryStats = tool({
+  description: "Muestra estadísticas de la memoria: total entradas, por categoría, y resúmenes de archivos.",
   args: {},
   async execute() {
-    const state = readMemory()
+    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 state.entries) {
+    for (const e of 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 {
-      title: "📊 Memoria del proyecto",
-      output: [
-        `Entradas totales: ${state.entries.length}`,
-        `Resúmenes de archivos: ${Object.keys(state.summaries).length}`,
-        "",
-        "Por categoría:",
-        catStr || "  (vacío)",
-        "",
-        "Últimas 5 entradas:",
-        recent || "  (ninguna)",
-      ].join("\n"),
-    }
+
+    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 stats.join("\n")
   },
 })
 
-export const memory_summary = tool({
-  description:
-    "Guarda o recupera un resumen de un archivo grande. El agente puede leer el resumen en vez del archivo completo para ahorrar tokens.",
+export const memorySummary = tool({
+  description: "Guarda o recupera un resumen de un archivo grande. El agente puede leer el resumen en vez del archivo completo para ahorrar tokens.",
   args: {
-    action: tool.schema
-      .enum(["get", "set"])
-      .describe("get para leer, set para guardar"),
-    file: tool.schema
-      .string()
-      .describe("Ruta del archivo"),
-    summary: tool.schema
-      .string()
-      .describe("Resumen del archivo (solo para set)")
-      .default(""),
+    action: tool.schema.enum({
+      description: "get para leer, set para guardar",
+      options: ["get", "set"],
+    }),
+    file: tool.schema.string({
+      description: "Ruta del archivo",
+    }),
+    summary: tool.schema.string({
+      description: "Resumen del archivo (solo para set)",
+    }),
   },
-  async execute({ action, file, summary }) {
-    const state = readMemory()
-    if (action === "get") {
-      const s = state.summaries[file]
-      if (!s) {
-        return {
-          title: "📄 Sin resumen",
-          output: `No hay resumen para "${file}". Usar memory_summary action=set para guardar uno.`,
-        }
+  async execute(args) {
+    const data = readMemory()
+
+    if (args.action === "get") {
+      const lines = data.split("\n")
+      const summaryIdx = lines.findIndex((l) => l.trim().startsWith("summaries:"))
+      if (summaryIdx === -1) {
+        return `No hay resúmenes guardados para "${args.file}"`
       }
-      return { title: `📄 ${file}`, output: s }
+
+      const summaryLines = lines.slice(summaryIdx + 1).filter((l) => l.includes(":"))
+      const match = summaryLines.find((l) => l.startsWith(`  ${args.file}:`))
+      if (!match) {
+        return `No hay resumen para "${args.file}"`
+      }
+
+      const summaryText = match.replace(`  ${args.file}: `, "")
+      return 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
     }
-    state.summaries[file] = summary
-    writeMemory(state)
-    return {
-      title: "📄 Resumen guardado",
-      output: `${file} actualizado.`,
+
+    const summaryLines = lines.slice(summaryIdx + 1).filter((l) => l.includes(":"))
+    const existingIdx = summaryLines.findIndex((l) => l.startsWith(`  ${args.file}:`))
+
+    if (existingIdx !== -1) {
+      summaryLines[existingIdx] = `  ${args.file}: ${args.summary}`
+    } else {
+      summaryLines.push(`  ${args.file}: ${args.summary}`)
     }
+
+    lines.splice(summaryIdx + 1, lines.length - summaryIdx - 1, ...summaryLines)
+    writeMemory(lines.join("\n"))
+    return `📝 Resumen guardado para ${args.file}`
   },
 })

package/README.md

@@ -1,66 +0,0 @@
-# toon-memory
-
-Persistent memory system for [OpenCode](https://opencode.ai) AI agent using TOON format.
-
-**40% fewer tokens than JSON** for the same data. The agent remembers decisions, patterns, and bugs between sessions.
-
-## Install
-
-```bash
-# In your project
-npm install toon-memory @toon-format/toon
-npx toon-memory
-```
-
-Or globally:
-
-```bash
-npm install -g toon-memory @toon-format/toon
-# Then in any project:
-npx toon-memory
-```
-
-## What it does
-
-Copies 3 files to your project:
-
-| File | Purpose |
-|------|---------|
-| `.opencode/tools/memory.ts` | 5 tools for the AI agent |
-| `.opencode/memory/data.toon` | Your project's memory (TOON format) |
-| `.opencode/skills/toon-memory.md` | Usage instructions |
-
-## Tools
-
-| Tool | Description |
-|------|-------------|
-| `memory_remember` | Save a decision, pattern, bug, or knowledge |
-| `memory_recall` | Search memory (use BEFORE reading files) |
-| `memory_forget` | Remove an entry by key or id |
-| `memory_stats` | View memory state |
-| `memory_summary` | Save/retrieve file summaries |
-
-## How it works
-
-The agent stores entries in TOON format (Token-Oriented Object Notation):
-
-```
-version: 1
-entries[2|]{id|category|key|content|file|tags|date}:
-  a1b2c3d4|decision|use-pandas|Use pandas for time series|indicators.py|python;analytics|2026-07-10
-  e5f6g7h8|bug|redis-pool|max_connections missing|redis.adapter.ts|redis;pool|2026-07-10
-summaries:
-  path/to/file.py: Brief summary of what this file does
-```
-
-## Token savings
-
-| Format | Tokens (10 entries) | vs JSON |
-|--------|---------------------|---------|
-| JSON | ~800 | baseline |
-| YAML | ~650 | -19% |
-| **TOON** | **~480** | **-40%** |
-
-## License
-
-MIT