superlocalmemory 2.3.5 → 2.3.7

package/CHANGELOG.md

@@ -16,6 +16,52 @@ SuperLocalMemory V2 - Intelligent local memory system for AI coding assistants.
 
 ---
 
+## [2.3.7] - 2026-02-09
+
+### Added
+- **--full flag**: Show complete memory content without truncation in search/list/recent/cluster commands
+- **Smart truncation**: Memories <5000 chars shown in full, ≥5000 chars truncated to 2000 chars (previously always truncated at 200 chars)
+- **Help text**: Added --full flag documentation to CLI help output
+
+### Fixed
+- **CLI bug**: Fixed `get` command error - `get_memory()` → `get_by_id()` method call
+- **Content display**: Recall now shows full content for short/medium memories instead of always truncating at 200 chars
+- **User experience**: Agents and users can now see complete memory content by default for most memories
+
+### Changed
+- **Truncation logic**: 200 char limit → 2000 char preview for memories ≥5000 chars
+- **Node.js wrappers**: memory-recall-skill.js and memory-list-skill.js updated to pass --full flag through
+
+### Technical Details
+- Added `format_content()` helper function in memory_store_v2.py (line 918)
+- Updated search/list/recent/cluster commands to use smart truncation
+- Backward compatible: same output structure, MCP/API calls unaffected
+- All 74+ existing memories tested: short memories show full, long memories truncate intelligently
+
+---
+
+## [2.3.5] - 2026-02-09
+
+### Added
+- **ChatGPT Connector Support**: `search(query)` and `fetch(id)` MCP tools per OpenAI spec
+- **Streamable HTTP transport**: `slm serve --transport streamable-http` for ChatGPT 2026+
+- **UI: Memory detail modal**: Click any memory row to see full content, tags, metadata
+- **UI: Dark mode toggle**: Sun/moon icon in navbar, saved to localStorage, respects system preference
+- **UI: Export buttons**: Export All (JSON/JSONL), Export Search Results, Export individual memory as Markdown
+- **UI: Search score bars**: Color-coded relevance bars (red/yellow/green) in search results
+- **UI: Animated stat counters**: Numbers animate up on page load with ease-out cubic
+- **UI: Loading spinners and empty states**: Professional feedback across all tabs
+- npm keywords: chatgpt, chatgpt-connector, openai, deep-research
+
+### Fixed
+- **XSS vulnerability**: Replaced inline onclick with JSON injection with safe event delegation
+- **UI: Content preview**: Increased from 80 to 100 characters
+
+### Changed
+- npm package now includes `ui/`, `ui_server.py`, `api_server.py`
+
+---
+
 ## [2.3.0] - 2026-02-08
 
 **Release Type:** Universal Integration Release

package/README.md

@@ -268,7 +268,7 @@ slm recall "API design patterns"
 | **OpenCode** | ✅ MCP | Native MCP tools |
 | **Perplexity** | ✅ MCP | Native MCP tools |
 | **Antigravity** | ✅ MCP + Skills | Native MCP tools |
-| **ChatGPT** | ✅ HTTP Transport | `slm serve` + tunnel |
+| **ChatGPT** | ✅ MCP Connector | `search()` + `fetch()` via HTTP tunnel |
 | **Aider** | ✅ Smart Wrapper | `aider-smart` with context |
 | **Any Terminal** | ✅ Universal CLI | `slm remember "content"` |
 

package/docs/ARCHITECTURE.md

@@ -85,13 +85,15 @@ Simple Storage → Intelligent Organization → Adaptive Learning
 
 The MCP server provides native integration with modern AI tools:
 
-**6 Tools:**
+**8 Tools:**
 - `remember(content, tags, project)` - Save memories
 - `recall(query, limit)` - Search memories
 - `list_recent(limit)` - Recent memories
 - `get_status()` - System status
 - `build_graph()` - Build knowledge graph
 - `switch_profile(name)` - Change profile
+- `search(query)` - Search memories (OpenAI MCP spec for ChatGPT Connectors)
+- `fetch(id)` - Fetch memory by ID (OpenAI MCP spec for ChatGPT Connectors)
 
 **4 Resources:**
 - `memory://recent` - Recent memories feed
@@ -106,6 +108,7 @@ The MCP server provides native integration with modern AI tools:
 **Transport Support:**
 - stdio (default) - For local IDE integration
 - HTTP - For remote/network access
+- streamable-http - For ChatGPT 2026+ Connectors
 
 **Key Design:** Zero duplication - calls existing `memory_store_v2.py` functions
 

package/docs/MCP-MANUAL-SETUP.md

@@ -390,34 +390,75 @@ PYTHONPATH = "/Users/yourusername/.claude-memory"
 
 ---
 
-### ChatGPT Desktop App
+### ChatGPT Desktop App / ChatGPT Connectors
 
-**Important:** ChatGPT requires HTTP transport, not stdio. You need to run a local HTTP server and expose it via a tunnel.
+**Important:** ChatGPT requires HTTP transport, not stdio. You need to run a local HTTP server and expose it via a tunnel. As of v2.3.5, SuperLocalMemory includes `search(query)` and `fetch(id)` MCP tools required by OpenAI's MCP spec for ChatGPT Connectors and Deep Research.
 
-**Steps:**
+**Requirements:**
+- ChatGPT Plus, Team, or Enterprise plan
+- **Developer Mode** must be enabled in ChatGPT settings
+- A tunnel tool: `cloudflared` (recommended, free) or `ngrok`
+- Reference: https://platform.openai.com/docs/mcp
+
+**Available Tools in ChatGPT:**
+
+| Tool | Purpose |
+|------|---------|
+| `search(query)` | Search memories (required by OpenAI MCP spec) |
+| `fetch(id)` | Fetch a specific memory by ID (required by OpenAI MCP spec) |
+| `remember(content, tags, project)` | Save a new memory |
+| `recall(query, limit)` | Search memories with full options |
+
+**Step-by-Step Setup:**
 
 1. **Start the MCP HTTP server:**
    ```bash
-   slm serve --port 8001
-   # or: python3 ~/.claude-memory/mcp_server.py --transport http --port 8001
+   slm serve --port 8417
+   # or with streamable-http transport (ChatGPT 2026+):
+   slm serve --port 8417 --transport streamable-http
+   # or using Python directly:
+   python3 ~/.claude-memory/mcp_server.py --transport http --port 8417
    ```
 
-2. **Expose via tunnel** (in another terminal):
+2. **Expose via cloudflared tunnel** (in another terminal):
    ```bash
-   ngrok http 8001
-   # or: cloudflared tunnel --url http://localhost:8001
-   ```
+   # Install cloudflared (if not installed)
+   # macOS: brew install cloudflared
+   # Linux: sudo apt install cloudflared
 
-3. **Copy the HTTPS URL** from ngrok/cloudflared output
-
-4. **Add to ChatGPT:**
-   - Open ChatGPT Desktop
-   - Go to **Settings → Apps & Connectors → Developer Mode**
-   - Add the HTTPS URL as an MCP endpoint
+   cloudflared tunnel --url http://localhost:8417
+   ```
+   Cloudflared will output a URL like `https://random-name.trycloudflare.com`
 
-5. In a new chat, look for MCP tools in the tool selector
+   **Alternative — ngrok:**
+   ```bash
+   ngrok http 8417
+   ```
 
-**Note:** 100% local — your MCP server runs on YOUR machine. The tunnel just makes it reachable by ChatGPT.
+3. **Copy the HTTPS URL** from cloudflared/ngrok output
+
+4. **Add to ChatGPT as a Connector:**
+   - Open ChatGPT (desktop or web)
+   - Go to **Settings → Connectors** (or **Settings → Apps & Connectors → Developer Mode**)
+   - Click **"Add Connector"**
+   - Paste the HTTPS URL with the `/sse/` suffix:
+     ```
+     https://random-name.trycloudflare.com/sse/
+     ```
+   - Name it: `SuperLocalMemory`
+   - Click **Save**
+
+5. **Verify in a new chat:**
+   - Start a new conversation in ChatGPT
+   - Look for the SuperLocalMemory connector in the tool selector
+   - Try: "Search my memories for authentication decisions"
+   - ChatGPT will call `search()` and return your local memories
+
+**Important Notes:**
+- The `/sse/` suffix on the URL is **required** by ChatGPT's MCP implementation
+- 100% local — your MCP server runs on YOUR machine. The tunnel just makes it reachable by ChatGPT. Your data is served on demand and never stored by OpenAI beyond the conversation.
+- The tunnel URL changes each time you restart cloudflared (unless you set up a named tunnel)
+- For persistent URLs, configure a cloudflared named tunnel: `cloudflared tunnel create slm`
 
 **Auto-configured by install.sh:** ❌ No (requires HTTP transport + tunnel)
 
@@ -690,7 +731,7 @@ In your IDE/app, check:
 
 ## Available MCP Tools
 
-Once configured, these 6 tools are available:
+Once configured, these 8 tools are available:
 
 | Tool | Purpose | Example Usage |
 |------|---------|---------------|
@@ -700,6 +741,10 @@ Once configured, these 6 tools are available:
 | `get_status()` | System health | "How many memories do I have?" |
 | `build_graph()` | Build knowledge graph | "Build the knowledge graph" |
 | `switch_profile()` | Change profile | "Switch to work profile" |
+| `search()` | Search memories (OpenAI MCP spec) | Used by ChatGPT Connectors and Deep Research |
+| `fetch()` | Fetch memory by ID (OpenAI MCP spec) | Used by ChatGPT Connectors and Deep Research |
+
+**Note:** `search()` and `fetch()` are required by OpenAI's MCP specification for ChatGPT Connectors. They are available in all transports but primarily used by ChatGPT.
 
 Plus **2 MCP prompts** and **4 MCP resources** for advanced use.
 

package/docs/UI-SERVER.md

@@ -22,7 +22,15 @@ Web-based visualization interface for exploring the SuperLocalMemory knowledge g
 - **Cluster Analysis**: Visual breakdown of thematic clusters with top entities
 - **Pattern Viewer**: Display learned preferences and coding styles
 - **Timeline**: Chart showing memory creation over time
-- **Statistics Dashboard**: Real-time system metrics
+- **Statistics Dashboard**: Real-time system metrics with animated stat counters (ease-out cubic on page load)
+- **Memory Detail Modal**: Click any memory row to see full content, metadata, and tags in an overlay modal
+- **Dark Mode Toggle**: Sun/moon icon in the navbar; preference saved to localStorage and respects system preference (`prefers-color-scheme`)
+- **Export Functionality**:
+  - **Export All**: Download entire memory database as JSON or JSONL
+  - **Export Search Results**: Export current search results to JSON
+  - **Export as Markdown**: Export an individual memory as a Markdown file
+- **Search Score Bars**: Color-coded relevance bars in search results (red for low, yellow for medium, green for high relevance)
+- **Loading Spinners and Empty States**: Professional loading feedback and informative empty states across all tabs
 
 ## Quick Start
 
@@ -242,9 +250,9 @@ This UI server is intended for **local development** only.
 
 - Add authentication for multi-user access
 - Implement real-time updates via WebSockets
-- Add export functionality (JSON, CSV)
 - Create memory editing interface
 - Build cluster visualization with hierarchical layout
+- Add CSV export format alongside existing JSON/JSONL/Markdown exports
 
 ## Support
 

package/docs/UNIVERSAL-INTEGRATION.md

@@ -231,6 +231,62 @@ aider-smart "Add authentication to the API"
 3. Passes context to Aider
 4. Aider gets relevant memories without you asking
 
+### ChatGPT (Connectors / Deep Research) ✅
+
+**How It Works:** HTTP transport with `search()` and `fetch()` MCP tools per OpenAI spec. Requires a tunnel to expose local server to ChatGPT.
+
+**Requirements:**
+- ChatGPT Plus, Team, or Enterprise plan
+- Developer Mode enabled in ChatGPT settings
+- `cloudflared` (recommended) or `ngrok` for tunneling
+- Reference: https://platform.openai.com/docs/mcp
+
+**Setup:**
+
+```bash
+# Terminal 1: Start MCP server
+slm serve --port 8417
+
+# Terminal 2: Start tunnel
+cloudflared tunnel --url http://localhost:8417
+```
+
+Then in ChatGPT:
+1. Go to **Settings → Connectors**
+2. Click **"Add Connector"**
+3. Paste the HTTPS URL from cloudflared with `/sse/` suffix:
+   ```
+   https://random-name.trycloudflare.com/sse/
+   ```
+4. Name it `SuperLocalMemory` and save
+
+**Available Tools in ChatGPT:**
+
+| Tool | Purpose |
+|------|---------|
+| `search(query)` | Search memories (required by OpenAI MCP spec) |
+| `fetch(id)` | Fetch a specific memory by ID (required by OpenAI MCP spec) |
+| `remember(content, tags, project)` | Save a new memory |
+| `recall(query, limit)` | Search memories with full options |
+
+**Usage Examples:**
+```
+User: "Search my memories for database decisions"
+ChatGPT: [calls search("database decisions")]
+→ Returns matching memories from your local database
+
+User: "What's memory #42 about?"
+ChatGPT: [calls fetch(42)]
+→ Returns full content, tags, and metadata for memory 42
+```
+
+**Notes:**
+- 100% local — your data is served on demand and never stored beyond the conversation
+- The tunnel URL changes on restart unless you configure a named cloudflared tunnel
+- For streamable-http transport (ChatGPT 2026+): `slm serve --port 8417 --transport streamable-http`
+
+---
+
 ### Any Terminal / Script ✅
 
 **How It Works:** Universal CLI wrapper

package/hooks/context-hook.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+/**
+ * SuperLocalMemory V2 - Session Start Context Hook
+ * Copyright (c) 2026 Varun Pratap Bhardwaj
+ * Licensed under MIT License
+ *
+ * Loads recent memories and learned patterns on Claude Code session start.
+ * Outputs context to stderr (Claude Code reads hook stderr as context).
+ * Fails gracefully — never blocks session start if DB is missing or errors occur.
+ */
+
+const { execFile } = require('child_process');
+const { promisify } = require('util');
+const path = require('path');
+const fs = require('fs');
+
+const execFileAsync = promisify(execFile);
+
+const MEMORY_DIR = path.join(process.env.HOME, '.claude-memory');
+const DB_PATH = path.join(MEMORY_DIR, 'memory.db');
+const MEMORY_SCRIPT = path.join(MEMORY_DIR, 'memory_store_v2.py');
+
+async function loadSessionContext() {
+  // Fail gracefully if not installed
+  if (!fs.existsSync(DB_PATH)) {
+    return;
+  }
+
+  if (!fs.existsSync(MEMORY_SCRIPT)) {
+    return;
+  }
+
+  try {
+    // Get stats (memory_store_v2.py stats → JSON output)
+    const { stdout: statsOutput } = await execFileAsync('python3', [
+      MEMORY_SCRIPT, 'stats'
+    ], { timeout: 5000 });
+
+    // Get recent memories (memory_store_v2.py list <limit>)
+    const { stdout: recentOutput } = await execFileAsync('python3', [
+      MEMORY_SCRIPT, 'list', '5'
+    ], { timeout: 5000 });
+
+    // Build context output
+    let context = '';
+
+    if (statsOutput && statsOutput.trim()) {
+      try {
+        const stats = JSON.parse(statsOutput.trim());
+        const total = stats.total_memories || 0;
+        const clusters = stats.total_clusters || 0;
+        if (total > 0) {
+          context += 'SuperLocalMemory: ' + total + ' memories, ' + clusters + ' clusters loaded.\n';
+        }
+      } catch (e) {
+        // Stats output wasn't JSON — use first line as-is
+        context += 'SuperLocalMemory: ' + statsOutput.trim().split('\n')[0] + '\n';
+      }
+    }
+
+    if (context) {
+      process.stderr.write(context);
+    }
+  } catch (error) {
+    // Never fail — session start must not be blocked
+    // Silently ignore errors (timeout, missing python, etc.)
+  }
+}
+
+loadSessionContext();

package/hooks/memory-list-skill.js

@@ -34,6 +34,7 @@ Options:
                          • recent: Latest created first (default)
                          • accessed: Most recently accessed
                          • importance: Highest importance first
+  --full                 Show complete content without truncation
 
 Examples:
   memory-list
@@ -42,17 +43,17 @@ Examples:
 
   memory-list --sort importance
 
-  memory-list --limit 10 --sort accessed
+  memory-list --limit 10 --sort accessed --full
 
 Output Format:
-  • ID, Content (truncated), Tags, Importance
+  • ID, Content (smart truncated), Tags, Importance
   • Creation timestamp
   • Access count and last accessed time
 
 Notes:
   • Default shows last 20 memories
-  • Content is truncated to 100 chars for readability
-  • Use ID with memory-recall to see full content
+  • Smart truncation: full content if <5000 chars, preview if ≥5000 chars
+  • Use --full flag to always show complete content
   • Sort by 'accessed' to find frequently used memories
 `);
     return;
@@ -61,6 +62,7 @@ Notes:
   // Parse options
   let limit = 20;
   let sortBy = 'recent';
+  let showFull = false;
 
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -83,6 +85,8 @@ Notes:
         return;
       }
       i++;
+    } else if (arg === '--full') {
+      showFull = true;
     }
   }
 
@@ -97,6 +101,11 @@ Notes:
     pythonArgs = ['list', limit.toString()];
   }
 
+  // Add --full flag if requested
+  if (showFull) {
+    pythonArgs.push('--full');
+  }
+
   try {
     const { stdout, stderr } = await execFileAsync('python3', [memoryScript, ...pythonArgs]);
 

package/hooks/memory-recall-skill.js

@@ -33,13 +33,14 @@ Arguments:
 
 Options:
   --limit <n>            Maximum results to return (default: 10)
+  --full                 Show complete content without truncation
 
 Examples:
   memory-recall "authentication bug"
 
   memory-recall "API configuration" --limit 5
 
-  memory-recall "security best practices"
+  memory-recall "security best practices" --full
 
   memory-recall "user preferences"
 
@@ -47,6 +48,8 @@ Output Format:
   • Ranked by relevance (TF-IDF cosine similarity)
   • Shows: ID, Content, Tags, Importance, Timestamp
   • Higher scores = better matches
+  • Smart truncation: full content if <5000 chars, preview if ≥5000 chars
+  • Use --full flag to always show complete content
 
 Notes:
   • Uses local TF-IDF search (no external APIs)
@@ -67,6 +70,8 @@ Notes:
     if (arg === '--limit' && i + 1 < args.length) {
       // Note: V1 store doesn't support --limit in search, will truncate output instead
       i++; // Skip but don't add to pythonArgs
+    } else if (arg === '--full') {
+      pythonArgs.push('--full');
     } else if (!arg.startsWith('--') && query === null) {
       query = arg;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlocalmemory",
-  "version": "2.3.5",
+  "version": "2.3.7",
   "description": "Your AI Finally Remembers You - Local-first intelligent memory system for AI assistants. Works with Claude, Cursor, Windsurf, VS Code/Copilot, Codex, and 16+ AI tools. 100% local, zero cloud dependencies.",
   "keywords": [
     "ai-memory",

package/src/memory_store_v2.py

@@ -915,6 +915,25 @@ class MemoryStoreV2:
         return ''.join(output)
 
 
+def format_content(content: str, full: bool = False, threshold: int = 5000, preview_len: int = 2000) -> str:
+    """
+    Smart content formatting with optional truncation.
+
+    Args:
+        content: Content to format
+        full: If True, always show full content
+        threshold: Max length before truncation (default 5000)
+        preview_len: Preview length when truncating (default 2000)
+
+    Returns:
+        Formatted content string
+    """
+    if full or len(content) < threshold:
+        return content
+    else:
+        return f"{content[:preview_len]}..."
+
+
 # CLI interface (V1 compatible + V2 extensions)
 if __name__ == "__main__":
     import sys
@@ -925,16 +944,18 @@ if __name__ == "__main__":
         print("MemoryStore V2 CLI")
         print("\nV1 Compatible Commands:")
         print("  python memory_store_v2.py add <content> [--project <path>] [--tags tag1,tag2]")
-        print("  python memory_store_v2.py search <query>")
-        print("  python memory_store_v2.py list [limit]")
+        print("  python memory_store_v2.py search <query> [--full]")
+        print("  python memory_store_v2.py list [limit] [--full]")
         print("  python memory_store_v2.py get <id>")
-        print("  python memory_store_v2.py recent [limit]")
+        print("  python memory_store_v2.py recent [limit] [--full]")
         print("  python memory_store_v2.py stats")
         print("  python memory_store_v2.py context <query>")
         print("  python memory_store_v2.py delete <id>")
         print("\nV2 Extensions:")
         print("  python memory_store_v2.py tree [parent_id]")
-        print("  python memory_store_v2.py cluster <cluster_id>")
+        print("  python memory_store_v2.py cluster <cluster_id> [--full]")
+        print("\nOptions:")
+        print("  --full    Show complete content (default: smart truncation at 5000 chars)")
         sys.exit(0)
 
     command = sys.argv[1]
@@ -954,6 +975,7 @@ if __name__ == "__main__":
 
     elif command == "cluster" and len(sys.argv) >= 3:
         cluster_id = int(sys.argv[2])
+        show_full = '--full' in sys.argv
         results = store.get_by_cluster(cluster_id)
 
         if not results:
@@ -962,7 +984,7 @@ if __name__ == "__main__":
             print(f"Cluster {cluster_id} - {len(results)} memories:")
             for r in results:
                 print(f"\n[{r['id']}] Importance: {r['importance']}")
-                print(f"  {r['content'][:200]}...")
+                print(f"  {format_content(r['content'], full=show_full)}")
 
     elif command == "stats":
         stats = store.get_stats()
@@ -996,10 +1018,11 @@ if __name__ == "__main__":
     elif command == "search":
         if len(sys.argv) < 3:
             print("Error: Search query required")
-            print("Usage: python memory_store_v2.py search <query>")
+            print("Usage: python memory_store_v2.py search <query> [--full]")
             sys.exit(1)
 
         query = sys.argv[2]
+        show_full = '--full' in sys.argv
         results = store.search(query, limit=5)
 
         if not results:
@@ -1011,11 +1034,18 @@ if __name__ == "__main__":
                     print(f"Project: {r['project_name']}")
                 if r.get('tags'):
                     print(f"Tags: {', '.join(r['tags'])}")
-                print(f"Content: {r['content'][:200]}...")
+                print(f"Content: {format_content(r['content'], full=show_full)}")
                 print(f"Created: {r['created_at']}")
 
     elif command == "recent":
-        limit = int(sys.argv[2]) if len(sys.argv) > 2 else 10
+        show_full = '--full' in sys.argv
+        # Parse limit (skip --full flag)
+        limit = 10
+        for i, arg in enumerate(sys.argv[2:], start=2):
+            if arg != '--full' and arg.isdigit():
+                limit = int(arg)
+                break
+
         results = store.get_recent(limit)
 
         if not results:
@@ -1027,17 +1057,24 @@ if __name__ == "__main__":
                     print(f"Project: {r['project_name']}")
                 if r.get('tags'):
                     print(f"Tags: {', '.join(r['tags'])}")
-                print(f"Content: {r['content'][:200]}...")
+                print(f"Content: {format_content(r['content'], full=show_full)}")
 
     elif command == "list":
-        limit = int(sys.argv[2]) if len(sys.argv) > 2 else 10
+        show_full = '--full' in sys.argv
+        # Parse limit (skip --full flag)
+        limit = 10
+        for i, arg in enumerate(sys.argv[2:], start=2):
+            if arg != '--full' and arg.isdigit():
+                limit = int(arg)
+                break
+
         results = store.get_recent(limit)
 
         if not results:
             print("No memories found.")
         else:
             for r in results:
-                print(f"[{r['id']}] {r['content'][:100]}...")
+                print(f"[{r['id']}] {format_content(r['content'], full=show_full)}")
 
     elif command == "get":
         if len(sys.argv) < 3:
@@ -1046,7 +1083,7 @@ if __name__ == "__main__":
             sys.exit(1)
 
         mem_id = int(sys.argv[2])
-        memory = store.get_memory(mem_id)
+        memory = store.get_by_id(mem_id)
 
         if not memory:
             print(f"Memory {mem_id} not found.")