superlocalmemory 2.8.6 → 3.0.0

package/ide/integrations/langchain/tests/test_chat_message_history.py

@@ -0,0 +1,215 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""SuperLocalMemory V2 - LangChain Chat Message History Tests
+
+Functional tests for SuperLocalMemoryChatMessageHistory.
+All tests use a temporary database -- the user's real memory is never touched.
+"""
+import os
+import tempfile
+
+import pytest
+from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
+
+from langchain_superlocalmemory import SuperLocalMemoryChatMessageHistory
+
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture
+def tmp_db():
+    """Yield a path to a temporary SQLite database that is cleaned up after use."""
+    with tempfile.TemporaryDirectory() as d:
+        db = os.path.join(d, "test_memory.db")
+        yield db
+
+
+@pytest.fixture
+def history(tmp_db):
+    """Return a fresh history instance bound to the temp DB."""
+    return SuperLocalMemoryChatMessageHistory(session_id="test-session", db_path=tmp_db)
+
+
+# ---------------------------------------------------------------------------
+# Tests
+# ---------------------------------------------------------------------------
+
+
+def test_add_single_human_message(tmp_db):
+    """A single HumanMessage can be added and retrieved."""
+    h = SuperLocalMemoryChatMessageHistory(session_id="s1", db_path=tmp_db)
+    h.add_messages([HumanMessage(content="Hello, world!")])
+
+    msgs = h.messages
+    assert len(msgs) == 1
+    assert isinstance(msgs[0], HumanMessage)
+    assert msgs[0].content == "Hello, world!"
+
+
+def test_add_single_ai_message(tmp_db):
+    """A single AIMessage can be added and retrieved."""
+    h = SuperLocalMemoryChatMessageHistory(session_id="s1", db_path=tmp_db)
+    h.add_messages([AIMessage(content="I am an AI.")])
+
+    msgs = h.messages
+    assert len(msgs) == 1
+    assert isinstance(msgs[0], AIMessage)
+    assert msgs[0].content == "I am an AI."
+
+
+def test_add_multiple_messages(tmp_db):
+    """A batch of three messages is stored and all are retrievable."""
+    h = SuperLocalMemoryChatMessageHistory(session_id="s1", db_path=tmp_db)
+    h.add_messages([
+        HumanMessage(content="Hi"),
+        AIMessage(content="Hello"),
+        HumanMessage(content="How are you?"),
+    ])
+
+    msgs = h.messages
+    assert len(msgs) == 3
+    assert msgs[0].content == "Hi"
+    assert msgs[1].content == "Hello"
+    assert msgs[2].content == "How are you?"
+
+
+def test_messages_order(tmp_db):
+    """Messages are returned in chronological (insertion) order."""
+    h = SuperLocalMemoryChatMessageHistory(session_id="s1", db_path=tmp_db)
+
+    h.add_messages([HumanMessage(content="first")])
+    h.add_messages([AIMessage(content="second")])
+    h.add_messages([HumanMessage(content="third")])
+
+    msgs = h.messages
+    assert [m.content for m in msgs] == ["first", "second", "third"]
+
+
+def test_message_roundtrip(tmp_db):
+    """A HumanMessage with additional_kwargs survives serialization."""
+    h = SuperLocalMemoryChatMessageHistory(session_id="s1", db_path=tmp_db)
+
+    original = HumanMessage(
+        content="Test with kwargs",
+        additional_kwargs={"custom_key": "custom_value", "number": 42},
+    )
+    h.add_messages([original])
+
+    msgs = h.messages
+    assert len(msgs) == 1
+    assert msgs[0].content == "Test with kwargs"
+    assert msgs[0].additional_kwargs.get("custom_key") == "custom_value"
+    assert msgs[0].additional_kwargs.get("number") == 42
+
+
+def test_system_message(tmp_db):
+    """A SystemMessage round-trips correctly."""
+    h = SuperLocalMemoryChatMessageHistory(session_id="s1", db_path=tmp_db)
+    h.add_messages([SystemMessage(content="You are a helpful assistant.")])
+
+    msgs = h.messages
+    assert len(msgs) == 1
+    assert isinstance(msgs[0], SystemMessage)
+    assert msgs[0].content == "You are a helpful assistant."
+
+
+def test_clear(tmp_db):
+    """clear() removes all messages from the session."""
+    h = SuperLocalMemoryChatMessageHistory(session_id="s1", db_path=tmp_db)
+    h.add_messages([
+        HumanMessage(content="A"),
+        AIMessage(content="B"),
+    ])
+
+    assert len(h.messages) == 2
+    h.clear()
+    assert len(h.messages) == 0
+
+
+def test_clear_only_affects_session(tmp_db):
+    """Clearing session A does not affect session B."""
+    ha = SuperLocalMemoryChatMessageHistory(session_id="session-a", db_path=tmp_db)
+    hb = SuperLocalMemoryChatMessageHistory(session_id="session-b", db_path=tmp_db)
+
+    ha.add_messages([HumanMessage(content="Message in A")])
+    hb.add_messages([HumanMessage(content="Message in B")])
+
+    ha.clear()
+
+    assert len(ha.messages) == 0
+    assert len(hb.messages) == 1
+    assert hb.messages[0].content == "Message in B"
+
+
+def test_session_isolation(tmp_db):
+    """Two sessions with the same DB path do not see each other's messages."""
+    ha = SuperLocalMemoryChatMessageHistory(session_id="alpha", db_path=tmp_db)
+    hb = SuperLocalMemoryChatMessageHistory(session_id="beta", db_path=tmp_db)
+
+    ha.add_messages([HumanMessage(content="Alpha message")])
+    hb.add_messages([HumanMessage(content="Beta message")])
+
+    assert len(ha.messages) == 1
+    assert ha.messages[0].content == "Alpha message"
+
+    assert len(hb.messages) == 1
+    assert hb.messages[0].content == "Beta message"
+
+
+def test_empty_session(tmp_db):
+    """A brand-new session returns an empty list."""
+    h = SuperLocalMemoryChatMessageHistory(session_id="empty", db_path=tmp_db)
+    assert h.messages == []
+
+
+def test_persistence_across_instances(tmp_db):
+    """Messages persist when a new Python instance is created with the same session_id."""
+    h1 = SuperLocalMemoryChatMessageHistory(session_id="persist", db_path=tmp_db)
+    h1.add_messages([HumanMessage(content="Persisted message")])
+
+    # Create a completely new instance pointing at the same DB + session.
+    h2 = SuperLocalMemoryChatMessageHistory(session_id="persist", db_path=tmp_db)
+    msgs = h2.messages
+    assert len(msgs) == 1
+    assert msgs[0].content == "Persisted message"
+
+
+def test_unicode_content(tmp_db):
+    """Unicode and emoji content round-trips correctly."""
+    h = SuperLocalMemoryChatMessageHistory(session_id="unicode", db_path=tmp_db)
+    text = "Bonjour le monde! Hola mundo! Konnichiwa sekai!"
+    h.add_messages([HumanMessage(content=text)])
+
+    msgs = h.messages
+    assert len(msgs) == 1
+    assert msgs[0].content == text
+
+
+def test_long_content(tmp_db):
+    """A 10K character message is stored and retrieved intact."""
+    h = SuperLocalMemoryChatMessageHistory(session_id="long", db_path=tmp_db)
+    long_text = "A" * 10_000
+    h.add_messages([HumanMessage(content=long_text)])
+
+    msgs = h.messages
+    assert len(msgs) == 1
+    assert len(msgs[0].content) == 10_000
+    assert msgs[0].content == long_text
+
+
+def test_special_chars_session_id(tmp_db):
+    """Session IDs with dots, dashes, and underscores work correctly."""
+    for sid in ["my.session.123", "my-session-456", "my_session_789", "a.b-c_d"]:
+        h = SuperLocalMemoryChatMessageHistory(session_id=sid, db_path=tmp_db)
+        h.add_messages([HumanMessage(content=f"msg for {sid}")])
+
+        msgs = h.messages
+        assert len(msgs) == 1, f"Failed for session_id={sid}"
+        assert msgs[0].content == f"msg for {sid}"
+
+        h.clear()
+        assert len(h.messages) == 0, f"clear() failed for session_id={sid}"

package/ide/integrations/langchain/tests/test_security.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""SuperLocalMemory V2 - LangChain Integration Security Tests
+
+Security tests covering SQL injection, XSS payloads, oversized content,
+and edge-case session identifiers.  These mirror OWASP agentic-AI concerns
+relevant to a local-first memory store.
+"""
+import os
+import tempfile
+
+import pytest
+from langchain_core.messages import HumanMessage
+
+from langchain_superlocalmemory import SuperLocalMemoryChatMessageHistory
+
+
+@pytest.fixture
+def tmp_db():
+    """Yield a path to a temporary SQLite database that is cleaned up after use."""
+    with tempfile.TemporaryDirectory() as d:
+        db = os.path.join(d, "test_memory.db")
+        yield db
+
+
+# ---------------------------------------------------------------------------
+# SQL injection
+# ---------------------------------------------------------------------------
+
+
+def test_sql_injection_session_id(tmp_db):
+    """SQL injection in session_id should not work."""
+    history = SuperLocalMemoryChatMessageHistory(
+        session_id="'; DROP TABLE memories; --", db_path=tmp_db
+    )
+    history.add_messages([HumanMessage(content="test")])
+    assert len(history.messages) == 1  # Should work normally, not crash
+
+
+def test_sql_injection_content(tmp_db):
+    """SQL injection in message content is safely stored and retrieved."""
+    history = SuperLocalMemoryChatMessageHistory(session_id="test", db_path=tmp_db)
+    payload = "'; DROP TABLE memories; --"
+    history.add_messages([HumanMessage(content=payload)])
+
+    msgs = history.messages
+    assert len(msgs) == 1
+    assert msgs[0].content == payload
+
+
+# ---------------------------------------------------------------------------
+# XSS
+# ---------------------------------------------------------------------------
+
+
+def test_xss_content(tmp_db):
+    """XSS payloads are stored verbatim (no sanitization needed for storage)."""
+    history = SuperLocalMemoryChatMessageHistory(session_id="test", db_path=tmp_db)
+    payload = "<script>alert('xss')</script>"
+    history.add_messages([HumanMessage(content=payload)])
+
+    msgs = history.messages
+    assert len(msgs) == 1
+    assert "<script>" in msgs[0].content
+
+
+# ---------------------------------------------------------------------------
+# Size limits
+# ---------------------------------------------------------------------------
+
+
+def test_large_content(tmp_db):
+    """A large message (near the SLM 1 MB limit) is stored and retrieved intact.
+
+    MemoryStoreV2 enforces MAX_CONTENT_SIZE = 1_000_000 on the *stored*
+    string, which is the JSON-serialized message (not the raw text).  The
+    JSON envelope adds ~150 bytes of overhead, so we use 999_000 chars to
+    stay safely under the limit.
+    """
+    history = SuperLocalMemoryChatMessageHistory(session_id="test", db_path=tmp_db)
+    big_msg = "x" * 999_000
+    history.add_messages([HumanMessage(content=big_msg)])
+
+    msgs = history.messages
+    assert len(msgs) == 1
+    assert len(msgs[0].content) == 999_000
+
+
+def test_oversized_content_raises(tmp_db):
+    """Content that exceeds SLM's 1 MB limit after serialization raises ValueError."""
+    history = SuperLocalMemoryChatMessageHistory(session_id="test", db_path=tmp_db)
+    # 1_000_000 chars + JSON overhead will exceed the 1 MB limit.
+    big_msg = "x" * 1_000_000
+    with pytest.raises(ValueError, match="exceeds maximum size"):
+        history.add_messages([HumanMessage(content=big_msg)])
+
+
+# ---------------------------------------------------------------------------
+# Edge-case session IDs
+# ---------------------------------------------------------------------------
+
+
+def test_empty_session_id(tmp_db):
+    """An empty string session_id still functions correctly."""
+    history = SuperLocalMemoryChatMessageHistory(session_id="", db_path=tmp_db)
+    history.add_messages([HumanMessage(content="test")])
+    assert len(history.messages) == 1
+
+
+def test_null_bytes_session_id(tmp_db):
+    """Null bytes in session_id do not cause crashes."""
+    history = SuperLocalMemoryChatMessageHistory(
+        session_id="test\x00evil", db_path=tmp_db
+    )
+    history.add_messages([HumanMessage(content="test")])
+    assert len(history.messages) == 1

package/ide/integrations/llamaindex/README.md

@@ -0,0 +1,81 @@
+# LlamaIndex Chat Store — SuperLocalMemory V2
+
+A LlamaIndex `BaseChatStore` implementation backed by [SuperLocalMemory V2](https://github.com/varun369/SuperLocalMemoryV2). All chat history stays **100% local** on your machine — zero cloud calls, zero telemetry, zero API keys.
+
+## Prerequisites
+
+- Python 3.9+
+- SuperLocalMemory V2 installed (`~/.claude-memory/` must exist)
+
+```bash
+# Install SuperLocalMemory V2 (one-time)
+curl -fsSL https://raw.githubusercontent.com/varun369/SuperLocalMemoryV2/main/install.sh | bash
+```
+
+## Installation
+
+```bash
+pip install llama-index-storage-chat-store-superlocalmemory
+```
+
+## Quick Start
+
+```python
+from llama_index.core.memory import ChatMemoryBuffer
+from llama_index.core.base.llms.types import ChatMessage, MessageRole
+from llama_index.storage.chat_store.superlocalmemory import SuperLocalMemoryChatStore
+
+# Create the chat store (uses default SLM database)
+chat_store = SuperLocalMemoryChatStore()
+
+# Use with ChatMemoryBuffer for automatic conversation management
+memory = ChatMemoryBuffer.from_defaults(
+    chat_store=chat_store,
+    chat_store_key="user-123",
+    token_limit=3000,
+)
+
+# Or use directly for manual message management
+chat_store.add_message("session-1", ChatMessage(role=MessageRole.USER, content="Hello!"))
+chat_store.add_message("session-1", ChatMessage(role=MessageRole.ASSISTANT, content="Hi there!"))
+
+messages = chat_store.get_messages("session-1")
+print(messages)  # [ChatMessage(role=user, content="Hello!"), ChatMessage(role=assistant, content="Hi there!")]
+
+# List all session keys
+keys = chat_store.get_keys()
+
+# Delete a session
+chat_store.delete_messages("session-1")
+```
+
+## Features
+
+- **100% Local** — All data stored in SQLite at `~/.claude-memory/memory.db`
+- **Zero Cloud** — No API keys, no subscriptions, no data leaves your machine
+- **Shared Memory** — Chat history is accessible from Claude, Cursor, Windsurf, and 16+ other AI tools via SuperLocalMemory
+- **Session Isolation** — Each chat key is cleanly isolated using SLM tags
+- **Persistent** — Survives process restarts (SQLite-backed, not in-memory)
+- **Full BaseChatStore API** — `set_messages`, `get_messages`, `add_message`, `delete_messages`, `delete_message`, `delete_last_message`, `get_keys`
+- **Async Support** — Async methods inherited from BaseChatStore (delegates to sync via `asyncio.to_thread`)
+
+## How It Works
+
+Each chat message is stored as a separate memory entry in SuperLocalMemory V2:
+- **Content**: JSON-serialized `{role, content, additional_kwargs}`
+- **Tag**: `llamaindex:chat:<session_key>` for session isolation
+- **Project**: `llamaindex` for easy identification
+- **Importance**: 3 (low, since chat messages are transient)
+
+## Custom Database Path
+
+```python
+# Use a custom database file
+chat_store = SuperLocalMemoryChatStore(db_path="/path/to/custom/memory.db")
+```
+
+## Links
+
+- [SuperLocalMemory V2](https://github.com/varun369/SuperLocalMemoryV2)
+- [LlamaIndex Documentation](https://docs.llamaindex.ai/)
+- [LlamaIndex Chat Stores Guide](https://docs.llamaindex.ai/en/stable/module_guides/storing/chat_stores/)

package/ide/integrations/llamaindex/llama_index/storage/chat_store/superlocalmemory/__init__.py

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