toon-memory 1.0.8 → 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Luis Angel Valencia Valera
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,220 @@
+# toon-memory
+
+Persistent memory for AI coding agents — remember decisions, patterns, and bugs between sessions.
+
+🎉 **1.0 Released!**
+
+Supercharge **OpenCode, VS Code Copilot, Claude Code, Cursor, Windsurf, Cline, Continue** and more with Persistent Memory
+
+Saves context in **TOON format** (40% fewer tokens than JSON) · 5 MCP tools · Works everywhere
+
+[![npm version](https://img.shields.io/npm/v/toon-memory.svg)](https://www.npmjs.com/package/toon-memory)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+---
+
+## What is toon-memory?
+
+AI agents forget everything between sessions. toon-memory fixes this by providing persistent memory that survives restarts.
+
+**Use cases:**
+- Remember design decisions ("Why did we choose X over Y?")
+- Track patterns ("This project uses Zod for validation")
+- Store bug resolutions ("Redis pool exhaustion fix")
+- Save project knowledge ("Broker uses RESP protocol")
+
+---
+
+## Get Started
+
+### 1. Install (one command)
+
+```bash
+# macOS / Linux
+curl -fsSL https://raw.githubusercontent.com/LuiggiVal08/toon-memory/main/install.sh | sh
+
+# Windows (PowerShell)
+irm https://raw.githubusercontent.com/LuiggiVal08/toon-memory/main/install.ps1 | iex
+
+# Or with npm (any platform)
+npm i -g toon-memory
+```
+
+### 2. Configure your agent(s)
+
+```bash
+# Interactive installer — detects agents and configures MCP
+npx toon-memory
+```
+
+### 3. Use it
+
+```bash
+# In your next session, run:
+memory_stats      # See what's in memory
+memory_recall     # Search memory before reading files
+memory_remember   # Save important decisions
+```
+
+---
+
+## Supported Agents
+
+| Agent | Config Location | Status |
+|-------|-----------------|--------|
+| **OpenCode** | `.opencode/opencode.json` | ✅ Full support |
+| **VS Code / Copilot** | `.vscode/mcp.json` | ✅ Full support |
+| **Claude Code** | `.claude/settings.json` | ✅ Full support |
+| **Cursor** | `.cursor/mcp.json` | ✅ Full support |
+| **Windsurf** | `.windsurfrules` | ✅ Full support |
+| **Cline** | `.cline/mcp.json` | ✅ Full support |
+| **Continue** | `.continue/config.json` | ✅ Full support |
+| **Aider** | `.aider.conf.yml` | ⚠️ Manual config |
+
+---
+
+## 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
+
+1. **MCP Server** — runs locally, talks to your agent via stdio
+2. **TOON Format** — stores data in Token-Oriented Object Notation (~40% fewer tokens than JSON)
+3. **Per-project memory** — each project gets `.opencode/memory/data.toon`
+4. **Zero config** — just install and use
+
+### Memory File Format
+
+```
+version: 1
+entries[3|]{id|category|key|content|file|tags|date}:
+  a1b2c3d4|decision|use-zod|Use Zod for validation|src/types.ts|validation;types|2026-07-10
+  e5f6g7h8|pattern|pydantic-configs|Project uses Pydantic v2|config.py|python;patterns|2026-07-10
+  i9j0k1l2|bug|redis-pool-fix|Added max_connections=20|redis.ts|redis;fix|2026-07-10
+summaries:
+  src/services/redis.ts: Redis connection pool with retry logic
+```
+
+---
+
+## CLI Commands
+
+```bash
+npx toon-memory          # Interactive installer
+npx toon-memory init     # Quick setup (no prompts)
+npx toon-memory mcp      # Run MCP server directly
+npx toon-memory status   # Check installation status
+npx toon-memory upgrade  # Update to latest version
+npx toon-memory uninstall # Remove from all agents
+```
+
+---
+
+## Uninstall
+
+```bash
+# Remove from all agents and uninstall CLI
+npx toon-memory uninstall
+
+# Or with the global install
+toon-memory uninstall
+```
+
+---
+
+## Configuration
+
+### Global (all projects)
+
+Add to `~/.config/opencode/opencode.json`:
+
+```json
+{
+  "mcp": {
+    "toon-memory": {
+      "type": "local",
+      "command": ["npx", "-y", "toon-memory", "mcp"],
+      "enabled": true
+    }
+  }
+}
+```
+
+### Project-level
+
+Add to `.opencode/opencode.json`:
+
+```json
+{
+  "mcp": {
+    "toon-memory": {
+      "type": "local",
+      "command": ["npx", "-y", "toon-memory", "mcp"],
+      "enabled": true
+    }
+  }
+}
+```
+
+### VS Code
+
+Add to `.vscode/mcp.json`:
+
+```json
+{
+  "servers": {
+    "toon-memory": {
+      "command": "npx",
+      "args": ["-y", "toon-memory", "mcp"]
+    }
+  }
+}
+```
+
+---
+
+## Why TOON?
+
+TOON (Token-Oriented Object Notation) is designed for LLMs:
+
+| Format | Token Count | LLM Accuracy |
+|--------|-------------|--------------|
+| JSON | 100 | 75% |
+| YAML | 95 | 72% |
+| **TOON** | **60** | **76.4%** |
+
+- **40% fewer tokens** than JSON
+- **Lossless roundtrip** — no data loss
+- **Better LLM comprehension** — structured for AI consumption
+
+---
+
+## Development
+
+```bash
+git clone https://github.com/LuiggiVal08/toon-memory.git
+cd toon-memory
+npm install
+npm run build
+```
+
+---
+
+## License
+
+MIT
+
+---
+
+## Credits
+
+Built with [@toon-format/toon](https://www.npmjs.com/package/@toon-format/toon) and [@modelcontextprotocol/server](https://www.npmjs.com/package/@modelcontextprotocol/server).

package/bin/setup.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { existsSync, mkdirSync, readFileSync, writeFileSync, cpSync } from "fs"
+import { existsSync, mkdirSync, readFileSync, writeFileSync, cpSync, unlinkSync } from "fs"
 import { dirname, join } from "path"
 import { fileURLToPath } from "url"
 import { execSync } from "child_process"
@@ -9,7 +9,7 @@ import { createRequire } from "module"
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const projectRoot = process.cwd()
 const sourceDir = join(__dirname, "..", "src")
-const HOME = process.env.HOME || "~"
+const HOME = process.env.HOME || process.env.USERPROFILE || "~"
 
 // Auto-install @toon-format/toon if not present
 try {
@@ -26,89 +26,62 @@ function detectAgents() {
   // OpenCode
   const opencodeGlobal = join(HOME, ".config", "opencode", "opencode.json")
   const opencodeLocal = join(projectRoot, ".opencode", "opencode.json")
-  if (existsSync(opencodeGlobal) || existsSync(opencodeLocal) || true) { // Always show opencode
-    agents.push({ 
-      name: "opencode", 
-      global: opencodeGlobal, 
-      local: opencodeLocal,
-      mcpKey: "mcp"
-    })
-  }
+  agents.push({ 
+    name: "opencode", 
+    global: opencodeGlobal, 
+    local: opencodeLocal,
+    mcpKey: "mcp"
+  })
   
   // VS Code / GitHub Copilot
   const vscodeLocal = join(projectRoot, ".vscode", "mcp.json")
-  const vscodeGlobal = join(HOME, ".config", "Code", "User", "globalStorage", "github.copilot-chat", "mcp.json")
-  if (existsSync(vscodeLocal) || existsSync(vscodeGlobal) || true) {
-    agents.push({ 
-      name: "vscode/copilot", 
-      global: vscodeGlobal, 
-      local: vscodeLocal,
-      mcpKey: "servers"
-    })
-  }
+  agents.push({ 
+    name: "vscode/copilot", 
+    local: vscodeLocal,
+    mcpKey: "servers"
+  })
   
   // Claude Code
   const claudeGlobal = join(HOME, ".claude", "settings.json")
   const claudeLocal = join(projectRoot, ".claude", "settings.json")
-  if (existsSync(claudeGlobal) || existsSync(claudeLocal)) {
-    agents.push({ 
-      name: "claude", 
-      global: claudeGlobal, 
-      local: claudeLocal,
-      mcpKey: "mcpServers"
-    })
-  }
+  agents.push({ 
+    name: "claude", 
+    global: claudeGlobal, 
+    local: claudeLocal,
+    mcpKey: "mcpServers"
+  })
   
   // Cursor
   const cursorLocal = join(projectRoot, ".cursor", "mcp.json")
-  if (existsSync(cursorLocal)) {
-    agents.push({ 
-      name: "cursor", 
-      local: cursorLocal,
-      mcpKey: "mcpServers"
-    })
-  }
+  agents.push({ 
+    name: "cursor", 
+    local: cursorLocal,
+    mcpKey: "mcpServers"
+  })
   
   // Windsurf
-  const windsurfLocal = join(projectRoot, ".windsurfrules")
   const windsurfGlobal = join(HOME, ".codeium", "windsurf", "mcp_config.json")
-  if (existsSync(windsurfLocal) || existsSync(windsurfGlobal)) {
-    agents.push({ 
-      name: "windsurf", 
-      global: windsurfGlobal, 
-      local: windsurfLocal,
-      mcpKey: "mcpServers"
-    })
-  }
+  agents.push({ 
+    name: "windsurf", 
+    global: windsurfGlobal,
+    mcpKey: "mcpServers"
+  })
   
   // Cline
   const clineLocal = join(projectRoot, ".cline", "mcp.json")
-  if (existsSync(clineLocal)) {
-    agents.push({ 
-      name: "cline", 
-      local: clineLocal,
-      mcpKey: "mcpServers"
-    })
-  }
+  agents.push({ 
+    name: "cline", 
+    local: clineLocal,
+    mcpKey: "mcpServers"
+  })
   
   // Continue
   const continueLocal = join(projectRoot, ".continue", "config.json")
-  if (existsSync(continueLocal)) {
-    agents.push({ 
-      name: "continue", 
-      local: continueLocal,
-      mcpKey: "mcpServers"
-    })
-  }
-  
-  // Aider
-  const aiderLocal = join(projectRoot, ".aider.conf.yml")
-  if (existsSync(aiderLocal)) {
-    agents.push({ 
-      name: "aider", 
-      local: aiderLocal
-    })
-  }
+  agents.push({ 
+    name: "continue", 
+    local: continueLocal,
+    mcpKey: "mcpServers"
+  })
   
   return agents
 }
@@ -152,44 +125,171 @@ function installMCPConfig(agent, scope) {
     }
   }
   
-  const mcpKey = agent.mcpKey || "mcp"
+  const mcpKey = agent.mcpKey || "mcpServers"
   if (!config[mcpKey]) config[mcpKey] = {}
   
-  // Different agents use different config formats
-  if (agent.name === "vscode/copilot") {
-    config[mcpKey]["toon-memory"] = {
-      command: "npx",
-      args: ["-y", "toon-memory", "mcp"],
-      env: {}
+  config[mcpKey]["toon-memory"] = {
+    command: "npx",
+    args: ["-y", "toon-memory", "mcp"]
+  }
+  
+  writeFileSync(configPath, JSON.stringify(config, null, 2))
+  console.log(`  MCP server added to ${configPath}`)
+}
+
+// Uninstall from all agents
+function uninstall() {
+  console.log("\n🧠 toon-memory uninstaller\n")
+  
+  const agents = detectAgents()
+  
+  for (const agent of agents) {
+    const configs = [agent.global, agent.local].filter(Boolean)
+    
+    for (const configPath of configs) {
+      if (!existsSync(configPath)) continue
+      
+      try {
+        const config = JSON.parse(readFileSync(configPath, "utf-8"))
+        const mcpKey = agent.mcpKey || "mcpServers"
+        
+        if (config[mcpKey]?.["toon-memory"]) {
+          delete config[mcpKey]["toon-memory"]
+          writeFileSync(configPath, JSON.stringify(config, null, 2))
+          console.log(`  ✅ Removed from ${agent.name} (${configPath})`)
+        }
+      } catch {}
     }
-  } else if (agent.name === "aider") {
-    // Aider uses YAML, skip JSON config
-    console.log(`  ${agent.name}: Add to .aider.conf.yml:`)
-    console.log(`    mcp Servers:\n      toon-memory:\n        command: npx\n        args: ["-y", "toon-memory", "mcp"]`)
-    return
+  }
+  
+  // Remove custom tools
+  const toolsFile = join(projectRoot, ".opencode", "tools", "memory.ts")
+  if (existsSync(toolsFile)) {
+    unlinkSync(toolsFile)
+    console.log("  ✅ Removed .opencode/tools/memory.ts")
+  }
+  
+  console.log("\n✅ toon-memory uninstalled from all agents\n")
+}
+
+// Quick init without interactive prompts
+function init(scope = "local") {
+  console.log("\n🧠 toon-memory init\n")
+  
+  const agents = detectAgents()
+  
+  for (const agent of agents) {
+    console.log(`${agent.name}:`)
+    
+    if (agent.name === "opencode") {
+      installOpenCodeTools()
+    }
+    
+    installMCPConfig(agent, scope)
+    console.log("")
+  }
+  
+  console.log("Done! Restart your agent to use memory tools.\n")
+}
+
+// Show installation status
+function status() {
+  console.log("\n🧠 toon-memory status\n")
+  
+  // Check npm package
+  try {
+    const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"))
+    console.log(`Version: ${pkg.version}`)
+  } catch {
+    console.log("Version: unknown")
+  }
+  
+  // Check memory file
+  const memoryFile = join(projectRoot, ".opencode", "memory", "data.toon")
+  if (existsSync(memoryFile)) {
+    const data = readFileSync(memoryFile, "utf-8")
+    const lines = data.split("\n").filter((l) => l.startsWith("  ") && l.includes("|"))
+    console.log(`Memory: ${lines.length} entries`)
   } else {
-    config[mcpKey]["toon-memory"] = {
-      command: "npx",
-      args: ["-y", "toon-memory", "mcp"]
+    console.log("Memory: not initialized")
+  }
+  
+  // Check agent configs
+  const agents = detectAgents()
+  console.log("\nAgent configs:")
+  
+  for (const agent of agents) {
+    const configs = [agent.global, agent.local].filter(Boolean)
+    let found = false
+    
+    for (const configPath of configs) {
+      if (!existsSync(configPath)) continue
+      
+      try {
+        const config = JSON.parse(readFileSync(configPath, "utf-8"))
+        const mcpKey = agent.mcpKey || "mcpServers"
+        
+        if (config[mcpKey]?.["toon-memory"]) {
+          console.log(`  ✅ ${agent.name} (${configPath})`)
+          found = true
+        }
+      } catch {}
+    }
+    
+    if (!found) {
+      console.log(`  ❌ ${agent.name} (not configured)`)
     }
   }
   
-  writeFileSync(configPath, JSON.stringify(config, null, 2))
-  console.log(`  MCP server added to ${configPath}`)
+  console.log("")
+}
+
+// Upgrade to latest version
+function upgrade() {
+  console.log("\n🧠 toon-memory upgrade\n")
+  
+  try {
+    console.log("Checking for updates...")
+    const latest = execSync("npm view toon-memory version", { encoding: "utf-8" }).trim()
+    console.log(`Latest version: ${latest}`)
+    
+    console.log("Upgrading...")
+    execSync("npm install -g toon-memory@" + latest, { stdio: "inherit" })
+    
+    console.log("\n✅ Upgraded to toon-memory@" + latest)
+    console.log("Restart your agent to use the new version.\n")
+  } catch (error) {
+    console.error("Upgrade failed:", error.message)
+  }
 }
 
 // Main
-const agents = detectAgents()
-console.log("\n🧠 toon-memory installer\n")
+const args = process.argv.slice(2)
+
+if (args[0] === "uninstall") {
+  uninstall()
+  process.exit(0)
+}
 
-if (agents.length === 0) {
-  console.log("No supported agents detected. Installing custom tools...")
-  installOpenCodeTools()
-  console.log("\nDone! Restart your agent to use memory tools.")
+if (args[0] === "init") {
+  init(args[1] || "local")
   process.exit(0)
 }
 
-console.log("Detected/supported agents:")
+if (args[0] === "status") {
+  status()
+  process.exit(0)
+}
+
+if (args[0] === "upgrade") {
+  upgrade()
+  process.exit(0)
+}
+
+const agents = detectAgents()
+console.log("\n🧠 toon-memory installer\n")
+
+console.log("Supported agents:")
 agents.forEach((a, i) => console.log(`  ${i + 1}. ${a.name}`))
 console.log("")
 
@@ -210,5 +310,6 @@ rl.question("Install (1) Local or (2) Global? [1/2]: ", (answer) => {
   }
   
   console.log("Done! Restart your agent to use memory tools.")
+  console.log("Run 'npx toon-memory uninstall' to remove.\n")
   rl.close()
 })

package/install.ps1

@@ -0,0 +1,62 @@
+# toon-memory installer for Windows (PowerShell)
+# Usage: irm https://raw.githubusercontent.com/LuiggiVal08/toon-memory/main/install.ps1 | iex
+
+$TOON_VERSION = "1.0.9"
+
+Write-Host "🧠 toon-memory installer" -ForegroundColor Cyan
+Write-Host ""
+
+# Check if npm is available
+if (Get-Command npm -ErrorAction SilentlyContinue) {
+    Write-Host "Installing toon-memory via npm..."
+    npm install -g toon-memory@$TOON_VERSION
+    Write-Host ""
+    Write-Host "✅ toon-memory installed!" -ForegroundColor Green
+    Write-Host ""
+    Write-Host "Next steps:"
+    Write-Host "  1. Run: npx toon-memory"
+    Write-Host "  2. Select your agent(s)"
+    Write-Host "  3. Choose local or global install"
+    Write-Host ""
+} else {
+    Write-Host "npm not found. Installing standalone..." -ForegroundColor Yellow
+    Write-Host ""
+    
+    # Create installation directory
+    $INSTALL_DIR = "$env:USERPROFILE\.toon-memory"
+    New-Item -ItemType Directory -Force -Path $INSTALL_DIR | Out-Null
+    
+    # Download the package
+    Write-Host "Downloading toon-memory v$TOON_VERSION..."
+    $url = "https://registry.npmjs.org/toon-memory/-/toon-memory-$TOON_VERSION.tgz"
+    $tgzPath = "$INSTALL_DIR\toon-memory.tgz"
+    Invoke-WebRequest -Uri $url -OutFile $tgzPath
+    
+    # Extract
+    cd $INSTALL_DIR
+    tar xzf toon-memory.tgz
+    Move-Item -Path "package\*" -Destination "." -Force
+    Remove-Item -Path "package" -Recurse -Force
+    Remove-Item -Path $tgzPath -Force
+    
+    # Create launcher script
+    $launcherContent = @"
+`$SCRIPT_DIR = Split-Path -Parent `$MyInvocation.MyCommand.Path
+node "`$SCRIPT_DIR\bin\toon-memory.js" @args
+"@
+    Set-Content -Path "$INSTALL_DIR\toon-memory.ps1" -Value $launcherContent
+    
+    # Add to PATH if not already there
+    $currentPath = [Environment]::GetEnvironmentVariable("Path", "User")
+    if ($currentPath -notlike "*$INSTALL_DIR*") {
+        [Environment]::SetEnvironmentVariable("Path", "$INSTALL_DIR;$currentPath", "User")
+        Write-Host "Added to PATH"
+    }
+    
+    Write-Host ""
+    Write-Host "✅ toon-memory installed to $INSTALL_DIR" -ForegroundColor Green
+    Write-Host ""
+    Write-Host "⚠️  Open a new PowerShell window, then run:"
+    Write-Host "  toon-memory.ps1"
+    Write-Host ""
+}

package/install.sh

@@ -0,0 +1,75 @@
+#!/bin/bash
+set -e
+
+# toon-memory installer for macOS/Linux
+# Usage: curl -fsSL https://raw.githubusercontent.com/luiggival/toon-memory/main/install.sh | sh
+
+TOON_VERSION="1.0.8"
+NPM_REGISTRY="https://registry.npmjs.org"
+
+echo "🧠 toon-memory installer"
+echo ""
+
+# Check if npm is available
+if command -v npm &> /dev/null; then
+    echo "Installing toon-memory via npm..."
+    npm install -g toon-memory@${TOON_VERSION}
+    echo ""
+    echo "✅ toon-memory installed!"
+    echo ""
+    echo "Next steps:"
+    echo "  1. Run: npx toon-memory"
+    echo "  2. Select your agent(s)"
+    echo "  3. Choose local or global install"
+    echo ""
+else
+    echo "npm not found. Installing standalone..."
+    echo ""
+    
+    # Create installation directory
+    INSTALL_DIR="${HOME}/.toon-memory"
+    mkdir -p "${INSTALL_DIR}"
+    
+    # Download the package
+    echo "Downloading toon-memory v${TOON_VERSION}..."
+    curl -fsSL "https://registry.npmjs.org/toon-memory/-/toon-memory-${TOON_VERSION}.tgz" -o "${INSTALL_DIR}/toon-memory.tgz"
+    
+    # Extract
+    cd "${INSTALL_DIR}"
+    tar xzf toon-memory.tgz
+    mv package/* .
+    rmdir package
+    rm toon-memory.tgz
+    
+    # Create launcher script
+    cat > "${INSTALL_DIR}/toon-memory" << 'LAUNCHER'
+#!/bin/bash
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+node "${SCRIPT_DIR}/bin/toon-memory.js" "$@"
+LAUNCHER
+    chmod +x "${INSTALL_DIR}/toon-memory"
+    
+    # Add to PATH if not already there
+    SHELL_RC=""
+    if [ -f "${HOME}/.bashrc" ]; then
+        SHELL_RC="${HOME}/.bashrc"
+    elif [ -f "${HOME}/.zshrc" ]; then
+        SHELL_RC="${HOME}/.zshrc"
+    fi
+    
+    if [ -n "${SHELL_RC}" ]; then
+        if ! grep -q "${INSTALL_DIR}" "${SHELL_RC}" 2>/dev/null; then
+            echo "" >> "${SHELL_RC}"
+            echo "# toon-memory" >> "${SHELL_RC}"
+            echo "export PATH=\"${INSTALL_DIR}:\$PATH\"" >> "${SHELL_RC}"
+            echo "Added to PATH in ${SHELL_RC}"
+        fi
+    fi
+    
+    echo ""
+    echo "✅ toon-memory installed to ${INSTALL_DIR}"
+    echo ""
+    echo "⚠️  Open a new terminal, then run:"
+    echo "  toon-memory"
+    echo ""
+fi

package/mcp/server.js

@@ -623,7 +623,7 @@ function $constructor(name, initializer3, params) {
   Object.defineProperty(_, "name", { value: name });
   return _;
 }
-var $brand = /* @__PURE__ */ Symbol("zod_brand");
+var $brand = Symbol("zod_brand");
 var $ZodAsyncError = class extends Error {
   constructor() {
     super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
@@ -10366,8 +10366,8 @@ function yo_default() {
 
 // node_modules/zod/v4/core/registries.js
 var _a2;
-var $output = /* @__PURE__ */ Symbol("ZodOutput");
-var $input = /* @__PURE__ */ Symbol("ZodInput");
+var $output = Symbol("ZodOutput");
+var $input = Symbol("ZodInput");
 var $ZodRegistry = class {
   constructor() {
     this._map = /* @__PURE__ */ new WeakMap();
@@ -21148,14 +21148,14 @@ var Ajv = import_ajv.Ajv;
 import process3 from "node:process";
 
 // node_modules/@modelcontextprotocol/server/dist/mcp-CM8J1mhp.mjs
-var COMPLETABLE_SYMBOL = /* @__PURE__ */ Symbol.for("mcp.completable");
+var COMPLETABLE_SYMBOL = Symbol.for("mcp.completable");
 function isCompletable(schema) {
   return !!schema && typeof schema === "object" && COMPLETABLE_SYMBOL in schema;
 }
 function getCompleter(schema) {
   return schema[COMPLETABLE_SYMBOL]?.complete;
 }
-var BRANDS = /* @__PURE__ */ Symbol.for("mcp.sdk.errorBrands");
+var BRANDS = Symbol.for("mcp.sdk.errorBrands");
 function stampErrorBrands(instance, ctor) {
   const brands = /* @__PURE__ */ new Set();
   let current = ctor;
@@ -22468,7 +22468,7 @@ var CACHEABLE_RESULT_METHODS = [
 function isCacheableResultMethod(method) {
   return CACHEABLE_RESULT_METHODS.includes(method);
 }
-var RESULT_CACHE_HINT_FALLBACK = /* @__PURE__ */ Symbol("modelcontextprotocol.resultCacheHintFallback");
+var RESULT_CACHE_HINT_FALLBACK = Symbol("modelcontextprotocol.resultCacheHintFallback");
 function attachCacheHintFallback(result, hint) {
   if (hint === void 0) return result;
   const attached = result[RESULT_CACHE_HINT_FALLBACK];
@@ -27664,7 +27664,7 @@ function generateId() {
   return randomBytes(4).toString("hex");
 }
 var server = new McpServer(
-  { name: "toon-memory", version: "1.0.8" },
+  { name: "toon-memory", version: "1.1.0" },
   { capabilities: { tools: { listChanged: true } } }
 );
 server.registerTool(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toon-memory",
-  "version": "1.0.8",
+  "version": "1.1.0",
   "description": "Persistent memory system for AI coding agents using TOON format (40% fewer tokens than JSON)",
   "type": "module",
   "bin": {
@@ -10,13 +10,23 @@
     "src/",
     "bin/",
     "mcp/",
-    "skills/"
+    "skills/",
+    "install.sh",
+    "install.ps1",
+    "uninstall.sh"
   ],
+  "scripts": {
+    "build": "esbuild src/mcp/server.ts --bundle --platform=node --format=esm --outfile=mcp/server.js",
+    "prepublishOnly": "npm run build"
+  },
   "dependencies": {
     "@modelcontextprotocol/server": "^2.0.0-beta.3",
     "@toon-format/toon": "^2.3.0",
     "zod": "^4.4.3"
   },
+  "devDependencies": {
+    "esbuild": "^0.25.0"
+  },
   "keywords": [
     "opencode",
     "vscode",
@@ -33,5 +43,14 @@
     "llm",
     "token-efficiency"
   ],
-  "license": "MIT"
+  "author": "luiggival",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/luiggival/toon-memory.git"
+  },
+  "homepage": "https://github.com/luiggival/toon-memory#readme",
+  "bugs": {
+    "url": "https://github.com/luiggival/toon-memory/issues"
+  }
 }

package/src/mcp/server.ts

@@ -32,7 +32,7 @@ function generateId(): string {
 }
 
 const server = new McpServer(
-  { name: "toon-memory", version: "1.0.8" },
+  { name: "toon-memory", version: "1.1.0" },
   { capabilities: { tools: { listChanged: true } } }
 )
 

package/uninstall.sh

@@ -0,0 +1,107 @@
+#!/bin/bash
+set -e
+
+# toon-memory uninstaller
+# Usage: npx toon-memory uninstall
+
+echo "🧠 toon-memory uninstaller"
+echo ""
+
+# Remove from OpenCode
+OPENCODE_GLOBAL="${HOME}/.config/opencode/opencode.json"
+OPENCODE_LOCAL=".opencode/opencode.json"
+
+remove_from_config() {
+    local file="$1"
+    local name="$2"
+    
+    if [ -f "${file}" ]; then
+        if grep -q "toon-memory" "${file}" 2>/dev/null; then
+            echo "Removing from ${name} (${file})..."
+            # Use node to remove the MCP entry
+            node -e "
+                const fs = require('fs');
+                const config = JSON.parse(fs.readFileSync('${file}', 'utf-8'));
+                if (config.mcp && config.mcp['toon-memory']) {
+                    delete config.mcp['toon-memory'];
+                    fs.writeFileSync('${file}', JSON.stringify(config, null, 2));
+                    console.log('  ✅ Removed');
+                } else if (config.mcpServers && config.mcpServers['toon-memory']) {
+                    delete config.mcpServers['toon-memory'];
+                    fs.writeFileSync('${file}', JSON.stringify(config, null, 2));
+                    console.log('  ✅ Removed');
+                } else {
+                    console.log('  ⚠️  Not found');
+                }
+            " 2>/dev/null || echo "  ⚠️  Could not parse config"
+        fi
+    fi
+}
+
+# OpenCode
+remove_from_config "${OPENCODE_GLOBAL}" "OpenCode (global)"
+remove_from_config "${OPENCODE_LOCAL}" "OpenCode (local)"
+
+# VS Code
+remove_from_config ".vscode/mcp.json" "VS Code"
+
+# Claude
+remove_from_config "${HOME}/.claude/settings.json" "Claude (global)"
+remove_from_config ".claude/settings.json" "Claude (local)"
+
+# Cursor
+remove_from_config ".cursor/mcp.json" "Cursor"
+
+# Cline
+remove_from_config ".cline/mcp.json" "Cline"
+
+# Continue
+remove_from_config ".continue/config.json" "Continue"
+
+# Remove custom tools if they exist
+if [ -d ".opencode/tools" ]; then
+    if [ -f ".opencode/tools/memory.ts" ]; then
+        echo "Removing custom tools..."
+        rm -f ".opencode/tools/memory.ts"
+        echo "  ✅ Removed memory.ts"
+    fi
+fi
+
+# Remove memory file (ask user)
+if [ -f ".opencode/memory/data.toon" ]; then
+    echo ""
+    read -p "Remove memory file (.opencode/memory/data.toon)? [y/N] " -n 1 -r
+    echo
+    if [[ $REPLY =~ ^[Yy]$ ]]; then
+        rm -rf ".opencode/memory"
+        echo "  ✅ Removed memory directory"
+    fi
+fi
+
+# Uninstall npm package
+echo ""
+read -p "Uninstall toon-memory CLI? [y/N] " -n 1 -r
+echo
+if [[ $REPLY =~ ^[Yy]$ ]]; then
+    if command -v npm &> /dev/null; then
+        npm uninstall -g toon-memory 2>/dev/null && echo "  ✅ Uninstalled from npm" || echo "  ⚠️  Not installed via npm"
+    fi
+    
+    # Remove standalone install
+    if [ -d "${HOME}/.toon-memory" ]; then
+        rm -rf "${HOME}/.toon-memory"
+        echo "  ✅ Removed standalone install"
+    fi
+    
+    # Remove from PATH in shell configs
+    for rc in "${HOME}/.bashrc" "${HOME}/.zshrc"; do
+        if [ -f "${rc}" ] && grep -q "toon-memory" "${rc}" 2>/dev/null; then
+            sed -i '/# toon-memory/d;/.toon-memory/d' "${rc}"
+            echo "  ✅ Cleaned ${rc}"
+        fi
+    done
+fi
+
+echo ""
+echo "✅ toon-memory uninstalled"
+echo ""