superlocalmemory 2.8.6 → 3.0.0

package/ide/hooks/memory-reset-skill.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+/**
+ * Memory Reset CLI Skill (V3)
+ * Provides /memory-reset command with safety warnings
+ */
+
+const { execFile } = require('child_process');
+const { promisify } = require('util');
+const readline = require('readline');
+
+const execFileAsync = promisify(execFile);
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+const question = (query) => new Promise((resolve) => rl.question(query, resolve));
+
+async function memoryResetSkill() {
+  const args = process.argv.slice(2);
+
+  // Show help if no args
+  if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+    console.log(`
+SuperLocalMemory V3 - Reset Commands
+
+Usage: /memory-reset <command> [options]
+
+Commands:
+  status              Show current memory system status (SAFE)
+  soft                Clear all memories, keep schema (DESTRUCTIVE)
+  hard --confirm      Delete everything, reinitialize (NUCLEAR)
+
+Examples:
+  /memory-reset status
+  /memory-reset soft
+  /memory-reset hard --confirm
+
+WARNING: soft/hard operations create automatic backups
+         but will delete data. Always check status first!
+`);
+    rl.close();
+    return;
+  }
+
+  const command = args[0];
+
+  // STATUS command (safe, no warnings)
+  if (command === 'status') {
+    try {
+      const { stdout } = await execFileAsync('python3', [
+        '-m', 'superlocalmemory.cli.main', 'status'
+      ]);
+      console.log(stdout);
+    } catch (error) {
+      console.error('Error:', error.message);
+    }
+    rl.close();
+    return;
+  }
+
+  // SOFT RESET command (destructive, show warning)
+  if (command === 'soft') {
+    console.log(`
+WARNING: SOFT RESET
+
+This will:
+  - Delete ALL memories from current profile
+  - Clear graph data (nodes, edges, clusters)
+  - Clear learned patterns
+  - Create automatic backup before deletion
+  - Keep V3 schema structure intact
+
+Backup location: ~/.superlocalmemory/backups/pre-reset-[timestamp].db
+`);
+
+    const answer = await question('Proceed with soft reset? (yes/no): ');
+
+    if (answer.toLowerCase() === 'yes') {
+      try {
+        const { stdout } = await execFileAsync('python3', [
+          '-m', 'superlocalmemory.cli.main', 'reset', 'soft'
+        ]);
+        console.log(stdout);
+      } catch (error) {
+        console.error('Error:', error.message);
+      }
+    } else {
+      console.log('\nCancelled. No changes made.');
+    }
+
+    rl.close();
+    return;
+  }
+
+  // HARD RESET command (nuclear, extra warnings)
+  if (command === 'hard') {
+    if (!args.includes('--confirm')) {
+      console.log(`
+Error: Hard reset requires --confirm flag
+
+HARD RESET is DESTRUCTIVE and will:
+  - Delete the ENTIRE database file
+  - Remove ALL memories permanently
+  - Remove ALL graph data permanently
+  - Remove ALL learned patterns permanently
+
+To proceed, use:
+  /memory-reset hard --confirm
+`);
+      rl.close();
+      return;
+    }
+
+    console.log(`
+DANGER: HARD RESET
+
+This will:
+  - DELETE the entire database file (memory.db)
+  - DESTROY all memories (cannot undo within system)
+  - ERASE all graph relationships
+  - REMOVE all learned patterns
+  - Reinitialize fresh V3 schema
+
+Backup location: ~/.superlocalmemory/backups/pre-reset-[timestamp].db
+`);
+
+    const answer = await question('Type "DELETE EVERYTHING" to confirm: ');
+
+    if (answer === 'DELETE EVERYTHING') {
+      try {
+        const { stdout } = await execFileAsync('python3', [
+          '-m', 'superlocalmemory.cli.main', 'reset', 'hard', '--confirm'
+        ]);
+        console.log(stdout);
+      } catch (error) {
+        console.error('Error:', error.message);
+      }
+    } else {
+      console.log('\nCancelled. No changes made.');
+      console.log('(You must type exactly "DELETE EVERYTHING" to confirm)');
+    }
+
+    rl.close();
+    return;
+  }
+
+  // Unknown command
+  console.log(`
+Unknown command: ${command}
+
+Valid commands: status, soft, hard
+
+Use: /memory-reset --help for more information
+`);
+  rl.close();
+}
+
+memoryResetSkill();

package/{hooks → ide/hooks}/post-recall-hook.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * SuperLocalMemory V2 - Post-Recall Hook (v2.7.4)
+ * SuperLocalMemory V3 - Post-Recall Hook
  * Copyright (c) 2026 Varun Pratap Bhardwaj
  * Licensed under MIT License
  *
@@ -16,7 +16,7 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
-const MEMORY_DIR = path.join(os.homedir(), '.claude-memory');
+const MEMORY_DIR = path.join(os.homedir(), '.superlocalmemory');
 const HOOK_LOG = path.join(MEMORY_DIR, 'recall-events.jsonl');
 
 // Parse input from Claude Code hook system

package/ide/integrations/langchain/README.md

@@ -0,0 +1,106 @@
+# langchain-superlocalmemory
+
+LangChain chat message history backed by [SuperLocalMemory V2](https://github.com/varun369/SuperLocalMemoryV2) -- 100% local, zero cloud.
+
+Every message stays on your machine in a SQLite database. No API keys, no subscriptions, no telemetry.
+
+## Prerequisites
+
+- Python 3.10+
+- [SuperLocalMemory V2](https://github.com/varun369/SuperLocalMemoryV2) installed (`~/.claude-memory/` must exist)
+- `langchain-core >= 1.0.0`
+
+## Installation
+
+```bash
+pip install langchain-superlocalmemory
+```
+
+Or install from source:
+
+```bash
+cd integrations/langchain
+pip install -e .
+```
+
+## Quick Start
+
+```python
+from langchain_core.messages import AIMessage, HumanMessage
+from langchain_superlocalmemory import SuperLocalMemoryChatMessageHistory
+
+# Create a history for a conversation session
+history = SuperLocalMemoryChatMessageHistory(session_id="my-chat-session")
+
+# Add messages
+history.add_messages([
+    HumanMessage(content="What is SuperLocalMemory?"),
+    AIMessage(content="It's a local-first memory system for AI assistants."),
+])
+
+# Retrieve messages (chronological order)
+for msg in history.messages:
+    print(f"{msg.type}: {msg.content}")
+
+# Clear the session
+history.clear()
+```
+
+## Features
+
+- **Local-first storage** -- all data stays in `~/.claude-memory/memory.db`
+- **Session isolation** -- each `session_id` is completely independent
+- **Full LangChain compatibility** -- implements `BaseChatMessageHistory`
+- **Persistent across restarts** -- SQLite-backed, survives process exit
+- **Works alongside SLM** -- messages are queryable via CLI, MCP, Skills, and REST API
+- **All message types** -- HumanMessage, AIMessage, SystemMessage, FunctionMessage, ToolMessage
+- **additional_kwargs preserved** -- metadata round-trips through serialization
+
+## Multi-Session Example
+
+```python
+from langchain_superlocalmemory import SuperLocalMemoryChatMessageHistory
+
+# Two independent conversations
+support = SuperLocalMemoryChatMessageHistory(session_id="support-ticket-42")
+coding = SuperLocalMemoryChatMessageHistory(session_id="code-review-pr-99")
+
+# Messages are isolated -- support session cannot see coding session
+support.add_messages([HumanMessage(content="My app is crashing")])
+coding.add_messages([HumanMessage(content="Review this PR please")])
+
+assert len(support.messages) == 1
+assert len(coding.messages) == 1
+```
+
+## Custom Database Path
+
+By default the package uses `~/.claude-memory/memory.db`. You can point to a different database:
+
+```python
+history = SuperLocalMemoryChatMessageHistory(
+    session_id="my-session",
+    db_path="/path/to/custom/memory.db",
+)
+```
+
+## How It Works
+
+Each LangChain message is stored as an individual memory entry in SuperLocalMemory V2:
+
+- **Content**: JSON-serialized message (type, content, additional_kwargs)
+- **Tags**: `["langchain", "langchain:session:<session_id>"]`
+- **Importance**: 3 (lower than user memories, so chat history does not crowd search results)
+- **Project**: `"langchain"`
+
+This means your LangChain conversations are visible in the SLM dashboard, searchable via `slm recall`, and accessible from any SLM-integrated tool.
+
+## License
+
+MIT -- see [LICENSE](../../LICENSE) for details.
+
+## Links
+
+- [SuperLocalMemory V2 Repository](https://github.com/varun369/SuperLocalMemoryV2)
+- [Documentation](https://superlocalmemory.com/)
+- [LangChain Documentation](https://python.langchain.com/)

package/ide/integrations/langchain/langchain_superlocalmemory/__init__.py

@@ -0,0 +1,9 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+from langchain_superlocalmemory.chat_message_history import (
+    SuperLocalMemoryChatMessageHistory,
+)
+
+__all__ = ["SuperLocalMemoryChatMessageHistory"]
+__version__ = "0.1.0"

package/ide/integrations/langchain/langchain_superlocalmemory/chat_message_history.py

@@ -0,0 +1,201 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""SuperLocalMemory V2 - LangChain Chat Message History
+
+Implements LangChain's BaseChatMessageHistory backed by SuperLocalMemory V2's
+local SQLite storage. All data stays on your machine -- zero cloud, zero telemetry.
+
+Usage:
+    from langchain_superlocalmemory import SuperLocalMemoryChatMessageHistory
+
+    history = SuperLocalMemoryChatMessageHistory(session_id="my-session")
+    history.add_messages([HumanMessage(content="Hello")])
+    print(history.messages)
+"""
+import json
+import sys
+from pathlib import Path
+from typing import List, Optional, Sequence
+
+from langchain_core.chat_history import BaseChatMessageHistory
+from langchain_core.messages import (
+    AIMessage,
+    BaseMessage,
+    FunctionMessage,
+    HumanMessage,
+    SystemMessage,
+    ToolMessage,
+    message_to_dict,
+    messages_from_dict,
+)
+
+# ---------------------------------------------------------------------------
+# MemoryStoreV2 import strategy
+# ---------------------------------------------------------------------------
+# SuperLocalMemory V2 installs to ~/.claude-memory/. We add that path so
+# the MemoryStoreV2 class can be imported. If SLM is not installed, we
+# raise a clear error at construction time (not import time) so the package
+# itself can still be imported for introspection.
+# ---------------------------------------------------------------------------
+
+_SLM_PATH = Path.home() / ".claude-memory"
+_MemoryStoreV2 = None
+
+
+def _ensure_slm_imported():
+    """Lazily import MemoryStoreV2, raising a clear error if unavailable."""
+    global _MemoryStoreV2
+    if _MemoryStoreV2 is not None:
+        return _MemoryStoreV2
+
+    slm_path_str = str(_SLM_PATH)
+    if slm_path_str not in sys.path:
+        sys.path.insert(0, slm_path_str)
+
+    try:
+        from memory_store_v2 import MemoryStoreV2  # type: ignore[import-untyped]
+
+        _MemoryStoreV2 = MemoryStoreV2
+        return _MemoryStoreV2
+    except ImportError as exc:
+        raise ImportError(
+            "SuperLocalMemory V2 is not installed. "
+            "Run the installer from https://github.com/varun369/SuperLocalMemoryV2 "
+            "or ensure ~/.claude-memory/memory_store_v2.py exists."
+        ) from exc
+
+
+# ---------------------------------------------------------------------------
+# Message (de)serialization helpers
+# ---------------------------------------------------------------------------
+
+# Map from LangChain message type string to the concrete class used for
+# deserialization. LangChain's own `messages_from_dict` handles this, but we
+# keep a lookup for the fallback path in case the dict format diverges.
+
+_MESSAGE_TYPE_MAP = {
+    "human": HumanMessage,
+    "ai": AIMessage,
+    "system": SystemMessage,
+    "function": FunctionMessage,
+    "tool": ToolMessage,
+}
+
+
+def _serialize_message(message: BaseMessage) -> str:
+    """Serialize a LangChain BaseMessage to a JSON string for SLM storage."""
+    return json.dumps(message_to_dict(message), ensure_ascii=False)
+
+
+def _deserialize_messages(dicts: List[dict]) -> List[BaseMessage]:
+    """Deserialize a list of message dicts back to BaseMessage instances.
+
+    Uses LangChain's ``messages_from_dict`` which handles all known message
+    types including ``additional_kwargs``.
+    """
+    return messages_from_dict(dicts)
+
+
+# ---------------------------------------------------------------------------
+# Main class
+# ---------------------------------------------------------------------------
+
+
+class SuperLocalMemoryChatMessageHistory(BaseChatMessageHistory):
+    """LangChain chat message history backed by SuperLocalMemory V2.
+
+    Each message is stored as an individual memory entry in the SLM SQLite
+    database, tagged with the session ID for isolation.  This keeps the data
+    fully local and queryable via any SLM access method (MCP, CLI, Skills,
+    REST API).
+
+    Parameters
+    ----------
+    session_id : str
+        Unique identifier for the conversation session.  Messages from
+        different session IDs are completely isolated.
+    db_path : str or None
+        Path to the SQLite database file.  Defaults to
+        ``~/.claude-memory/memory.db``.
+    """
+
+    # Tag prefix used to isolate LangChain session messages inside SLM.
+    _TAG_PREFIX = "langchain:session:"
+
+    def __init__(self, session_id: str, db_path: Optional[str] = None) -> None:
+        self.session_id = session_id
+        self.db_path = db_path
+
+        MemoryStoreV2 = _ensure_slm_imported()
+        store_path = Path(db_path) if db_path else None
+        self._store = MemoryStoreV2(db_path=store_path)
+
+    # -- property: messages ------------------------------------------------
+
+    @property
+    def messages(self) -> List[BaseMessage]:  # type: ignore[override]
+        """Return all messages for this session, ordered chronologically."""
+        session_tag = f"{self._TAG_PREFIX}{self.session_id}"
+
+        # Retrieve a generous batch from SLM.  We filter by tag in Python
+        # because list_all does not accept a tag filter parameter.
+        all_memories = self._store.list_all(limit=10_000)
+
+        # Filter to memories belonging to this session.
+        session_memories = [
+            m for m in all_memories if session_tag in (m.get("tags") or [])
+        ]
+
+        # list_all returns newest-first (ORDER BY created_at DESC).
+        # We need chronological (oldest-first) order for chat history.
+        session_memories.sort(key=lambda m: m.get("created_at", ""))
+
+        # Deserialize each memory's content back to a BaseMessage.
+        message_dicts: List[dict] = []
+        for mem in session_memories:
+            try:
+                parsed = json.loads(mem["content"])
+                message_dicts.append(parsed)
+            except (json.JSONDecodeError, KeyError, TypeError):
+                # Skip malformed entries silently -- they may be non-LangChain
+                # memories that happen to share the tag pattern.
+                continue
+
+        if not message_dicts:
+            return []
+
+        return _deserialize_messages(message_dicts)
+
+    # -- add_messages ------------------------------------------------------
+
+    def add_messages(self, messages: Sequence[BaseMessage]) -> None:
+        """Persist messages to SuperLocalMemory V2.
+
+        Each message becomes a separate memory entry tagged with the session
+        identifier.  Importance is set to 3 (lower than typical user
+        memories at 5) so LangChain history does not crowd out higher-value
+        entries in search results.
+        """
+        session_tag = f"{self._TAG_PREFIX}{self.session_id}"
+
+        for message in messages:
+            serialized = _serialize_message(message)
+            self._store.add_memory(
+                content=serialized,
+                tags=["langchain", session_tag],
+                importance=3,
+                project_name="langchain",
+            )
+
+    # -- clear -------------------------------------------------------------
+
+    def clear(self) -> None:
+        """Remove all messages for this session from the store."""
+        session_tag = f"{self._TAG_PREFIX}{self.session_id}"
+
+        all_memories = self._store.list_all(limit=10_000)
+
+        for mem in all_memories:
+            if session_tag in (mem.get("tags") or []):
+                self._store.delete_memory(mem["id"])

package/ide/integrations/langchain/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "langchain-superlocalmemory"
+version = "0.1.0"
+description = "LangChain chat message history backed by SuperLocalMemory — 100% local, zero cloud"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "Varun Pratap Bhardwaj" },
+]
+keywords = ["langchain", "memory", "local-first", "privacy", "sqlite", "chat-history", "mcp"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "langchain-core>=1.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/varun369/SuperLocalMemoryV2"
+Documentation = "https://superlocalmemory.com/"
+Repository = "https://github.com/varun369/SuperLocalMemoryV2"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

package/{src/learning → ide/integrations/langchain}/tests/__init__.py

@@ -1,2 +1,3 @@
+#!/usr/bin/env python3
 # SPDX-License-Identifier: MIT
 # Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)