graph-mind-memory 0.4.0__tar.gz → 0.5.0__tar.gz

{graph_mind_memory-0.4.0/graph_mind_memory.egg-info → graph_mind_memory-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graph-mind-memory
-Version: 0.4.0
+Version: 0.5.0
 Summary: Local-first memory for AI coding assistants: verbatim, on your own PC, no LLM calls at write time.
 Author-email: Yohan Ko <goyohan0611@gmail.com>
 License-Expression: AGPL-3.0-only
@@ -20,6 +20,7 @@ Requires-Dist: tokenizers>=0.15
 Requires-Dist: huggingface_hub>=0.20
 Requires-Dist: pgserver; python_version < "3.13"
 Requires-Dist: psycopg[binary]
+Requires-Dist: cryptography
 Requires-Dist: psutil
 Requires-Dist: fasteners
 Dynamic: license-file
@@ -142,7 +143,8 @@ The installer:
 
 - installs the packages (no PyTorch: the embedding model runs on ONNX Runtime);
 - registers the MCP server with every app it finds: Claude Code, Claude Desktop (including the
-  Microsoft Store build) and Codex;
+  Microsoft Store build), Codex, Cursor, Windsurf, Gemini CLI, VS Code (Copilot), Cline and
+  LM Studio;
 - starts the capture service at login (Windows Startup folder, a macOS LaunchAgent, or an XDG
   autostart entry on Linux);
 - downloads the embedding model (about 470 MB, once).
@@ -169,6 +171,7 @@ stops the capture service. Your memory stays in `~/.graph-mind` unless you add `
 | Claude Code: terminal, VS Code, Claude desktop's Code tab | every turn |
 | Claude desktop: Cowork | every turn |
 | Claude desktop: chat | what the model saves with `brain_remember` |
+| Cursor, Windsurf, Gemini CLI, VS Code, Cline, LM Studio | what the model saves with `brain_remember` (memory tools connected; their transcripts are not read yet) |
 
 Before anything is stored, these are masked: API keys, tokens from GitHub, AWS, Google and Slack,
 private keys, passwords inside URLs, values written after `password:` / `api_key=` / `token:`,
@@ -232,8 +235,10 @@ PCs reach it over the local network in the office, or over [Tailscale](https://t
 anywhere. Each connection tries the addresses in turn and uses the first that answers.
 
 Other PCs log in with a generated password, as a role that can reach only the memory database. The
-Windows firewall rule admits only the local network and Tailscale. The code contains the password:
-do not post it publicly.
+Windows firewall rule admits only the local network and Tailscale. Every line of memory is
+encrypted (AES with an HMAC) under a key derived from that password before it leaves a PC, so the
+network and the hub's own database carry only ciphertext. The code contains the password: do not
+post it publicly.
 
 A synced folder also works. Tell the AI *"use my Google Drive's Graph-MIND folder as my memory"* on
 each PC.

{graph_mind_memory-0.4.0 → graph_mind_memory-0.5.0}/README.md

@@ -116,7 +116,8 @@ The installer:
 
 - installs the packages (no PyTorch: the embedding model runs on ONNX Runtime);
 - registers the MCP server with every app it finds: Claude Code, Claude Desktop (including the
-  Microsoft Store build) and Codex;
+  Microsoft Store build), Codex, Cursor, Windsurf, Gemini CLI, VS Code (Copilot), Cline and
+  LM Studio;
 - starts the capture service at login (Windows Startup folder, a macOS LaunchAgent, or an XDG
   autostart entry on Linux);
 - downloads the embedding model (about 470 MB, once).
@@ -143,6 +144,7 @@ stops the capture service. Your memory stays in `~/.graph-mind` unless you add `
 | Claude Code: terminal, VS Code, Claude desktop's Code tab | every turn |
 | Claude desktop: Cowork | every turn |
 | Claude desktop: chat | what the model saves with `brain_remember` |
+| Cursor, Windsurf, Gemini CLI, VS Code, Cline, LM Studio | what the model saves with `brain_remember` (memory tools connected; their transcripts are not read yet) |
 
 Before anything is stored, these are masked: API keys, tokens from GitHub, AWS, Google and Slack,
 private keys, passwords inside URLs, values written after `password:` / `api_key=` / `token:`,
@@ -206,8 +208,10 @@ PCs reach it over the local network in the office, or over [Tailscale](https://t
 anywhere. Each connection tries the addresses in turn and uses the first that answers.
 
 Other PCs log in with a generated password, as a role that can reach only the memory database. The
-Windows firewall rule admits only the local network and Tailscale. The code contains the password:
-do not post it publicly.
+Windows firewall rule admits only the local network and Tailscale. Every line of memory is
+encrypted (AES with an HMAC) under a key derived from that password before it leaves a PC, so the
+network and the hub's own database carry only ciphertext. The code contains the password: do not
+post it publicly.
 
 A synced folder also works. Tell the AI *"use my Google Drive's Graph-MIND folder as my memory"* on
 each PC.

{graph_mind_memory-0.4.0 → graph_mind_memory-0.5.0}/brain_log.py

@@ -145,6 +145,7 @@ def share(open_firewall: bool = True) -> dict:
     local_postgres()                        # first: it explains a missing pgserver
     from pgserver._commands import pg_ctl
     password = _config().get("share_password") or secrets.token_urlsafe(18)
+    _save({"share_password": password})          # before sealing: the line key derives from it
     data = _pg_data()
     with psycopg.connect(_admin_uri(), autocommit=True) as admin:
         # token_urlsafe is [A-Za-z0-9_-]: nothing in it can close the quoted literal
@@ -160,11 +161,11 @@ def share(open_firewall: bool = True) -> dict:
     pg_ctl(["-w", "-m", "fast", "restart"] if restart else ["reload"], pgdata=data, timeout=60,
            **_DETACHED)
     set_folder("local")
-    _save({"share_password": password})
+    sealed = _seal_existing(local_postgres())
     hosts = _addresses()
     code = CODE_PREFIX + base64.urlsafe_b64encode(json.dumps(
         {"h": hosts, "p": PORT, "k": password}).encode()).decode().rstrip("=")
-    return {"connection_code": code, "addresses": hosts, "port": PORT,
+    return {"connection_code": code, "addresses": hosts, "port": PORT, "lines_sealed": sealed,
             "firewall": _firewall() if open_firewall else "not changed"}
 
 
@@ -308,7 +309,8 @@ def _shared_ids(shared) -> set:
     """(kind, id) of every turn and memory the shared log holds, forgotten ones included."""
     if is_database(shared):
         with _pg(shared) as connection:
-            lines = [row[0] for row in connection.execute("SELECT line FROM brain_log")]
+            lines = [line for line in (_unseal(shared, row[0]) for row in
+                     connection.execute("SELECT line FROM brain_log")) if line is not None]
     else:
         lines = [line for log in (Path(shared) / "log").glob("*.jsonl")
                  for line in log.read_text(encoding="utf-8", errors="replace").splitlines()]
@@ -390,6 +392,66 @@ def _cursor_db(index: Path) -> sqlite3.Connection:
     return db
 
 
+SEALED = "gme1:"
+_KEYS = {}
+
+
+def _line_key(url):
+    """The key that seals this hub's lines, or None when it has none.
+
+    The Postgres that pgserver ships is built without SSL, so the connection to a hub is not
+    encrypted: on a shared network anyone could read memory off the wire. Each line is sealed
+    instead (Fernet: AES with an HMAC) under a key derived from the password in the connection
+    code, which every PC that joined holds and nobody else does. The hub stores ciphertext too.
+    A joined PC finds the password in its URL; the hub PC in its own config."""
+    import urllib.parse
+    password = urllib.parse.urlsplit(url).password
+    password = urllib.parse.unquote(password) if password else _config().get("share_password")
+    if not password:
+        return None                               # a hub never shared: nothing leaves this PC
+    if password not in _KEYS:
+        from cryptography.fernet import Fernet
+        from cryptography.hazmat.primitives import hashes
+        from cryptography.hazmat.primitives.kdf.hkdf import HKDF
+        raw = HKDF(algorithm=hashes.SHA256(), length=32, salt=b"graph-mind brain_log",
+                   info=b"line key v1").derive(password.encode())
+        _KEYS[password] = Fernet(base64.urlsafe_b64encode(raw))
+    return _KEYS[password]
+
+
+def _seal(url, lines):
+    key = _line_key(url)
+    return [SEALED + key.encrypt(line.encode()).decode() if key else line for line in lines]
+
+
+def _unseal(url, line):
+    """The plain line, or None when it cannot be opened with this hub's key."""
+    if not line.startswith(SEALED):
+        return line                               # written before sealing began
+    key = _line_key(url)
+    if key is None:
+        return None
+    from cryptography.fernet import InvalidToken
+    try:
+        return key.decrypt(line[len(SEALED):].encode()).decode()
+    except InvalidToken:
+        return None
+
+
+def _seal_existing(url) -> int:
+    """Seal the lines the hub held before it was shared, so none crosses the network in clear."""
+    if _line_key(url) is None:
+        return 0
+    with _pg(url) as connection:
+        rows = connection.execute("SELECT seq, line FROM brain_log WHERE line NOT LIKE %s",
+                                  (SEALED + "%",)).fetchall()
+        with connection.cursor() as cursor:
+            cursor.executemany("UPDATE brain_log SET line = %s WHERE seq = %s",
+                               [(_seal(url, [line])[0], seq) for seq, line in rows])
+        connection.commit()
+    return len(rows)
+
+
 def _pg(url):
     import psycopg
     connection = psycopg.connect(url, autocommit=False)
@@ -432,7 +494,7 @@ def _pg_append(url, lines) -> int:
         connection.execute("SELECT pg_advisory_xact_lock(4242)")
         with connection.cursor() as cursor:
             cursor.executemany("INSERT INTO brain_log(device, line) VALUES (%s, %s)",
-                               [(device_name(), line) for line in lines])
+                               [(device_name(), line) for line in _seal(url, lines)])
         connection.commit()
     return len(lines)
 
@@ -459,7 +521,8 @@ def _new_lines(db: sqlite3.Connection, shared) -> list[str]:
             with db:
                 db.execute("INSERT OR REPLACE INTO brain_log_cursor VALUES(?,?)",
                            (source, rows[-1][0]))
-        return [line for _, line in rows]
+        opened = [_unseal(shared, line) for _, line in rows]
+        return [line for line in opened if line is not None]
     lines = []
     for log in sorted((Path(shared) / "log").glob("*.jsonl")):
         row = db.execute("SELECT offset FROM brain_log_cursor WHERE source=?",

{graph_mind_memory-0.4.0 → graph_mind_memory-0.5.0}/forget.py

@@ -96,13 +96,17 @@ def scrub_shared(shared, ids: dict) -> int:
     if not keys:
         return 0
     if is_database(shared):
-        with _pg(shared) as connection:
-            removed = 0
-            for key in keys:
-                removed += connection.execute(
-                    "DELETE FROM brain_log WHERE strpos(line, %s) > 0", (key,)).rowcount
+        from brain_log import _unseal
+        with _pg(shared) as connection:          # lines are sealed: open each to find targets
+            doomed = []
+            for seq, line in connection.execute("SELECT seq, line FROM brain_log").fetchall():
+                text = _unseal(shared, line) or ""
+                if any(key in text for key in keys) and '"kind": "forget"' not in text:
+                    doomed.append(seq)
+            if doomed:
+                connection.execute("DELETE FROM brain_log WHERE seq = ANY(%s)", (doomed,))
             connection.commit()
-        return removed
+        return len(doomed)
     removed = 0
     for log in (Path(shared) / "log").glob("*.jsonl"):
         data = log.read_bytes()

{graph_mind_memory-0.4.0 → graph_mind_memory-0.5.0/graph_mind_memory.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graph-mind-memory
-Version: 0.4.0
+Version: 0.5.0
 Summary: Local-first memory for AI coding assistants: verbatim, on your own PC, no LLM calls at write time.
 Author-email: Yohan Ko <goyohan0611@gmail.com>
 License-Expression: AGPL-3.0-only
@@ -20,6 +20,7 @@ Requires-Dist: tokenizers>=0.15
 Requires-Dist: huggingface_hub>=0.20
 Requires-Dist: pgserver; python_version < "3.13"
 Requires-Dist: psycopg[binary]
+Requires-Dist: cryptography
 Requires-Dist: psutil
 Requires-Dist: fasteners
 Dynamic: license-file
@@ -142,7 +143,8 @@ The installer:
 
 - installs the packages (no PyTorch: the embedding model runs on ONNX Runtime);
 - registers the MCP server with every app it finds: Claude Code, Claude Desktop (including the
-  Microsoft Store build) and Codex;
+  Microsoft Store build), Codex, Cursor, Windsurf, Gemini CLI, VS Code (Copilot), Cline and
+  LM Studio;
 - starts the capture service at login (Windows Startup folder, a macOS LaunchAgent, or an XDG
   autostart entry on Linux);
 - downloads the embedding model (about 470 MB, once).
@@ -169,6 +171,7 @@ stops the capture service. Your memory stays in `~/.graph-mind` unless you add `
 | Claude Code: terminal, VS Code, Claude desktop's Code tab | every turn |
 | Claude desktop: Cowork | every turn |
 | Claude desktop: chat | what the model saves with `brain_remember` |
+| Cursor, Windsurf, Gemini CLI, VS Code, Cline, LM Studio | what the model saves with `brain_remember` (memory tools connected; their transcripts are not read yet) |
 
 Before anything is stored, these are masked: API keys, tokens from GitHub, AWS, Google and Slack,
 private keys, passwords inside URLs, values written after `password:` / `api_key=` / `token:`,
@@ -232,8 +235,10 @@ PCs reach it over the local network in the office, or over [Tailscale](https://t
 anywhere. Each connection tries the addresses in turn and uses the first that answers.
 
 Other PCs log in with a generated password, as a role that can reach only the memory database. The
-Windows firewall rule admits only the local network and Tailscale. The code contains the password:
-do not post it publicly.
+Windows firewall rule admits only the local network and Tailscale. Every line of memory is
+encrypted (AES with an HMAC) under a key derived from that password before it leaves a PC, so the
+network and the hub's own database carry only ciphertext. The code contains the password: do not
+post it publicly.
 
 A synced folder also works. Tell the AI *"use my Google Drive's Graph-MIND folder as my memory"* on
 each PC.

{graph_mind_memory-0.4.0 → graph_mind_memory-0.5.0}/graph_mind_memory.egg-info/requires.txt

@@ -4,6 +4,7 @@ onnxruntime>=1.17
 tokenizers>=0.15
 huggingface_hub>=0.20
 psycopg[binary]
+cryptography
 psutil
 fasteners
 

{graph_mind_memory-0.4.0 → graph_mind_memory-0.5.0}/install.py

@@ -3,8 +3,8 @@
     python install.py                      # this PC keeps its own brain
     python install.py --join gm1.XXXX      # ...and joins the brain another PC shared
 
-It installs the Python packages, registers the memory server with Claude Code, Claude Desktop and
-Codex (whichever are installed), starts the capture service at login, and downloads the local
+It installs the Python packages, registers the memory server with every MCP client it finds
+(Claude Code, Claude Desktop, Codex, Cursor, Windsurf, Gemini CLI, VS Code, Cline, LM Studio), starts the capture service at login, and downloads the local
 embedding model so the first question is not the one that waits for it. Running it again is
 safe, and after moving this folder it re-points everything at the new place.
 """
@@ -42,9 +42,9 @@ def packages():
                  "  or install Python or this folder under a shorter path, e.g. C:\\graph-mind")
 
 
-def _json_entry(path: Path, **extra) -> None:
+def _json_entry(path: Path, key: str = "mcpServers", **extra) -> None:
     settings = json.loads(path.read_text(encoding="utf-8")) if path.exists() else {}
-    servers = settings.setdefault("mcpServers", {})
+    servers = settings.setdefault(key, {})
     environment = {**servers.get(NAME, {}).get("env", {}), **ENV}   # keep the user's own settings
     servers[NAME] = {**extra, "command": sys.executable, "args": [str(SERVER)], "env": environment}
     temporary = path.with_suffix(".graph-mind.tmp")
@@ -85,6 +85,46 @@ def claude_desktop(home: Path) -> list[str]:
     return done[:1]
 
 
+def _vscode_user_dir(home: Path) -> Path:
+    if platform.system() == "Windows":
+        return Path(os.environ.get("APPDATA", home / "AppData" / "Roaming")) / "Code" / "User"
+    if platform.system() == "Darwin":
+        return home / "Library" / "Application Support" / "Code" / "User"
+    return Path(os.environ.get("XDG_CONFIG_HOME") or home / ".config") / "Code" / "User"
+
+
+def _other_apps(home: Path) -> list:
+    """(name, config file, servers key, extra fields) for MCP clients beyond Claude and Codex.
+    An app counts as installed when its own folder exists; its config file is created if not."""
+    vscode = _vscode_user_dir(home)
+    return [
+        ("Cursor", home / ".cursor", home / ".cursor" / "mcp.json", "mcpServers", {}),
+        ("Windsurf", home / ".codeium" / "windsurf",
+         home / ".codeium" / "windsurf" / "mcp_config.json", "mcpServers", {}),
+        ("Gemini CLI", home / ".gemini", home / ".gemini" / "settings.json", "mcpServers", {}),
+        ("LM Studio", home / ".lmstudio", home / ".lmstudio" / "mcp.json", "mcpServers", {}),
+        ("VS Code", vscode, vscode / "mcp.json", "servers", {"type": "stdio"}),
+        ("Cline", vscode / "globalStorage" / "saoudrizwan.claude-dev",
+         vscode / "globalStorage" / "saoudrizwan.claude-dev" / "settings" / "cline_mcp_settings.json",
+         "mcpServers", {}),
+    ]
+
+
+def other_apps(home: Path) -> list[str]:
+    done = []
+    for name, folder, config, key, extra in _other_apps(home):
+        if not folder.is_dir():
+            continue
+        try:
+            config.parent.mkdir(parents=True, exist_ok=True)
+            _json_entry(config, key, **extra)
+            done.append(name)
+        except ValueError:
+            # a settings file with comments (VS Code allows them) is not JSON: leave it alone
+            step(f"{name}: could not edit {config}; add the server there by hand")
+    return done
+
+
 def _without_codex_block(text: str) -> str:
     """The Codex config without Graph-MIND's server table (and its env table); the rest kept."""
     header = f"[mcp_servers.{NAME}]"
@@ -227,7 +267,8 @@ def main(argv=None):
         step("installing packages (the first time takes a few minutes)")
         packages()
     home = Path.home()
-    apps = [name for name in [claude_code(home), *claude_desktop(home), codex(home)] if name]
+    apps = [name for name in [claude_code(home), *claude_desktop(home), codex(home),
+                              *other_apps(home)] if name]
     step("memory connected to: " + (", ".join(apps) if apps else
                                      "no AI app found yet; install one and run this again"))
     step(capture_service(start=not args.no_start))
@@ -255,17 +296,23 @@ def uninstall(argv=None):
     claude = shutil.which("claude")
     if claude:
         subprocess.run([claude, "mcp", "remove", "-s", "user", NAME], capture_output=True)
-    for config in [home / ".claude.json"] + [r / "claude_desktop_config.json"
-                                              for r in _desktop_roots(home)]:
+    targets = ([("Claude Code", home / ".claude.json", "mcpServers")]
+               + [("Claude Desktop", r / "claude_desktop_config.json", "mcpServers")
+                  for r in _desktop_roots(home)]
+               + [(name, config, key) for name, _, config, key, _ in _other_apps(home)])
+    for label, config, key in targets:
         if not config.exists():
             continue
-        settings = json.loads(config.read_text(encoding="utf-8"))
-        if settings.get("mcpServers", {}).pop(NAME, None) is not None:
+        try:
+            settings = json.loads(config.read_text(encoding="utf-8"))
+        except ValueError:
+            continue
+        if settings.get(key, {}).pop(NAME, None) is not None:
             temporary = config.with_suffix(".graph-mind.tmp")
             temporary.write_text(json.dumps(settings, ensure_ascii=False, indent=2),
                                  encoding="utf-8")
             os.replace(temporary, config)
-            removed.append("Claude Code" if config.name == ".claude.json" else "Claude Desktop")
+            removed.append(label)
     codex_config = home / ".codex" / "config.toml"
     if codex_config.exists():
         text = codex_config.read_text(encoding="utf-8")

{graph_mind_memory-0.4.0 → graph_mind_memory-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "graph-mind-memory"
-version = "0.4.0"
+version = "0.5.0"
 description = "Local-first memory for AI coding assistants: verbatim, on your own PC, no LLM calls at write time."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -27,6 +27,7 @@ dependencies = [
     # brain (psycopg) and everything else work on any supported Python.
     "pgserver; python_version < '3.13'",
     "psycopg[binary]",
+    "cryptography",          # seals lines on a shared hub
     "psutil",
     "fasteners",
 ]