aether-cache 0.1.2__tar.gz → 0.1.4__tar.gz

{aether_cache-0.1.2 → aether_cache-0.1.4}/.gitignore

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

aether_cache-0.1.2/README.md → aether_cache-0.1.4/PKG-INFO

@@ -1,9 +1,24 @@
+Metadata-Version: 2.5
+Name: aether-cache
+Version: 0.1.4
+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:
@@ -89,9 +104,8 @@ m1 retired; m3 replaces it.
 
 ## Quick start
 
-You need **Java 11+** (`brew install openjdk@21` on macOS, or [adoptium.net](https://adoptium.net)) and
-[**uv**](https://docs.astral.sh/uv/) (`curl -LsSf https://astral.sh/uv/install.sh | sh`), which also takes care of
-Python for you. Then:
+You need [**uv**](https://docs.astral.sh/uv/) (`curl -LsSf https://astral.sh/uv/install.sh | sh`), which also takes
+care of Python for you. Then:
 
 ```sh
 uv tool install aether-cache
@@ -106,6 +120,13 @@ repo and try:
 
 Then start a new session and ask how to run the tests.
 
+The engine runs on Java 11+. If you have it, it's used. If you don't, `setup` downloads a private copy (about
+50 MB) into `~/.aether-cache/java`, checks it against its published checksum, and uses it only for Aether Cache;
+nothing is installed system-wide, and `aether-cache uninstall` removes it.
+
+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`.
 
@@ -114,15 +135,18 @@ the engine only accepts connections from it, and your memories live in `~/.aethe
 | `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
 
@@ -333,9 +357,11 @@ src/main/java/Main.java      the engine (single file, from the CodeCrafters setu
 aether_cache/                the Python package behind the `aether-cache` command
   server.py                  MCP server: embeddings, git staleness, AGENTS.md/CLAUDE.md sync
   engine.py                  finds Java, starts and stops the engine in the background
+  javart.py                  downloads a private copy of Java when the computer has none
   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.2/PKG-INFO → aether_cache-0.1.4/README.md

@@ -1,21 +1,11 @@
-Metadata-Version: 2.5
-Name: aether-cache
-Version: 0.1.2
-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:
@@ -101,9 +91,8 @@ m1 retired; m3 replaces it.
 
 ## Quick start
 
-You need **Java 11+** (`brew install openjdk@21` on macOS, or [adoptium.net](https://adoptium.net)) and
-[**uv**](https://docs.astral.sh/uv/) (`curl -LsSf https://astral.sh/uv/install.sh | sh`), which also takes care of
-Python for you. Then:
+You need [**uv**](https://docs.astral.sh/uv/) (`curl -LsSf https://astral.sh/uv/install.sh | sh`), which also takes
+care of Python for you. Then:
 
 ```sh
 uv tool install aether-cache
@@ -118,6 +107,13 @@ repo and try:
 
 Then start a new session and ask how to run the tests.
 
+The engine runs on Java 11+. If you have it, it's used. If you don't, `setup` downloads a private copy (about
+50 MB) into `~/.aether-cache/java`, checks it against its published checksum, and uses it only for Aether Cache;
+nothing is installed system-wide, and `aether-cache uninstall` removes it.
+
+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`.
 
@@ -126,15 +122,18 @@ the engine only accepts connections from it, and your memories live in `~/.aethe
 | `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
 
@@ -345,9 +344,11 @@ src/main/java/Main.java      the engine (single file, from the CodeCrafters setu
 aether_cache/                the Python package behind the `aether-cache` command
   server.py                  MCP server: embeddings, git staleness, AGENTS.md/CLAUDE.md sync
   engine.py                  finds Java, starts and stops the engine in the background
+  javart.py                  downloads a private copy of Java when the computer has none
   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.2 → aether_cache-0.1.4}/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.2"
+__version__ = "0.1.4"

{aether_cache-0.1.2 → aether_cache-0.1.4}/aether_cache/cli.py

@@ -17,11 +17,38 @@ def _say(mark: str, text: str) -> None:
 
 # ---------- commands ----------
 
+def _java_label(java: str) -> str:
+    return f"private copy in {java_dir()}" if engine.is_private(java) else java
+
+
+def java_dir():
+    from .javart import JAVA_DIR
+    return JAVA_DIR
+
+
+def _java_for_setup():
+    """The computer's own Java if it has a recent enough one; otherwise downloads a private copy."""
+    try:
+        return engine.find_java()
+    except engine.EngineError as missing:
+        from . import javart
+        reason = str(missing).splitlines()[0]  # "Java isn't installed." or "Found Java 8, which is too old."
+        print(f"[ .... ] {reason} Downloading a private copy of Java {javart.FEATURE_VERSION} for Aether Cache "
+              f"(about 50 MB, only the first time).\n"
+              f"         It goes in {javart.JAVA_DIR}, only Aether Cache uses it, and nothing else on your "
+              f"computer changes.", flush=True)
+        try:
+            javart.download()
+        except javart.JavaDownloadError as e:
+            raise engine.EngineError(str(e))
+        return engine.find_java()
+
+
 def cmd_setup(args) -> int:
     print(f"Setting up Aether Cache {__version__}\n")
     try:
-        java, major = engine.find_java()
-        _say(OK, f"Java {major} ({java})")
+        java, major = _java_for_setup()
+        _say(OK, f"Java {major} ({_java_label(java)})")
         _say(OK, engine.start())
     except engine.EngineError as e:
         _say(FAIL, str(e))
@@ -31,7 +58,10 @@ def cmd_setup(args) -> int:
     if config.FAKE_EMBEDDER:
         _say(OK, "Embedding model: test mode, nothing to download")
     else:
-        print("[ .... ] Downloading the embedding model (about 90 MB, only the first time)...", flush=True)
+        if any(config.MODELS_DIR.glob("*")):
+            print("[ .... ] Loading the embedding model...", flush=True)
+        else:
+            print("[ .... ] Downloading the embedding model (about 90 MB, only the first time)...", flush=True)
         try:
             from .server import embed
             embed("warm up")
@@ -121,7 +151,7 @@ def cmd_doctor(args) -> int:
     _say(OK, f"Aether Cache {__version__}, Python {sys.version.split()[0]} ({sys.executable})")
     try:
         java, major = engine.find_java()
-        _say(OK, f"Java {major} ({java})")
+        _say(OK, f"Java {major} ({_java_label(java)})")
     except engine.EngineError as e:
         _say(FAIL, str(e))
         problems += 1
@@ -195,6 +225,148 @@ def cmd_add(args) -> int:
     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:
+        from . import javart
+        if javart.remove():
+            _say(OK, f"Removed Aether Cache's private copy of Java ({javart.JAVA_DIR})")
+        _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()
@@ -239,6 +411,17 @@ def main(argv=None) -> None:
     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.2 → aether_cache-0.1.4}/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}

{aether_cache-0.1.2 → aether_cache-0.1.4}/aether_cache/engine.py

@@ -34,30 +34,44 @@ def java_install_hint() -> str:
         how = "winget install EclipseAdoptium.Temurin.21.JRE   (or download it from https://adoptium.net)"
     else:
         how = "sudo apt install openjdk-21-jre-headless   (or your distro's equivalent, or https://adoptium.net)"
-    return f"Aether Cache needs Java {MIN_JAVA} or newer. Install it with:\n    {how}"
+    return (f"Run `aether-cache setup` and it downloads a private copy of Java for you, "
+            f"or install Java {MIN_JAVA}+ yourself:\n    {how}")
+
+
+def _java_version(java: str) -> Optional[int]:
+    try:
+        out = subprocess.run([java, "-version"], capture_output=True, text=True, timeout=15)
+    except (OSError, subprocess.SubprocessError):
+        return None
+    match = re.search(r'version "(\d+)(?:\.(\d+))?', out.stderr + out.stdout)
+    if out.returncode != 0 or not match:
+        return None
+    major = int(match.group(1))
+    if major == 1 and match.group(2):  # old-style "1.8.0" means Java 8
+        major = int(match.group(2))
+    return major
 
 
 def find_java() -> Tuple[str, int]:
     """(path to a working java, its major version). Raises EngineError if there's no usable Java.
+    Prefers the computer's own Java; falls back to the private copy `setup` downloads when there isn't one.
     Runs `java -version` rather than trusting the PATH: macOS ships a /usr/bin/java stub that only
     says "Unable to locate a Java Runtime"."""
+    from .javart import private_java
     candidates = []
-    if os.environ.get("JAVA_HOME"):
-        candidates.append(str(Path(os.environ["JAVA_HOME"]) / "bin" / ("java.exe" if os.name == "nt" else "java")))
-    if shutil.which("java"):
-        candidates.append(shutil.which("java"))
+    if not os.environ.get("AETHER_IGNORE_SYSTEM_JAVA"):  # testing only: act as if this computer had no Java
+        if os.environ.get("JAVA_HOME"):
+            candidates.append(str(Path(os.environ["JAVA_HOME"]) / "bin" / ("java.exe" if os.name == "nt" else "java")))
+        if shutil.which("java"):
+            candidates.append(shutil.which("java"))
+    private = private_java()
+    if private:
+        candidates.append(str(private))
     too_old = None
     for java in candidates:
-        try:
-            out = subprocess.run([java, "-version"], capture_output=True, text=True, timeout=15)
-        except (OSError, subprocess.SubprocessError):
+        major = _java_version(java)
+        if major is None:
             continue
-        match = re.search(r'version "(\d+)(?:\.(\d+))?', out.stderr + out.stdout)
-        if out.returncode != 0 or not match:
-            continue
-        major = int(match.group(1))
-        if major == 1 and match.group(2):  # old-style "1.8.0" means Java 8
-            major = int(match.group(2))
         if major >= MIN_JAVA:
             return java, major
         too_old = major
@@ -66,6 +80,14 @@ def find_java() -> Tuple[str, int]:
     raise EngineError("Java isn't installed.\n" + java_install_hint())
 
 
+def is_private(java: str) -> bool:
+    from .javart import JAVA_DIR
+    try:
+        return Path(java).resolve().is_relative_to(JAVA_DIR.resolve())
+    except (OSError, ValueError):
+        return False
+
+
 # ---------- talking to the engine ----------
 
 def client(timeout: Optional[float] = None) -> redis.Redis: