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

{graph_mind_memory-0.1.5 → graph_mind_memory-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graph-mind-memory
-Version: 0.1.5
+Version: 0.2.1
 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
@@ -41,6 +41,10 @@ Local-first memory for AI coding assistants. Verbatim storage, on your own PC:
 
 *Switch models; keep the memory.*
 
+<img src="demo/demo.gif" alt="A decision made in Claude Code on Monday, recalled from Codex on Wednesday" width="760">
+
+<sub>A real run, not a mock-up: <code>python demo/record_demo.py</code> records it from a fresh store.</sub>
+
 </div>
 
 > [!NOTE]
@@ -162,25 +166,33 @@ Then restart your AI apps. The server is also listed in the
 Before anything is stored, these are masked: API keys, tokens from GitHub, AWS, Google and Slack,
 private keys, and passwords inside URLs.
 
+Only what you actually send is captured: the service reads each app's transcript, which is written
+after you press Enter, so a paste you delete before sending never reaches it. A plain password
+like `hunter2` has no recognizable format and is **not** masked. To remove something:
+
+```bash
+graph-mind-forget          # asks for the phrase without showing it, then confirms
+```
+
+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
+(for Claude Code, `~/.claude/projects`) is separate and is not touched.
+
 ---
 
 ## MCP tools
 
 | tool | what it does |
 |---|---|
-| `brain_context` | a bounded packet of the memories and conversation turns that answer a request |
-| `brain_recall` | inspect memories and captured turns directly |
-| `brain_remember` | save a sourced memory (secrets masked) |
-| `brain_associate` | recall from a vague cue |
-| `brain_timeline` | everything about one thing, oldest first, with replaced entries marked |
-| `brain_folder` | show or choose where the memory lives; share it with other PCs |
-| `brain_index` | bring an imported backlog up to date |
-| `conversation_recall` | search the captured turns themselves |
-| `code_activity` | what changed in a project, file or symbol, and when |
-| `memory_record` | record a development event or decision |
-| `project_status` | current state of a project |
-| `resume_project` | everything needed to pick a project back up |
-| `explain_decision` | a decision, its reason and its history |
+| `brain_context` | a bounded packet of the past turns and memories that answer a request; `recent=true` for "where did we leave off?" |
+| `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 |
+| `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
+tools get confused with each other. Version 0.1 had thirteen.
 
 ---
 
@@ -228,6 +240,8 @@ python -m unittest discover -p "test_*.py"
 
 ## Known limits
 
+- **The first question after an AI app starts waits for the embedding model to load** (a few
+  seconds; 30-50 s on a slow or synced disk). Later questions take well under a second.
 - **Daily use on Windows only so far.** macOS and Linux pass the tests in CI but have not seen real
   use.
 - **Capture follows each app's transcript format,** which is not a public interface. An app update

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

@@ -15,6 +15,10 @@ Local-first memory for AI coding assistants. Verbatim storage, on your own PC:
 
 *Switch models; keep the memory.*
 
+<img src="demo/demo.gif" alt="A decision made in Claude Code on Monday, recalled from Codex on Wednesday" width="760">
+
+<sub>A real run, not a mock-up: <code>python demo/record_demo.py</code> records it from a fresh store.</sub>
+
 </div>
 
 > [!NOTE]
@@ -136,25 +140,33 @@ Then restart your AI apps. The server is also listed in the
 Before anything is stored, these are masked: API keys, tokens from GitHub, AWS, Google and Slack,
 private keys, and passwords inside URLs.
 
+Only what you actually send is captured: the service reads each app's transcript, which is written
+after you press Enter, so a paste you delete before sending never reaches it. A plain password
+like `hunter2` has no recognizable format and is **not** masked. To remove something:
+
+```bash
+graph-mind-forget          # asks for the phrase without showing it, then confirms
+```
+
+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
+(for Claude Code, `~/.claude/projects`) is separate and is not touched.
+
 ---
 
 ## MCP tools
 
 | tool | what it does |
 |---|---|
-| `brain_context` | a bounded packet of the memories and conversation turns that answer a request |
-| `brain_recall` | inspect memories and captured turns directly |
-| `brain_remember` | save a sourced memory (secrets masked) |
-| `brain_associate` | recall from a vague cue |
-| `brain_timeline` | everything about one thing, oldest first, with replaced entries marked |
-| `brain_folder` | show or choose where the memory lives; share it with other PCs |
-| `brain_index` | bring an imported backlog up to date |
-| `conversation_recall` | search the captured turns themselves |
-| `code_activity` | what changed in a project, file or symbol, and when |
-| `memory_record` | record a development event or decision |
-| `project_status` | current state of a project |
-| `resume_project` | everything needed to pick a project back up |
-| `explain_decision` | a decision, its reason and its history |
+| `brain_context` | a bounded packet of the past turns and memories that answer a request; `recent=true` for "where did we leave off?" |
+| `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 |
+| `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
+tools get confused with each other. Version 0.1 had thirteen.
 
 ---
 
@@ -202,6 +214,8 @@ python -m unittest discover -p "test_*.py"
 
 ## Known limits
 
+- **The first question after an AI app starts waits for the embedding model to load** (a few
+  seconds; 30-50 s on a slow or synced disk). Later questions take well under a second.
 - **Daily use on Windows only so far.** macOS and Linux pass the tests in CI but have not seen real
   use.
 - **Capture follows each app's transcript format,** which is not a public interface. An app update

{graph_mind_memory-0.1.5 → graph_mind_memory-0.2.1}/brain_log.py

@@ -36,7 +36,7 @@ import platform
 import re
 import sqlite3
 
-KINDS = ("memory", "turn")
+KINDS = ("memory", "turn", "forget")   # forget: ids another PC erased (forget.py)
 
 
 def device_name() -> str:
@@ -48,7 +48,10 @@ def device_name() -> str:
 def config_path() -> Path:
     """Where the chosen brain folder is remembered for every client on this machine."""
     override = os.environ.get("GRAPH_MIND_CONFIG")
-    return Path(override) if override else Path.home() / ".graph-mind" / "config.json"
+    if override:
+        return Path(override)
+    from development_paths import graph_mind_home
+    return graph_mind_home() / "config.json"            # ~/.graph-mind unless GRAPH_MIND_HOME
 
 
 def _config() -> dict:
@@ -423,6 +426,8 @@ def sync(shared: Path, index: Path) -> dict:
             except ValueError:
                 continue                                  # a corrupt line is skipped, not fatal
         items.sort(key=lambda pair: pair[0].get("written_at", ""))
+        forgets = [item["record"] for item, _ in items if item.get("kind") == "forget"]
+        items = [(item, line) for item, line in items if item.get("kind") != "forget"]
         imported, conflicts, waiting = 0, 0, []
         with LocalBrainStore(index) as brain, ConversationMemoryStore(index) as turns:
             # A supersession can arrive before the memory it replaces when two devices' logs are
@@ -447,6 +452,10 @@ def sync(shared: Path, index: Path) -> dict:
                 if not progress:
                     waiting = [line for _, line in retry]
                     break
+        if forgets:                         # after the imports: a forgotten turn may be in them
+            from forget import erase
+            for record in forgets:
+                erase(index, record)
         with db:
             db.execute("DELETE FROM brain_log_pending")
             db.executemany("INSERT OR IGNORE INTO brain_log_pending VALUES(?)",

graph_mind_memory-0.2.1/forget.py

@@ -0,0 +1,166 @@
+"""Forget everything that contains a phrase: on this PC, in the shared log, and on the other PCs.
+
+    graph-mind-forget                  # asks for the phrase without echoing it (keeps it out of
+                                       # the shell history), shows what matches, asks to confirm
+    graph-mind-forget "hunter2" --yes
+
+A captured turn or memory lives in its store, in that store's word index, and as an engram in the
+associative index; all three go. In the shared log its lines go too: Postgres rows are deleted, a
+folder's lines are blanked in place (same length, so other PCs' read offsets stay valid). Then a
+"forget" record listing the ids, never the phrase, tells every other PC to erase its own copies.
+
+Not covered: the AI app's own transcript (Claude Code keeps ~/.claude/projects/*.jsonl) and the
+embedding vectors, which are numbers keyed by a hash and hold no text.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+import argparse
+import getpass
+import json
+import sqlite3
+import sys
+
+
+def find(index: Path, phrase: str) -> dict:
+    """Ids of the turns and memories whose text contains the phrase (exact, case-sensitive)."""
+    db = sqlite3.connect(index, timeout=30)
+    try:
+        tables = {row[0] for row in db.execute("SELECT name FROM sqlite_master")}
+        turns = [row[0] for row in db.execute(
+            "SELECT turn_id FROM conversation_turns WHERE instr(content_redacted, ?) > 0",
+            (phrase,))] if "conversation_turns" in tables else []
+        memories = [row[0] for row in db.execute(
+            "SELECT memory_id FROM local_brain_memories "
+            "WHERE instr(content, ?) > 0 OR instr(title, ?) > 0",
+            (phrase, phrase))] if "local_brain_memories" in tables else []
+    finally:
+        db.close()
+    return {"turn_ids": turns, "memory_ids": memories}
+
+
+def erase(index: Path, ids: dict) -> dict:
+    """Delete these turns and memories, with every index entry derived from them."""
+    turns, memories = list(ids.get("turn_ids", [])), list(ids.get("memory_ids", []))
+    db = sqlite3.connect(index, timeout=30)
+    try:
+        tables = {row[0] for row in db.execute("SELECT name FROM sqlite_master")}
+        with db:
+            if turns and "conversation_turns" in tables:
+                marks = ",".join("?" * len(turns))
+                rows = db.execute(f"SELECT revision, content_redacted FROM conversation_turns "
+                                  f"WHERE turn_id IN ({marks})", turns).fetchall()
+                # an external-content FTS table keeps its words until told to drop them
+                db.executemany("INSERT INTO conversation_turns_fts(conversation_turns_fts, rowid, "
+                               "content_redacted) VALUES('delete', ?, ?)", rows)
+                db.execute(f"DELETE FROM conversation_turns WHERE turn_id IN ({marks})", turns)
+            if memories and "local_brain_memories" in tables:
+                marks = ",".join("?" * len(memories))
+                db.execute(f"DELETE FROM local_brain_memories WHERE memory_id IN ({marks})",
+                           memories)
+                if "local_brain_memory_profiles" in tables:
+                    db.execute(f"DELETE FROM local_brain_memory_profiles "
+                               f"WHERE memory_id IN ({marks})", memories)
+            sources = turns + memories
+            if sources and "associative_engrams" in tables:
+                marks = ",".join("?" * len(sources))
+                engrams = [row[0] for row in db.execute(
+                    f"SELECT engram_id FROM associative_engrams WHERE source_id IN ({marks})",
+                    sources)]
+                if engrams:
+                    em = ",".join("?" * len(engrams))
+                    for table, column in (("associative_engrams_fts", "engram_id"),
+                                          ("associative_terms", "engram_id"),
+                                          ("associative_edges", "source_engram_id"),
+                                          ("associative_edges", "target_engram_id"),
+                                          ("associative_pending_edges", "source_engram_id"),
+                                          ("associative_pending_edges", "target_engram_id"),
+                                          ("associative_engrams", "engram_id")):
+                        if table in tables:
+                            db.execute(f"DELETE FROM {table} WHERE {column} IN ({em})", engrams)
+    finally:
+        db.close()
+    return {"turns": len(turns), "memories": len(memories)}
+
+
+def _keys(ids: dict) -> list[str]:
+    """How a target's log line spells its id (brain_log writes sorted keys, ": " separators)."""
+    return ([f'"turn_id": {json.dumps(t)}' for t in ids.get("turn_ids", [])]
+            + [f'"memory_id": {json.dumps(m)}' for m in ids.get("memory_ids", [])])
+
+
+def scrub_shared(shared, ids: dict) -> int:
+    """Remove the targets' lines from the shared log. Returns how many lines went."""
+    from brain_log import _pg, is_database
+    keys = _keys(ids)
+    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
+            connection.commit()
+        return removed
+    removed = 0
+    for log in (Path(shared) / "log").glob("*.jsonl"):
+        data = log.read_bytes()
+        lines = data.split(b"\n")
+        changed = False
+        for n, line in enumerate(lines):
+            text = line.decode("utf-8", "replace")
+            if any(key in text for key in keys) and '"kind": "forget"' not in text:
+                lines[n] = b" " * len(line)        # same length: readers' offsets stay valid
+                changed, removed = True, removed + 1
+        if changed:
+            with log.open("r+b") as stream:            # in place: the file is never shorter
+                stream.write(b"\n".join(lines))
+    return removed
+
+
+def forget(phrase: str, index: Path, shared=None) -> dict:
+    """Find, erase 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"]):
+        return {"turns": 0, "memories": 0, "shared_lines_removed": 0}
+    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
+    return result
+
+
+def main(argv=None):
+    from brain_log import folder
+    from development_paths import default_development_db
+    parser = argparse.ArgumentParser(description="Forget every captured turn and memory "
+                                                 "that contains a phrase, on every PC.")
+    parser.add_argument("phrase", nargs="?", help="omit it to type it without echo")
+    parser.add_argument("--yes", action="store_true", help="do not ask for confirmation")
+    args = parser.parse_args(argv)
+    phrase = args.phrase or getpass.getpass("Phrase to forget (not shown): ")
+    if len(phrase.strip()) < 4:
+        sys.exit("Use at least 4 characters, so a short word does not wipe half the memory.")
+    index = default_development_db()
+    ids = find(index, phrase)
+    count = len(ids["turn_ids"]) + len(ids["memory_ids"])
+    if not count:
+        print("Nothing in this PC's memory contains that phrase.")
+        return
+    print(f"{len(ids['turn_ids'])} conversation turns and {len(ids['memory_ids'])} memories "
+          "contain it.")
+    if not args.yes and input("Forget them here and on your other PCs? [y/N] ").lower() != "y":
+        print("Nothing changed.")
+        return
+    shared = folder()
+    result = forget(phrase, index, shared)
+    print(f"Forgotten: {result['turns']} turns, {result['memories']} memories"
+          + (f"; {result['shared_lines_removed']} lines removed from the shared memory, "
+             "other PCs follow on their next sync" if shared else "") + ".")
+    print("Your AI app may still have it in its own history (Claude Code: ~/.claude/projects).")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -15,7 +15,6 @@ from mcp.server import MCPServer
 from associative_memory import AssociativeMemoryIndex
 from coding_memory import CodingMemoryStore
 from conversation_memory import ConversationMemoryStore
-from development_memory import DevelopmentMemoryStore
 from development_paths import default_development_db
 from local_brain import LocalBrainStore
 from universal_personal_memory import build_context_pack, decide_recall
@@ -26,14 +25,6 @@ if hasattr(sys.stderr, "reconfigure"):
 
 
 SERVER_VERSION = "0.5.0"
-RecordableEventType = Literal[
-    "OBJECTIVE_SET", "TASK_STARTED", "TASK_COMPLETED", "TASK_BLOCKED",
-    "TASK_CANCELLED", "FILE_CHANGED", "DECISION_RECORDED", "TEST_RECORDED",
-    "NEXT_ACTION_SET", "NEXT_ACTION_COMPLETED", "SESSION_SUMMARY",
-    "EXPERIMENT_STARTED", "EXPERIMENT_STOPPED",
-]
-
-
 # The embedding model is loaded from the local Hugging Face cache, but the library still asks the
 # hub over the network whether a newer revision exists, every time it loads. That made the first
 # save of a session take ~95 s and sent requests off the machine for no reason. Once the model is
@@ -346,17 +337,12 @@ def build_server(db_path=None):
             "stored or noted something, and do not add lines like 'I saved that to memory'. "
             "Mention memory only when the user asks what you remember or whether it was saved. "
             "Call brain_context first when a request may depend on the user's prior conversations, "
-            "facts, preferences, documents, projects or work. It skips unrelated requests and "
-            "returns a bounded evidence packet instead of replaying full history. Use brain_recall "
-            "for direct memory inspection. It searches curated memories and automatically captured "
-            "conversation turns without requiring a project ID. Use brain_associate for vague cues "
-            "or indirect reminders, then verify its candidate sources with the deterministic tools. "
-            "For questions about code changed in a time range, project, file or symbol, translate "
-            "the wording into code_activity filters and use its indexed evidence. "
-            "Call project_status or resume_project when an exact project ID is already known. "
-            "Treat scope_completeness=UNATTESTED as partial observed history. "
-            "Use brain_remember for general sourced memories and memory_record for sourced "
-            "development events. Preserve provenance."
+            "facts, preferences, decisions, projects or work, including 'where did we leave off?'. "
+            "It skips unrelated requests and returns a bounded evidence packet instead of "
+            "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."
         ),
         version=SERVER_VERSION,
     )
@@ -395,6 +381,8 @@ def build_server(db_path=None):
         required: put the user's own sentence there verbatim. Add `entities` (who or what it is
         about) and `effective_at` (when it happened, ISO time) when you know them. If it updates
         something remembered earlier, pass that memory's id as `supersedes_memory_id`.
+        Decisions and their reasons are memories too: `memory_type="decision"`, the reason in
+        `content`, the project or component in `entities`.
 
         Save silently. Do not tell the user you saved it ("I've noted that", "저장해 뒀어"); just
         carry on with the conversation. Talk about memory only if the user asks what you remember
@@ -443,14 +431,21 @@ def build_server(db_path=None):
             openWorldHint=False,
         ),
     )
-    def brain_recall(query: str, scopes: list[str] | None = None,
+    def brain_recall(query: str = "", entity: str | None = None,
+                     scopes: list[str] | None = None,
                      as_of: str | None = None,
                      knowledge_cutoff: str | None = None,
                      limit: int = 8, recent: bool = False,
                      since: str | None = None,
                      about_assistant: bool = False,
                      around: str | None = None) -> dict[str, Any]:
-        """Recall relevant local memories from natural wording without requiring a project ID.
+        """Look up memories and captured conversation turns directly, from natural wording.
+
+        `entity` instead answers "what happened to X, in order": every memory about that one
+        thing (the auth module, this project, my address), oldest first, with replaced entries
+        marked and the current one picked out. Similarity search returns only the nearest one or
+        two of four decisions made about one thing in four sessions; this returns all four. With
+        neither `query` nor `entity`, it lists what the store knows about, busiest first.
 
         Set `recent=true` whenever the question is about what happened lately or what the user was
         just doing: "what was I working on?", "where did we leave off?", "what did I do
@@ -467,6 +462,21 @@ def build_server(db_path=None):
         mention events days or weeks before or after, so that date misleads (measured: on dev2
         it pushed the answering turn out in 2 of 11 questions and helped 2).
         """
+        if entity or not query:
+            import sqlite3
+
+            import entity_timeline as timeline_index
+            shared_sync(database)              # every device's memories are in this one index
+            db = sqlite3.connect(database)
+            try:
+                if not entity:
+                    return {"entities": timeline_index.entities(db, limit=max(limit, 50))}
+                rows = timeline_index.timeline(db, entity, limit=max(limit, 50))
+            finally:
+                db.close()
+            current = [r for r in rows if not r["superseded"]]
+            return {"entity": entity, "entries": rows, "count": len(rows),
+                    "current": current[-1] if current else None}
         return gather(database, query, scopes=scopes, as_of=as_of or _now(),
                       knowledge_cutoff=knowledge_cutoff, limit=limit, recent=recent, since=since,
                       about_assistant=about_assistant, around=around)
@@ -526,75 +536,6 @@ def build_server(db_path=None):
                 "STRUCTURED_EXECUTION_REQUIRED_FOR_COMPLETE_SCOPE_CLAIMS")
         return packet
 
-    @server.tool(
-        name="brain_associate",
-        structured_output=True,
-        annotations=types.ToolAnnotations(
-            readOnlyHint=True,
-            destructiveHint=False,
-            idempotentHint=True,
-            openWorldHint=False,
-        ),
-    )
-    def brain_associate(query: str, scopes: list[str] | None = None,
-                        concept_cues: list[str] | None = None,
-                        seed_limit: int = 12, hops: int = 2,
-                        fanout: int = 12, max_nodes: int = 40,
-                        limit: int = 8,
-                        minimum_concept_coverage: float = 0.75,
-                        grounding: str = "semantic",
-                        semantic_threshold: float = 0.35) -> dict[str, Any]:
-        """Recall indirect candidate memories through bounded associative activation.
-
-        grounding="semantic" (default, v0.7.3): on-device embedding pipeline — FTS seed ->
-          local-embedding semantic gate -> query re-ranking. On untouched production evals it
-          recovers Korean paraphrase recall (Vague Hit@5 0%->57%) at 0% control false association,
-          and matches or beats literal on exact. Loads a local model lazily; all text stays on-device.
-        grounding="auto": cheap literal gate first, semantic fallback only when literal abstains.
-        grounding="literal": the deterministic token-overlap coverage gate only.
-        """
-        with AssociativeMemoryIndex(database) as index:
-            if grounding in ("semantic", "auto"):
-                from semantic_recall import (auto_associate, default_embedder,
-                                             semantic_associate)
-                embedder = default_embedder(database)
-                if grounding == "auto":
-                    result = auto_associate(index, query, concept_cues, embedder=embedder,
-                        literal_gate=minimum_concept_coverage,
-                        semantic_threshold=semantic_threshold, scopes=scopes)
-                else:
-                    result = semantic_associate(index, query, concept_cues,
-                        embedder=embedder, scopes=scopes, threshold=semantic_threshold)
-            else:
-                result = index.activate(query, scopes=scopes, concept_cues=concept_cues,
-                    seed_limit=seed_limit, hops=hops, fanout=fanout,
-                    max_nodes=max_nodes, limit=limit,
-                    minimum_concept_coverage=minimum_concept_coverage)
-        result["evidence_status"] = "CANDIDATES_REQUIRE_SOURCE_VERIFICATION"
-        return result
-
-    @server.tool(
-        name="brain_index",
-        structured_output=True,
-        annotations=types.ToolAnnotations(
-            readOnlyHint=False,
-            destructiveHint=False,
-            idempotentHint=True,
-            openWorldHint=False,
-        ),
-    )
-    def brain_index(limit: int = 1000) -> dict[str, Any]:
-        """Bring the search index up to date: link new memories, then embed the unembedded ones.
-
-        brain_remember already does this for what it writes; run this after importing a backlog, or
-        on a store that was written by an older version.
-        """
-        from embedding_warmup import warm
-        with AssociativeMemoryIndex(database) as index:
-            synced = index.sync_sources(limit=limit)
-        return {"synced": synced, "vectors_warmed": warm(database, limit=limit),
-                "store": str(database)}
-
     @server.tool(
         name="brain_folder",
         structured_output=True,
@@ -605,7 +546,8 @@ def build_server(db_path=None):
             openWorldHint=False,
         ),
     )
-    def brain_folder(path: str | None = None, share_existing: bool = False) -> dict[str, Any]:
+    def brain_folder(path: str | None = None, share_existing: bool = False,
+                     reindex: bool = False) -> dict[str, Any]:
         """Show or choose the folder that holds the user's brain.
 
         Call it with `path` when the user names a folder for their memory, e.g. "use my Google
@@ -624,7 +566,16 @@ def build_server(db_path=None):
 
         `share_existing=true` copies what this PC already remembered into the folder, which uploads
         it to wherever the folder syncs. Set it only when the user has explicitly agreed to that.
+
+        `reindex=true` brings the search index up to date (links new memories, embeds unembedded
+        ones). Saving already does this; it is for a large imported backlog.
         """
+        if reindex:
+            from embedding_warmup import warm
+            with AssociativeMemoryIndex(database) as index:
+                synced = index.sync_sources(limit=1000)
+            return {"synced": synced, "vectors_warmed": warm(database, limit=1000),
+                    "store": str(database)}
         from brain_log import device_name, devices, export_history, folder, set_folder, share, sync
         shared_out = None
         if path == "share":
@@ -654,62 +605,6 @@ 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_timeline",
-        structured_output=True,
-        annotations=types.ToolAnnotations(
-            readOnlyHint=True,
-            destructiveHint=False,
-            idempotentHint=True,
-            openWorldHint=False,
-        ),
-    )
-    def brain_timeline(entity: str | None = None, limit: int = 50) -> dict[str, Any]:
-        """Every memory about ONE thing, oldest first, with replaced entries marked.
-
-        Similarity search answers "what relates to this question"; this answers "what happened to
-        the auth module / this project / this device, in order". Those are the questions that keep
-        failing otherwise, because the four decisions about one thing sit in four different
-        sessions and only the nearest one or two come back. Call it with no entity to list what the
-        store knows about, busiest first.
-        """
-        import sqlite3
-
-        import entity_timeline as timeline_index
-
-        shared_sync(database)                  # every device's memories are in this one index
-        db = sqlite3.connect(database)
-        try:
-            if not entity:
-                return {"entities": timeline_index.entities(db, limit=limit)}
-            rows = timeline_index.timeline(db, entity, limit=limit)
-        finally:
-            db.close()
-        current = [r for r in rows if not r["superseded"]]
-        return {"entity": entity, "entries": rows[:limit], "count": len(rows),
-                "current": current[-1] if current else None}
-
-    @server.tool(
-        name="conversation_recall",
-        structured_output=True,
-        annotations=types.ToolAnnotations(
-            readOnlyHint=True,
-            destructiveHint=False,
-            idempotentHint=True,
-            openWorldHint=False,
-        ),
-    )
-    def conversation_recall(query: str, scopes: list[str] | None = None,
-                            limit: int = 10) -> dict[str, Any]:
-        """Search redacted conversation turns captured after Local Brain activation."""
-        try:
-            with ConversationMemoryStore(database) as store:
-                return store.search(query, scopes=scopes, limit=limit)
-        except ValueError as error:
-            return {"status": "UNKNOWN", "reason": "INVALID_CONVERSATION_QUERY",
-                    "detail": str(error), "scope_completeness": "UNATTESTED",
-                    "turns": []}
-
     @server.tool(
         name="code_activity",
         structured_output=True,
@@ -728,7 +623,10 @@ def build_server(db_path=None):
                       change_kind: str | None = None,
                       limit: int = 20,
                       max_diff_chars: int = 6000) -> dict[str, Any]:
-        """Return indexed code changes and diff evidence without rereading a repository."""
+        """Code changes the capture service recorded, with diff excerpts, filtered by project,
+        time range (`happened_from`/`happened_to`, ISO), file, symbol or kind. For "what did I
+        change in auth.py last week?" or "when did the parser change?". Empty unless a code folder
+        is being watched (automatic-capture.json, code_workspaces)."""
         try:
             bounded_diff_chars = max(200, min(max_diff_chars, 20000))
             with CodingMemoryStore(database) as store:
@@ -741,100 +639,6 @@ def build_server(db_path=None):
                     "detail": str(error), "scope_completeness": "UNATTESTED",
                     "changes": []}
 
-    @server.tool(
-        name="memory_record",
-        structured_output=True,
-        annotations=types.ToolAnnotations(
-            readOnlyHint=False,
-            destructiveHint=False,
-            idempotentHint=False,
-            openWorldHint=False,
-        ),
-    )
-    def memory_record(project_id: str, session_id: str, event_type: RecordableEventType,
-                      subject_id: str, payload: dict[str, Any], source_ref: str,
-                      effective_at: str | None = None,
-                      source_type: str = "mcp-client",
-                      supersedes_event_id: str | None = None,
-                      event_id: str | None = None) -> dict[str, Any]:
-        """Append one sourced development event without overwriting prior history."""
-        known_at = _now()
-        event = {"event_id": event_id or "mcp-" + uuid.uuid4().hex,
-            "project_id": project_id, "session_id": session_id,
-            "event_type": event_type, "effective_at": effective_at or known_at,
-            "known_at": known_at, "actor": "assistant", "subject_id": subject_id,
-            "payload": payload,
-            "provenance": {"source_type": source_type, "source_ref": source_ref},
-            "supersedes_event_id": supersedes_event_id}
-        with DevelopmentMemoryStore(database) as store:
-            result = store.record_event(event)
-        return {**result, "project_id": project_id, "store": str(database)}
-
-    @server.tool(
-        name="project_status",
-        structured_output=True,
-        annotations=types.ToolAnnotations(
-            readOnlyHint=True,
-            destructiveHint=False,
-            idempotentHint=True,
-            openWorldHint=False,
-        ),
-    )
-    def project_status(project_id: str, as_of: str | None = None,
-                       knowledge_cutoff: str | None = None) -> dict[str, Any]:
-        """Return the current objective, active work and next actions for a project."""
-        when = as_of or _now()
-        with DevelopmentMemoryStore(database) as store:
-            resumed = store.resume_project(project_id, as_of=when,
-                                           knowledge_cutoff=knowledge_cutoff)
-        if resumed["status"] != "KNOWN":
-            return resumed
-        return {key: resumed[key] for key in (
-            "status", "reason", "project_id", "as_of", "knowledge_cutoff",
-            "scope_completeness", "warnings", "objective", "current_task",
-            "open_tasks", "next_actions", "active_experiments", "last_session",
-            "evidence_event_ids")}
-
-    @server.tool(
-        name="resume_project",
-        structured_output=True,
-        annotations=types.ToolAnnotations(
-            readOnlyHint=True,
-            destructiveHint=False,
-            idempotentHint=True,
-            openWorldHint=False,
-        ),
-    )
-    def resume_project(project_id: str, as_of: str | None = None,
-                       knowledge_cutoff: str | None = None,
-                       recent_file_limit: int = 10,
-                       recent_test_limit: int = 10) -> dict[str, Any]:
-        """Build a full evidence-backed packet for continuing work in a new session."""
-        when = as_of or _now()
-        with DevelopmentMemoryStore(database) as store:
-            return store.resume_project(project_id, as_of=when,
-                knowledge_cutoff=knowledge_cutoff, recent_file_limit=recent_file_limit,
-                recent_test_limit=recent_test_limit)
-
-    @server.tool(
-        name="explain_decision",
-        structured_output=True,
-        annotations=types.ToolAnnotations(
-            readOnlyHint=True,
-            destructiveHint=False,
-            idempotentHint=True,
-            openWorldHint=False,
-        ),
-    )
-    def explain_decision(project_id: str, decision_id: str,
-                         as_of: str | None = None,
-                         knowledge_cutoff: str | None = None) -> dict[str, Any]:
-        """Return the active decision, reason, correction history and provenance."""
-        when = as_of or _now()
-        with DevelopmentMemoryStore(database) as store:
-            return store.explain_decision(project_id, decision_id, as_of=when,
-                                          knowledge_cutoff=knowledge_cutoff)
-
     return server
 
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graph-mind-memory
-Version: 0.1.5
+Version: 0.2.1
 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
@@ -41,6 +41,10 @@ Local-first memory for AI coding assistants. Verbatim storage, on your own PC:
 
 *Switch models; keep the memory.*
 
+<img src="demo/demo.gif" alt="A decision made in Claude Code on Monday, recalled from Codex on Wednesday" width="760">
+
+<sub>A real run, not a mock-up: <code>python demo/record_demo.py</code> records it from a fresh store.</sub>
+
 </div>
 
 > [!NOTE]
@@ -162,25 +166,33 @@ Then restart your AI apps. The server is also listed in the
 Before anything is stored, these are masked: API keys, tokens from GitHub, AWS, Google and Slack,
 private keys, and passwords inside URLs.
 
+Only what you actually send is captured: the service reads each app's transcript, which is written
+after you press Enter, so a paste you delete before sending never reaches it. A plain password
+like `hunter2` has no recognizable format and is **not** masked. To remove something:
+
+```bash
+graph-mind-forget          # asks for the phrase without showing it, then confirms
+```
+
+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
+(for Claude Code, `~/.claude/projects`) is separate and is not touched.
+
 ---
 
 ## MCP tools
 
 | tool | what it does |
 |---|---|
-| `brain_context` | a bounded packet of the memories and conversation turns that answer a request |
-| `brain_recall` | inspect memories and captured turns directly |
-| `brain_remember` | save a sourced memory (secrets masked) |
-| `brain_associate` | recall from a vague cue |
-| `brain_timeline` | everything about one thing, oldest first, with replaced entries marked |
-| `brain_folder` | show or choose where the memory lives; share it with other PCs |
-| `brain_index` | bring an imported backlog up to date |
-| `conversation_recall` | search the captured turns themselves |
-| `code_activity` | what changed in a project, file or symbol, and when |
-| `memory_record` | record a development event or decision |
-| `project_status` | current state of a project |
-| `resume_project` | everything needed to pick a project back up |
-| `explain_decision` | a decision, its reason and its history |
+| `brain_context` | a bounded packet of the past turns and memories that answer a request; `recent=true` for "where did we leave off?" |
+| `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 |
+| `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
+tools get confused with each other. Version 0.1 had thirteen.
 
 ---
 
@@ -228,6 +240,8 @@ python -m unittest discover -p "test_*.py"
 
 ## Known limits
 
+- **The first question after an AI app starts waits for the embedding model to load** (a few
+  seconds; 30-50 s on a slow or synced disk). Later questions take well under a second.
 - **Daily use on Windows only so far.** macOS and Linux pass the tests in CI but have not seen real
   use.
 - **Capture follows each app's transcript format,** which is not a public interface. An app update

{graph_mind_memory-0.1.5 → graph_mind_memory-0.2.1}/graph_mind_memory.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ development_memory.py
 development_paths.py
 embedding_warmup.py
 entity_timeline.py
+forget.py
 graph_mind_mcp_server.py
 install.py
 local_brain.py

{graph_mind_memory-0.1.5 → graph_mind_memory-0.2.1}/graph_mind_memory.egg-info/entry_points.txt

@@ -1,4 +1,5 @@
 [console_scripts]
 graph-mind = graph_mind_mcp_server:main
 graph-mind-capture = automatic_capture_cli:main
+graph-mind-forget = forget:main
 graph-mind-install = install:main

{graph_mind_memory-0.1.5 → graph_mind_memory-0.2.1}/graph_mind_memory.egg-info/top_level.txt

@@ -9,6 +9,7 @@ development_memory
 development_paths
 embedding_warmup
 entity_timeline
+forget
 graph_mind_mcp_server
 install
 local_brain

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "graph-mind-memory"
-version = "0.1.5"
+version = "0.2.1"
 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"
@@ -39,6 +39,7 @@ Issues = "https://github.com/goyohan0611-png/graph-mind/issues"
 graph-mind = "graph_mind_mcp_server:main"
 graph-mind-install = "install:main"
 graph-mind-capture = "automatic_capture_cli:main"
+graph-mind-forget = "forget:main"
 
 [tool.setuptools]
 # ponytail: flat modules, as in the repository; a graph_mind/ package is the upgrade path.
@@ -54,6 +55,7 @@ py-modules = [
     "development_paths",
     "embedding_warmup",
     "entity_timeline",
+    "forget",
     "graph_mind_mcp_server",
     "install",
     "local_brain",