comodor 0.2.2__tar.gz → 0.2.3__tar.gz

{comodor-0.2.2 → comodor-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: comodor
-Version: 0.2.2
+Version: 0.2.3
 Summary: Comodor — a self-improving terminal coding agent with a Rich TUI
 Project-URL: Homepage, https://comodor.ai
 Project-URL: Repository, https://github.com/ifekri/Comodor

{comodor-0.2.2 → comodor-0.2.3}/src/comodor/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.2.2'
-__version_tuple__ = version_tuple = (0, 2, 2)
+__version__ = version = '0.2.3'
+__version_tuple__ = version_tuple = (0, 2, 3)
 
 __commit_id__ = commit_id = None

{comodor-0.2.2 → comodor-0.2.3}/src/comodor/uninstall.py

@@ -439,7 +439,7 @@ def survey(config: Config | None = None, cwd: Path | None = None) -> Survey:
             detail=install.detail,
             path=install.root,
             size=directory_size(install.root) if install.root else 0,
-            remove=lambda tool=tool: _run_uninstaller(tool),
+            remove=lambda tool=tool, root=install.root: _run_uninstaller(tool, root),
             deferred=sys.platform == "win32",
         ))
     elif install.method == "venv" and install.owned:
@@ -490,9 +490,17 @@ def survey(config: Config | None = None, cwd: Path | None = None) -> Survey:
 
     others = _other_launchers(BIN_DIR)
     if others:
+        # Named, not counted. "2 other programs live there" leaves the reader
+        # with a decision they have no information for; `uv, uvx` tells them
+        # whether the line is worth keeping, and those two in particular were
+        # very likely fetched by this installer in the first place.
+        listed = ", ".join(others[:4])
+        if len(others) > 4:
+            listed += f" and {len(others) - 4} more"
         found.notes.append(
-            f"{BIN_DIR} stays on your PATH: {others} other program"
-            f"{'s' if others != 1 else ''} live there")
+            f"{BIN_DIR} stays on your PATH, and so does the line that put it "
+            f"there: {listed} still live in it. Remove the line by hand if "
+            f"none of those matter to you.")
     else:
         for profile, _ in profile_edits(BIN_DIR):
             found.add(Item(
@@ -525,30 +533,84 @@ def _within(path: Path, root: Path) -> bool:
         return False
 
 
-def _other_launchers(directory: Path) -> int:
-    """How many programs besides ours live in the launcher directory."""
+def _other_launchers(directory: Path) -> list[str]:
+    """What else lives in the launcher directory, by name."""
     if not directory.is_dir():
-        return 0
+        return []
     ours = {"comodor", "comodor.exe", "comodor.cmd", "comodor-script.py"}
     try:
-        return sum(1 for entry in directory.iterdir() if entry.name not in ours)
+        return sorted(entry.name for entry in directory.iterdir()
+                      if entry.name not in ours)
     except OSError:
-        return 0
-
+        return []
+
+
+#: Where a tool manager lives when it is not on PATH. The same list the
+#: installer searches, and for the same reason: `curl | sh` runs without the
+#: user's profile, so `uv` gets bootstrapped into ~/.local/bin and nothing in
+#: that session ever puts it on PATH.
+TOOL_DIRS = (
+    Path.home() / ".local" / "bin",
+    Path.home() / ".cargo" / "bin",
+    Path.home() / "bin",
+    Path("/opt/homebrew/bin"),
+    Path("/usr/local/bin"),
+    Path("/home/linuxbrew/.linuxbrew/bin"),
+)
+
+
+def find_tool(name: str) -> str | None:
+    """`name` on PATH, or in the places an installer would have put it."""
+    found = shutil.which(name)
+    if found:
+        return found
+    suffixes = (".exe", ".cmd", "") if sys.platform == "win32" else ("",)
+    for directory in TOOL_DIRS:
+        for suffix in suffixes:
+            candidate = directory / f"{name}{suffix}"
+            if candidate.is_file():
+                return str(candidate)
+    return None
+
+
+def _run_uninstaller(tool: str, root: Path | None = None) -> str:
+    """Hand the package back to whatever installed it.
+
+    And if that is not possible, take it off anyway.
+
+    uv and pipx keep a record of the tools they manage, so asking them is the
+    tidy way: it removes the environment *and* the entry. But the installer
+    fetches `uv` into `~/.local/bin` when the machine has none, and a shell
+    that ran `curl | sh` never read a profile, so `uv` is frequently installed
+    and simultaneously not on PATH — which is how a real uninstall reported
+    "No such file or directory: 'uv'" and left seventy megabytes behind.
+
+    So the tool is looked for where an installer would have put it, and if it
+    genuinely is not there the environment is deleted directly. That leaves uv
+    with an entry for something that is gone, which is worth saying out loud —
+    and is a great deal better than leaving the thing itself.
+    """
+    if tool == "pip":
+        command = [sys.executable, "-m", "pip", "uninstall", "-y", "comodor"]
+    else:
+        executable = find_tool(tool)
+        if executable is None:
+            if root is None:
+                raise RuntimeError(f"{tool} is not installed any more")
+            _rmtree(root)
+            return f"{root} (removed directly: {tool} is not on this machine)"
+        command = ([executable, "tool", "uninstall", "comodor"] if tool == "uv"
+                   else [executable, "uninstall", "comodor"])
 
-def _run_uninstaller(tool: str) -> str:
-    """Hand the package back to whatever installed it."""
-    commands = {
-        "uv": ["uv", "tool", "uninstall", "comodor"],
-        "pipx": ["pipx", "uninstall", "comodor"],
-        "pip": [sys.executable, "-m", "pip", "uninstall", "-y", "comodor"],
-    }
-    command = commands[tool]
     result = subprocess.run(command, capture_output=True, text=True, timeout=180)
     if result.returncode != 0:
+        if root is not None and root.exists():
+            _rmtree(root)
+            reason = (result.stderr or result.stdout).strip().splitlines()
+            return f"{root} (removed directly: {reason[-1][:80] if reason else tool})"
         raise RuntimeError((result.stderr or result.stdout).strip()[:200]
                            or f"{tool} exited {result.returncode}")
-    return " ".join(command[-3:] if tool != "pip" else command[1:])
+    return " ".join(command[1:])
 
 
 # --------------------------------------------------------------------------- #

{comodor-0.2.2 → comodor-0.2.3}/tests/test_uninstall.py

@@ -22,6 +22,7 @@ Comodor and then checks it starts failed with "command not found".
 from __future__ import annotations
 
 import json
+import os
 from pathlib import Path
 
 import pytest
@@ -211,7 +212,8 @@ def test_a_shared_bin_directory_keeps_its_place_on_path(tmp_path, monkeypatch):
     found = survey(config)
 
     assert not [item for item in found.items if item.kind == "path"]
-    assert any("stays on your PATH" in note for note in found.notes)
+    # Named, so the reader can judge whether the line is worth keeping.
+    assert any("ruff" in note for note in found.notes)
 
 
 def test_a_directory_that_was_only_ours_gives_the_path_line_back(tmp_path,
@@ -305,6 +307,42 @@ def test_the_command_itself_goes_too(tmp_path, monkeypatch):
     assert not launcher.exists()
 
 
+def test_a_tool_manager_off_the_path_is_still_found(tmp_path, monkeypatch):
+    """`curl | sh` bootstraps uv into ~/.local/bin and never reads a profile.
+
+    So the shell that installed Comodor frequently has uv installed and not on
+    PATH at the same time, and `shutil.which` says it is not there at all.
+    """
+    from comodor.uninstall import find_tool
+
+    tool = Path.home() / ".local" / "bin" / ("uv.exe" if os.name == "nt" else "uv")
+    tool.write_text("#!/bin/sh", encoding="utf-8")
+    monkeypatch.setattr("comodor.uninstall.TOOL_DIRS", (tool.parent,))
+    monkeypatch.setattr("shutil.which", lambda name: None)
+
+    assert find_tool("uv") == str(tool)
+    assert find_tool("pipx") is None
+
+
+def test_a_missing_tool_manager_does_not_leave_the_environment_behind(tmp_path,
+                                                                     monkeypatch):
+    """Reported honestly and left on disk is still left on disk.
+
+    Deleting it directly leaves uv with an entry for something that is gone.
+    Seventy megabytes of environment is the worse of the two.
+    """
+    from comodor.uninstall import _run_uninstaller
+
+    environment = tmp_path / "uv" / "tools" / "comodor"
+    (environment / "bin").mkdir(parents=True)
+    monkeypatch.setattr("comodor.uninstall.find_tool", lambda name: None)
+
+    outcome = _run_uninstaller("uv", environment)
+
+    assert not environment.exists()
+    assert "removed directly" in outcome
+
+
 def test_a_removal_that_fails_is_reported_rather_than_raised(tmp_path):
     """One thing that will not go must not stop the rest from going."""
     def explode() -> str: