toon-memory 1.7.0 → 2.0.0

package/src/mcp/server.ts

@@ -9,7 +9,7 @@ import { randomBytes, createCipheriv, createDecipheriv } from "crypto"
 const __dirname = dirname(fileURLToPath(import.meta.url))
 
 /** Base directory for memory storage */
-const MEMORY_DIR = join(process.cwd(), ".opencode", "memory")
+const MEMORY_DIR = join(process.cwd(), ".toon-memory", "memory")
 
 /** Main memory data file */
 const MEMORY_FILE = join(MEMORY_DIR, "data.toon")
@@ -91,7 +91,7 @@ function ensureMemoryDir(): void {
 function ensureMemoryFile(): void {
   ensureMemoryDir()
   if (!existsSync(MEMORY_FILE)) {
-    writeFileSync(MEMORY_FILE, "version: 1\nentries[0|]{id|category|key|content|file|tags|date}:\n")
+    writeFileSync(MEMORY_FILE, "version: 1\nentries[0|]{id|category|key|content|file|tags|date|ttl}:\n")
   }
 }
 
@@ -207,6 +207,130 @@ function generateId(): string {
   return randomBytes(4).toString("hex")
 }
 
+/**
+ * Parse a TTL value into an absolute date string (YYYY-MM-DD).
+ * Supports: exact dates (2026-07-17), relative days (7d, 30d).
+ * Returns empty string if no TTL.
+ */
+function parseTTL(ttl: string): string {
+  if (!ttl || !ttl.trim()) return ""
+  const trimmed = ttl.trim()
+  const dayMatch = trimmed.match(/^(\d+)d$/)
+  if (dayMatch) {
+    const days = parseInt(dayMatch[1])
+    const d = new Date()
+    d.setDate(d.getDate() + days)
+    return d.toISOString().split("T")[0]
+  }
+  if (/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) return trimmed
+  return ""
+}
+
+/**
+ * Check if a TTL value has expired (date is in the past).
+ */
+function isExpired(ttl: string): boolean {
+  if (!ttl) return false
+  const ttlDate = parseTTL(ttl) || ttl
+  const today = new Date().toISOString().split("T")[0]
+  return ttlDate <= today
+}
+
+/** Built-in vocabulary for automatic tag inference */
+const TAG_VOCABULARY: Record<string, string[]> = {
+  "redis": ["redis", "cache", "caching", "memcached"],
+  "auth": ["auth", "authentication", "authorization", "login", "token", "jwt", "session", "oauth"],
+  "api": ["api", "endpoint", "rest", "graphql", "route", "router", "controller"],
+  "db": ["database", "db", "sql", "postgres", "mysql", "mongo", "query", "migration", "schema"],
+  "security": ["security", "encrypt", "decrypt", "vulnerability", "xss", "csrf", "cors", "sanitiz"],
+  "test": ["test", "testing", "vitest", "jest", "spec", "mock", "assert", "coverage"],
+  "deploy": ["deploy", "docker", "ci/cd", "github actions", "pipeline", "kubernetes", "k8s"],
+  "config": ["config", "configuration", "settings", "env", "environment", "dotenv"],
+  "performance": ["performance", "optimize", "benchmark", "latency", "throughput", "cache"],
+  "refactor": ["refactor", "cleanup", "restructure", "reorganize", "rework"],
+  "error": ["error", "exception", "throw", "catch", "handling", "retry", "fallback"],
+  "logging": ["log", "logging", "logger", "debug", "trace", "monitor", "observability"],
+  "types": ["typescript", "types", "type", "interface", "generic", "enum", "zod", "schema"],
+  "async": ["async", "await", "promise", "concurrent", "parallel", "worker", "queue"],
+  "state": ["state", "store", "redux", "context", "reducer", "action", "observable"],
+  "ui": ["ui", "component", "render", "dom", "css", "style", "layout", "responsive"],
+  "storage": ["storage", "file", "filesystem", "s3", "blob", "upload", "download"],
+  "email": ["email", "mail", "smtp", "sendgrid", "newsletter", "notification"],
+  "payment": ["payment", "stripe", "billing", "invoice", "checkout", "subscription"],
+  "webhook": ["webhook", "callback", "event", "listener", "hook"],
+}
+
+/**
+ * Infer tags from content and key by matching against vocabulary.
+ * Returns semicolon-separated tags.
+ */
+function inferTags(content: string, key: string): string {
+  const text = `${key} ${content}`.toLowerCase()
+  const matched: string[] = []
+  for (const [tag, keywords] of Object.entries(TAG_VOCABULARY)) {
+    if (keywords.some((kw) => text.includes(kw))) {
+      matched.push(tag)
+    }
+  }
+  return matched.join(";")
+}
+
+/**
+ * Parse a relative date string into an absolute YYYY-MM-DD date.
+ * Supports: "24h", "7d", "30d", or an exact date "2026-07-10".
+ */
+function parseRelativeDate(since: string): string {
+  const trimmed = since.trim()
+  const hourMatch = trimmed.match(/^(\d+)h$/)
+  if (hourMatch) {
+    const d = new Date()
+    d.setHours(d.getHours() - parseInt(hourMatch[1]))
+    return d.toISOString().split("T")[0]
+  }
+  const dayMatch = trimmed.match(/^(\d+)d$/)
+  if (dayMatch) {
+    const d = new Date()
+    d.setDate(d.getDate() - parseInt(dayMatch[1]))
+    return d.toISOString().split("T")[0]
+  }
+  if (/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) return trimmed
+  const today = new Date().toISOString().split("T")[0]
+  return today
+}
+
+const normalize = (s: string) => s.toLowerCase().replace(/[-_]/g, " ").replace(/\s+/g, " ").trim()
+
+/**
+ * Find entries related to the given text by fuzzy matching.
+ * Returns top N results ranked by match quality.
+ */
+function findRelatedEntries(text: string, excludeKey: string = "", limit: number = 3): Array<{ id: string; cat: string; key: string; content: string; file: string; tags: string; date: string; score: number }> {
+  const data = readMemory()
+  const lines = data.split("\n").filter((l) => l.startsWith("  ") && l.includes("|") && !l.startsWith("  summaries:"))
+  const queryTokens = normalize(text).split(" ").filter(Boolean)
+
+  const scored = 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 (key === excludeKey) return null
+      const searchStr = normalize(`${id} ${cat} ${key} ${content} ${file} ${tags}`)
+      let score = 0
+      for (const token of queryTokens) {
+        if (searchStr.includes(token)) score++
+      }
+      if (score === 0) return null
+      return { id, cat, key, content, file, tags, date, score }
+    })
+    .filter(Boolean)
+    .sort((a, b) => b!.score - a!.score)
+    .slice(0, limit)
+
+  return scored as Array<{ id: string; cat: string; key: string; content: string; file: string; tags: string; date: string; score: number }>
+}
+
 /**
  * Archive entries older than ARCHIVE_DAYS to archive.toon.
  * 
@@ -241,7 +365,10 @@ function archiveOldEntries(): { archived: number; kept: number } {
     const parts = line.trim().split("|")
     if (parts.length >= 7) {
       const date = parts[6]
-      if (date < cutoffStr) {
+      const ttl = parts[7] || ""
+      const isOld = date < cutoffStr
+      const isTtlExpired = ttl && isExpired(ttl)
+      if (isOld || isTtlExpired) {
         toArchive.push(line.trim())
       } else {
         toKeep.push(line.trim())
@@ -287,8 +414,71 @@ function archiveOldEntries(): { archived: number; kept: number } {
 }
 
 const server = new McpServer(
-  { name: "toon-memory", version: "1.1.0" },
-  { capabilities: { tools: { listChanged: true } } }
+  { name: "toon-memory", version: "2.0.0" },
+  { capabilities: { tools: { listChanged: true }, resources: { listChanged: true } } }
+)
+
+/**
+ * Register memory entries as an MCP resource.
+ * Agents can read this as context in the system prompt.
+ */
+server.registerResource(
+  "memory-entries",
+  "toon://memory/entries",
+  { title: "Memory Entries", mimeType: "text/plain" },
+  async (uri) => {
+    const data = readMemory()
+    return { contents: [{ uri: uri.href, text: data }] }
+  }
+)
+
+/**
+ * Register memory stats as an MCP resource.
+ */
+server.registerResource(
+  "memory-stats",
+  "toon://memory/stats",
+  { title: "Memory Stats", mimeType: "text/plain" },
+  async (uri) => {
+    const data = readMemory()
+    const lines = data.split("\n").filter((l) => l.startsWith("  ") && l.includes("|") && !l.startsWith("  summaries:"))
+    const entries = lines.map((l) => {
+      const parts = l.trim().split("|")
+      return { category: parts[1] || "unknown", ttl: parts[7] || "" }
+    })
+    const byCategory: Record<string, number> = {}
+    for (const e of entries) {
+      byCategory[e.category] = (byCategory[e.category] || 0) + 1
+    }
+    const withTtl = entries.filter((e) => e.ttl).length
+    const expired = entries.filter((e) => e.ttl && isExpired(e.ttl)).length
+    const text = [
+      `Entradas totales: ${entries.length}`,
+      `TTL: ${withTtl} con expiración, ${expired} expiradas`,
+      "Por categoría:",
+      ...Object.entries(byCategory).map(([k, v]) => `  ${k}: ${v}`),
+    ].join("\n")
+    return { contents: [{ uri: uri.href, text }] }
+  }
+)
+
+/**
+ * Register memory summaries as an MCP resource.
+ */
+server.registerResource(
+  "memory-summaries",
+  "toon://memory/summaries",
+  { title: "Memory Summaries", mimeType: "text/plain" },
+  async (uri) => {
+    const data = readMemory()
+    const lines = data.split("\n")
+    const summaryIdx = lines.findIndex((l) => l.trim().startsWith("summaries:"))
+    if (summaryIdx === -1) {
+      return { contents: [{ uri: uri.href, text: "No hay resúmenes guardados" }] }
+    }
+    const summaryText = lines.slice(summaryIdx + 1).filter((l) => l.includes(":")).join("\n")
+    return { contents: [{ uri: uri.href, text: summaryText || "No hay resúmenes guardados" }] }
+  }
 )
 
 /**
@@ -316,9 +506,10 @@ server.registerTool(
       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)"),
+      ttl: z.string().optional().default("").describe("Time to live (ej: 7d, 2026-07-17). Vacío = sin expiración"),
     },
   },
-  async ({ category, key, content, file, tags }) => {
+  async ({ category, key, content, file, tags, ttl }) => {
     const data = readMemory()
     const newId = generateId()
     const date = new Date().toISOString().split("T")[0]
@@ -346,8 +537,11 @@ server.registerTool(
     }
 
     const entryId = existingIdx !== -1 ? existingId : newId
-    const newEntry = `${entryId}|${category}|${key}|${content}|${file || ""}|${tags || ""}|${date}`
+    const resolvedTtl = parseTTL(ttl)
+    const resolvedTags = tags ? tags : inferTags(content, key)
+    const newEntry = `${entryId}|${category}|${key}|${content}|${file || ""}|${resolvedTags}|${date}|${resolvedTtl}`
     let action = "Guardado"
+    const tagsInferred = !tags && resolvedTags ? true : false
 
     if (existingIdx !== -1) {
       // Update existing entry
@@ -362,8 +556,30 @@ server.registerTool(
     }
 
     writeMemory(lines.join("\n"))
+
+    // Auto-archive if we exceed MAX_ENTRIES
+    const headerMatch = lines[headerIdx].match(/\[(\d+)\|/)
+    const entryCount = headerMatch ? parseInt(headerMatch[1]) : 0
+    let archiveMsg = ""
+    if (entryCount > MAX_ENTRIES) {
+      const result = archiveOldEntries()
+      if (result.archived > 0) {
+        archiveMsg = `\n📦 Auto-archived ${result.archived} old entries (${result.kept} kept)`
+      }
+    }
+
+    const ttlMsg = resolvedTtl ? `\n⏰ TTL: ${resolvedTtl}` : ""
+    const inferredMsg = tagsInferred ? `\n🏷️ Tags inferidos: ${resolvedTags}` : ""
+
+    const related = findRelatedEntries(`${key} ${content} ${resolvedTags}`, key, 3)
+    let relatedMsg = ""
+    if (related.length > 0) {
+      const items = related.map((r) => `  [${r.cat}] ${r.key} — ${r.content.slice(0, 80)}`).join("\n")
+      relatedMsg = `\n\n🔗 Entradas relacionadas:\n${items}`
+    }
+
     return {
-      content: [{ type: "text" as const, text: `🧠 ${action}: ${category}/${key} (${entryId})\n${content}` }],
+      content: [{ type: "text" as const, text: `🧠 ${action}: ${category}/${key} (${entryId})\n${content}${ttlMsg}${inferredMsg}${archiveMsg}${relatedMsg}` }],
     }
   }
 )
@@ -404,10 +620,11 @@ server.registerTool(
         const trimmed = line.trim()
         const parts = trimmed.split("|")
         if (parts.length < 7) return null
-        const [id, cat, key, content, file, tags, date] = parts
+        const [id, cat, key, content, file, tags, date, ttl] = parts
         if (category && cat !== category) return null
         if (from_date && date < from_date) return null
         if (to_date && date > to_date) return null
+        if (ttl && isExpired(ttl)) return null
         const searchStr = normalize(`${id} ${cat} ${key} ${content} ${file} ${tags}`)
         // All query tokens must match (AND logic)
         if (!queryTokens.every((token) => searchStr.includes(token))) return null
@@ -494,7 +711,7 @@ server.registerTool(
     const lines = data.split("\n").filter((l) => l.startsWith("  ") && l.includes("|") && !l.startsWith("  summaries:"))
     const entries = lines.map((l) => {
       const parts = l.trim().split("|")
-      return { category: parts[1] || "unknown" }
+      return { category: parts[1] || "unknown", ttl: parts[7] || "" }
     })
 
     const byCategory: Record<string, number> = {}
@@ -502,6 +719,9 @@ server.registerTool(
       byCategory[e.category] = (byCategory[e.category] || 0) + 1
     }
 
+    const withTtl = entries.filter((e) => e.ttl).length
+    const expired = entries.filter((e) => e.ttl && isExpired(e.ttl)).length
+
     const summaryLines = data.split("\n").filter((l) => l.includes(":") && !l.startsWith("  ") && !l.startsWith("version") && !l.startsWith("entries") && !/^\[\d+\|]/.test(l))
     const stats = [
       `Entradas totales: ${entries.length}`,
@@ -510,10 +730,13 @@ server.registerTool(
       "Por categoría:",
       ...Object.entries(byCategory).map(([k, v]) => `  ${k}: ${v}`),
       "",
+      `TTL: ${withTtl} con expiración, ${expired} expiradas`,
+      "",
       `Últimas 5 entradas:`,
       ...lines.slice(-5).map((l) => {
         const parts = l.trim().split("|")
-        return `  [${parts[1]}] ${parts[2]} (${parts[0]})`
+        const ttlInfo = parts[7] ? ` | TTL: ${parts[7]}` : ""
+        return `  [${parts[1]}] ${parts[2]} (${parts[0]})${ttlInfo}`
       }),
     ]
 
@@ -521,6 +744,99 @@ server.registerTool(
   }
 )
 
+/**
+ * Register the memory_diff tool.
+ * Show what changed in memory since a given date.
+ */
+server.registerTool(
+  "memory_diff",
+  {
+    title: "Memory Diff",
+    description: "Muestra qué cambió en la memoria desde una fecha. Útil para saber qué se aprendió desde la última sesión.",
+    inputSchema: {
+      since: z.string().describe("Desde cuándo mostrar cambios (ej: 24h, 7d, 2026-07-10)"),
+      type: z.enum(["all", "created", "updated"]).optional().default("all").describe("Filtrar por tipo de cambio"),
+    },
+  },
+  async ({ since, type }) => {
+    const sinceDate = parseRelativeDate(since)
+    const today = new Date().toISOString().split("T")[0]
+    const data = readMemory()
+    const lines = data.split("\n").filter((l) => l.startsWith("  ") && l.includes("|") && !l.startsWith("  summaries:"))
+
+    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 (date < sinceDate) return null
+        // For "updated" we check if date is recent but key existed before
+        // For simplicity: same date as today = created today, otherwise "updated" if date >= sinceDate
+        const changeType = date === today ? "created" : "updated"
+        if (type !== "all" && changeType !== type) return null
+        return { id, cat, key, content, file, tags, date, changeType }
+      })
+      .filter(Boolean)
+
+    if (results.length === 0) {
+      return { content: [{ type: "text" as const, text: `No hay cambios desde ${sinceDate}` }] }
+    }
+
+    const created = results.filter((r) => r!.changeType === "created")
+    const updated = results.filter((r) => r!.changeType === "updated")
+
+    const sections: string[] = [`📋 Cambios desde ${sinceDate}:`, ""]
+
+    if (created.length > 0 && (type === "all" || type === "created")) {
+      sections.push(`➕ Nuevas (${created.length}):`)
+      for (const r of created) {
+        sections.push(`  [${r!.cat}] ${r!.key} (${r!.id})\n    ${r!.content}`)
+      }
+      sections.push("")
+    }
+
+    if (updated.length > 0 && (type === "all" || type === "updated")) {
+      sections.push(`✏️  Actualizadas (${updated.length}):`)
+      for (const r of updated) {
+        sections.push(`  [${r!.cat}] ${r!.key} (${r!.id}) — ${r!.date}`)
+      }
+      sections.push("")
+    }
+
+    return { content: [{ type: "text" as const, text: sections.join("\n") }] }
+  }
+)
+
+/**
+ * Register the memory_suggest tool.
+ * Suggest related entries for a given text context.
+ */
+server.registerTool(
+  "memory_suggest",
+  {
+    title: "Suggest Related Memories",
+    description: "Sugiere entradas de memoria relacionadas con un contexto dado. Útil para obtener contexto antes de una tarea.",
+    inputSchema: {
+      context: z.string().describe("Texto o contexto para buscar sugerencias"),
+      limit: z.number().optional().default(5).describe("Máximo de sugerencias"),
+    },
+  },
+  async ({ context, limit }) => {
+    const related = findRelatedEntries(context, "", limit)
+
+    if (related.length === 0) {
+      return { content: [{ type: "text" as const, text: `No se encontraron entradas relacionadas con "${context}"` }] }
+    }
+
+    const formatted = related
+      .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: `🔍 Sugerencias para "${context}":\n\n${formatted}` }] }
+  }
+)
+
 /**
  * Register the memory_summary tool.
  * Get or set file summaries to save tokens when reading large files.

package/uninstall.sh

@@ -24,7 +24,7 @@ remove_from_config ".opencode/opencode.json"
 # VS Code
 remove_from_config ".vscode/mcp.json"
 
-# Claude
+# Claude Code
 remove_from_config "${HOME}/.claude/settings.json"
 remove_from_config ".claude/settings.json"
 
@@ -40,7 +40,28 @@ remove_from_config ".cline/mcp.json"
 # Continue
 remove_from_config ".continue/config.json"
 
-# Remove custom tools if they exist
+# Codex CLI
+remove_from_config ".codex/config.toml"
+
+# Gemini CLI
+remove_from_config ".gemini/settings.json"
+
+# Zed
+remove_from_config "${HOME}/.config/zed/settings.json"
+
+# Antigravity
+remove_from_config ".gemini/config/mcp_config.json"
+
+# KiloCode
+remove_from_config "${HOME}/.kilocode/mcp_settings.json"
+
+# OpenClaw
+remove_from_config ".openclaw.json"
+
+# Kiro
+remove_from_config ".kiro/settings/mcp.json"
+
+# Remove custom tools (legacy)
 if [ -d ".opencode/tools" ]; then
     if [ -f ".opencode/tools/memory.ts" ]; then
         echo "Removing custom tools..."
@@ -49,13 +70,20 @@ if [ -d ".opencode/tools" ]; then
     fi
 fi
 
+# Remove hook scripts
+if [ -d ".toon-memory/hooks" ]; then
+    echo "Removing hooks..."
+    rm -rf ".toon-memory/hooks"
+    echo "  ✅ Removed .toon-memory/hooks/"
+fi
+
 # Remove memory file (ask user)
-if [ -f ".opencode/memory/data.toon" ]; then
+if [ -f ".toon-memory/memory/data.toon" ]; then
     echo ""
-    read -p "Remove memory file (.opencode/memory/data.toon)? [y/N] " -n 1 -r
+    read -p "Remove memory file (.toon-memory/memory/)? [y/N] " -n 1 -r
     echo
     if [[ $REPLY =~ ^[Yy]$ ]]; then
-        rm -rf ".opencode/memory"
+        rm -rf ".toon-memory/memory"
         echo "  ✅ Removed memory directory"
     fi
 fi