clsplusplus 7.3.0__tar.gz → 7.3.1__tar.gz

{clsplusplus-7.3.0 → clsplusplus-7.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clsplusplus
-Version: 7.3.0
+Version: 7.3.1
 Summary: Brain-inspired, model-agnostic persistent memory for LLMs. Learn, recall, forget — like a brain. Works with OpenAI, Claude, Gemini, Llama.
 Author-email: AlphaForge AI Labs <contact@alphaforge.ai>
 Maintainer-email: Rajamohan Jabbala <contact@alphaforge.ai>

{clsplusplus-7.3.0 → clsplusplus-7.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "clsplusplus"
-version = "7.3.0"
+version = "7.3.1"
 description = "Brain-inspired, model-agnostic persistent memory for LLMs. Learn, recall, forget — like a brain. Works with OpenAI, Claude, Gemini, Llama."
 readme = "README.md"
 requires-python = ">=3.9"

{clsplusplus-7.3.0 → clsplusplus-7.3.1}/src/clsplusplus/api.py

@@ -481,6 +481,20 @@ def create_app(settings: Optional[Settings] = None) -> FastAPI:
             "distinct_id": distinct_id,
         }
 
+    @app.get("/v1/config/extension")
+    async def extension_provider_config():
+        """Hot-updatable provider URL rules for the Chrome extension.
+
+        When ChatGPT/Claude/Gemini change API paths, update extension/provider_rules.json
+        on the server — clients pick it up without a Chrome Web Store redeploy.
+        """
+        rules_path = FilePath(__file__).resolve().parents[2] / "extension" / "provider_rules.json"
+        try:
+            import json as _json
+            return _json.loads(rules_path.read_text(encoding="utf-8"))
+        except Exception:
+            return {"version": 0, "providers": {}}
+
     @app.get("/admin/weblab")
     async def admin_weblab_status(request: Request):
         """Weblab control status — watched flags + latest green/red verdict."""

{clsplusplus-7.3.0 → clsplusplus-7.3.1}/src/clsplusplus.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clsplusplus
-Version: 7.3.0
+Version: 7.3.1
 Summary: Brain-inspired, model-agnostic persistent memory for LLMs. Learn, recall, forget — like a brain. Works with OpenAI, Claude, Gemini, Llama.
 Author-email: AlphaForge AI Labs <contact@alphaforge.ai>
 Maintainer-email: Rajamohan Jabbala <contact@alphaforge.ai>

{clsplusplus-7.3.0 → clsplusplus-7.3.1}/src/clsplusplus.egg-info/SOURCES.txt

@@ -120,6 +120,7 @@ tests/test_cross_llm_memory.py
 tests/test_debug_console.py
 tests/test_demo_llm.py
 tests/test_embeddings.py
+tests/test_extension_cross_model_runtime.py
 tests/test_extension_integration.py
 tests/test_extension_ui.py
 tests/test_feedback_github.py

clsplusplus-7.3.1/tests/test_extension_cross_model_runtime.py

@@ -0,0 +1,280 @@
+"""
+Executable cross-model extension runtime tests.
+
+Simulates the ChatGPT → Claude handoff without a browser:
+store on GPT-shaped body, prefetch mailbox, inject on Claude-shaped bodies.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import time
+from copy import deepcopy
+
+import pytest
+
+EXT_DIR = os.path.join(os.path.dirname(__file__), "..", "extension")
+CTX_MARKER = "For context, here are some things I have mentioned before"
+
+
+def read_ext(name: str) -> str:
+    with open(os.path.join(EXT_DIR, name), "r") as f:
+        return f.read()
+
+
+def build_ctx(facts: list[str]) -> str:
+    return (
+        "For context, here are some things I have mentioned before in other conversations:\n"
+        + "\n".join(f"- {f[:200]}" for f in facts)
+        + "\n\nNow, my actual question:\n"
+    )
+
+
+def is_llm(url: str, host: str) -> bool:
+    u = url.lower()
+    h = host.lower()
+    if "chatgpt" in h or "openai" in h:
+        if "/backend-api/" not in u or "conversation" not in u:
+            return False
+        if "/init" in u or "/prepare" in u:
+            return False
+        return True
+    if "claude" in h:
+        if "/v1/sessions/" in u and "/events" in u:
+            return True
+        if "/api/organizations/" in u and "chat_conversations" in u and "completion" in u:
+            return True
+        return "/api/" in u and any(k in u for k in ("chat", "completion", "message"))
+    if "gemini" in h:
+        return "batchexecute" in u
+    return False
+
+
+def extract(body: str, host: str) -> tuple[str, callable] | None:
+    try:
+        b = json.loads(body)
+    except json.JSONDecodeError:
+        return None
+
+    if "chatgpt" in host or "openai" in host:
+        messages = b.get("messages") or []
+        if messages:
+            m = messages[-1]
+            content = m.get("content")
+            if isinstance(content, dict) and content.get("parts"):
+                q = content["parts"][0]
+                def setter(ctx, _b=b, _m=m):
+                    _m["content"]["parts"][0] = ctx + q
+                    return json.dumps(_b)
+                return q, setter
+            if isinstance(content, str):
+                def setter(ctx, _b=b, _m=m):
+                    _m["content"] = ctx + content
+                    return json.dumps(_b)
+                return content, setter
+
+    if isinstance(b.get("prompt"), str) and len(b["prompt"]) > 3:
+        q = b["prompt"]
+        def setter(ctx, _b=b):
+            _b["prompt"] = ctx + q
+            return json.dumps(_b)
+        return q, setter
+
+    events = b.get("events")
+    if isinstance(events, list):
+        for ev in reversed(events):
+            if not ev or ev.get("type") != "user":
+                continue
+            msg = ev.get("message") or {}
+            content = msg.get("content")
+            if isinstance(content, str) and content:
+                def setter(ctx, _msg=msg, _q=content, _b=b):
+                    _msg["content"] = ctx + _q
+                    return json.dumps(_b)
+                return content, setter
+            if isinstance(content, list):
+                for block in content:
+                    if block.get("type") == "text" and block.get("text"):
+                        q = block["text"]
+                        def setter(ctx, _block=block, _q=q, _b=b):
+                            _block["text"] = ctx + _q
+                            return json.dumps(_b)
+                        return q, setter
+    return None
+
+
+def inject(body: str, host: str, facts: list[str]) -> str | None:
+    parsed = extract(body, host)
+    if not parsed:
+        return None
+    _q, setter = parsed
+    return setter(build_ctx(facts))
+
+
+class TestURLDetection:
+    def test_chatgpt_conversation(self):
+        assert is_llm("https://chatgpt.com/backend-api/conversation", "chatgpt.com")
+
+    def test_claude_completion_legacy(self):
+        url = "https://claude.ai/api/organizations/org/chat_conversations/conv/completion"
+        assert is_llm(url, "claude.ai")
+
+    def test_claude_sessions_events_2026(self):
+        url = "https://claude.ai/v1/sessions/session_01ABC/events"
+        assert is_llm(url, "claude.ai")
+
+    def test_claude_org_list_not_llm(self):
+        assert not is_llm("https://claude.ai/api/organizations", "claude.ai")
+
+
+class TestCrossModelInjection:
+    def test_chatgpt_store_shape_injects(self):
+        body = json.dumps({
+            "messages": [{
+                "role": "user",
+                "content": {"parts": ["My favorite color is teal"]},
+            }]
+        })
+        out = inject(body, "chatgpt.com", ["My favorite color is teal", "I live in Austin"])
+        assert out
+        assert CTX_MARKER in out
+        assert "teal" in out
+
+    def test_claude_completion_injects(self):
+        body = json.dumps({"prompt": "What is my favorite color?"})
+        out = inject(body, "claude.ai", ["My favorite color is teal"])
+        assert out
+        assert CTX_MARKER in out
+        assert "teal" in out
+
+    def test_claude_sessions_events_injects(self):
+        body = json.dumps({
+            "events": [{
+                "type": "user",
+                "message": {"role": "user", "content": "What is my favorite color?"},
+            }]
+        })
+        out = inject(body, "claude.ai", ["My favorite color is teal"])
+        assert out
+        assert CTX_MARKER in out
+        assert "teal" in out
+
+    def test_claude_sessions_blocks_injects(self):
+        body = json.dumps({
+            "events": [{
+                "type": "user",
+                "message": {
+                    "role": "user",
+                    "content": [{"type": "text", "text": "Remind me where I live"}],
+                },
+            }]
+        })
+        out = inject(body, "claude.ai", ["I live in Springfield"])
+        assert out
+        assert "Springfield" in out
+
+
+class TestMailboxRace:
+    def test_delayed_mailbox_still_injects_within_wait_window(self):
+        """Simulates capture.js prefetch arriving after GPT store but before Claude send."""
+        facts: list[str] = []
+        mailbox_ready_at = time.time() + 0.15
+
+        def get_ctx_now() -> str:
+            if time.time() < mailbox_ready_at or not facts:
+                return ""
+            return build_ctx(facts)
+
+        def wait_for_ctx(timeout_ms: int = 1200) -> str:
+            deadline = time.time() + timeout_ms / 1000
+            while time.time() < deadline:
+                ctx = get_ctx_now()
+                if ctx:
+                    return ctx
+                time.sleep(0.04)
+            return ""
+
+        # GPT turn stores fact (async)
+        facts.append("My dog is named Max")
+
+        claude_body = json.dumps({"prompt": "What is my dog's name?"})
+        parsed = extract(claude_body, "claude.ai")
+        assert parsed
+        q, setter = parsed
+
+        ctx = get_ctx_now()
+        if not ctx:
+            ctx = wait_for_ctx()
+        assert ctx
+        out = setter(ctx)
+        assert "Max" in out
+
+
+class TestExtensionSourceGuards:
+    def test_intercept_has_sessions_extractor(self):
+        js = read_ext("intercept.js")
+        assert "b.events" in js
+        assert "/v1/sessions/" in js
+
+    def test_intercept_async_uses_wait_path(self):
+        js = read_ext("intercept.js")
+        assert "async function injectBody" in js
+        assert "await injectBody(body, 'async')" in js
+
+    def test_background_bumps_mailbox_after_store(self):
+        js = read_ext("background.js")
+        assert "cls_mem_bump" in js
+
+    def test_capture_listens_for_mem_bump(self):
+        js = read_ext("capture.js")
+        assert "cls_mem_bump" in js
+
+    def test_query_aware_recall_on_send(self):
+        js = read_ext("capture.js")
+        assert "data-cls-query" in js
+        assert "FETCH_RELEVANT" in js
+        assert "refreshMemoriesForQuery" in js
+
+    def test_remote_provider_rules_sync(self):
+        js = read_ext("capture.js")
+        assert "data-cls-provider-rules" in js
+        assert "GET_PROVIDER_RULES" in js
+        js2 = read_ext("intercept.js")
+        assert "getProviderRules" in js2
+        js3 = read_ext("background.js")
+        assert "/v1/config/extension" in js3
+
+
+@pytest.mark.asyncio
+async def test_prototype_mock_claude_sessions_endpoint():
+    """Server mock validates injected sessions API body."""
+    import sys
+    from pathlib import Path
+    from httpx import ASGITransport, AsyncClient
+
+    root = Path(__file__).resolve().parents[1]
+    for p in (str(root / "prototype"), str(root / "src")):
+        if p not in sys.path:
+            sys.path.insert(0, p)
+    import server as proto_server  # noqa: PLC0415
+
+    transport = ASGITransport(app=proto_server.app)
+    async with AsyncClient(transport=transport, base_url="http://test") as client:
+        body = {
+            "events": [{
+                "type": "user",
+                "message": {
+                    "role": "user",
+                    "content": (
+                        "For context, here are some things I have mentioned before in other conversations:\n"
+                        "- My favorite color is teal\n\n"
+                        "Now, my actual question:\nWhat is my favorite color?"
+                    ),
+                },
+            }]
+        }
+        r = await client.post("/v1/sessions/session_test/events", json=body)
+        assert r.status_code == 200
+        assert r.json().get("injection_ok") is True

{clsplusplus-7.3.0 → clsplusplus-7.3.1}/tests/test_extension_integration.py

@@ -90,7 +90,8 @@ class TestInterceptClaudeExtraction:
 
     def test_detects_claude_url(self):
         assert "claude" in self.js
-        assert "/api/" in self.js
+        assert "/v1/sessions/" in self.js
+        assert "chat_conversations" in self.js
 
     def test_extracts_prompt_field(self):
         assert "b.prompt" in self.js
@@ -106,6 +107,12 @@ class TestInterceptClaudeExtraction:
     def test_extracts_text_field(self):
         assert "b.text" in self.js
 
+    def test_has_short_wait_fallback_for_first_claude_send(self):
+        """Injection waits for mailbox when facts are not ready yet."""
+        assert "waitForCtx" in self.js
+        assert "async function injectBody" in self.js
+        assert "await injectBody(body, 'async')" in self.js
+
 
 class TestInterceptGeminiExtraction:
     """Verify Gemini batchexecute URL-encoded form data extraction."""
@@ -212,6 +219,10 @@ class TestCaptureDOMMailbox:
     def test_writes_timestamp(self):
         assert "data-ts" in self.js
 
+    def test_uses_bridge_node_fallback_before_body_exists(self):
+        """Early document_start execution may run before body is available."""
+        assert "document.body || document.documentElement" in self.js
+
     def test_reads_outbox(self):
         assert "data-cls-outbox" in self.js
         assert "JSON.parse" in self.js
@@ -365,7 +376,8 @@ class TestBackgroundMessageRouting:
 
     def test_handles_all_message_types(self):
         required = [
-            "STORE", "FETCH", "ACTIVITY", "USAGE", "SEARCH",
+            "STORE", "FETCH", "FETCH_RELEVANT", "GET_PROVIDER_RULES",
+            "ACTIVITY", "USAGE", "SEARCH",
             "DAILY_COUNTERS", "INCREMENT_INJECTED", "VERIFY_KEY", "OPEN_PANEL",
         ]
         for msg_type in required:
@@ -431,6 +443,12 @@ class TestCrossWorldArchitecture:
         assert main[0]["js"] == ["intercept.js"]
         assert isolated[0]["js"] == ["capture.js"]
 
+    def test_capture_runs_at_document_start(self):
+        """Capture must initialize mailbox before first provider send."""
+        manifest = json.loads(read_ext("manifest.json"))
+        capture = [s for s in manifest["content_scripts"] if s.get("js") == ["capture.js"]][0]
+        assert capture["run_at"] == "document_start"
+
 
 # ═══════════════════════════════════════════════════════════════════════════════
 # Memory Filter Logic (capture.js)
@@ -457,3 +475,9 @@ class TestMemoryFiltering:
 
     def test_filters_questions(self):
         assert "?" in self.js  # endsWith('?') filter
+
+    def test_refreshes_on_tab_reentry(self):
+        """Switching models/tabs should trigger immediate prefetch refresh."""
+        assert "visibilitychange" in self.js
+        assert "pageshow" in self.js
+        assert "focus" in self.js

{clsplusplus-7.3.0 → clsplusplus-7.3.1}/tests/test_extension_ui.py

@@ -648,7 +648,7 @@ class TestCaptureJS:
         assert "data-facts" in self.js
 
     def test_refresh_interval(self):
-        assert "setInterval(refreshMemories, 30000)" in self.js
+        assert "setInterval(refreshMemories, 10000)" in self.js
 
     def test_outbox_poll_interval(self):
         assert "setInterval(checkOutbox, 500)" in self.js