aether-cache 0.1.1__tar.gz → 0.1.3__tar.gz

{aether_cache-0.1.1 → aether_cache-0.1.3}/.gitignore

@@ -19,3 +19,4 @@ dist/
 .impeccable/
 PRODUCT.md
 DESIGN.md
+.DS_Store

aether_cache-0.1.1/README.md → aether_cache-0.1.3/PKG-INFO

@@ -1,9 +1,24 @@
+Metadata-Version: 2.5
+Name: aether-cache
+Version: 0.1.3
+Summary: Shared memory for AI coding tools that stays true to your code.
+Project-URL: Homepage, https://anishchugh05.github.io/Aether-Cache-Redis-Compatible-Vector-Store/
+Project-URL: Repository, https://github.com/anishchugh05/Aether-Cache-Redis-Compatible-Vector-Store
+Author: Anish Chugh
+Requires-Python: >=3.10
+Requires-Dist: fastembed>=0.3
+Requires-Dist: mcp>=1.2
+Requires-Dist: redis>=5.0
+Description-Content-Type: text/markdown
+
 [![progress-banner](https://backend.codecrafters.io/progress/redis/f43a7cd3-11e6-45dc-a8ba-9d6690c73ac0)](https://app.codecrafters.io/users/anishchugh05?r=2qF)
 
 # Aether Cache
 
 **Shared memory for AI coding tools that stays true to your code.**
 
+**[Website](https://anishchugh05.github.io/Aether-Cache-Redis-Compatible-Vector-Store/)** · **[PyPI](https://pypi.org/project/aether-cache/)**
+
 Claude Code, Cursor, and other AI tools each forget your project between sessions, and when they do remember things,
 nothing checks whether those memories are still correct. Aether Cache gives every tool one shared, local memory, and keeps
 it honest:
@@ -106,22 +121,29 @@ repo and try:
 
 Then start a new session and ask how to run the tests.
 
+Already keep notes for your AI in `CLAUDE.md`, `AGENTS.md`, or Cursor rules? Run `aether-cache import` in the repo
+(or use **Import notes** in the dashboard) to turn them into memories, linked to the files they mention.
+
 Memories are kept per project (the git repo's folder name), so projects never mix. Everything stays on your machine:
 the engine only accepts connections from it, and your memories live in `~/.aether-cache`.
 
 | Command | What it does |
 |---|---|
 | `aether-cache setup` | One-time setup: engine, model, and AI tools |
+| `aether-cache add` | Adds the repo you're in (or a path) so the dashboard can check its files; the dashboard can also find and add repos for you |
 | `aether-cache ui` | Opens the dashboard: see what your AI remembers, and confirm or retire memories whose files changed |
+| `aether-cache import` | Turns the notes in `CLAUDE.md`, `AGENTS.md`, and Cursor rules into memories; shows them first and asks |
+| `aether-cache export` | Saves memories, with their linked files and history, to a JSON file (`-p` for one project) |
 | `aether-cache status` | Is it running, and what's in this project's memory |
 | `aether-cache doctor` | Checks everything and tells you how to fix what's wrong |
 | `aether-cache list` / `recall "query"` / `explain m1` | Look at memories from the terminal |
 | `aether-cache sync` | Writes current memories into `AGENTS.md` / `CLAUDE.md` |
 | `aether-cache connect cursor` | Connects one tool (`--print` shows config for any other MCP tool) |
 | `aether-cache start` / `stop` | Runs or stops the engine (it also starts on its own when a tool needs it) |
+| `aether-cache uninstall` | Disconnects your AI tools, stops the engine, and asks before deleting memories |
 
 If `aether-cache` isn't found after installing, run `uv tool update-shell` and open a new terminal. Port 7380 taken?
-Set `AETHER_PORT` and run `setup` again. To uninstall: `aether-cache stop && uv tool uninstall aether-cache`.
+Set `AETHER_PORT` and run `setup` again. To uninstall: `aether-cache uninstall`, then `uv tool uninstall aether-cache`.
 
 ## Tools the AI can call
 
@@ -335,6 +357,7 @@ aether_cache/                the Python package behind the `aether-cache` comman
   connect.py                 registers Aether Cache with Claude Code, Cursor, and Codex
   cli.py                     the `aether-cache` command
   ui.py, ui/index.html       the dashboard (`aether-cache ui`): a local server, its API, and the page
+  portability.py             import from notes files, export to JSON
   engine/aether-engine.jar   the prebuilt engine (rebuild with `python scripts/build_engine.py`)
 memory_mcp/calibrate.py      similarity calibration for duplicate/contradiction thresholds
 vector_bench.py              HNSW benchmark (writes results.json)

aether_cache-0.1.1/PKG-INFO → aether_cache-0.1.3/README.md

@@ -1,21 +1,11 @@
-Metadata-Version: 2.5
-Name: aether-cache
-Version: 0.1.1
-Summary: Shared memory for AI coding tools that stays true to your code.
-Project-URL: Homepage, https://github.com/anishchugh05/Aether-Cache-Redis-Compatible-Vector-Store
-Author: Anish Chugh
-Requires-Python: >=3.10
-Requires-Dist: fastembed>=0.3
-Requires-Dist: mcp>=1.2
-Requires-Dist: redis>=5.0
-Description-Content-Type: text/markdown
-
 [![progress-banner](https://backend.codecrafters.io/progress/redis/f43a7cd3-11e6-45dc-a8ba-9d6690c73ac0)](https://app.codecrafters.io/users/anishchugh05?r=2qF)
 
 # Aether Cache
 
 **Shared memory for AI coding tools that stays true to your code.**
 
+**[Website](https://anishchugh05.github.io/Aether-Cache-Redis-Compatible-Vector-Store/)** · **[PyPI](https://pypi.org/project/aether-cache/)**
+
 Claude Code, Cursor, and other AI tools each forget your project between sessions, and when they do remember things,
 nothing checks whether those memories are still correct. Aether Cache gives every tool one shared, local memory, and keeps
 it honest:
@@ -118,22 +108,29 @@ repo and try:
 
 Then start a new session and ask how to run the tests.
 
+Already keep notes for your AI in `CLAUDE.md`, `AGENTS.md`, or Cursor rules? Run `aether-cache import` in the repo
+(or use **Import notes** in the dashboard) to turn them into memories, linked to the files they mention.
+
 Memories are kept per project (the git repo's folder name), so projects never mix. Everything stays on your machine:
 the engine only accepts connections from it, and your memories live in `~/.aether-cache`.
 
 | Command | What it does |
 |---|---|
 | `aether-cache setup` | One-time setup: engine, model, and AI tools |
+| `aether-cache add` | Adds the repo you're in (or a path) so the dashboard can check its files; the dashboard can also find and add repos for you |
 | `aether-cache ui` | Opens the dashboard: see what your AI remembers, and confirm or retire memories whose files changed |
+| `aether-cache import` | Turns the notes in `CLAUDE.md`, `AGENTS.md`, and Cursor rules into memories; shows them first and asks |
+| `aether-cache export` | Saves memories, with their linked files and history, to a JSON file (`-p` for one project) |
 | `aether-cache status` | Is it running, and what's in this project's memory |
 | `aether-cache doctor` | Checks everything and tells you how to fix what's wrong |
 | `aether-cache list` / `recall "query"` / `explain m1` | Look at memories from the terminal |
 | `aether-cache sync` | Writes current memories into `AGENTS.md` / `CLAUDE.md` |
 | `aether-cache connect cursor` | Connects one tool (`--print` shows config for any other MCP tool) |
 | `aether-cache start` / `stop` | Runs or stops the engine (it also starts on its own when a tool needs it) |
+| `aether-cache uninstall` | Disconnects your AI tools, stops the engine, and asks before deleting memories |
 
 If `aether-cache` isn't found after installing, run `uv tool update-shell` and open a new terminal. Port 7380 taken?
-Set `AETHER_PORT` and run `setup` again. To uninstall: `aether-cache stop && uv tool uninstall aether-cache`.
+Set `AETHER_PORT` and run `setup` again. To uninstall: `aether-cache uninstall`, then `uv tool uninstall aether-cache`.
 
 ## Tools the AI can call
 
@@ -347,6 +344,7 @@ aether_cache/                the Python package behind the `aether-cache` comman
   connect.py                 registers Aether Cache with Claude Code, Cursor, and Codex
   cli.py                     the `aether-cache` command
   ui.py, ui/index.html       the dashboard (`aether-cache ui`): a local server, its API, and the page
+  portability.py             import from notes files, export to JSON
   engine/aether-engine.jar   the prebuilt engine (rebuild with `python scripts/build_engine.py`)
 memory_mcp/calibrate.py      similarity calibration for duplicate/contradiction thresholds
 vector_bench.py              HNSW benchmark (writes results.json)

{aether_cache-0.1.1 → aether_cache-0.1.3}/aether_cache/__init__.py

@@ -1,3 +1,3 @@
 """Aether Cache: shared memory for AI coding tools that stays true to your code."""
 
-__version__ = "0.1.1"
+__version__ = "0.1.3"

{aether_cache-0.1.1 → aether_cache-0.1.3}/aether_cache/cli.py

@@ -179,6 +179,161 @@ def _tool_output(name: str, *tool_args) -> int:
     return 0
 
 
+def cmd_add(args) -> int:
+    from . import repos
+    from .server import EngineDown, store_down
+    try:
+        engine.ensure_running()
+        added = repos.add(args.path)
+    except repos.RepoError as e:
+        print(e)
+        return 1
+    except (engine.EngineError, EngineDown) as e:
+        print(store_down(e))
+        return 1
+    print(f"Added {added['name']} ({added['path']})" + (f", github.com/{added['github']}" if added["github"] else "") + ".")
+    return 0
+
+
+def _ask(question: str) -> bool:
+    if not sys.stdin.isatty():
+        return False
+    try:
+        return input(f"{question} [y/N] ").strip().lower() in ("y", "yes")
+    except EOFError:
+        return False
+
+
+def cmd_import(args) -> int:
+    from pathlib import Path
+    from . import portability, repos, server
+    folder = Path(args.path).expanduser()
+    if not folder.is_dir():
+        print(f"{args.path} isn't a folder.")
+        return 1
+    root = repos.git_top(folder) or folder.resolve()
+    project = root.name
+    try:
+        engine.ensure_running()
+        found = portability.scan(project, root)
+    except (engine.EngineError, server.EngineDown) as e:
+        print(server.store_down(e))
+        return 1
+    if not found["files"]:
+        print(f"No notes files in {root}.\nAether Cache looks for: " + ", ".join(portability.NOTE_FILES)
+              + ", and .cursor/rules/.")
+        return 0
+    notes = found["notes"]
+    new = [n for n in notes if n["selected"]]
+    left_out = [n for n in notes if not n["known"] and not n["selected"]]
+    known = [n for n in notes if n["known"]]
+    print(f"Found {len(notes)} notes in " + ", ".join(f["path"] for f in found["files"]) + f" ({project})\n")
+    for i, n in enumerate(new, 1):
+        print(f"  {i:>3}. {n['text']}" + (f"\n       linked to {', '.join(n['files'])}" if n["files"] else ""))
+    if left_out:
+        print(f"\nLeft out ({len(left_out)}):")
+        for n in left_out:
+            why = (f"mentions {', '.join(n['missing'])}, which doesn't exist (probably out of date)"
+                   if n["missing"] else "doesn't look like a fact about the project")
+            print(f"     - {n['text']}\n       {why}")
+    if known:
+        print(f"\nAlready remembered: {len(known)}")
+    if not new:
+        print("\nNothing new to import.")
+        return 0
+    if left_out:
+        print("\nTo pick notes one by one, including the left-out ones, use Import notes in `aether-cache ui`.")
+    if not args.yes and not _ask(f"\nImport {len(new)} {'memory' if len(new) == 1 else 'memories'} into {project}?"):
+        print("Nothing imported." + ("" if sys.stdin.isatty() else " Pass --yes to import without asking."))
+        return 0
+    try:
+        result = portability.apply(project, root)
+        repos.add(str(root))  # so the dashboard can check the imported memories' files
+    except repos.RepoError:
+        pass
+    except server.EngineDown as e:
+        print(server.store_down(e))
+        return 1
+    saved = len(result["saved"])
+    print(f"Imported {saved} {'memory' if saved == 1 else 'memories'} into {project}."
+          + (f" {result['duplicates']} matched memories you already had." if result["duplicates"] else "")
+          + (f"\n{result['conflicts']} may contradict an existing memory: decide in `aether-cache ui`."
+             if result["conflicts"] else ""))
+    return 0
+
+
+def cmd_export(args) -> int:
+    import json
+    from pathlib import Path
+    from . import portability, server
+    try:
+        engine.ensure_running()
+        data = portability.export(args.project or None)
+    except (engine.EngineError, server.EngineDown) as e:
+        print(server.store_down(e))
+        return 1
+    text = json.dumps(data, indent=2, ensure_ascii=False) + "\n"
+    if args.output == "-":
+        sys.stdout.write(text)
+        return 0
+    out = Path(args.output or portability.export_filename(args.project[0] if len(args.project or []) == 1 else None))
+    out = out.expanduser()
+    out.write_text(text, encoding="utf-8")
+    n = sum(len(p["memories"]) for p in data["projects"])
+    print(f"Exported {n} {'memory' if n == 1 else 'memories'} from {len(data['projects'])} "
+          f"{'project' if len(data['projects']) == 1 else 'projects'} to {out.resolve()}")
+    return 0
+
+
+def _uninstall_command() -> str:
+    exe = sys.executable.replace("\\", "/")
+    if "/uv/tools/" in exe or "/uv/tool/" in exe:
+        return "uv tool uninstall aether-cache"
+    if "/pipx/" in exe:
+        return "pipx uninstall aether-cache"
+    return f"{sys.executable} -m pip uninstall aether-cache"
+
+
+def cmd_uninstall(args) -> int:
+    import shutil
+    print("Uninstalling Aether Cache\n")
+    failed = False
+    for tool in connect.TOOLS:
+        done, message = connect.DISCONNECTORS[tool]()
+        _say(OK if done else FAIL, message)
+        failed |= not done
+    print("         Restart any AI tools that are open, so they stop using Aether Cache.")
+    count = None
+    if engine.probe() == "aether":
+        try:
+            from .ui import all_memories
+            count = len(all_memories())
+        except Exception:
+            pass
+    stopped = engine.stop()
+    still_running = engine.probe() == "aether"
+    _say(FAIL if still_running else OK, stopped)
+    failed |= still_running
+
+    has_data = config.HOME.exists()
+    if still_running and has_data:  # it would rewrite them anyway
+        print(f"\nYour memories are kept in {config.HOME}: stop the engine first to delete them.")
+        print(f"\nLast step, remove the program itself:\n  {_uninstall_command()}")
+        return 1
+    delete = args.delete_data
+    if has_data and not delete:
+        what = f"Your {count} {'memory is' if count == 1 else 'memories are'}" if count else "Your memories are"
+        print(f"\n{what} in {config.HOME}.")
+        delete = _ask("Delete them too? This can't be undone (keep a copy first with `aether-cache export`).")
+    if has_data and delete:
+        shutil.rmtree(config.HOME, ignore_errors=True)
+        _say(OK, f"Deleted {config.HOME}")
+    elif has_data:
+        _say(OK, f"Kept your memories in {config.HOME}. Reinstall any time and they're back.")
+    print(f"\nLast step, remove the program itself:\n  {_uninstall_command()}")
+    return 1 if failed else 0
+
+
 def cmd_serve(args) -> int:
     from .server import serve
     serve()
@@ -220,6 +375,20 @@ def main(argv=None) -> None:
         func=lambda a: _tool_output("sync_to_files"))
     sub.add_parser("check", help="retire memories whose linked files changed").set_defaults(
         func=lambda a: _tool_output("check_stale"))
+    p = sub.add_parser("add", help="add a repo so the dashboard can check its files (default: this folder)")
+    p.add_argument("path", nargs="?", default=".")
+    p.set_defaults(func=cmd_add)
+    p = sub.add_parser("import", help="turn notes in CLAUDE.md, AGENTS.md, and Cursor rules into memories")
+    p.add_argument("path", nargs="?", default=".", help="the repo to import from (default: this folder)")
+    p.add_argument("--yes", "-y", action="store_true", help="import without asking")
+    p.set_defaults(func=cmd_import)
+    p = sub.add_parser("export", help="save memories, with their history, to a JSON file")
+    p.add_argument("--project", "-p", action="append", metavar="NAME", help="only this project (repeatable; default: all)")
+    p.add_argument("--output", "-o", metavar="FILE", help="where to write it (default: aether-cache-<date>.json here; - for stdout)")
+    p.set_defaults(func=cmd_export)
+    p = sub.add_parser("uninstall", help="disconnect your AI tools, stop the engine, and optionally delete memories")
+    p.add_argument("--delete-data", action="store_true", help="also delete all memories, without asking")
+    p.set_defaults(func=cmd_uninstall)
     p = sub.add_parser("ui", help="open the dashboard: see and fix what your AI tools remember")
     p.add_argument("--port", type=int, help="port for the dashboard (default 7381)")
     p.add_argument("--no-open", action="store_true", help="don't open a browser, just print the link")

{aether_cache-0.1.1 → aether_cache-0.1.3}/aether_cache/connect.py

@@ -66,6 +66,28 @@ def add_instructions(path: Path) -> str:
     return f"told it to use Aether Cache for project memory in {path}"
 
 
+def remove_instructions(path: Path) -> bool:
+    """Takes our section back out of an instruction file, leaving the rest exactly as it was.
+    Deletes the file only if our section was all that was in it. Returns whether anything changed."""
+    try:
+        old = path.read_text(encoding="utf-8")
+    except OSError:
+        return False
+    if INSTR_START not in old or INSTR_END not in old:
+        return False
+    before, after = old[:old.index(INSTR_START)], old[old.index(INSTR_END) + len(INSTR_END):]
+    new = before.rstrip() + ("\n\n" + after.lstrip("\n") if before.strip() and after.strip() else after.lstrip("\n"))
+    if not new.strip():
+        path.unlink()
+        return True
+    if not new.endswith("\n"):
+        new += "\n"
+    tmp = path.with_name(path.name + ".aether-tmp")
+    tmp.write_text(new, encoding="utf-8")
+    os.replace(tmp, path)
+    return True
+
+
 def claude_instructions_file() -> Path:
     return Path(os.environ.get("CLAUDE_CONFIG_DIR", Path.home() / ".claude")) / "CLAUDE.md"
 
@@ -95,6 +117,20 @@ def connect_claude_code() -> Tuple[bool, str]:
     return True, "Claude Code: connected for all projects (" + "; ".join(notes) + ")."
 
 
+def disconnect_claude_code() -> Tuple[bool, str]:
+    notes = []
+    if shutil.which("claude"):
+        removed = [scope for scope in ("user", "local")
+                   if _claude("mcp", "remove", NAME, "--scope", scope).returncode == 0]
+        if removed:
+            notes.append("removed the MCP server")
+        if _claude("mcp", "get", NAME).returncode == 0:
+            return False, "Claude Code: couldn't remove it. Run `claude mcp remove aether-cache` yourself."
+    if remove_instructions(claude_instructions_file()):
+        notes.append(f"removed our section from {claude_instructions_file()}")
+    return True, "Claude Code: disconnected" + (f" ({'; '.join(notes)})." if notes else " (it wasn't connected).")
+
+
 def claude_code_connected() -> bool:
     return bool(shutil.which("claude")) and _claude("mcp", "get", NAME).returncode == 0
 
@@ -128,6 +164,25 @@ def connect_cursor() -> Tuple[bool, str]:
     return True, f"Cursor: connected for all projects ({path}). Restart Cursor to pick it up."
 
 
+def disconnect_cursor() -> Tuple[bool, str]:
+    path = cursor_config()
+    try:
+        data = json.loads(path.read_text(encoding="utf-8") or "{}")
+    except OSError:
+        return True, "Cursor: disconnected (it wasn't connected)."
+    except json.JSONDecodeError as e:
+        return False, f"Cursor: couldn't read {path} ({e}). Remove the \"{NAME}\" entry yourself."
+    servers = data.get("mcpServers") if isinstance(data, dict) else None
+    if not isinstance(servers, dict) or NAME not in servers:
+        return True, "Cursor: disconnected (it wasn't connected)."
+    shutil.copyfile(path, path.with_name("mcp.json.bak"))
+    del servers[NAME]
+    tmp = path.with_name("mcp.json.aether-tmp")
+    tmp.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+    os.replace(tmp, path)
+    return True, f"Cursor: disconnected ({path}). Restart Cursor to pick it up."
+
+
 def cursor_connected() -> bool:
     try:
         return NAME in json.loads(cursor_config().read_text(encoding="utf-8")).get("mcpServers", {})
@@ -155,14 +210,7 @@ def _is_our_header(line: str) -> bool:
 def connect_codex() -> Tuple[bool, str]:
     path = codex_config()
     text = path.read_text(encoding="utf-8") if path.exists() else ""
-    # drop our old section (if any): from its header to the next table header
-    kept, skipping = [], False
-    for line in text.splitlines():
-        if line.strip().startswith("["):
-            skipping = _is_our_header(line)
-        if not skipping:
-            kept.append(line)
-    body = "\n".join(kept).rstrip()
+    body = _without_our_section(text)  # drop our old section (if any): from its header to the next table header
     new = (body + "\n\n" if body else "") + _codex_block()
     if path.exists():
         shutil.copyfile(path, path.with_name("config.toml.bak"))
@@ -174,6 +222,35 @@ def connect_codex() -> Tuple[bool, str]:
     return True, f"Codex: connected ({path}; {note})."
 
 
+def _without_our_section(text: str) -> str:
+    kept, skipping = [], False
+    for line in text.splitlines():
+        if line.strip().startswith("["):
+            skipping = _is_our_header(line)
+        if not skipping:
+            kept.append(line)
+    return "\n".join(kept).rstrip()
+
+
+def disconnect_codex() -> Tuple[bool, str]:
+    path = codex_config()
+    notes = []
+    try:
+        text = path.read_text(encoding="utf-8")
+    except OSError:
+        text = ""
+    if any(_is_our_header(l) for l in text.splitlines()):
+        shutil.copyfile(path, path.with_name("config.toml.bak"))
+        body = _without_our_section(text)
+        tmp = path.with_name("config.toml.aether-tmp")
+        tmp.write_text(body + "\n" if body else "", encoding="utf-8")
+        os.replace(tmp, path)
+        notes.append(f"removed the MCP server from {path}")
+    if remove_instructions(path.with_name("AGENTS.md")):
+        notes.append(f"removed our section from {path.with_name('AGENTS.md')}")
+    return True, "Codex: disconnected" + (f" ({'; '.join(notes)})." if notes else " (it wasn't connected).")
+
+
 def codex_connected() -> bool:
     try:
         return any(_is_our_header(l) for l in codex_config().read_text(encoding="utf-8").splitlines())
@@ -192,4 +269,6 @@ def generic_instructions() -> str:
 
 
 CONNECTORS = {"claude-code": connect_claude_code, "cursor": connect_cursor, "codex": connect_codex}
+DISCONNECTORS = {"claude-code": disconnect_claude_code, "cursor": disconnect_cursor, "codex": disconnect_codex}
+LABELS = {"claude-code": "Claude Code", "cursor": "Cursor", "codex": "Codex"}
 CHECKS = {"claude-code": claude_code_connected, "cursor": cursor_connected, "codex": codex_connected}