graph-mind-memory 0.2.1__tar.gz → 0.3.0__tar.gz

{graph_mind_memory-0.2.1/graph_mind_memory.egg-info → graph_mind_memory-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graph-mind-memory
-Version: 0.2.1
+Version: 0.3.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
@@ -174,6 +174,10 @@ like `hunter2` has no recognizable format and is **not** masked. To remove somet
 graph-mind-forget          # asks for the phrase without showing it, then confirms
 ```
 
+Or just ask your AI: *"delete the password I typed earlier"*. It lists masked candidates
+(`wifi password is ****`), deletes only the ones you pick, and the conversation about deleting
+is not saved.
+
 It deletes every captured turn and memory containing the phrase from this PC and its indexes,
 removes their lines from the shared memory, and tells your other PCs to delete their copies on
 their next sync. Only ids are shared for that, never the phrase. Your AI app's own history
@@ -189,9 +193,10 @@ their next sync. Only ids are shared for that, never the phrase. Your AI app's o
 | `brain_recall` | look memories and captured turns up directly; `entity=` for everything about one thing, in order |
 | `brain_remember` | save a sourced memory or decision (secrets masked) |
 | `brain_folder` | where the memory lives; share it with your other PCs; reindex an imported backlog |
+| `brain_forget` | "delete the password I typed": lists masked candidates, deletes only what you pick, everywhere; the exchange itself is not saved |
 | `code_activity` | what changed in a project, file or symbol, and when (when a code folder is watched) |
 
-Five tools on purpose: every tool's description is read by the model on every turn, and similar
+Six tools on purpose: every tool's description is read by the model on every turn, and similar
 tools get confused with each other. Version 0.1 had thirteen.
 
 ---

{graph_mind_memory-0.2.1 → graph_mind_memory-0.3.0}/README.md

@@ -148,6 +148,10 @@ like `hunter2` has no recognizable format and is **not** masked. To remove somet
 graph-mind-forget          # asks for the phrase without showing it, then confirms
 ```
 
+Or just ask your AI: *"delete the password I typed earlier"*. It lists masked candidates
+(`wifi password is ****`), deletes only the ones you pick, and the conversation about deleting
+is not saved.
+
 It deletes every captured turn and memory containing the phrase from this PC and its indexes,
 removes their lines from the shared memory, and tells your other PCs to delete their copies on
 their next sync. Only ids are shared for that, never the phrase. Your AI app's own history
@@ -163,9 +167,10 @@ their next sync. Only ids are shared for that, never the phrase. Your AI app's o
 | `brain_recall` | look memories and captured turns up directly; `entity=` for everything about one thing, in order |
 | `brain_remember` | save a sourced memory or decision (secrets masked) |
 | `brain_folder` | where the memory lives; share it with your other PCs; reindex an imported backlog |
+| `brain_forget` | "delete the password I typed": lists masked candidates, deletes only what you pick, everywhere; the exchange itself is not saved |
 | `code_activity` | what changed in a project, file or symbol, and when (when a code folder is watched) |
 
-Five tools on purpose: every tool's description is read by the model on every turn, and similar
+Six tools on purpose: every tool's description is read by the model on every turn, and similar
 tools get confused with each other. Version 0.1 had thirteen.
 
 ---

{graph_mind_memory-0.2.1 → graph_mind_memory-0.3.0}/automatic_capture.py

@@ -118,24 +118,26 @@ class AutomaticCaptureService:
         if shared:
             from brain_log import append
             publish = lambda turn: append(shared, "turn", turn)     # a folder or a Postgres URL
+        from forget import forget_ids
+        forget = lambda turn_ids: forget_ids({"turn_ids": turn_ids}, self.db_path, shared)
         sources = []
         # A source whose folder does not exist yet (Codex never run on this PC) is skipped, not
         # fatal: it used to stop every source, so a Claude-Code-only user captured nothing.
         if Path(self.config["codex_sessions_root"]).is_dir():
             sources.append(("codex", CodexConversationCapture(
                 self.config["codex_sessions_root"], store, state_path=self.conversation_cursor,
-                workspace_scopes=scopes, now=self.now, publish=publish), self.conversation_cursor))
+                workspace_scopes=scopes, now=self.now, publish=publish, forget=forget), self.conversation_cursor))
         claude_root = Path(self.config.get("claude_projects_root")
                            or Path.home() / ".claude" / "projects")
         if claude_root.is_dir():
             sources.append(("claude-code", ClaudeCodeConversationCapture(
                 claude_root, store, state_path=self.claude_cursor,
-                workspace_scopes=scopes, now=self.now, publish=publish), self.claude_cursor))
+                workspace_scopes=scopes, now=self.now, publish=publish, forget=forget), self.claude_cursor))
         cowork = self.config.get("claude_cowork_root") or cowork_root()
         if cowork and Path(cowork).is_dir():
             sources.append(("claude-cowork", ClaudeCoworkConversationCapture(
                 cowork, store, state_path=self.cowork_cursor,
-                workspace_scopes=scopes, now=self.now, publish=publish), self.cowork_cursor))
+                workspace_scopes=scopes, now=self.now, publish=publish, forget=forget), self.cowork_cursor))
         return sources
 
     def baseline(self):

{graph_mind_memory-0.2.1 → graph_mind_memory-0.3.0}/conversation_memory.py

@@ -238,7 +238,7 @@ class CodexConversationCapture:
     CLIENT = "codex"
 
     def __init__(self, sessions_root, store, *, state_path, workspace_scopes=None,
-                 now=None, publish=None):
+                 now=None, publish=None, forget=None):
         self.sessions_root = Path(sessions_root).resolve()
         if not self.sessions_root.is_dir():
             raise ValueError("CODEX_SESSIONS_ROOT_NOT_FOUND")
@@ -251,6 +251,46 @@ class CodexConversationCapture:
                                  for key, value in (workspace_scopes or {}).items()}
         self.now = now or (lambda: datetime.now().isoformat(timespec="microseconds"))
         self.publish = publish            # called with each turn that is new to this store
+        # erases captured turns everywhere (forget.forget_ids with the shared log); by default
+        # this store only
+        self.forget = forget or (lambda turn_ids: __import__("forget").erase(
+            self.store.path, {"turn_ids": turn_ids}))
+
+    FORGET_TOOL = "brain_forget"
+    FORGET_WINDOW_MINUTES = 30
+
+    def _forget_call(self, item):
+        """Whether this record is the assistant calling brain_forget. Codex: a function call
+        named for it, or (code mode) a completed MCP tool call of it."""
+        payload = item.get("payload") or {}
+        if payload.get("type") in {"function_call", "custom_tool_call"}:
+            return str(payload.get("name", "")).endswith(self.FORGET_TOOL)
+        call = payload.get("item") if isinstance(payload.get("item"), dict) else {}
+        return call.get("type") == "McpToolCall" and call.get("tool") == self.FORGET_TOOL
+
+    def _forget_exchange(self, session_id, at, sessions):
+        """The assistant called brain_forget: what led up to it is a conversation about deleting,
+        so it goes too. From the user turn that asked (or from the previous forget call, when this
+        is the second, deleting call of the same exchange) up to now; the assistant's reply that
+        follows is skipped until the user speaks again."""
+        at = self.store._time(at)
+        previous = sessions.get(session_id, {}).get("signal_at")
+        db = self.store.db
+        if previous and (datetime.fromisoformat(at) - datetime.fromisoformat(previous)
+                         ).total_seconds() <= self.FORGET_WINDOW_MINUTES * 60:
+            since = previous
+        else:
+            since = db.execute(
+                "SELECT max(happened_at) FROM conversation_turns WHERE client=? AND "
+                "client_session_id=? AND role='user' AND happened_at<=?",
+                (self.CLIENT, session_id, at)).fetchone()[0]
+        if since:
+            ids = [row[0] for row in db.execute(
+                "SELECT turn_id FROM conversation_turns WHERE client=? AND client_session_id=? "
+                "AND happened_at>=?", (self.CLIENT, session_id, since))]
+            if ids:
+                self.forget(ids)
+        sessions[session_id] = {"signal_at": at, "quiet": True}
 
     def _files(self):
         return sorted(self.sessions_root.rglob("*.jsonl"))
@@ -293,11 +333,13 @@ class CodexConversationCapture:
         value = json.loads(self.state_path.read_text(encoding="utf-8"))
         if value.get("capture_version") != CAPTURE_VERSION:
             raise ValueError("CONVERSATION_CAPTURE_VERSION_MISMATCH")
+        self._forget_sessions = value.get("forget_sessions", {})
         return value.get("offsets", {})
 
     def _write_state(self, offsets):
         value = {"capture_version": CAPTURE_VERSION,
-                 "sessions_root": str(self.sessions_root), "offsets": offsets}
+                 "sessions_root": str(self.sessions_root), "offsets": offsets,
+                 "forget_sessions": getattr(self, "_forget_sessions", {})}
         temporary = self.state_path.with_suffix(".tmp")
         temporary.write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n",
                              encoding="utf-8")
@@ -332,12 +374,21 @@ class CodexConversationCapture:
                         item = json.loads(line.decode("utf-8", "strict"))
                     except (UnicodeDecodeError, json.JSONDecodeError):
                         continue
+                    if self._forget_call(item):
+                        self._forget_exchange(session_id, item.get("timestamp") or known_at,
+                                              self._forget_sessions)
+                        continue
                     message = self._message(item)
                     if message is None:
                         continue
                     role, raw = message
                     if not raw.strip():
                         continue
+                    quiet = self._forget_sessions.get(session_id)
+                    if quiet and quiet.get("quiet"):
+                        if role == "assistant":
+                            continue           # the reply to a forget call: not remembered
+                        quiet["quiet"] = False  # the user spoke again: the exchange is over
                     cleaned, count = _redact(raw)
                     if not cleaned:
                         continue
@@ -413,6 +464,15 @@ class ClaudeCodeConversationCapture(CodexConversationCapture):
         resolved_cwd = str(Path(cwd).resolve()) if isinstance(cwd, str) and cwd else None
         return session_id, cwd, self.workspace_scopes.get(resolved_cwd, "global")
 
+    def _forget_call(self, item):
+        """An assistant record with a tool_use block calling brain_forget (any MCP prefix)."""
+        if item.get("type") != "assistant" or item.get("isSidechain"):
+            return False
+        content = (item.get("message") or {}).get("content")
+        return isinstance(content, list) and any(
+            isinstance(block, dict) and block.get("type") == "tool_use"
+            and str(block.get("name", "")).endswith(self.FORGET_TOOL) for block in content)
+
     def _message(self, item):
         if item.get("isSidechain") or item.get("isMeta"):
             return None

{graph_mind_memory-0.2.1 → graph_mind_memory-0.3.0}/forget.py

@@ -119,19 +119,56 @@ def scrub_shared(shared, ids: dict) -> int:
     return removed
 
 
-def forget(phrase: str, index: Path, shared=None) -> dict:
-    """Find, erase here, scrub the shared log, and tell the other PCs."""
+def forget_ids(ids: dict, index: Path, shared=None) -> dict:
+    """Erase these turns and memories here, scrub the shared log, and tell the other PCs."""
     from brain_log import append
-    ids = find(index, phrase)
-    if not (ids["turn_ids"] or ids["memory_ids"]):
+    if not (ids.get("turn_ids") or ids.get("memory_ids")):
         return {"turns": 0, "memories": 0, "shared_lines_removed": 0}
+    ids = {"turn_ids": list(ids.get("turn_ids", [])),
+           "memory_ids": list(ids.get("memory_ids", []))}
     result = erase(index, ids)
     if shared:
         result["shared_lines_removed"] = scrub_shared(shared, ids)
-        append(shared, "forget", ids)                  # ids only: the phrase never leaves here
+        append(shared, "forget", ids)                  # ids only: the text never leaves here
     return result
 
 
+def forget(phrase: str, index: Path, shared=None) -> dict:
+    """Find everything containing the phrase, then forget it as forget_ids does."""
+    return forget_ids(find(index, phrase), index, shared)
+
+
+SECRET_HINTS = ("password", "passwd", "pw", "pin", "비밀번호", "비번", "암호", "key", "token",
+                "secret", "api")
+LINKS = {"is", "was", "=", ":", "->", "는", "은", "이", "가"}
+
+
+def masked_preview(text: str, width: int = 90) -> str:
+    """Enough of a turn to recognise it, with what could be a secret replaced by ****: the word
+    after "password"/"비번"/"key"..., anything after "password:" or "key=", and any word that
+    mixes letters with digits or symbols. Over-masks on purpose; the original is never shown, so
+    listing candidates does not put a secret back into the chat it is being removed from."""
+    out, hide_next = [], False
+    for token in str(text).split():
+        lowered = token.lower()
+        bare = token.strip(".,!?\"'()[]{}")
+        hint = any(word in lowered for word in SECRET_HINTS)
+        if hint and (":" in token or "=" in token):
+            separator = ":" if ":" in token else "="
+            out.append(token.split(separator, 1)[0] + separator + "****")
+            hide_next = not token.split(separator, 1)[1]
+            continue
+        if hide_next and lowered in LINKS:          # "password is ...", "비번은 = ..."
+            out.append(token)
+            continue
+        secretish = hide_next or (any(c.isdigit() for c in bare) and any(c.isalpha() for c in bare)) \
+            or any(c in "!@#$%^&*_=+<>|~`\\" for c in bare)
+        out.append("****" if secretish else token)
+        hide_next = hint
+    preview = " ".join(out)
+    return preview if len(preview) <= width else preview[:width] + "…"
+
+
 def main(argv=None):
     from brain_log import folder
     from development_paths import default_development_db

{graph_mind_memory-0.2.1 → graph_mind_memory-0.3.0}/graph_mind_mcp_server.py

@@ -342,7 +342,9 @@ def build_server(db_path=None):
             "replaying full history. Use brain_recall to look memories up directly, or with "
             "`entity` for the history of one thing in order. For code changed in a time range, "
             "project, file or symbol, use code_activity. brain_folder shows or changes where the "
-            "memory lives and shares it with the user's other PCs. Preserve provenance."
+            "memory lives and shares it with the user's other PCs. When the user asks to "
+            "delete something from memory, use brain_forget: list first, delete only what the "
+            "user picks. Preserve provenance."
         ),
         version=SERVER_VERSION,
     )
@@ -605,6 +607,67 @@ def build_server(db_path=None):
                 "existing_memories_shared": exported or "not shared; ask the user before "
                                                        "setting share_existing=true"}
 
+    @server.tool(
+        name="brain_forget",
+        structured_output=True,
+        annotations=types.ToolAnnotations(
+            readOnlyHint=False,
+            destructiveHint=True,
+            idempotentHint=True,
+            openWorldHint=False,
+        ),
+    )
+    def brain_forget(query: str | None = None, ids: list[str] | None = None) -> dict[str, Any]:
+        """Delete what the user wants gone from memory: "delete the password I typed earlier",
+        "그 토큰 지워줘", "forget what I said about my ex".
+
+        Always two calls. First `query`: what to look for, in general words ("password", "wifi",
+        "DB login"); never repeat a secret the user typed. It returns numbered candidates with
+        masked previews. Show the user exactly those previews and ask which to delete; never
+        quote the original text. Then call again with the `ids` the user picked, and only those.
+
+        Deleting removes them from this PC, its search indexes, the shared memory and the user's
+        other PCs. This exchange about deleting is not saved either. The AI app's own chat
+        history is separate and untouched (Claude Code keeps ~/.claude/projects).
+        """
+        import sqlite3
+
+        from forget import forget_ids, masked_preview
+        if ids:
+            db = sqlite3.connect(database, timeout=30)
+            try:
+                turns = [row[0] for row in db.execute(
+                    "SELECT turn_id FROM conversation_turns WHERE turn_id IN ("
+                    + ",".join("?" * len(ids)) + ")", ids)]
+                memories = [row[0] for row in db.execute(
+                    "SELECT memory_id FROM local_brain_memories WHERE memory_id IN ("
+                    + ",".join("?" * len(ids)) + ")", ids)]
+            except sqlite3.OperationalError:
+                turns, memories = [], []
+            finally:
+                db.close()
+            from brain_log import folder
+            try:
+                shared = folder()
+            except Exception:
+                shared = None
+            result = forget_ids({"turn_ids": turns, "memory_ids": memories}, database, shared)
+            return {"status": "FORGOTTEN", **result,
+                    "not_found": [i for i in ids if i not in turns and i not in memories]}
+        if not query:
+            return {"status": "QUERY_OR_IDS_REQUIRED", "candidates": []}
+        recalled = gather(database, query, as_of=_now(), limit=10)
+        candidates = [{"id": m["memory_id"], "kind": "memory", "when": m.get("effective_at"),
+                       "preview": masked_preview(m.get("content", ""))}
+                      for m in recalled.get("matches", [])]
+        candidates += [{"id": t["turn_id"], "kind": f"{t.get('role')} turn in {t.get('client')}",
+                        "when": t.get("happened_at"),
+                        "preview": masked_preview(t.get("content", ""))}
+                       for t in recalled.get("conversation_turns", [])]
+        return {"status": "CANDIDATES", "candidates": candidates,
+                "next": "Show these numbered with their masked previews exactly as given, ask "
+                        "which to delete, then call brain_forget with those ids."}
+
     @server.tool(
         name="code_activity",
         structured_output=True,

{graph_mind_memory-0.2.1 → graph_mind_memory-0.3.0/graph_mind_memory.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graph-mind-memory
-Version: 0.2.1
+Version: 0.3.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
@@ -174,6 +174,10 @@ like `hunter2` has no recognizable format and is **not** masked. To remove somet
 graph-mind-forget          # asks for the phrase without showing it, then confirms
 ```
 
+Or just ask your AI: *"delete the password I typed earlier"*. It lists masked candidates
+(`wifi password is ****`), deletes only the ones you pick, and the conversation about deleting
+is not saved.
+
 It deletes every captured turn and memory containing the phrase from this PC and its indexes,
 removes their lines from the shared memory, and tells your other PCs to delete their copies on
 their next sync. Only ids are shared for that, never the phrase. Your AI app's own history
@@ -189,9 +193,10 @@ their next sync. Only ids are shared for that, never the phrase. Your AI app's o
 | `brain_recall` | look memories and captured turns up directly; `entity=` for everything about one thing, in order |
 | `brain_remember` | save a sourced memory or decision (secrets masked) |
 | `brain_folder` | where the memory lives; share it with your other PCs; reindex an imported backlog |
+| `brain_forget` | "delete the password I typed": lists masked candidates, deletes only what you pick, everywhere; the exchange itself is not saved |
 | `code_activity` | what changed in a project, file or symbol, and when (when a code folder is watched) |
 
-Five tools on purpose: every tool's description is read by the model on every turn, and similar
+Six tools on purpose: every tool's description is read by the model on every turn, and similar
 tools get confused with each other. Version 0.1 had thirteen.
 
 ---

{graph_mind_memory-0.2.1 → graph_mind_memory-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "graph-mind-memory"
-version = "0.2.1"
+version = "0.3.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"