The Memory Layer for AI Agents - Drop-in memory infrastructure for AI agents and apps. Context that persists. Built for production.
Python agentic-memoryagentic-memory-systemagentsaiai-agentschatgptgenaillmlong-term-memorymemorymemory-managementpythonragstate-management
fix(mem0-plugin): v0.2.2 (#5234)
Kartik16a7702d09dd
diff --git a/.claude-plugin/marketplace.json b/.claude-plugin/marketplace.jsonindex 07482b3f6..b137cb7f8 100644--- a/.claude-plugin/marketplace.json+++ b/.claude-plugin/marketplace.json@@ -12,7 +12,7 @@"name": "mem0","source": "./mem0-plugin","description": "Mem0 memory layer for AI applications. Add persistent memory, personalization, and semantic search to Claude workflows.",- "version": "0.2.1"+ "version": "0.2.2"}]}diff --git a/.cursor-plugin/marketplace.json b/.cursor-plugin/marketplace.jsonindex d9c8f4342..c884692b7 100644--- a/.cursor-plugin/marketplace.json+++ b/.cursor-plugin/marketplace.json@@ -12,7 +12,7 @@"name": "mem0","source": "./mem0-plugin","description": "Mem0 memory layer for AI applications. Add persistent memory, personalization, and semantic search.",- "version": "0.2.1"+ "version": "0.2.2"}]}diff --git a/mem0-plugin/.claude-plugin/plugin.json b/mem0-plugin/.claude-plugin/plugin.jsonindex 3e3487fa2..9e638dd1c 100644--- a/mem0-plugin/.claude-plugin/plugin.json+++ b/mem0-plugin/.claude-plugin/plugin.json@@ -1,6 +1,6 @@{"name": "mem0",- "version": "0.2.1",+ "version": "0.2.2","description": "Mem0 memory layer for AI applications. Add persistent memory, personalization, and semantic search to Claude workflows using the Mem0 Platform MCP server.","author": {"name": "Mem0",diff --git a/mem0-plugin/.codex-plugin/plugin.json b/mem0-plugin/.codex-plugin/plugin.jsonindex 90ce43c45..bc29f76df 100644--- a/mem0-plugin/.codex-plugin/plugin.json+++ b/mem0-plugin/.codex-plugin/plugin.json@@ -1,6 +1,6 @@{"name": "mem0",- "version": "0.2.1",+ "version": "0.2.2","description": "Mem0 memory layer for AI applications. Add persistent memory, personalization, and semantic search to Codex workflows using the Mem0 Platform MCP server.","author": {"name": "Mem0",diff --git a/mem0-plugin/.cursor-plugin/plugin.json b/mem0-plugin/.cursor-plugin/plugin.jsonindex 3bb15d67c..de4aab2d2 100644--- a/mem0-plugin/.cursor-plugin/plugin.json+++ b/mem0-plugin/.cursor-plugin/plugin.json@@ -1,6 +1,6 @@{"name": "mem0",- "version": "0.2.1",+ "version": "0.2.2","description": "Mem0 memory layer for AI applications. Add persistent memory, personalization, and semantic search using the Mem0 Platform MCP server.","author": {"name": "Mem0",diff --git a/mem0-plugin/hooks/codex-hooks.json b/mem0-plugin/hooks/codex-hooks.jsonindex c74c8d0c9..368120361 100644--- a/mem0-plugin/hooks/codex-hooks.json+++ b/mem0-plugin/hooks/codex-hooks.json@@ -1,5 +1,17 @@{"hooks": {+ "PreToolUse": [+ {+ "matcher": "mcp__mem0__add_memory|mcp__plugin_mem0_mem0__add_memory",+ "hooks": [+ {+ "type": "command",+ "command": "${CODEX_PLUGIN_ROOT}/scripts/enforce_metadata_defaults.sh",+ "timeout": 3+ }+ ]+ }+ ],"SessionStart": [{"matcher": "startup|resume",@@ -42,12 +54,7 @@"type": "command","command": "${CODEX_PLUGIN_ROOT}/scripts/on_post_commit.sh","timeout": 5- }- ]- },- {- "matcher": "Bash",- "hooks": [+ },{"type": "command","command": "${CODEX_PLUGIN_ROOT}/scripts/on_bash_output.sh",diff --git a/mem0-plugin/hooks/cursor-hooks.json b/mem0-plugin/hooks/cursor-hooks.jsonindex f9187631a..13ccd456c 100644--- a/mem0-plugin/hooks/cursor-hooks.json+++ b/mem0-plugin/hooks/cursor-hooks.json@@ -10,6 +10,11 @@{"command": "${CURSOR_PLUGIN_ROOT}/scripts/block_memory_write_cursor.sh","matcher": "Write|Edit"+ },+ {+ "command": "${CURSOR_PLUGIN_ROOT}/scripts/enforce_metadata_defaults.sh",+ "matcher": "mcp__mem0__add_memory|mcp__plugin_mem0_mem0__add_memory",+ "timeout": 3}],"postToolUse": [diff --git a/mem0-plugin/hooks/hooks.json b/mem0-plugin/hooks/hooks.jsonindex a1c6e29af..db424633f 100644--- a/mem0-plugin/hooks/hooks.json+++ b/mem0-plugin/hooks/hooks.json@@ -54,6 +54,16 @@"timeout": 5}]+ },+ {+ "matcher": "mcp__mem0__add_memory|mcp__plugin_mem0_mem0__add_memory",+ "hooks": [+ {+ "type": "command",+ "command": "${CLAUDE_PLUGIN_ROOT}/scripts/enforce_metadata_defaults.sh",+ "timeout": 3+ }+ ]}],"PostToolUse": [@@ -74,12 +84,7 @@"type": "command","command": "${CLAUDE_PLUGIN_ROOT}/scripts/on_post_commit.sh","timeout": 5- }- ]- },- {- "matcher": "Bash",- "hooks": [+ },{"type": "command","command": "${CLAUDE_PLUGIN_ROOT}/scripts/on_bash_output.sh",diff --git a/mem0-plugin/scripts/_chunking.py b/mem0-plugin/scripts/_chunking.pynew file mode 100644index 000000000..359199d9d--- /dev/null+++ b/mem0-plugin/scripts/_chunking.py@@ -0,0 +1,75 @@+"""Shared content-chunking utilities for mem0-plugin import scripts."""++from __future__ import annotations++MIN_CHUNK_CHARS = 50+MAX_CHUNK_CHARS = 10_000+++def split_by_headers(content: str, header_prefix: str = "## ") -> list[str]:+ """Split content by Markdown header lines (e.g. '## ').++ The header line is included at the start of each chunk.+ Returns a list of non-empty chunk strings.+ """+ chunks: list[str] = []+ current_lines: list[str] = []++ for line in content.splitlines(keepends=True):+ if line.startswith(header_prefix) and current_lines:+ chunk = "".join(current_lines).strip()+ if chunk:+ chunks.append(chunk)+ current_lines = [line]+ else:+ current_lines.append(line)++ if current_lines:+ chunk = "".join(current_lines).strip()+ if chunk:+ chunks.append(chunk)++ return chunks+++def split_by_hr_or_headers(content: str) -> list[str]:+ """Split content by '---' horizontal rules or '## ' headers.++ Used for .continue/rules.md which may use either convention.+ """+ import re++ # Split on lines that are exactly "---" or start with "## "+ chunks: list[str] = []+ current_lines: list[str] = []++ for line in content.splitlines(keepends=True):+ is_hr = re.match(r"^---\s*$", line)+ is_h2 = line.startswith("## ")++ if (is_hr or is_h2) and current_lines:+ chunk = "".join(current_lines).strip()+ if chunk:+ chunks.append(chunk)+ current_lines = [] if is_hr else [line]+ else:+ current_lines.append(line)++ if current_lines:+ chunk = "".join(current_lines).strip()+ if chunk:+ chunks.append(chunk)++ return chunks+++def filter_and_truncate(chunks: list[str]) -> list[str]:+ """Filter out chunks shorter than MIN_CHUNK_CHARS, truncate long chunks."""+ result: list[str] = []+ for chunk in chunks:+ if len(chunk) < MIN_CHUNK_CHARS:+ continue+ if len(chunk) > MAX_CHUNK_CHARS:+ chunk = chunk[:MAX_CHUNK_CHARS]+ result.append(chunk)+ return resultdiff --git a/mem0-plugin/scripts/_project.py b/mem0-plugin/scripts/_project.pyindex 692922588..eb64272b5 100644--- a/mem0-plugin/scripts/_project.py+++ b/mem0-plugin/scripts/_project.py@@ -3,6 +3,7 @@Resolution priority (project_id):1. MEM0_PROJECT_ID env var (explicit override)2. ~/.mem0/project_map.json lookup by cwd+ 2b. ~/.mem0/project_map.json lookup by remote hash (self-healing fallback)3. Git remote slug: strip protocol/prefix, strip .git, replace / and : with -e.g. [email protected]:mem0ai/mem0.git -> mem0ai-mem04. Fallback: basename of cwd@@ -10,6 +11,7 @@ Resolution priority (project_id):from __future__ import annotations+import hashlibimport jsonimport osimport re@@ -34,6 +36,19 @@ def resolve_project_id(cwd: str | None = None) -> str:mapped = project_map.get(cwd, "").strip()if mapped:return mapped+ # 2b. Remote hash fallback (self-healing when folder is moved/renamed)+ remote_key = _remote_hash_key(cwd)+ if remote_key:+ mapped = project_map.get(remote_key, "").strip()+ if mapped:+ # Self-heal: write the new CWD key so future lookups are fast+ project_map[cwd] = mapped+ try:+ with open(map_path, "w") as f:+ json.dump(project_map, f, indent=2)+ except OSError:+ pass+ return mappedexcept (OSError, json.JSONDecodeError, AttributeError):pass@@ -76,7 +91,7 @@ def resolve_branch(cwd: str | None = None) -> str:def save_project_mapping(cwd: str, project_id: str) -> None:- """Write cwd -> project_id into ~/.mem0/project_map.json."""+ """Write cwd -> project_id (and remote hash key -> project_id) into ~/.mem0/project_map.json."""mem0_dir = os.path.expanduser("~/.mem0")os.makedirs(mem0_dir, exist_ok=True)map_path = os.path.join(mem0_dir, "project_map.json")@@ -88,10 +103,40 @@ def save_project_mapping(cwd: str, project_id: str) -> None:except (OSError, json.JSONDecodeError):project_map = {}project_map[cwd] = project_id+ # Also write the remote hash key so the mapping survives folder moves/renames+ remote_key = _remote_hash_key(cwd)+ if remote_key:+ project_map[remote_key] = project_idwith open(map_path, "w") as f:json.dump(project_map, f, indent=2)+def _remote_hash_key(cwd: str | None = None) -> str:+ """Return a stable key derived from the git remote URL.++ Runs ``git config --get remote.origin.url`` in *cwd* and returns a string+ of the form ``remote:<sha256(url)[:16]>``. Returns an empty string when+ the directory is not a git repo or has no remote configured.+ """+ if cwd is None:+ cwd = os.getcwd()+ try:+ result = subprocess.run(+ ["git", "config", "--get", "remote.origin.url"],+ capture_output=True,+ text=True,+ check=True,+ cwd=cwd,+ )+ url = result.stdout.strip()+ if not url:+ return ""+ digest = hashlib.sha256(url.encode()).hexdigest()[:16]+ return f"remote:{digest}"+ except (subprocess.CalledProcessError, OSError):+ return ""++def _remote_url_to_slug(url: str) -> str:"""Convert a git remote URL to a deterministic slug.diff --git a/mem0-plugin/scripts/auto_import.py b/mem0-plugin/scripts/auto_import.pyindex a04f63a64..3f4be30a2 100644--- a/mem0-plugin/scripts/auto_import.py+++ b/mem0-plugin/scripts/auto_import.py@@ -21,6 +21,7 @@ import urllib.errorimport urllib.requestsys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))+from _chunking import filter_and_truncate, split_by_headersfrom _identity import resolve_api_key, resolve_user_idfrom _project import resolve_branch, resolve_project_id@@ -198,10 +199,24 @@ def main() -> None:log.debug("Cannot read %s: %s", filename, e)continue- if post_memory(api_key, content, user_id, filename, project_id, branch):+ is_markdown = filename.endswith(".md")+ if is_markdown:+ chunks = filter_and_truncate(split_by_headers(content))+ else:+ chunks = filter_and_truncate([content])++ if not chunks:+ chunks = [content[:10000]]++ success = True+ for i, chunk in enumerate(chunks):+ chunk_name = f"{filename}[{i+1}/{len(chunks)}]" if len(chunks) > 1 else filename+ if not post_memory(api_key, chunk, user_id, chunk_name, project_id, branch):+ success = False++ if success:hashes[hash_key] = current_hashupdated = True- # on API failure we don't update the hash — retry next sessionif updated:save_hashes(hashes)diff --git a/mem0-plugin/scripts/enforce_metadata_defaults.sh b/mem0-plugin/scripts/enforce_metadata_defaults.shnew file mode 100755index 000000000..1e0ba4c19--- /dev/null+++ b/mem0-plugin/scripts/enforce_metadata_defaults.sh@@ -0,0 +1,65 @@+#!/usr/bin/env bash+# PreToolUse hook for mcp__mem0__add_memory.+# Injects default metadata fields (confidence, files, source, type) when the+# agent omits them. Uses the hookSpecificOutput.updatedInput contract to+# actually modify the tool call parameters.+#+# Hook contract:+# exit 0 = allow. If stdout contains {"hookSpecificOutput": {"updatedInput": ...}},+# the updatedInput replaces the tool's input parameters.+# exit 2 = block (stderr shown as rejection reason).++set -euo pipefail++INPUT=$(cat)++TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // ""' 2>/dev/null)+case "$TOOL_NAME" in+ mcp__mem0__add_memory|mcp__plugin_mem0_mem0__add_memory) ;;+ *) exit 0 ;;+esac++TOOL_INPUT=$(echo "$INPUT" | jq -r '.tool_input // "{}"' 2>/dev/null)++PATCHED=$(python3 -c "+import json, sys++raw = sys.stdin.read()+try:+ inp = json.loads(raw)+except Exception:+ sys.exit(0)++meta = inp.get('metadata') or {}+changed = False++if 'confidence' not in meta:+ meta['confidence'] = 0.7+ changed = True+if 'files' not in meta:+ meta['files'] = ['*']+ changed = True+if 'source' not in meta:+ meta['source'] = 'auto_capture'+ changed = True+if 'type' not in meta:+ meta['type'] = 'task_learning'+ changed = True++if changed:+ inp['metadata'] = meta+ print(json.dumps(inp))+" <<< "$TOOL_INPUT" 2>/dev/null || true)++if [ -n "$PATCHED" ]; then+ # Use hookSpecificOutput.updatedInput to actually modify the tool call+ jq -n --argjson updated "$PATCHED" '{+ "hookSpecificOutput": {+ "hookEventName": "PreToolUse",+ "permissionDecision": "allow",+ "updatedInput": $updated+ }+ }'+fi++exit 0diff --git a/mem0-plugin/scripts/ensure_deps.sh b/mem0-plugin/scripts/ensure_deps.shindex 3b77e1b38..8bb54a483 100755--- a/mem0-plugin/scripts/ensure_deps.sh+++ b/mem0-plugin/scripts/ensure_deps.sh@@ -11,6 +11,8 @@ REQ_STAMP="${DATA_DIR}/requirements.txt"mkdir -p "${DATA_DIR}"+LOCKDIR="${DATA_DIR}/.install-lock"+needs_install=falseif [ ! -f "${VENV_DIR}/bin/python3" ]; then@@ -20,13 +22,29 @@ elif ! diff -q "${REQ_SRC}" "${REQ_STAMP}" >/dev/null 2>&1; thenfiif [ "${needs_install}" = "true" ]; then- python3 -m venv "${VENV_DIR}" 2>/dev/null || python -m venv "${VENV_DIR}"- "${VENV_DIR}/bin/pip" install --quiet --upgrade pip >/dev/null 2>&1 || true- if "${VENV_DIR}/bin/pip" install --quiet -r "${REQ_SRC}" 2>/dev/null; then- cp "${REQ_SRC}" "${REQ_STAMP}"+ if mkdir "${LOCKDIR}" 2>/dev/null; then+ # We acquired the lock — proceed with installation+ trap 'rmdir "${LOCKDIR}" 2>/dev/null || true' EXIT+ python3 -m venv "${VENV_DIR}" 2>/dev/null || python -m venv "${VENV_DIR}"+ "${VENV_DIR}/bin/pip" install --quiet --upgrade pip >/dev/null 2>&1 || true+ if "${VENV_DIR}/bin/pip" install --quiet -r "${REQ_SRC}" 2>/dev/null; then+ cp "${REQ_SRC}" "${REQ_STAMP}"+ rm -f "${DATA_DIR}/.install-failed"+ else+ rm -f "${REQ_STAMP}"+ touch "${DATA_DIR}/.install-failed"+ echo "mem0 plugin: failed to install Python dependencies" >&2+ exit 0+ fielse- rm -f "${REQ_STAMP}"- echo "mem0 plugin: failed to install Python dependencies" >&2- exit 0+ # Another process holds the lock — wait up to 60s for it to finish+ for i in $(seq 1 60); do+ [ ! -d "${LOCKDIR}" ] && break+ sleep 1+ done+ # Check if the other process's install failed+ if [ -f "${DATA_DIR}/.install-failed" ]; then+ echo "mem0 plugin: dependency installation failed (by another session)" >&2+ fififidiff --git a/mem0-plugin/scripts/import_competing_tools.py b/mem0-plugin/scripts/import_competing_tools.pyindex 2c8f54673..2fd86b6de 100644--- a/mem0-plugin/scripts/import_competing_tools.py+++ b/mem0-plugin/scripts/import_competing_tools.py@@ -24,87 +24,15 @@ import urllib.errorimport urllib.requestsys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))+from _chunking import (+ filter_and_truncate,+ split_by_headers,+ split_by_hr_or_headers,+)from _identity import resolve_api_key, resolve_user_idfrom _project import resolve_branch, resolve_project_idAPI_URL = "https://api.mem0.ai"-MIN_CHUNK_CHARS = 50-MAX_CHUNK_CHARS = 10_000---# ----------------------------------------------------------------------------# Content splitting utilities-# ------------------------------------------------------------------------------def split_by_headers(content: str, header_prefix: str = "## ") -> list[str]:- """Split content by Markdown header lines (e.g. '## ').-- The header line is included at the start of each chunk.- Returns a list of non-empty chunk strings.- """- chunks: list[str] = []- current_lines: list[str] = []-- for line in content.splitlines(keepends=True):- if line.startswith(header_prefix) and current_lines:- chunk = "".join(current_lines).strip()- if chunk:- chunks.append(chunk)- current_lines = [line]- else:- current_lines.append(line)-- if current_lines:- chunk = "".join(current_lines).strip()- if chunk:- chunks.append(chunk)-- return chunks---def split_by_hr_or_headers(content: str) -> list[str]:- """Split content by '---' horizontal rules or '## ' headers.-- Used for .continue/rules.md which may use either convention.- """- import re-- # Split on lines that are exactly "---" or start with "## "- chunks: list[str] = []- current_lines: list[str] = []-- for line in content.splitlines(keepends=True):- is_hr = re.match(r"^---\s*$", line)- is_h2 = line.startswith("## ")-- if (is_hr or is_h2) and current_lines:- chunk = "".join(current_lines).strip()- if chunk:- chunks.append(chunk)- current_lines = [] if is_hr else [line]- else:- current_lines.append(line)-- if current_lines:- chunk = "".join(current_lines).strip()- if chunk:- chunks.append(chunk)-- return chunks---def filter_and_truncate(chunks: list[str]) -> list[str]:- """Filter out chunks shorter than MIN_CHUNK_CHARS, truncate long chunks."""- result: list[str] = []- for chunk in chunks:- if len(chunk) < MIN_CHUNK_CHARS:- continue- if len(chunk) > MAX_CHUNK_CHARS:- chunk = chunk[:MAX_CHUNK_CHARS]- result.append(chunk)- return result-# ---------------------------------------------------------------------------# API helpersdiff --git a/mem0-plugin/scripts/on_bash_output.sh b/mem0-plugin/scripts/on_bash_output.shindex 8b407f881..a79a705b1 100755--- a/mem0-plugin/scripts/on_bash_output.sh+++ b/mem0-plugin/scripts/on_bash_output.sh@@ -33,7 +33,9 @@ esac# Detect stack traces and error patterns in command outputHAS_ERROR=""-if echo "$TOOL_RESULT" | grep -qiE '(Traceback \(most recent|Error:|Exception:|panic:|FAILED|fatal:|FAIL:| at .+\.[a-z]+:[0-9]+|error\[E[0-9]+\])'; then+if echo "$TOOL_RESULT" | grep -qE '(Traceback \(most recent call last\)|panic: |FATAL:|error\[E[0-9]+\])'; then+ HAS_ERROR="true"+elif [ "$(echo "$TOOL_RESULT" | grep -cE '(Error:|Exception:)')" -ge 2 ]; thenHAS_ERROR="true"fidiff --git a/mem0-plugin/scripts/on_git_commit_capture.sh b/mem0-plugin/scripts/on_git_commit_capture.shindex c2637533c..a1fcabd3f 100755--- a/mem0-plugin/scripts/on_git_commit_capture.sh+++ b/mem0-plugin/scripts/on_git_commit_capture.sh@@ -1,9 +1,8 @@#!/usr/bin/env bash# Hook: PreToolUse (matcher: Bash)#-# Detects `git commit` commands and:-# 1. Fires on_pre_commit.py in the background to capture staged changes as memory-# 2. Searches for relevant memories about the changed files and surfaces them+# Detects `git commit` commands and searches for relevant memories+# about the changed files, surfacing them as pre-commit context.## Input: JSON on stdin with tool_name, tool_input# Output: JSON with additionalContext (relevant memories for the commit)diff --git a/mem0-plugin/scripts/on_post_commit.sh b/mem0-plugin/scripts/on_post_commit.shindex d9c29a985..bb5f968ee 100755--- a/mem0-plugin/scripts/on_post_commit.sh+++ b/mem0-plugin/scripts/on_post_commit.sh@@ -44,8 +44,15 @@ if [ -z "${MEM0_API_KEY:-}" ]; thenexit 0fi+# C5: commit prompts default OFF — only prompt if explicitly enabled in mem0.md+MEM0_CWD=$(git rev-parse --show-toplevel 2>/dev/null || echo ".")+COMMIT_PROMPTS=$(python3 "$SCRIPT_DIR/parse_mem0_config.py" --key settings.commit_prompts "$MEM0_CWD" 2>/dev/null || echo "")+if [ "$COMMIT_PROMPTS" != "true" ]; then+ exit 0+fi+# Extract changed files from commit-CHANGED_FILES=$(git diff --name-only HEAD~1 HEAD 2>/dev/null | head -10 || echo "")+CHANGED_FILES=$(git diff-tree --no-commit-id --name-only -r HEAD 2>/dev/null | head -10 || echo "")if [ -z "$CHANGED_FILES" ]; thenexit 0fidiff --git a/mem0-plugin/scripts/on_pre_commit.py b/mem0-plugin/scripts/on_pre_commit.pydeleted file mode 100644index 566347ffb..000000000--- a/mem0-plugin/scripts/on_pre_commit.py+++ /dev/null@@ -1,135 +0,0 @@-#!/usr/bin/env python3-"""Pre-commit memory capture.--Captures a summary of staged changes as a mem0 memory before each commit.-Runs as a background fire-and-forget call — never blocks the commit.--Usage:- git diff --cached --stat | python3 on_pre_commit.py- # or with full diff:- git diff --cached | python3 on_pre_commit.py --full--Env vars required: MEM0_API_KEY (or CLAUDE_PLUGIN_OPTION_MEM0_API_KEY)-Env vars optional: MEM0_RESOLVED_USER_ID, MEM0_PROJECT_ID, MEM0_BRANCH-"""--from __future__ import annotations--import json-import os-import subprocess-import sys-import urllib.error-import urllib.request--sys.path.insert(0, os.path.dirname(__file__))-from _identity import resolve_api_key, resolve_user_id--try:- from _project import resolve_branch, resolve_project_id-except ImportError:- def resolve_project_id() -> str:- return os.path.basename(os.getcwd())-- def resolve_branch() -> str:- return "unknown"---def get_commit_message() -> str:- """Read the current commit message from COMMIT_EDITMSG (pre-commit context).-- Falls back to HEAD's message if COMMIT_EDITMSG doesn't exist yet- (e.g., when invoked outside the git hook context).- """- try:- git_dir = subprocess.run(- ["git", "rev-parse", "--git-dir"],- capture_output=True, text=True, timeout=5,- )- if git_dir.returncode == 0:- editmsg = os.path.join(git_dir.stdout.strip(), "COMMIT_EDITMSG")- if os.path.isfile(editmsg):- with open(editmsg) as f:- first_line = f.readline().strip()- if first_line and not first_line.startswith("#"):- return first_line- except Exception:- pass- try:- result = subprocess.run(- ["git", "log", "-1", "--format=%s", "HEAD"],- capture_output=True, text=True, timeout=5,- )- return result.stdout.strip() if result.returncode == 0 else ""- except Exception:- return ""---def get_staged_summary() -> str:- try:- result = subprocess.run(- ["git", "diff", "--cached", "--stat"],- capture_output=True, text=True, timeout=10,- )- return result.stdout.strip() if result.returncode == 0 else ""- except Exception:- return ""---def main() -> int:- api_key = resolve_api_key()- if not api_key:- return 0-- diff_input = sys.stdin.read().strip() if not sys.stdin.isatty() else ""- staged = diff_input or get_staged_summary()- if not staged or len(staged) < 10:- return 0-- user_id = os.environ.get("MEM0_RESOLVED_USER_ID") or resolve_user_id()- project_id = os.environ.get("MEM0_PROJECT_ID") or resolve_project_id()- branch = os.environ.get("MEM0_BRANCH") or resolve_branch()- commit_msg = get_commit_message()-- lines = staged.splitlines()- if len(lines) > 30:- staged = "\n".join(lines[:30]) + f"\n... ({len(lines) - 30} more lines)"-- content = f"## Commit Context\n\nBranch: {branch}\n"- if commit_msg:- content += f"Message: {commit_msg}\n"- content += f"\n### Staged Changes\n```\n{staged}\n```"-- body = json.dumps({- "messages": [{"role": "user", "content": content}],- "user_id": user_id,- "app_id": project_id,- "metadata": {- "type": "commit_context",- "branch": branch,- "source": "pre-commit",- },- "infer": False,- }).encode()-- req = urllib.request.Request(- "https://api.mem0.ai/v3/memories/add/",- data=body,- headers={- "Authorization": f"Token {api_key}",- "Content-Type": "application/json",- },- method="POST",- )-- try:- with urllib.request.urlopen(req, timeout=10):- pass- except Exception:- pass-- return 0---if __name__ == "__main__":- sys.exit(main())diff --git a/mem0-plugin/scripts/on_session_start.sh b/mem0-plugin/scripts/on_session_start.shindex 20ce96765..29f8fbdac 100755--- a/mem0-plugin/scripts/on_session_start.sh+++ b/mem0-plugin/scripts/on_session_start.sh@@ -41,6 +41,15 @@ if [ -z "${MEM0_API_KEY:-}" ]; thenexit 0fi+# Check for failed dependency installation and warn the user+_DATA_DIR="${CLAUDE_PLUGIN_DATA:-$HOME/.mem0/plugin-data}"+if [ -f "${_DATA_DIR}/.install-failed" ]; then+ echo ""+ echo "⚠️ mem0 SDK installation failed. Some features may not work."+ echo "Run: ${CLAUDE_PLUGIN_ROOT:-$SCRIPT_DIR/..}/scripts/ensure_deps.sh"+ echo ""+fi+# Fetch project-scoped memory count (best-effort, don't block on failure, 5s timeout)MEM0_COUNT="?"if command -v python3 >/dev/null 2>&1; then@@ -96,10 +105,14 @@ if command -v python3 >/dev/null 2>&1; thenMEM0_PROJECT_CONFIG=$(python3 "$SCRIPT_DIR/parse_mem0_config.py" --full "$MEM0_CWD_RESOLVED" 2>/dev/null || echo "{}")fiif [ -n "$MEM0_PROJECT_CONFIG" ] && [ "$MEM0_PROJECT_CONFIG" != "{}" ]; then+ _CONFIG_KEYS=$(echo "$MEM0_PROJECT_CONFIG" | python3 -c "import sys,json; d=json.load(sys.stdin); print(len(d))" 2>/dev/null || echo "?")echo "### Project Config (mem0.md)"- echo "\`\`\`json"- echo "$MEM0_PROJECT_CONFIG"- echo "\`\`\`"+ echo "\`mem0.md loaded (${_CONFIG_KEYS} sections configured)\`"+ if [ -n "${MEM0_DEBUG:-}" ]; then+ echo "\`\`\`json"+ echo "$MEM0_PROJECT_CONFIG"+ echo "\`\`\`"+ fiecho ""fi@@ -108,6 +121,8 @@ if [ "$SOURCE" = "startup" ]; then_SAFE_PID=$(printf '%s' "$MEM0_PROJECT_ID" | tr '/:' '--')_ONBOARD_MARKER="$HOME/.mem0/.onboarded_${_SAFE_PID}"if [ ! -f "$_ONBOARD_MARKER" ]; then+ mkdir -p "$HOME/.mem0" 2>/dev/null || true+ touch "$_ONBOARD_MARKER"cat <<'EOF'## Mem0 First Run — Automatic Onboarding@@ -135,6 +150,22 @@ IMPORTANT: Do NOT skip this step. Always bootstrap context first.EOFfi+ # Detect native Claude Code auto-memory for THIS project+ _PROJ_KEY=$(printf '%s' "$MEM0_CWD_RESOLVED" | tr '/' '-')+ _MEMORY_MD="$HOME/.claude/projects/${_PROJ_KEY}/memory/MEMORY.md"+ if [ -f "$_MEMORY_MD" ] && [ -s "$_MEMORY_MD" ]; then+ cat <<MEMEOF++### Native auto-memory detected++Found \`$_MEMORY_MD\`. The mem0 plugin handles all memory storage.+To avoid two parallel memory systems:+- Add \`"autoMemoryEnabled": false\` to \`~/.claude/settings.json\`+- Or run \`/mem0:import\` to migrate existing MEMORY.md content into mem0++MEMEOF+ fi+# Auto-import declarative project files in backgroundMEM0_CWD="$(echo "$INPUT" | jq -r '.cwd // "."' 2>/dev/null || echo ".")" \python3 "$SCRIPT_DIR/auto_import.py" 2>/dev/null &diff --git a/mem0-plugin/scripts/on_subagent_stop.sh b/mem0-plugin/scripts/on_subagent_stop.shindex 4601be5b5..0ebcb0e87 100755--- a/mem0-plugin/scripts/on_subagent_stop.sh+++ b/mem0-plugin/scripts/on_subagent_stop.sh@@ -24,9 +24,17 @@ if [ ${#RESULT_SUMMARY} -lt 50 ]; thenexit 0fi+# Read subagent skip list from config, default to Explore|Plan+_SKIP_CSV=$(python3 "$SCRIPT_DIR/parse_mem0_config.py" --key settings.subagent_skip "$(git rev-parse --show-toplevel 2>/dev/null || echo ".")" 2>/dev/null || echo "")+if [ -n "$_SKIP_CSV" ]; then+ _SKIP_PATTERN=$(echo "$_SKIP_CSV" | tr -d ' ' | tr ',' '|')+else+ _SKIP_PATTERN="Explore|Plan"+fi+# Skip explorer/plan agents — read-only, rarely produce storable learningscase "$AGENT_TYPE" in- Explore|Plan)+ $_SKIP_PATTERN)exit 0;;esacdiff --git a/mem0-plugin/scripts/on_user_prompt.sh b/mem0-plugin/scripts/on_user_prompt.shindex b93b81e2d..e3e4f5a2a 100755--- a/mem0-plugin/scripts/on_user_prompt.sh+++ b/mem0-plugin/scripts/on_user_prompt.sh@@ -31,7 +31,11 @@ SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"# Detect stack traces and error patterns in the prompt (no API needed)HAS_ERROR=""-if echo "$PROMPT" | grep -qiE '(Traceback|Error:|Exception:|panic:|FAILED|fatal:| at .+\.[a-z]+:[0-9]+)'; then+if echo "$PROMPT" | grep -qE '(Traceback|panic:)'; then+ HAS_ERROR="true"+elif echo "$PROMPT" | grep -qE '^\s*fatal: '; then+ HAS_ERROR="true"+elif [ "$(echo "$PROMPT" | grep -cE '(Error:|Exception:|FAIL:)')" -ge 2 ]; thenHAS_ERROR="true"fidiff --git a/mem0-plugin/scripts/parse_mem0_config.py b/mem0-plugin/scripts/parse_mem0_config.pyindex 0db049c22..7dc132faa 100644--- a/mem0-plugin/scripts/parse_mem0_config.py+++ b/mem0-plugin/scripts/parse_mem0_config.py@@ -199,6 +199,10 @@ def load_full_config(cwd: str | None = None) -> dict:if ignore:config["ignore"] = ignore+ settings = parse_section_kv(content, "Settings")+ if settings:+ config["settings"] = settings+return config@@ -229,10 +233,44 @@ def main() -> int:With ``--full``, prints the complete config. Without it, prints onlyretention policies (backward-compatible).++ With ``--key <dotted.path>``, prints the scalar value at that path in the+ full config (e.g. ``--key settings.commit_prompts``). Prints an empty+ string when the key is absent. Exits 1 only on unexpected errors."""full_mode = "--full" in sys.argv- args = [a for a in sys.argv[1:] if not a.startswith("--")]- cwd = args[0] if args else os.getcwd()++ # Extract --key <value>+ key_path: str | None = None+ raw_args = sys.argv[1:]+ filtered_args: list[str] = []+ i = 0+ while i < len(raw_args):+ if raw_args[i] == "--key" and i + 1 < len(raw_args):+ key_path = raw_args[i + 1]+ i += 2+ elif raw_args[i].startswith("--key="):+ key_path = raw_args[i][len("--key="):]+ i += 1+ elif raw_args[i].startswith("--"):+ i += 1 # skip other flags like --full+ else:+ filtered_args.append(raw_args[i])+ i += 1++ cwd = filtered_args[0] if filtered_args else os.getcwd()++ if key_path is not None:+ config = load_full_config(cwd)+ # Traverse dotted path+ value: object = config+ for part in key_path.split("."):+ if not isinstance(value, dict):+ value = None+ break+ value = value.get(part)+ print(value if value is not None else "")+ return 0if full_mode:config = load_full_config(cwd)diff --git a/mem0-plugin/scripts/telemetry.py b/mem0-plugin/scripts/telemetry.pyindex 277389c60..08c53aa83 100644--- a/mem0-plugin/scripts/telemetry.py+++ b/mem0-plugin/scripts/telemetry.py@@ -27,7 +27,16 @@ import sysimport urllib.errorimport urllib.request-PLUGIN_VERSION = "0.2.1"++def _load_plugin_version() -> str:+ try:+ plugin_json = os.path.join(os.path.dirname(__file__), "..", ".claude-plugin", "plugin.json")+ with open(plugin_json) as f:+ return json.load(f).get("version", "unknown")+ except (OSError, json.JSONDecodeError, KeyError):+ return "unknown"++PLUGIN_VERSION = _load_plugin_version()POSTHOG_API_KEY = "phc_hgJkUVJFYtmaJqrvf6CYN67TIQ8yhXAkWzUn9AMU4yX"POSTHOG_HOST = "https://us.i.posthog.com/i/v0/e/"@@ -42,10 +51,10 @@ def _sha256(value: str) -> str:def _distinct_id() -> str:- """Stable anonymous ID: MD5 of API key if available, else SHA-256 of username."""+ """Stable anonymous ID: SHA-256 of API key if available, else SHA-256 of username."""api_key = os.environ.get("MEM0_API_KEY") or os.environ.get("CLAUDE_PLUGIN_OPTION_MEM0_API_KEY") or ""if api_key:- return hashlib.md5(api_key.encode()).hexdigest()+ return hashlib.sha256(api_key.encode()).hexdigest()[:32]user_id = os.environ.get("MEM0_RESOLVED_USER_ID") or os.environ.get("USER") or "unknown"return _sha256(user_id)@@ -75,6 +84,7 @@ def build_posthog_payload(event_name: str, properties: dict | None = None) -> di"distinct_id": _distinct_id(),"event": event_name,"properties": {+ **(properties or {}),"source": "plugin","platform": detect_platform(),"plugin_version": PLUGIN_VERSION,@@ -84,7 +94,6 @@ def build_posthog_payload(event_name: str, properties: dict | None = None) -> di"sample_rate": SAMPLE_RATE,"$process_person_profile": False,"$lib": "posthog-python",- **(properties or {}),},}diff --git a/mem0-plugin/skills/mem0-digest/SKILL.md b/mem0-plugin/skills/mem0-digest/SKILL.mddeleted file mode 100644index 0a77409f4..000000000--- a/mem0-plugin/skills/mem0-digest/SKILL.md+++ /dev/null@@ -1,123 +0,0 @@-----name: mem0-digest-description: >- Summarize recent memory activity for the current project. Shows new memories,- categories touched, and growth trends over the past 7 days.- TRIGGER: user runs /mem0:digest, or asks "weekly summary", "what's new in memory",- "mem0 digest", "memory recap".------# Mem0 Weekly Digest--Summarize recent memory activity for the current project.--## Execution--### Step 1: Fetch recent memories--Call `search_memories` in parallel with different time-scoped queries:--1. `query="decisions made this week"`, `filters={"AND": [{"user_id": "<id>"}, {"app_id": "<pid>"}, {"created_at": {"gte": "<7 days ago YYYY-MM-DD>"}}]}`, `limit=20`-2. `query="bugs errors fixes"`, same time filter, `limit=20`-3. `query="patterns conventions learnings"`, same time filter, `limit=20`--Also call `get_memories` with `user_id` + `app_id` to get the full count for comparison.--### Step 2: Deduplicate and analyze--Merge results by memory ID. For each memory, extract:-- `created_at` date-- `categories[0]` or `metadata.type`-- First 100 chars of content--Group into:-- **New this week** (created in last 7 days)-- **Older** (created before, but surfaced by search)--Calculate:-- Total memories in project-- Memories added in last 7 days-- Most active categories this week-- Days with most activity--### Step 3: Display--```-## mem0 Weekly Digest — <project_id>-Period: <start_date> to <today>--### New Memories This Week: <N>-<category>: <count>- - <memory summary, 80 chars> (<date>)- - ...-<category>: <count>- - ...--### Activity Pattern-Most active day: <day> (<N> memories)-Categories touched: <list>--### Project Totals-Total memories: <N> (up <N> from last week)-Top categories: <top 3 by count>--### Highlights-<2-3 sentence summary of the most important decisions, learnings, or patterns stored this week>-```--### Step 4: Write digest to file--After displaying, write the digest to `~/.mem0/weekly-digest.md` for persistence-and external consumption (email, Slack, etc.):--```bash-mkdir -p ~/.mem0-```--Write the full digest output (same markdown shown in terminal) to `~/.mem0/weekly-digest.md`-using the Write tool. **Overwrite** the file each time — it always contains the latest digest.--Also append a one-line summary to `~/.mem0/digest-history.log` for trend tracking:--```bash-echo "<YYYY-MM-DD> | <project_id> | +<new_count> memories | top: <top_category>" >> ~/.mem0/digest-history.log-```--Print at the end:-```-Digest saved to ~/.mem0/weekly-digest.md-```--### Step 5: Schedule recurring digests--When invoked with `--schedule` (e.g., `/mem0:digest --schedule weekly`), register-a cloud routine via Claude Code's `/schedule` command:--```-/schedule <frequency> /mem0:digest-```--For example:-- `/schedule weekly on Monday 9am /mem0:digest` — digest every Monday morning-- `/schedule daily at 8am /mem0:digest` — daily digest--Print:-```-Digest scheduled: <frequency>-Manage at: https://claude.ai/code/routines-```--If `/schedule` is unavailable, print a cron one-liner the user can install manually:-```bash-# macOS/Linux — weekly Monday 9am-(crontab -l 2>/dev/null; echo "0 9 * * 1 cd PROJECT_DIR && claude -p '/mem0:digest' >> /tmp/mem0-digest.log 2>&1") | crontab --```--### Step 6: Empty state--If no memories in the last 7 days:-```-No new memories in the past week for <project_id>.-Total project memories: <N>.-Tip: mem0 captures learnings automatically as you work. Start coding!-```diff --git a/mem0-plugin/skills/mem0-dream/SKILL.md b/mem0-plugin/skills/mem0-dream/SKILL.mdindex 9964b72ca..d0a8bccc2 100644--- a/mem0-plugin/skills/mem0-dream/SKILL.md+++ b/mem0-plugin/skills/mem0-dream/SKILL.md@@ -235,6 +235,58 @@ In auto mode:)```+## Forget mode (targeted deletion)++When invoked with `--forget` (e.g., `/mem0:dream --forget auth module decisions`+or `/mem0:dream --forget <memory_id>`), skip consolidation and go straight to+search-confirm-delete:++### F1: Parse input++The argument after `--forget` is either:+- A search query: `/mem0:dream --forget auth module decisions`+- A memory ID: `/mem0:dream --forget <memory_id>`++If no argument after `--forget`, ask: "What should I forget? Provide a search query or memory ID."++### F2: Find memories++**If memory ID provided** (looks like a UUID or hex string):+- Call `get_memory` with the ID to verify it exists.+- Show: `Found: "<memory content first 120 chars>" (created <date>)`++**If search query provided:**+- Call `search_memories` with:+ - `query=<user's query>`+ - `filters={"AND": [{"user_id": "<id>"}, {"app_id": "<project_id>"}]}`+ - `limit=10`+- Show numbered list:+ ```+ Found <N> memories matching "<query>":+ 1. <content, 120 chars> (type: <type>, created: <date>) [ID: <short_id>]+ 2. ...+ ```++### F3: Confirm++Ask: "Delete which memories? Enter numbers (e.g., 1,3,5), 'all', or 'cancel'."+For a single memory ID: "Delete this memory? [y/N]"++**Never delete without confirmation.**++### F4: Delete and report++Call `delete_memory` for each confirmed entry. Report: `Deleted <N> memories.`++### Undo recent writes++If the user says "undo last N memories" or "undo last write":+1. Run `python3 "$SCRIPT_DIR/session_stats.py" peek` to get `recent_ids`.+2. Show last N entries, ask for confirmation.+3. Delete confirmed entries via `delete_memory`.++---+## Scheduling recurring dreamsWhen invoked with `--schedule` (e.g., `/mem0:dream --schedule weekly`), register adiff --git a/mem0-plugin/skills/mem0-forget/SKILL.md b/mem0-plugin/skills/mem0-forget/SKILL.mddeleted file mode 100644index 3a2657de8..000000000--- a/mem0-plugin/skills/mem0-forget/SKILL.md+++ /dev/null@@ -1,76 +0,0 @@-----name: mem0-forget-description: >- Delete memories by search query or memory ID. Shows matches for confirmation- before deleting. Safe — always confirms before destructive action.- TRIGGER: user runs /mem0:forget <query>, or says "forget this", "delete memory",- "remove that memory about X".------# Mem0 Forget--Delete specific memories from mem0.--## Execution--### Step 1: Parse input--The user provides either:-- A search query: `/mem0:forget auth module decisions`-- A memory ID: `/mem0:forget <memory_id>`--If no argument, ask: "What should I forget? Provide a search query or memory ID."--### Step 2: Find memories--**If memory ID provided** (looks like a UUID or hex string):-- Call `get_memory` with the ID to verify it exists.-- Show: `Found: "<memory content first 120 chars>" (created <date>)`--**If search query provided:**-- Call `search_memories` with:- - `query=<user's query>`- - `user_id=<active_user_id>`- - `filters={"AND": [{"user_id": "<id>"}, {"app_id": "<project_id>"}]}`- - `limit=10`-- Show numbered list:- ```- Found <N> memories matching "<query>":- 1. <content, 120 chars> (type: <type>, created: <date>) [ID: <short_id>]- 2. ...- ```--### Step 3: Confirm--Ask: "Delete which memories? Enter numbers (e.g., 1,3,5), 'all', or 'cancel'."--For a single memory ID, ask: "Delete this memory? [y/N]"--**Never delete without confirmation.** This is destructive.--### Step 4: Delete--For each confirmed memory, call `delete_memory` with the memory ID.--### Step 5: Report--```-Deleted <N> memories.-```--If any deletions failed, report which ones and why.--## Undo recent writes--If the user says "undo last N memories" or "undo last write":--1. Read session stats to get recently written memory IDs:- ```bash- SCRIPT_DIR="${CLAUDE_PLUGIN_ROOT:-${CODEX_PLUGIN_ROOT:-${CURSOR_PLUGIN_ROOT:-}}}/scripts"- python3 "$SCRIPT_DIR/session_stats.py" peek- ```-2. Parse the `recent_ids` array from the JSON output. Each entry has `id`, `category`, `ts`.-3. Show the last N entries (default 1) and ask for confirmation.-4. Delete confirmed entries via `delete_memory`.--If `recent_ids` is empty, tell the user: "No recent memory IDs tracked this session. Use a search query instead."diff --git a/mem0-plugin/skills/mem0-import-tools/SKILL.md b/mem0-plugin/skills/mem0-import-tools/SKILL.mddeleted file mode 100644index 9336fe654..000000000--- a/mem0-plugin/skills/mem0-import-tools/SKILL.md+++ /dev/null@@ -1,106 +0,0 @@-----name: mem0-import-tools-description: >- Import memories from competing AI tool configuration files into mem0.- Supports Cursor (.cursorrules), GitHub Copilot (.github/copilot-instructions.md),- Cline (memory-bank/), and Continue (.continue/rules.md).- TRIGGER: user runs /mem0:import-tools, or asks "import from cursor",- "import cursorrules", "import from cline", "import from copilot",- "import from continue", "migrate from cursor", "migrate memories".------# Mem0 Import from Competing Tools--Import configuration and memory files from other AI coding tools into mem0.--## Supported Tools--| Tool | Default file/directory |-|------|----------------------|-| Cursor | `.cursorrules` |-| GitHub Copilot | `.github/copilot-instructions.md` |-| Cline | `memory-bank/` (directory of `.md` files) |-| Continue | `.continue/rules.md` |--## Execution--### Step 1: Detect which tool files exist--Check for the presence of each tool's file/directory in the current working directory:--```bash-# Check each location-test -f .cursorrules && echo "cursor: .cursorrules"-test -f .github/copilot-instructions.md && echo "copilot: .github/copilot-instructions.md"-test -d memory-bank/ && echo "cline: memory-bank/"-test -f .continue/rules.md && echo "continue: .continue/rules.md"-```--### Step 2: Report findings and ask user--List all found files to the user. For example:--```-Found the following tool configuration files:- [1] Cursor rules: .cursorrules- [2] Cline memory bank: memory-bank/--Which would you like to import? (enter numbers, comma-separated, or "all"):-```--If no files are found, print:-```-No competing tool configuration files found in the current directory.-Checked: .cursorrules, .github/copilot-instructions.md, memory-bank/, .continue/rules.md-```-and stop.--### Step 3: Run the import script for each selected tool--Determine the plugin root. Use the appropriate variable for the current platform:-- Claude Code: `${CLAUDE_PLUGIN_ROOT}`-- Codex: `${CODEX_PLUGIN_ROOT}`-- Cursor: `${CURSOR_PLUGIN_ROOT}`--For each tool the user selected, run the corresponding sub-command:--**Cursor (.cursorrules):**-```bash-python3 "<PLUGIN_ROOT>/scripts/import_competing_tools.py" cursorrules --path .cursorrules-```--**GitHub Copilot:**-```bash-python3 "<PLUGIN_ROOT>/scripts/import_competing_tools.py" copilot --path .github/copilot-instructions.md-```--**Cline:**-```bash-python3 "<PLUGIN_ROOT>/scripts/import_competing_tools.py" cline --path memory-bank/-```--**Continue:**-```bash-python3 "<PLUGIN_ROOT>/scripts/import_competing_tools.py" continue --path .continue/rules.md-```--### Step 4: Report results--After each script runs, echo its output to the user. Then print a combined summary:--```-Import complete.- Cursor: <N> memories- Copilot: <N> memories- Total: <N> memories imported into project <project_id>-```--Adjust the summary to reflect only the tools that were actually imported.--## Notes--- Memories are imported with `infer=False` — no AI inference is applied, content is stored as-is.-- Each section or file becomes a separate memory tagged with `metadata.source=<tool>-import` and `metadata.type=project_profile`.-- Sections shorter than 50 characters are automatically skipped (too short to be useful).-- Content longer than 10,000 characters is automatically truncated per chunk.-- You can re-run this skill safely — duplicate content will be caught by mem0's deduplication.diff --git a/mem0-plugin/skills/mem0-import/SKILL.md b/mem0-plugin/skills/mem0-import/SKILL.mdindex 3f3032364..34d9cdd59 100644--- a/mem0-plugin/skills/mem0-import/SKILL.md+++ b/mem0-plugin/skills/mem0-import/SKILL.md@@ -98,6 +98,87 @@ If any failed:Imported <N>/<total> memories into project <project_id> (<failed> failed)```+## Importing from competing AI tools (`--tools`)++When invoked with `--tools` (e.g., `/mem0:import --tools`), detect and import+from competing AI tool configuration files:++### Supported tools++| Tool | File/directory |+|------|---------------|+| Cursor | `.cursorrules` |+| GitHub Copilot | `.github/copilot-instructions.md` |+| Cline | `memory-bank/` (directory of `.md` files) |+| Continue | `.continue/rules.md` |++### T1: Detect++```bash+test -f .cursorrules && echo "cursor: .cursorrules"+test -f .github/copilot-instructions.md && echo "copilot: .github/copilot-instructions.md"+test -d memory-bank/ && echo "cline: memory-bank/"+test -f .continue/rules.md && echo "continue: .continue/rules.md"+```++### T2: Ask user++List found files, ask which to import (numbers, comma-separated, or "all").+If none found:+```+No competing tool configuration files found.+Checked: .cursorrules, .github/copilot-instructions.md, memory-bank/, .continue/rules.md+```++### T3: Run import++For each selected tool:+```bash+python3 "<PLUGIN_ROOT>/scripts/import_competing_tools.py" <tool> --path <file>+```++Tools: `cursorrules`, `copilot`, `cline`, `continue`.++### T4: Report++```+Import complete.+ Cursor: <N> memories+ Copilot: <N> memories+ Total: <N> memories imported into project <project_id>+```++Notes: `infer=False`, tagged `metadata.source=<tool>-import`, sections <50 chars+skipped, chunks >10k chars truncated, safe to re-run (deduplication handles it).++---++## Importing Claude Code's native MEMORY.md++When invoked with a path to Claude Code's native `MEMORY.md` file (typically+`~/.claude/projects/<proj-key>/memory/MEMORY.md`), or when `on_session_start.sh`+detects native auto-memory and the user chooses to import:++1. Read the file. It contains newline-separated memory entries (one fact per line,+ sometimes with `- ` bullet prefix).+2. Split by non-empty lines. Each line becomes one memory.+3. Skip lines shorter than 20 characters or lines that are just headers (`#`).+4. For each line, call `add_memory` with:+ - `messages=[{"role": "user", "content": "<line>"}]`+ - `user_id=<active_user_id>`+ - `app_id=<active_project_id>`+ - `metadata={"type": "task_learning", "source": "memory-md-import", "confidence": 0.8}`+ - `infer=False`+5. Report: `Imported <N> memories from MEMORY.md into project <project_id>`+6. Suggest disabling native auto-memory:+ ```+ To avoid duplicate memory systems, add to ~/.claude/settings.json:+ "autoMemoryEnabled": false+ ```++This handles the cold-start gap when a user has been using Claude Code's native+memory and switches to mem0.+## Error Handling- If the parser script is not found at `<PLUGIN_ROOT>/scripts/parse_export_file.py`, print an error and stop.diff --git a/mem0-plugin/skills/mem0-list-projects/SKILL.md b/mem0-plugin/skills/mem0-list-projects/SKILL.mdnew file mode 100644index 000000000..d5dfd6746--- /dev/null+++ b/mem0-plugin/skills/mem0-list-projects/SKILL.md@@ -0,0 +1,71 @@+---+name: mem0-list-projects+description: >+ List all project scopes (app_ids) that have stored memories for the current+ user. Essential for /mem0:switch-project discoverability and cross-project+ workflows.+ TRIGGER: user runs /mem0:list-projects, or asks "what projects does mem0 know",+ "list my mem0 projects", "show all projects", "which app_ids exist".+---++# Mem0 List Projects++Show all known project scopes for the current user.++## Execution++### Step 1: Fetch memories to discover app_ids++There is no dedicated "list projects" API endpoint. Discover projects by fetching+the user's memories and extracting distinct `app_id` values.++Call `get_memories` with:+- `user_id=<active_user_id>`+- `page_size=200`++Do NOT pass `app_id` — we want memories across ALL projects.++If the response indicates more pages, paginate until all are fetched (up to 1000+memories max to avoid excessive API calls).++### Step 2: Extract distinct projects++For each memory, read the `app_id` field (may also appear as `metadata.app_id`+on older memories). Collect distinct values.++For each project, count:+- Total memories+- Most recent `created_at` date+- Top 3 `metadata.type` values by frequency++### Step 3: Display++```+## mem0 Projects for <user_id>++| Project | Memories | Last Active | Top Categories |+|---------|----------|-------------|---------------|+| <app_id_1> | <count> | <date> | decision, convention, anti_pattern |+| <app_id_2> | <count> | <date> | task_learning, environmental |+| ... | | | |++Active project: <current_project_id> ← (current)+Total: <N> projects, <M> total memories+```++Mark the current project with `← (current)`.++### Step 4: Empty state++If zero memories found:+```+No projects found for user <user_id>.+Run /mem0:onboard in a project directory to get started.+```++### Step 5: Suggest next actions++```+Switch project: /mem0:switch-project <name>+Search across all: /mem0:tour --all-projects+```diff --git a/mem0-plugin/skills/mem0-mcp/SKILL.md b/mem0-plugin/skills/mem0-mcp/SKILL.mdindex 750e0275f..49cbe2848 100644--- a/mem0-plugin/skills/mem0-mcp/SKILL.md+++ b/mem0-plugin/skills/mem0-mcp/SKILL.md@@ -49,6 +49,21 @@ filters={"AND": [Empty results are normal. Proceed without context — they don't mean the system is broken.+### Contradiction detection at search time++After receiving search results, scan for contradictions before using them:++1. If 2+ results address the **same topic** (same `metadata.type`, overlapping file paths or entity names) but assert **opposing facts**, surface BOTH to the user instead of silently picking one.+2. Format:+ ```+ ⚠️ Conflicting memories found:+ - [mem0:<id1>] "<content1>" (confidence: <score1>, <date1>)+ - [mem0:<id2>] "<content2>" (confidence: <score2>, <date2>)+ Which is current?+ ```+3. After the user resolves: update the loser via `update_memory` to mark it superseded, or delete it. Store the winner's fact as authoritative if not already.+4. If the user doesn't resolve, default to the more recent memory with higher confidence, but note the ambiguity in your response.+### How to search wellWhen you do search, run **2–4 parallel** `search_memories` calls at different angles instead of one query echoing the user's prompt.@@ -130,6 +145,31 @@ search_memories(query="auth",Extract key learnings and store them using the `add_memory` tool:+### REQUIRED metadata fields++Every `add_memory` call MUST include these metadata fields. Do NOT omit them:++| Field | Type | Required | Description |+|-------|------|----------|-------------|+| `type` | string | YES | Memory category: `decision`, `task_learning`, `anti_pattern`, `convention`, `user_preference`, `environmental`, `session_state`, `compact_summary` |+| `confidence` | float | YES | 0.0–1.0 confidence score. Default: `0.7` for inferred learnings, `0.9` for explicit user statements |+| `files` | list[str] | YES | File paths relevant to this memory. Use `["*"]` for project-wide learnings |+| `source` | string | YES | How the memory was captured: `user_request`, `auto_capture`, `post_commit`, `error_recovery` |++**Example:**+```json+{+ "metadata": {+ "type": "decision",+ "confidence": 0.9,+ "files": ["src/auth/login.py", "src/auth/middleware.py"],+ "source": "user_request"+ }+}+```++**If you omit `confidence` or `files`, the memory will be harder to rank and retrieve later.**+- **Decisions made** -> Include metadata `{"type": "decision"}`- **Strategies that worked** -> Include metadata `{"type": "task_learning"}`- **Failed approaches** -> Include metadata `{"type": "anti_pattern"}`diff --git a/mem0-plugin/skills/mem0-onboard/SKILL.md b/mem0-plugin/skills/mem0-onboard/SKILL.mdindex ecf538f1f..e05ab8b64 100644--- a/mem0-plugin/skills/mem0-onboard/SKILL.md+++ b/mem0-plugin/skills/mem0-onboard/SKILL.md@@ -82,7 +82,7 @@ Then retry the categories script.## Step 5: Mark project as onboarded-Create a marker file so SessionStart won't re-trigger onboarding next session:+The marker file is already created by `on_session_start.sh` on first display of the onboard prompt. Touch it here for idempotency:```bash_SAFE_PID=$(printf '%s' "<active_project_id>" | tr '/:' '--')diff --git a/mem0-plugin/skills/mem0-peek/SKILL.md b/mem0-plugin/skills/mem0-peek/SKILL.mddeleted file mode 100644index f6ea48133..000000000--- a/mem0-plugin/skills/mem0-peek/SKILL.md+++ /dev/null@@ -1,46 +0,0 @@-----name: mem0-peek-description: >- Quick search — compact one-liner results. Faster and lighter than /mem0:tour.- Takes a search query as argument.- TRIGGER: user runs /mem0:peek <query>, or says "quick search mem0",- "what do we know about X", "peek at memories about Y".------# Mem0 Peek--Quick search with compact output. Lighter than `/mem0:tour`.--## Execution--### Step 1: Parse query--The user provides a search query: `/mem0:peek auth middleware`--If no query provided, ask: "What should I search for?"--### Step 2: Search--Run 2 parallel `search_memories` calls:--1. Broad: `query=<user's query>`, `filters={"AND": [{"user_id": "<id>"}, {"app_id": "<pid>"}]}`, `limit=10`-2. Targeted: `query=<user's query>`, `filters={"AND": [{"user_id": "<id>"}, {"app_id": "<pid>"}, {"metadata": {"type": "decision"}}]}`, `limit=5`--### Step 3: Display--Deduplicate by ID, then show compact results:--```-## mem0 peek: "<query>" (<N> results)--1. [decision] Auth module uses JWT with RS256 keys (2025-05-15) [mem0:a3f8b2c1]-2. [anti_pattern] Don't use symmetric HS256 — leaked in env (2025-05-10) [mem0:7e2d9f4a]-3. [convention] All middleware in src/middleware/ (2025-05-08) [mem0:c4d5e6f7]-```--Format: `<number>. [<type>] <content, 80 chars> (<date>) [mem0:<short_id>]`--If no results:-```-No memories matching "<query>" for project <project_id>.-```diff --git a/mem0-plugin/skills/mem0-pin/SKILL.md b/mem0-plugin/skills/mem0-pin/SKILL.mdindex 84e97aaea..ade371bad 100644--- a/mem0-plugin/skills/mem0-pin/SKILL.md+++ b/mem0-plugin/skills/mem0-pin/SKILL.md@@ -1,10 +1,12 @@---name: mem0-pindescription: >- Pin important memories so they surface prominently. Updates metadata to mark- a memory as pinned. Pinned memories should be prioritized during search.- TRIGGER: user runs /mem0:pin <query or ID>, or says "pin this memory",- "mark as important", "always remember this".+ Pin important memories so they surface prominently and are protected from+ consolidation. New pins use immutable: true (SDK v2.1.33+) to prevent+ deduplication from modifying or removing the memory. Existing memories get+ metadata.pinned: true as a search-time filter; full consolidation protection+ requires delete + re-add. TRIGGER: user runs /mem0:pin <query or ID>, or+ says "pin this memory", "mark as important", "always remember this".---# Mem0 Pin@@ -35,12 +37,28 @@ This is required because `update_memory` replaces the full memory — a metadata### Step 3: Pin it+There are two sub-cases depending on whether the user wants to pin an **existing** memory or create a **new** pinned memory from scratch.++#### 3a: Pinning a new memory (preferred path for full protection)++Use `add_memory` with `immutable: true` as a top-level parameter. The `immutable` flag is a first-class platform parameter (added in SDK v2.1.33) that prevents the memory from being modified or removed by consolidation/deduplication. `metadata.pinned: true` is also included as a search-time filter aid.++```python+add_memory(+ messages=[{"role": "user", "content": "<text to pin>"}],+ user_id=<user_id>,+ immutable=True,+ metadata={"pinned": True},+)+```++#### 3b: Pinning an existing memory+Call `update_memory` with:- `memory_id=<selected_id>`- `data=<original_text>` (preserve the existing content)- `metadata=` merge `original_metadata` with `{"pinned": true}`-Example:```pythonupdated_meta = {**original_metadata, "pinned": True}update_memory(memory_id=<selected_id>, data=<original_text>, metadata=updated_meta)@@ -48,12 +66,23 @@ update_memory(memory_id=<selected_id>, data=<original_text>, metadata=updated_me**Important:** `update_memory` requires the `data` (text) parameter. Passing only metadata may error or wipe content. Always read first, then update with the full text and explicit metadata.+**Consolidation-protection limitation:** `update_memory` cannot set the `immutable` flag on an existing memory. If the user needs full consolidation protection for an existing memory, they must delete it and re-add it using `add_memory` with `immutable: true` (path 3a above). In the confirm step (Step 4), note this limitation if the user pinned an existing memory via `update_memory`.+### Step 4: Confirm+For new pins created via `add_memory` with `immutable: true`:+```+Pinned: "<memory content, first 80 chars>..."+Memory ID: <id>+Pinned with consolidation protection (immutable). This memory will not be modified or removed by deduplication.+```++For existing memories pinned via `update_memory`:```Pinned: "<memory content, first 80 chars>..."Memory ID: <id>Pinned memories surface first when relevant to a search.+Note: consolidation protection (immutable flag) requires delete + re-add. Say "re-pin this with full protection" to do that.```### Unpindiff --git a/mem0-plugin/skills/mem0-stats/SKILL.md b/mem0-plugin/skills/mem0-stats/SKILL.mdindex d2d67c259..5f9215f4a 100644--- a/mem0-plugin/skills/mem0-stats/SKILL.md+++ b/mem0-plugin/skills/mem0-stats/SKILL.md@@ -94,3 +94,56 @@ Print a compact dashboard with an ASCII histogram for category distribution:- **Access count buckets:** Read `metadata.access_count` (default 0 if absent). Buckets: 0, 1–5, 6–20, 20+.Skip any section with zero data.++## Weekly digest mode++When invoked with `--weekly` (e.g., `/mem0:stats --weekly`), append a weekly+activity digest after the standard stats dashboard:++### W1: Fetch recent memories++Call `search_memories` in parallel with time-scoped queries:+1. `query="decisions made this week"`, `filters={"AND": [{"user_id": "<id>"}, {"app_id": "<pid>"}, {"created_at": {"gte": "<7 days ago YYYY-MM-DD>"}}]}`, `limit=20`+2. `query="bugs errors fixes"`, same time filter, `limit=20`+3. `query="patterns conventions learnings"`, same time filter, `limit=20`++### W2: Analyze++Merge by ID. Group into "New this week" by `categories[0]` or `metadata.type`.+Calculate: memories added last 7 days, most active categories, most active day.++### W3: Display++Append after the standard stats:++```+### Weekly Digest (<start_date> to <today>)++New Memories This Week: <N>+ <category>: <count>+ - <memory summary, 80 chars> (<date>)+ - ...++Activity Pattern+ Most active day: <day> (<N> memories)+ Categories touched: <list>++Highlights+ <2-3 sentence summary of most important decisions/learnings this week>+```++### W4: Write digest file++Write to `~/.mem0/weekly-digest.md` (overwrite). Append one-line to+`~/.mem0/digest-history.log`:+```+<YYYY-MM-DD> | <project_id> | +<new_count> memories | top: <top_category>+```++### W5: Empty state++If no new memories in 7 days:+```+No new memories in the past week for <project_id>.+Total project memories: <N>.+```diff --git a/mem0-plugin/skills/mem0-tour/SKILL.md b/mem0-plugin/skills/mem0-tour/SKILL.mdindex 1e28dca4a..6c808118a 100644--- a/mem0-plugin/skills/mem0-tour/SKILL.md+++ b/mem0-plugin/skills/mem0-tour/SKILL.md@@ -11,6 +11,55 @@ description: >Show the user what mem0 has stored for the current project.+## Cross-project mode++When invoked with `--all-projects` (e.g., `/mem0:tour --all-projects` or+`/mem0:tour --all-projects auth middleware`), search across ALL projects:++1. Call `get_memories` with `user_id=<active_user_id>`, `page_size=200` — **no `app_id` filter**.+2. If a search query was also provided, run `search_memories` with `query=<query>`,+ `filters={"AND": [{"user_id": "<id>"}]}`, `limit=20` — again no `app_id`.+3. Group results by `app_id` first, then by category within each project.+4. Display:+ ```+ ## Cross-Project Tour for <user_id>++ ### <app_id_1> (<N> memories)+ #### Architecture Decisions+ - <memory content>+ ...++ ### <app_id_2> (<N> memories)+ ...++ ---+ Total: <N> memories across <M> projects+ ```+5. Mark the current project with `← (current)` in the heading.++If `--all-projects` is NOT present, use the standard single-project flow below.++## Peek mode (compact search)++When `/mem0:tour` receives a search query argument (e.g., `/mem0:tour auth middleware`)+WITHOUT `--all-projects`, run in **peek mode** — compact one-liner results:++1. Run 2 parallel `search_memories` calls:+ - Broad: `query=<query>`, `filters={"AND": [{"user_id": "<id>"}, {"app_id": "<pid>"}]}`, `limit=10`+ - Targeted: `query=<query>`, `filters={"AND": [{"user_id": "<id>"}, {"app_id": "<pid>"}, {"metadata": {"type": "decision"}}]}`, `limit=5`+2. Deduplicate by ID, display compact results:+ ```+ ## mem0 search: "<query>" (<N> results)++ 1. [decision] Auth module uses JWT with RS256 keys (2025-05-15) [mem0:a3f8b2c1]+ 2. [anti_pattern] Don't use symmetric HS256 — leaked in env (2025-05-10) [mem0:7e2d9f4a]+ 3. [convention] All middleware in src/middleware/ (2025-05-08) [mem0:c4d5e6f7]+ ```+ Format: `<number>. [<type>] <content, 80 chars> (<date>) [mem0:<short_id>]`+3. If no results: `No memories matching "<query>" for project <project_id>.`++If no query argument and no `--all-projects` flag, use the full tour flow below.+## Execution### Step 1: Fetch ALL memories for this projectdiff --git a/mem0-plugin/tests/conftest.py b/mem0-plugin/tests/conftest.pyindex d760e5882..a7d4e4a4b 100644--- a/mem0-plugin/tests/conftest.py+++ b/mem0-plugin/tests/conftest.py@@ -22,6 +22,17 @@ def _scripts_on_path():sys.path.remove(abs_scripts)[email protected](autouse=True)+def _clean_project_map():+ """Remove project_map.json before each test to prevent cross-test pollution."""+ map_path = os.path.expanduser("~/.mem0/project_map.json")+ if os.path.isfile(map_path):+ os.remove(map_path)+ yield+ if os.path.isfile(map_path):+ os.remove(map_path)++@pytest.fixture()def tmp_git_repo(tmp_path):"""Create a temp dir with a git repo and HTTPS remote."""diff --git a/mem0-plugin/tests/test_import_competing_tools.py b/mem0-plugin/tests/test_import_competing_tools.pyindex 5c78a5a0c..48a76d700 100644--- a/mem0-plugin/tests/test_import_competing_tools.py+++ b/mem0-plugin/tests/test_import_competing_tools.py@@ -17,7 +17,7 @@ SCRIPTS_DIR = os.path.join(os.path.dirname(__file__), "..", "scripts")def test_split_by_headers_cursorrules():"""split_by_headers correctly splits .cursorrules content on ## headers."""- from import_competing_tools import split_by_headers+ from _chunking import split_by_headerscontent = """\# My Cursor Rules@@ -57,7 +57,7 @@ Write tests for all utility functions.def test_split_by_headers_copilot():"""split_by_headers correctly splits copilot-instructions.md on ## headers."""- from import_competing_tools import split_by_headers+ from _chunking import split_by_headerscontent = """\## Code Style@@ -78,7 +78,7 @@ Follow clean architecture principles. Keep business logic in domain layer.def test_split_by_headers_no_headers():"""split_by_headers returns entire content as one chunk if no headers found."""- from import_competing_tools import split_by_headers+ from _chunking import split_by_headerscontent = "This file has no headers at all. Just plain text."chunks = split_by_headers(content, "## ")@@ -88,7 +88,7 @@ def test_split_by_headers_no_headers():def test_split_cline_multiple_md_files(tmp_path):"""cmd_cline processes multiple .md files from memory-bank/ directory."""- from import_competing_tools import filter_and_truncate+ from _chunking import filter_and_truncate# Create a temporary memory-bank directory with .md filesmb_dir = tmp_path / "memory-bank"@@ -124,7 +124,7 @@ def test_split_cline_multiple_md_files(tmp_path):def test_split_by_hr_or_headers_continue():"""split_by_hr_or_headers correctly splits .continue/rules.md."""- from import_competing_tools import split_by_hr_or_headers+ from _chunking import split_by_hr_or_headerscontent = """\## First Section@@ -150,7 +150,7 @@ Third section without a header (just after HR).def test_filter_and_truncate_skips_short():"""filter_and_truncate skips chunks shorter than MIN_CHUNK_CHARS (50)."""- from import_competing_tools import filter_and_truncate+ from _chunking import filter_and_truncatechunks = ["Short", # < 50 chars, should be filtered@@ -165,7 +165,7 @@ def test_filter_and_truncate_skips_short():def test_filter_and_truncate_truncates_long():"""filter_and_truncate truncates chunks over MAX_CHUNK_CHARS (10000)."""- from import_competing_tools import MAX_CHUNK_CHARS, filter_and_truncate+ from _chunking import MAX_CHUNK_CHARS, filter_and_truncatelong_chunk = "X" * (MAX_CHUNK_CHARS + 500)result = filter_and_truncate([long_chunk])diff --git a/mem0-plugin/tests/test_parse_mem0_config.py b/mem0-plugin/tests/test_parse_mem0_config.pyindex d720f7802..4ba261f6d 100644--- a/mem0-plugin/tests/test_parse_mem0_config.py+++ b/mem0-plugin/tests/test_parse_mem0_config.py@@ -422,3 +422,18 @@ def test_cli_full_flag(tmp_path):data = json.loads(result.stdout)assert "retention" in dataassert "search" in data+++def test_load_full_config_settings_section(tmp_path):+ """Settings section is parsed by load_full_config."""+ mem0_md = tmp_path / "mem0.md"+ mem0_md.write_text("""\+## Settings+commit_prompts: true+subagent_skip: Explore, Plan, code-reviewer+""")+ sys.path.insert(0, SCRIPTS_DIR)+ from parse_mem0_config import load_full_config+ config = load_full_config(str(tmp_path))+ assert config.get("settings", {}).get("commit_prompts") == "true"+ assert config.get("settings", {}).get("subagent_skip") == "Explore, Plan, code-reviewer"diff --git a/mem0-plugin/tests/test_pre_commit.py b/mem0-plugin/tests/test_pre_commit.pydeleted file mode 100644index 5757778b8..000000000--- a/mem0-plugin/tests/test_pre_commit.py+++ /dev/null@@ -1,54 +0,0 @@-"""Tests for on_pre_commit.py — pre-commit memory capture."""--from __future__ import annotations--import os-from unittest.mock import MagicMock--SCRIPTS_DIR = os.path.join(os.path.dirname(__file__), "..", "scripts")---def test_import_succeeds():- """on_pre_commit module can be imported."""- import on_pre_commit-- assert hasattr(on_pre_commit, "main")---def test_no_api_key_exits_zero(monkeypatch):- """main() exits 0 when no API key is set."""- import on_pre_commit-- monkeypatch.delenv("MEM0_API_KEY", raising=False)- monkeypatch.delenv("CLAUDE_PLUGIN_OPTION_MEM0_API_KEY", raising=False)- monkeypatch.setattr("sys.stdin", MagicMock(isatty=lambda: True))-- assert on_pre_commit.main() == 0---def test_empty_diff_exits_zero(monkeypatch):- """main() exits 0 when stdin diff is empty."""- from io import StringIO-- import on_pre_commit-- monkeypatch.setenv("MEM0_API_KEY", "test-key")- monkeypatch.setattr("sys.stdin", StringIO(""))-- assert on_pre_commit.main() == 0---def test_get_staged_summary_runs():- """get_staged_summary doesn't crash even outside a git repo."""- import on_pre_commit-- result = on_pre_commit.get_staged_summary()- assert isinstance(result, str)---def test_get_commit_message_runs():- """get_commit_message doesn't crash even outside a git repo."""- import on_pre_commit-- result = on_pre_commit.get_commit_message()- assert isinstance(result, str)diff --git a/mem0-plugin/tests/test_project.py b/mem0-plugin/tests/test_project.pyindex 058ceee9f..39867b41d 100644--- a/mem0-plugin/tests/test_project.py+++ b/mem0-plugin/tests/test_project.py@@ -105,3 +105,67 @@ def test_resolve_project_id_priority_order(tmp_git_repo, monkeypatch):# Env var overrides everythingmonkeypatch.setenv("MEM0_PROJECT_ID", "from-env")assert resolve_project_id(str(tmp_git_repo)) == "from-env"+++def test_remote_hash_key_format(tmp_git_repo):+ """_remote_hash_key() returns 'remote:<16-char-hex>' for a repo with a remote."""+ import re++ from _project import _remote_hash_key++ key = _remote_hash_key(str(tmp_git_repo))+ assert re.fullmatch(r"remote:[0-9a-f]{16}", key), (+ f"Expected 'remote:<16-char-hex>', got {key!r}"+ )+++def test_remote_hash_key_no_git(tmp_no_git):+ """_remote_hash_key() returns empty string when not in a git repo."""+ from _project import _remote_hash_key++ key = _remote_hash_key(str(tmp_no_git))+ assert key == ""+++def test_save_project_mapping_writes_remote_key(tmp_git_repo):+ """save_project_mapping() writes both the CWD key and the remote hash key."""+ import re++ from _project import save_project_mapping++ save_project_mapping(str(tmp_git_repo), "my-project")+ map_path = os.path.expanduser("~/.mem0/project_map.json")+ with open(map_path) as f:+ data = json.load(f)++ assert data[str(tmp_git_repo)] == "my-project"+ remote_keys = [k for k in data if re.fullmatch(r"remote:[0-9a-f]{16}", k)]+ assert remote_keys, "Expected at least one remote:<hash> key in project_map.json"+ assert data[remote_keys[0]] == "my-project"+++def test_resolve_project_id_remote_hash_fallback(tmp_git_repo, tmp_path):+ """Moving the project folder: remote hash key is used as fallback."""+ from _project import resolve_project_id, save_project_mapping++ # Save mapping for original location+ save_project_mapping(str(tmp_git_repo), "stable-project")++ # Simulate folder move: resolve using a different CWD path that shares the same remote.+ # We use a second tmp_git_repo with the same remote URL to mimic a renamed directory.+ import subprocess as _sp+ new_repo = tmp_path / "moved_repo"+ new_repo.mkdir()+ _sp.run(["git", "init"], cwd=new_repo, capture_output=True, check=True)+ _sp.run(+ ["git", "remote", "add", "origin", "https://github.com/mem0ai/mem0.git"],+ cwd=new_repo,+ capture_output=True,+ check=True,+ )++ # The new CWD is NOT in project_map, but remote hash should match+ pid = resolve_project_id(str(new_repo))+ assert pid == "stable-project", (+ f"Expected 'stable-project' via remote hash fallback, got {pid!r}"+ )diff --git a/mem0-plugin/tests/test_telemetry.py b/mem0-plugin/tests/test_telemetry.pyindex 17db658f8..0103e3bc9 100644--- a/mem0-plugin/tests/test_telemetry.py+++ b/mem0-plugin/tests/test_telemetry.py@@ -57,7 +57,8 @@ def test_posthog_payload_structure(monkeypatch):assert payload["event"] == "plugin.session_start"assert "distinct_id" in payloadassert payload["properties"]["source"] == "plugin"- assert payload["properties"]["plugin_version"] == "0.2.1"+ assert isinstance(payload["properties"]["plugin_version"], str)+ assert payload["properties"]["plugin_version"] != ""assert payload["properties"]["memory_count"] == 5assert payload["properties"]["$process_person_profile"] is False@@ -66,13 +67,40 @@ def test_posthog_payload_structure(monkeypatch):assert "test-project" not in raw+def test_system_props_override_caller_props(monkeypatch):+ """H8: system properties must win over caller-supplied properties."""+ import telemetry++ monkeypatch.setenv("MEM0_RESOLVED_USER_ID", "testuser")+ monkeypatch.setenv("MEM0_PROJECT_ID", "test-project")+ monkeypatch.delenv("MEM0_API_KEY", raising=False)+ monkeypatch.delenv("CLAUDE_PLUGIN_OPTION_MEM0_API_KEY", raising=False)++ # Caller tries to override system-controlled properties+ caller_props = {+ "source": "CALLER_OVERRIDE",+ "platform": "CALLER_OVERRIDE",+ "plugin_version": "CALLER_OVERRIDE",+ "memory_count": 42,+ }+ payload = telemetry.build_posthog_payload("plugin.test", caller_props)+ props = payload["properties"]++ # System props must win+ assert props["source"] == "plugin"+ assert props["platform"] == telemetry.detect_platform()+ assert props["plugin_version"] == telemetry.PLUGIN_VERSION+ # Caller-only props still present+ assert props["memory_count"] == 42++def test_distinct_id_from_api_key(monkeypatch):import hashlibimport telemetrymonkeypatch.setenv("MEM0_API_KEY", "m0-testkey123")- expected = hashlib.md5(b"m0-testkey123").hexdigest()+ expected = hashlib.sha256(b"m0-testkey123").hexdigest()[:32]assert telemetry._distinct_id() == expected