toon-memory 1.6.9 → 1.8.0

package/mcp/server.js

@@ -27644,10 +27644,11 @@ import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 import { randomBytes, createCipheriv, createDecipheriv } from "crypto";
 var __dirname = dirname(fileURLToPath(import.meta.url));
-var MEMORY_DIR = join(process.cwd(), ".opencode", "memory");
+var MEMORY_DIR = join(process.cwd(), ".toon-memory", "memory");
 var MEMORY_FILE = join(MEMORY_DIR, "data.toon");
 var ARCHIVE_FILE = join(MEMORY_DIR, "archive.toon");
 var CONFIG_FILE = join(MEMORY_DIR, "config.json");
+var MAX_ENTRIES = 100;
 var ARCHIVE_DAYS = 30;
 var ALGORITHM = "aes-256-gcm";
 function loadConfig() {
@@ -27673,7 +27674,7 @@ function ensureMemoryDir() {
 function ensureMemoryFile() {
   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");
   }
 }
 function encrypt(text, key) {
@@ -27696,9 +27697,6 @@ function decrypt(encryptedData, key) {
   decrypted += decipher.final("utf8");
   return decrypted;
 }
-function generateKey() {
-  return randomBytes(32).toString("hex");
-}
 function readMemory() {
   ensureMemoryFile();
   const config2 = loadConfig();
@@ -27729,6 +27727,75 @@ function writeMemory(content) {
 function generateId() {
   return randomBytes(4).toString("hex");
 }
+function parseTTL(ttl) {
+  if (!ttl || !ttl.trim()) return "";
+  const trimmed = ttl.trim();
+  const dayMatch = trimmed.match(/^(\d+)d$/);
+  if (dayMatch) {
+    const days = parseInt(dayMatch[1]);
+    const d = /* @__PURE__ */ 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 "";
+}
+function isExpired(ttl) {
+  if (!ttl) return false;
+  const ttlDate = parseTTL(ttl) || ttl;
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return ttlDate <= today;
+}
+var TAG_VOCABULARY = {
+  "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"]
+};
+function inferTags(content, key) {
+  const text = `${key} ${content}`.toLowerCase();
+  const matched = [];
+  for (const [tag, keywords] of Object.entries(TAG_VOCABULARY)) {
+    if (keywords.some((kw) => text.includes(kw))) {
+      matched.push(tag);
+    }
+  }
+  return matched.join(";");
+}
+function parseRelativeDate(since) {
+  const trimmed = since.trim();
+  const hourMatch = trimmed.match(/^(\d+)h$/);
+  if (hourMatch) {
+    const d = /* @__PURE__ */ 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 = /* @__PURE__ */ 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 = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return today;
+}
 function archiveOldEntries() {
   const data = readMemory();
   const lines = data.split("\n");
@@ -27745,7 +27812,10 @@ function archiveOldEntries() {
     const parts = line.trim().split("|");
     if (parts.length >= 7) {
       const date5 = parts[6];
-      if (date5 < cutoffStr) {
+      const ttl = parts[7] || "";
+      const isOld = date5 < cutoffStr;
+      const isTtlExpired = ttl && isExpired(ttl);
+      if (isOld || isTtlExpired) {
         toArchive.push(line.trim());
       } else {
         toKeep.push(line.trim());
@@ -27795,10 +27865,11 @@ server.registerTool(
       key: external_exports.string().describe("T\xEDtulo corto en kebab-case (ej: risk-engine-prioridad)"),
       content: external_exports.string().describe("Contenido detallado del hecho"),
       file: external_exports.string().optional().default("").describe("Archivo o l\xEDnea relacionada (ej: spec.md:145)"),
-      tags: external_exports.string().optional().default("").describe("Tags separados por punto y coma (ej: risk;spec)")
+      tags: external_exports.string().optional().default("").describe("Tags separados por punto y coma (ej: risk;spec)"),
+      ttl: external_exports.string().optional().default("").describe("Time to live (ej: 7d, 2026-07-17). Vac\xEDo = sin expiraci\xF3n")
     }
   },
-  async ({ category, key, content, file: file2, tags }) => {
+  async ({ category, key, content, file: file2, tags, ttl }) => {
     const data = readMemory();
     const newId = generateId();
     const date5 = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
@@ -27822,8 +27893,11 @@ server.registerTool(
       }
     }
     const entryId = existingIdx !== -1 ? existingId : newId;
-    const newEntry = `${entryId}|${category}|${key}|${content}|${file2 || ""}|${tags || ""}|${date5}`;
+    const resolvedTtl = parseTTL(ttl);
+    const resolvedTags = tags ? tags : inferTags(content, key);
+    const newEntry = `${entryId}|${category}|${key}|${content}|${file2 || ""}|${resolvedTags}|${date5}|${resolvedTtl}`;
     let action = "Guardado";
+    const tagsInferred = !tags && resolvedTags ? true : false;
     if (existingIdx !== -1) {
       lines[existingIdx] = `  ${newEntry}`;
       action = "Actualizado";
@@ -27834,9 +27908,23 @@ server.registerTool(
       lines[headerIdx] = lines[headerIdx].replace(/\[\d+\|/, `[${count + 1}|`);
     }
     writeMemory(lines.join("\n"));
+    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 = `
+\u{1F4E6} Auto-archived ${result.archived} old entries (${result.kept} kept)`;
+      }
+    }
+    const ttlMsg = resolvedTtl ? `
+\u23F0 TTL: ${resolvedTtl}` : "";
+    const inferredMsg = tagsInferred ? `
+\u{1F3F7}\uFE0F Tags inferidos: ${resolvedTags}` : "";
     return {
       content: [{ type: "text", text: `\u{1F9E0} ${action}: ${category}/${key} (${entryId})
-${content}` }]
+${content}${ttlMsg}${inferredMsg}${archiveMsg}` }]
     };
   }
 );
@@ -27861,10 +27949,11 @@ server.registerTool(
       const trimmed = line.trim();
       const parts = trimmed.split("|");
       if (parts.length < 7) return null;
-      const [id, cat, key, content, file2, tags, date5] = parts;
+      const [id, cat, key, content, file2, tags, date5, ttl] = parts;
       if (category && cat !== category) return null;
       if (from_date && date5 < from_date) return null;
       if (to_date && date5 > to_date) return null;
+      if (ttl && isExpired(ttl)) return null;
       const searchStr = normalize(`${id} ${cat} ${key} ${content} ${file2} ${tags}`);
       if (!queryTokens.every((token) => searchStr.includes(token))) return null;
       return { id, cat, key, content, file: file2, tags, date: date5 };
@@ -27922,12 +28011,14 @@ 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 = {};
     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 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}`,
@@ -27936,15 +28027,67 @@ server.registerTool(
       "Por categor\xEDa:",
       ...Object.entries(byCategory).map(([k, v]) => `  ${k}: ${v}`),
       "",
+      `TTL: ${withTtl} con expiraci\xF3n, ${expired} expiradas`,
+      "",
       `\xDAltimas 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}`;
       })
     ];
     return { content: [{ type: "text", text: stats.join("\n") }] };
   }
 );
+server.registerTool(
+  "memory_diff",
+  {
+    title: "Memory Diff",
+    description: "Muestra qu\xE9 cambi\xF3 en la memoria desde una fecha. \xDAtil para saber qu\xE9 se aprendi\xF3 desde la \xFAltima sesi\xF3n.",
+    inputSchema: {
+      since: external_exports.string().describe("Desde cu\xE1ndo mostrar cambios (ej: 24h, 7d, 2026-07-10)"),
+      type: external_exports.enum(["all", "created", "updated"]).optional().default("all").describe("Filtrar por tipo de cambio")
+    }
+  },
+  async ({ since, type }) => {
+    const sinceDate = parseRelativeDate(since);
+    const today = (/* @__PURE__ */ 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, file2, tags, date5] = parts;
+      if (date5 < sinceDate) return null;
+      const changeType = date5 === today ? "created" : "updated";
+      if (type !== "all" && changeType !== type) return null;
+      return { id, cat, key, content, file: file2, tags, date: date5, changeType };
+    }).filter(Boolean);
+    if (results.length === 0) {
+      return { content: [{ type: "text", text: `No hay cambios desde ${sinceDate}` }] };
+    }
+    const created = results.filter((r) => r.changeType === "created");
+    const updated = results.filter((r) => r.changeType === "updated");
+    const sections = [`\u{1F4CB} Cambios desde ${sinceDate}:`, ""];
+    if (created.length > 0 && (type === "all" || type === "created")) {
+      sections.push(`\u2795 Nuevas (${created.length}):`);
+      for (const r of created) {
+        sections.push(`  [${r.cat}] ${r.key} (${r.id})
+    ${r.content}`);
+      }
+      sections.push("");
+    }
+    if (updated.length > 0 && (type === "all" || type === "updated")) {
+      sections.push(`\u270F\uFE0F  Actualizadas (${updated.length}):`);
+      for (const r of updated) {
+        sections.push(`  [${r.cat}] ${r.key} (${r.id}) \u2014 ${r.date}`);
+      }
+      sections.push("");
+    }
+    return { content: [{ type: "text", text: sections.join("\n") }] };
+  }
+);
 server.registerTool(
   "memory_summary",
   {
@@ -28025,18 +28168,16 @@ server.registerTool(
     if (config2.encrypted) {
       return { content: [{ type: "text", text: "La encriptaci\xF3n ya est\xE1 habilitada" }] };
     }
-    const key = generateKey();
+    const key = getKey();
+    if (!key) {
+      return { content: [{ type: "text", text: "\u274C Define TOON_MEMORY_KEY en el entorno antes de encriptar" }] };
+    }
     const data = readFileSync(MEMORY_FILE, "utf-8");
     const encrypted = encrypt(data, key);
     writeFileSync(MEMORY_FILE, encrypted);
     saveConfig({ encrypted: true });
     return {
-      content: [{
-        type: "text",
-        text: `\u{1F510} Encriptaci\xF3n habilitada
-\u26A0\uFE0F Guarda esta clave en TOON_MEMORY_KEY (no se puede recuperar):
-${key}`
-      }]
+      content: [{ type: "text", text: "\u{1F510} Encriptaci\xF3n habilitada" }]
     };
   }
 );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toon-memory",
-  "version": "1.6.9",
+  "version": "1.8.0",
   "description": "Persistent memory system for AI coding agents using TOON format (40% fewer tokens than JSON)",
   "type": "module",
   "bin": {
@@ -45,6 +45,14 @@
     "windsurf",
     "cline",
     "continue",
+    "codex",
+    "gemini",
+    "zed",
+    "antigravity",
+    "aider",
+    "kilocode",
+    "openclaw",
+    "kiro",
     "ai-agent",
     "memory",
     "toon",

package/skills/toon-memory.md

@@ -6,16 +6,23 @@ A persistent memory system for AI coding agents. It remembers decisions, pattern
 
 ## Supported Agents
 
-| Agent | Config File | Format |
-|-------|-------------|--------|
-| OpenCode | `.opencode/opencode.json` | MCP server |
-| VS Code / Copilot | `.vscode/mcp.json` | MCP server |
-| Claude | `.claude/settings.json` | MCP server |
-| Cursor | `.cursor/mcp.json` | MCP server |
-| Windsurf | `.windsurfrules` | MCP server |
-| Cline | `.cline/mcp.json` | MCP server |
-| Continue | `.continue/config.json` | MCP server |
-| Aider | `.aider.conf.yml` | Manual config |
+| Agent | Config File | Format | Hooks |
+|-------|-------------|--------|-------|
+| OpenCode | `.opencode/opencode.json` | MCP server | — |
+| VS Code / Copilot | `.vscode/mcp.json` | MCP server | — |
+| Claude Code | `.claude/settings.json` | MCP server | SessionStart |
+| Cursor | `.cursor/mcp.json` | MCP server | — |
+| Windsurf | `~/.codeium/windsurf/mcp_config.json` | MCP server | — |
+| Cline | `.cline/mcp.json` | MCP server | — |
+| Continue | `.continue/config.json` | MCP server | — |
+| Codex CLI | `.codex/config.toml` | TOML | SessionStart |
+| Gemini CLI | `.gemini/settings.json` | MCP server | SessionStart |
+| Zed | `~/.config/zed/settings.json` | JSONC | — |
+| Antigravity | `.gemini/config/mcp_config.json` | MCP server | SessionStart |
+| Aider | — | Instructions only | — |
+| KiloCode | `~/.kilocode/mcp_settings.json` | MCP server | — |
+| OpenClaw | `.openclaw.json` | MCP server | — |
+| Kiro | `.kiro/settings/mcp.json` | MCP server | — |
 
 ## Tools
 
@@ -26,6 +33,9 @@ A persistent memory system for AI coding agents. It remembers decisions, pattern
 | `memory_forget` | Remove an entry by key or id |
 | `memory_stats` | View memory state |
 | `memory_summary` | Save/retrieve file summaries |
+| `memory_archive` | Archive old entries |
+| `memory_encrypt` | Enable encryption |
+| `memory_decrypt` | Disable encryption |
 
 ## Installation
 
@@ -37,8 +47,9 @@ npx toon-memory
 
 This will:
 1. Detect installed agents
-2. Ask if you want local or global installation
-3. Configure the MCP server automatically
+2. Let you select which agents to configure
+3. Ask for local or global installation
+4. Configure MCP server, instructions, and hooks automatically
 
 ### Manual installation
 
@@ -71,7 +82,7 @@ Add to your agent's MCP config:
 ### When exploring the project
 
 1. First: `memory_recall(query="what you need to know")`
-2. If no result: use CodeGraph or grep
+2. If no result: use grep or search tools
 3. Only if both fail: read files directly
 
 ### At the END of every session
@@ -91,7 +102,7 @@ Add to your agent's MCP config:
 
 ## File format
 
-Data is stored in `.opencode/memory/data.toon` using TOON (Token-Oriented Object Notation):
+Data is stored in `.toon-memory/memory/data.toon` using TOON (Token-Oriented Object Notation):
 
 ```
 version: 1