chore: import upstream snapshot with attribution

integrations/mem0-plugin/scripts/auto_capture.py

@@ -0,0 +1,210 @@
+#!/usr/bin/env python3
+"""Auto-capture recent conversation exchanges into mem0.
+
+Runs in the background from UserPromptSubmit hook (every 3rd message).
+Reads the last few exchanges from the transcript, sends them to the
+mem0 API with infer=True so the platform extracts facts automatically.
+
+Input:  env vars (MEM0_API_KEY, MEM0_RESOLVED_USER_ID, MEM0_PROJECT_ID, etc.)
+        argv[1] = transcript_path
+Output: stderr logs only (exit 0 always — must not block)
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import sys
+import urllib.error
+import urllib.request
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from _identity import resolve_api_key, resolve_user_id
+from _project import resolve_branch, resolve_project_id
+
+log = logging.getLogger("mem0-auto-capture")
+log.setLevel(logging.DEBUG)
+_handler = logging.StreamHandler(sys.stderr)
+_handler.setFormatter(logging.Formatter("[mem0-auto-capture] %(message)s"))
+log.addHandler(_handler)
+
+if os.environ.get("MEM0_DEBUG"):
+    _log_dir = os.path.expanduser("~/.mem0")
+    try:
+        os.makedirs(_log_dir, exist_ok=True)
+        _fh = logging.FileHandler(os.path.join(_log_dir, "hooks.log"))
+        _fh.setFormatter(logging.Formatter("[mem0-auto-capture] %(asctime)s %(message)s"))
+        log.addHandler(_fh)
+    except OSError:
+        pass
+
+API_URL = "https://api.mem0.ai"
+TAIL_LINES = 200
+MAX_CONTENT_CHARS = 8000
+MIN_CONTENT_CHARS = 100
+
+
+def tail_lines(filepath: str, n: int) -> list[str]:
+    try:
+        with open(filepath, "rb") as f:
+            f.seek(0, 2)
+            file_size = f.tell()
+            if file_size == 0:
+                return []
+            chunk_size = min(file_size, n * 4096)
+            f.seek(max(0, file_size - chunk_size))
+            data = f.read().decode("utf-8", errors="replace")
+            return data.splitlines()[-n:]
+    except OSError:
+        return []
+
+
+def extract_recent_exchanges(lines: list[str], max_exchanges: int = 3) -> list[dict]:
+    """Extract the last N user+assistant message pairs from the transcript JSONL."""
+    messages = []
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            entry = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+
+        if entry.get("isCompactSummary"):
+            continue
+
+        msg = entry.get("message", {})
+        role = msg.get("role", "")
+        if role not in ("user", "assistant"):
+            continue
+
+        content = msg.get("content", "")
+        if isinstance(content, list):
+            parts = []
+            for block in content:
+                if isinstance(block, str):
+                    parts.append(block)
+                elif isinstance(block, dict) and block.get("type") == "text":
+                    parts.append(block.get("text", ""))
+            content = "\n".join(parts).strip()
+
+        if not content or len(content) < 20:
+            continue
+
+        # Skip tool-call-only assistant messages
+        if role == "assistant" and content.startswith("{"):
+            continue
+
+        messages.append({"role": role, "content": content[:2000]})
+
+    # Take last N exchanges (pairs of user+assistant)
+    if not messages:
+        return []
+
+    result = messages[-(max_exchanges * 2):]
+    return result
+
+
+def store_exchange(api_key: str, messages: list[dict], user_id: str,
+                   project_id: str, branch: str, session_id: str) -> bool:
+    metadata = {
+        "type": "auto_capture",
+        "source": "auto_capture",
+        "confidence": 0.7,
+    }
+    if branch:
+        metadata["branch"] = branch
+    if session_id:
+        metadata["session_id"] = session_id
+
+    body = {
+        "messages": messages,
+        "user_id": user_id,
+        "app_id": project_id,
+        "metadata": metadata,
+        "infer": True,
+    }
+
+    data = json.dumps(body).encode("utf-8")
+    req = urllib.request.Request(
+        f"{API_URL}/v3/memories/add/",
+        data=data,
+        headers={
+            "Content-Type": "application/json",
+            "Authorization": f"Token {api_key}",
+        },
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            if resp.status in (200, 201):
+                result = json.loads(resp.read())
+                log.info("Auto-captured: event_id=%s status=%s",
+                         result.get("event_id", "?"), result.get("status", "?"))
+                return True
+            log.warning("API returned status %d", resp.status)
+            return False
+    except urllib.error.URLError as e:
+        log.warning("API call failed: %s", e)
+        return False
+
+
+def main():
+    api_key = resolve_api_key()
+    if not api_key:
+        log.debug("MEM0_API_KEY not set, skipping")
+        return
+
+    if len(sys.argv) < 2:
+        log.debug("No transcript_path argument")
+        return
+
+    transcript_path = sys.argv[1]
+    if not transcript_path or not os.path.isfile(transcript_path):
+        log.debug("Transcript not found: %s", transcript_path)
+        return
+
+    user_id = resolve_user_id()
+    project_id = resolve_project_id()
+    branch = resolve_branch()
+    session_id = ""
+    sid_file = f"/tmp/mem0_session_id_{os.environ.get('USER', 'default')}"
+    if os.path.isfile(sid_file):
+        try:
+            with open(sid_file) as f:
+                session_id = f.read().strip()
+        except OSError:
+            pass
+
+    lines = tail_lines(transcript_path, TAIL_LINES)
+    if not lines:
+        log.debug("Transcript empty")
+        return
+
+    messages = extract_recent_exchanges(lines, max_exchanges=4)
+    if not messages:
+        log.debug("No substantial exchanges found")
+        return
+
+    total_chars = sum(len(m["content"]) for m in messages)
+    if total_chars < MIN_CONTENT_CHARS:
+        log.debug("Exchanges too short (%d chars), skipping", total_chars)
+        return
+
+    log.info("Auto-capturing %d messages (%d chars)", len(messages), total_chars)
+    if store_exchange(api_key, messages, user_id, project_id, branch, session_id):
+        try:
+            import session_stats
+            session_stats.record_add("auto_capture")
+        except Exception:
+            pass
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        log.error("Unexpected error: %s", e)
+    sys.exit(0)