paircode 0.8.1__tar.gz → 0.9.1__tar.gz

{paircode-0.8.1 → paircode-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: paircode
-Version: 0.8.1
+Version: 0.9.1
 Summary: Adversarial journey framework — orchestrate multiple LLM peers through research, plan, and execute stages with file-trace peer review.
 Project-URL: Homepage, https://github.com/starshipagentic/paircode
 Project-URL: Repository, https://github.com/starshipagentic/paircode
@@ -36,15 +36,18 @@ Description-Content-Type: text/markdown
 
 ```bash
 pipx install paircode       # or: pip install --user paircode
-paircode install            # registers /paircode in Claude Code (global slash command)
+paircode install            # registers /paircode in every detected LLM CLI
 ```
 
-After install, open Claude Code in any project and `/paircode` is available.
+After install, `/paircode` is available in all three:
 
-> **Note**: codex and gemini don't have a slash-command registration system
-> we can target, so `paircode install` is a no-op for them. From codex or
-> gemini, invoke paircode from your shell: `paircode status`, `paircode drive "..."`
-> etc. (or wrapped: `codex exec 'paircode status'`).
+| CLI | File installed |
+|---|---|
+| Claude Code | `~/.claude/commands/paircode.md` |
+| Codex CLI | `~/.codex/prompts/paircode.md` |
+| Gemini CLI | `~/.gemini/commands/paircode.toml` |
+
+Open any of them and type `/paircode`. In Gemini, you may need `/commands reload` the first time.
 
 As of v0.8.0, paircode delegates all CLI invocation to [`cliworker`](https://pypi.org/project/cliworker/) — one place to own
 the speed flags, MCP strip tricks, skip-cache, and subscription-first fallback

{paircode-0.8.1 → paircode-0.9.1}/README.md

@@ -8,15 +8,18 @@
 
 ```bash
 pipx install paircode       # or: pip install --user paircode
-paircode install            # registers /paircode in Claude Code (global slash command)
+paircode install            # registers /paircode in every detected LLM CLI
 ```
 
-After install, open Claude Code in any project and `/paircode` is available.
+After install, `/paircode` is available in all three:
 
-> **Note**: codex and gemini don't have a slash-command registration system
-> we can target, so `paircode install` is a no-op for them. From codex or
-> gemini, invoke paircode from your shell: `paircode status`, `paircode drive "..."`
-> etc. (or wrapped: `codex exec 'paircode status'`).
+| CLI | File installed |
+|---|---|
+| Claude Code | `~/.claude/commands/paircode.md` |
+| Codex CLI | `~/.codex/prompts/paircode.md` |
+| Gemini CLI | `~/.gemini/commands/paircode.toml` |
+
+Open any of them and type `/paircode`. In Gemini, you may need `/commands reload` the first time.
 
 As of v0.8.0, paircode delegates all CLI invocation to [`cliworker`](https://pypi.org/project/cliworker/) — one place to own
 the speed flags, MCP strip tricks, skip-cache, and subscription-first fallback

{paircode-0.8.1 → paircode-0.9.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "paircode"
-version = "0.8.1"
+version = "0.9.1"
 description = "Adversarial journey framework — orchestrate multiple LLM peers through research, plan, and execute stages with file-trace peer review."
 readme = "README.md"
 license = { text = "MIT" }

{paircode-0.8.1 → paircode-0.9.1}/src/paircode/__init__.py

@@ -2,4 +2,4 @@
 
 See README.md and diary/001-step-a-architecture.md for the full design.
 """
-__version__ = "0.8.0"
+__version__ = "0.9.0"

paircode-0.9.1/src/paircode/installer.py

@@ -0,0 +1,188 @@
+"""Install paircode's slash command into detected LLM CLIs.
+
+Strategy per CLI (all file-drop; see v1.0 roadmap for native register migration):
+  - Claude Code: ~/.claude/commands/paircode.md (Markdown + YAML frontmatter).
+                 First-class documented path.
+  - Codex CLI:   ~/.codex/prompts/paircode.md (Markdown + YAML frontmatter).
+                 Path marked "deprecated" by OpenAI (they're steering toward
+                 marketplaces), but still loads and remains the only file-drop
+                 path for user-typed slash commands in codex.
+  - Gemini CLI:  ~/.gemini/commands/paircode.toml (TOML with description + prompt).
+                 First-class, first-party format. Not Markdown.
+
+Also cleans up legacy broken files from paircode 0.1–0.7 which wrote
+~/.codex/rules/paircode.rules (that file is Starlark-parsed and our markdown
+broke codex's rule loader).
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from importlib import resources
+from pathlib import Path
+
+from paircode.detect import detect_all, CliInfo
+
+
+@dataclass(frozen=True)
+class InstallResult:
+    cli_name: str
+    action: str  # "installed", "skipped", "failed", "noop"
+    path: Path | None
+    message: str
+
+
+def _read_template(name: str) -> str:
+    return resources.files("paircode.templates").joinpath(name).read_text(encoding="utf-8")
+
+
+# ---------------------------------------------------------------------------
+# Per-CLI installers
+# ---------------------------------------------------------------------------
+
+def install_claude(info: CliInfo) -> InstallResult:
+    """Write ~/.claude/commands/paircode.md — a real Claude Code slash command."""
+    if not info.installed:
+        return InstallResult(
+            cli_name="claude", action="skipped", path=None,
+            message=f"claude CLI not on PATH. {info.install_hint}",
+        )
+    commands_dir = info.config_dir / "commands"
+    commands_dir.mkdir(parents=True, exist_ok=True)
+    target = commands_dir / "paircode.md"
+    target.write_text(_read_template("claude_slash_command.md"), encoding="utf-8")
+    return InstallResult(
+        cli_name="claude", action="installed", path=target,
+        message=f"Wrote /paircode slash command to {target}.",
+    )
+
+
+def install_codex(info: CliInfo) -> InstallResult:
+    """Write ~/.codex/prompts/paircode.md — codex's custom-prompt slash command path.
+
+    Codex flags this path as "deprecated" in favor of marketplace plugins, but
+    it's still the only file-drop path for user-typed slash commands. When
+    codex removes this (they haven't yet), paircode will migrate to
+    `codex marketplace add` with a satellite repo.
+    """
+    if not info.installed:
+        return InstallResult(
+            cli_name="codex", action="skipped", path=None,
+            message=f"codex CLI not on PATH. {info.install_hint}",
+        )
+    prompts_dir = info.config_dir / "prompts"
+    prompts_dir.mkdir(parents=True, exist_ok=True)
+    target = prompts_dir / "paircode.md"
+    target.write_text(_read_template("codex_slash_command.md"), encoding="utf-8")
+    return InstallResult(
+        cli_name="codex", action="installed", path=target,
+        message=f"Wrote /paircode slash command to {target}. Inside codex interactive, /paircode will appear.",
+    )
+
+
+def install_gemini(info: CliInfo) -> InstallResult:
+    """Write ~/.gemini/commands/paircode.toml — gemini's first-class custom command path.
+
+    Gemini uses TOML (not Markdown) with `description` and `prompt` fields.
+    After install, run `/commands reload` inside gemini or restart the session.
+    """
+    if not info.installed:
+        return InstallResult(
+            cli_name="gemini", action="skipped", path=None,
+            message=f"gemini CLI not on PATH. {info.install_hint}",
+        )
+    commands_dir = info.config_dir / "commands"
+    commands_dir.mkdir(parents=True, exist_ok=True)
+    target = commands_dir / "paircode.toml"
+    target.write_text(_read_template("gemini_slash_command.toml"), encoding="utf-8")
+    return InstallResult(
+        cli_name="gemini", action="installed", path=target,
+        message=(
+            f"Wrote /paircode slash command to {target}. "
+            "Run `/commands reload` inside gemini (or restart) to pick it up."
+        ),
+    )
+
+
+# ---------------------------------------------------------------------------
+# Public entry points
+# ---------------------------------------------------------------------------
+
+def install_all() -> list[InstallResult]:
+    """Run every CLI's installer. Also cleans up legacy broken files first."""
+    _clean_legacy_broken_files()
+    detected = detect_all()
+    installers = {
+        "claude": install_claude,
+        "codex": install_codex,
+        "gemini": install_gemini,
+    }
+    results: list[InstallResult] = []
+    for name, info in detected.items():
+        installer = installers.get(name)
+        if not installer:
+            continue
+        try:
+            results.append(installer(info))
+        except Exception as exc:  # pragma: no cover — defensive
+            results.append(InstallResult(
+                cli_name=name, action="failed", path=None,
+                message=f"{type(exc).__name__}: {exc}",
+            ))
+    return results
+
+
+def _clean_legacy_broken_files() -> None:
+    """Remove files prior paircode versions installed and which we now know
+    to be broken or misplaced. Silent best-effort."""
+    # v0.1–v0.7 wrote markdown to codex's Starlark rules dir, which broke
+    # codex's rule loader on every session startup.
+    legacy = Path.home() / ".codex" / "rules" / "paircode.rules"
+    try:
+        if legacy.exists():
+            legacy.unlink()
+    except OSError:
+        pass
+
+    # v0.1–v0.7 also dropped a reference file at ~/.gemini/paircode.md.
+    # v0.9+ writes the real slash command at ~/.gemini/commands/paircode.toml
+    # instead; clean up the old reference.
+    legacy_gemini = Path.home() / ".gemini" / "paircode.md"
+    try:
+        if legacy_gemini.exists():
+            legacy_gemini.unlink()
+    except OSError:
+        pass
+
+
+def uninstall_all() -> list[InstallResult]:
+    """Remove paircode entries from every CLI config dir (idempotent).
+    Also cleans up legacy broken paths from prior paircode versions."""
+    results: list[InstallResult] = []
+    paths: list[tuple[Path, str]] = [
+        # Current v0.9+ paths
+        (Path.home() / ".claude" / "commands" / "paircode.md", "claude"),
+        (Path.home() / ".codex" / "prompts" / "paircode.md", "codex"),
+        (Path.home() / ".gemini" / "commands" / "paircode.toml", "gemini"),
+        # Legacy paths from older paircode versions
+        (Path.home() / ".codex" / "rules" / "paircode.rules", "codex-legacy"),
+        (Path.home() / ".gemini" / "paircode.md", "gemini-legacy"),
+    ]
+    for path, cli_name in paths:
+        if path.exists():
+            try:
+                path.unlink()
+                results.append(InstallResult(
+                    cli_name=cli_name, action="installed",  # "removed"
+                    path=path, message=f"Removed {path}",
+                ))
+            except OSError as exc:
+                results.append(InstallResult(
+                    cli_name=cli_name, action="failed",
+                    path=path, message=f"Failed to remove {path}: {exc}",
+                ))
+        else:
+            results.append(InstallResult(
+                cli_name=cli_name, action="skipped",
+                path=path, message=f"Nothing to remove at {path}",
+            ))
+    return results

paircode-0.9.1/src/paircode/templates/codex_slash_command.md

@@ -0,0 +1,24 @@
+---
+description: Run paircode — adversarial journey framework for LLM peer review. Bootstraps .paircode/ if missing, otherwise advances the active focus.
+argument-hint: [SUBCOMMAND or TOPIC]
+---
+
+You have access to the `paircode` CLI. It's a Python tool that orchestrates multi-LLM peer review (research → plan → execute) with file-traces on disk.
+
+Behavior:
+
+1. **Parse the arguments.** Everything after `/paircode` is passed as CLI args. If empty, run `paircode` with no args (it prints status or bootstraps).
+2. **Run the CLI.** Invoke `paircode <args>` via shell. Capture stdout and stderr.
+3. **Relay output to the user.** Show what paircode printed.
+4. **If `paircode` spawns its own LLM subprocesses** (for research/plan/execute stages), it handles that internally — just relay status updates.
+5. **If the user's intent was a topic-level drive** (e.g., `/paircode "build a widget thing"`), invoke `paircode drive "<topic>"`.
+
+Common subcommands:
+- `paircode install` — register /paircode in Claude/Codex/Gemini
+- `paircode status` — summarize .paircode/ state in cwd
+- `paircode handshake` — detect installed LLM CLIs, propose peer roster
+- `paircode focus <name>` — open a new focus
+- `paircode stage {research|plan|execute}` — run one peer-review round
+- `paircode drive "<topic>"` — high-level: open focus, run research → plan → execute
+
+Always show the user what happened. Brief, honest, actionable.

paircode-0.9.1/src/paircode/templates/gemini_slash_command.toml

@@ -0,0 +1,25 @@
+description = "Run paircode — adversarial journey framework for LLM peer review. Bootstraps .paircode/ if missing, otherwise advances the active focus."
+
+prompt = """
+You have access to the `paircode` CLI — a Python tool that orchestrates multi-LLM peer review (research → plan → execute) with file-traces on disk.
+
+Arguments: {{args}}
+
+Behavior:
+
+1. Parse the arguments above. If empty, run `paircode` with no args (it prints status or bootstraps).
+2. Run the CLI: invoke `paircode {{args}}` via shell. Capture stdout and stderr.
+3. Relay output to the user. Show what paircode printed.
+4. If `paircode` spawns its own LLM subprocesses (for research/plan/execute stages), it handles that internally — just relay status updates.
+5. If the user's intent was a topic-level drive (e.g. `/paircode "build a widget thing"`), invoke `paircode drive "<topic>"`.
+
+Common subcommands:
+  paircode install      register /paircode in Claude/Codex/Gemini
+  paircode status       summarize .paircode/ state in cwd
+  paircode handshake    detect installed LLM CLIs, propose peer roster
+  paircode focus <name> open a new focus
+  paircode stage {research|plan|execute}   run one peer-review round
+  paircode drive "<topic>"                  high-level: run research → plan → execute
+
+Always show the user what happened. Brief, honest, actionable.
+"""

{paircode-0.8.1 → paircode-0.9.1}/tests/test_cli_smoke.py

@@ -194,9 +194,10 @@ def test_run_peer_fast_kwarg_passes_through(monkeypatch, tmp_path):
 # Installer: codex no-op + legacy cleanup
 # ---------------------------------------------------------------------------
 
-def test_installer_returns_noop_for_codex_not_installed_file(tmp_path, monkeypatch):
-    """Regression of the 'broken codex rules' bug: installer must never write
-    ~/.codex/rules/paircode.rules — that file breaks codex's rule loader."""
+def test_installer_writes_codex_prompt_never_broken_rules_file(tmp_path, monkeypatch):
+    """Regression of the 'broken codex rules' bug: installer must write to
+    ~/.codex/prompts/paircode.md (the correct path) and NEVER to
+    ~/.codex/rules/paircode.rules (that breaks codex's Starlark rule loader)."""
     fake_home = tmp_path / "home"
     fake_home.mkdir()
     monkeypatch.setenv("HOME", str(fake_home))
@@ -212,12 +213,39 @@ def test_installer_returns_noop_for_codex_not_installed_file(tmp_path, monkeypat
     results = inst.install_all()
 
     actions = {r.cli_name: r.action for r in results}
-    assert actions["codex"] == "noop"
-
-    # File must NOT exist
+    assert actions["codex"] == "installed"
+    assert (fake_home / ".codex" / "prompts" / "paircode.md").exists()
     assert not (fake_home / ".codex" / "rules" / "paircode.rules").exists()
 
 
+def test_installer_writes_gemini_toml_command(tmp_path, monkeypatch):
+    """Gemini slash commands are TOML (not markdown). Path must be
+    ~/.gemini/commands/paircode.toml with description + prompt fields."""
+    fake_home = tmp_path / "home"
+    fake_home.mkdir()
+    monkeypatch.setenv("HOME", str(fake_home))
+    import importlib
+
+    import paircode.detect as d
+    import paircode.installer as inst
+
+    importlib.reload(d)
+    importlib.reload(inst)
+
+    monkeypatch.setattr("shutil.which", lambda b: f"/fake/{b}")
+    results = inst.install_all()
+
+    actions = {r.cli_name: r.action for r in results}
+    assert actions["gemini"] == "installed"
+    target = fake_home / ".gemini" / "commands" / "paircode.toml"
+    assert target.exists()
+    content = target.read_text()
+    assert 'description' in content
+    assert 'prompt' in content
+    # TOML syntax sanity — triple-quoted prompt
+    assert '"""' in content
+
+
 # ---------------------------------------------------------------------------
 # Init + status dispatch smoke
 # ---------------------------------------------------------------------------

{paircode-0.8.1 → paircode-0.9.1}/tests/test_smoke.py

@@ -76,25 +76,34 @@ def test_install_writes_to_tmp_claude(tmp_path, monkeypatch):
 
     results = inst.install_all()
     actions = {r.cli_name: r.action for r in results}
-    # claude gets a real install (writes slash command file)
+    # v0.9: all three CLIs get a real slash command file drop.
     assert actions["claude"] == "installed"
-    # codex and gemini are intentional no-ops as of v0.8 — we stopped writing
-    # broken files to ~/.codex/rules/. Both should report "noop" not "installed".
-    assert actions["codex"] == "noop", (
-        f"codex should be noop (not installed), got {actions['codex']!r}"
-    )
-    assert actions["gemini"] == "noop", (
-        f"gemini should be noop (not installed), got {actions['gemini']!r}"
-    )
-    # Verify claude slash command actually landed on disk
+    assert actions["codex"] == "installed"
+    assert actions["gemini"] == "installed"
+
+    # Correct paths per CLI
     claude_cmd = fake_home / ".claude" / "commands" / "paircode.md"
     assert claude_cmd.exists()
-    content = claude_cmd.read_text()
-    assert "paircode" in content
-    # And verify we do NOT write a broken codex rules file
+    assert "paircode" in claude_cmd.read_text()
+
+    codex_cmd = fake_home / ".codex" / "prompts" / "paircode.md"
+    assert codex_cmd.exists(), (
+        f"v0.9 must write codex slash command to {codex_cmd}"
+    )
+    assert "paircode" in codex_cmd.read_text()
+
+    gemini_cmd = fake_home / ".gemini" / "commands" / "paircode.toml"
+    assert gemini_cmd.exists(), (
+        f"v0.9 must write gemini slash command to {gemini_cmd} (note: TOML, not markdown)"
+    )
+    gemini_content = gemini_cmd.read_text()
+    assert "description" in gemini_content
+    assert "prompt" in gemini_content
+
+    # And verify we still do NOT write the legacy broken codex rules file
     codex_rules = fake_home / ".codex" / "rules" / "paircode.rules"
     assert not codex_rules.exists(), (
-        f"paircode should not write {codex_rules} — that file breaks codex's rule loader"
+        f"paircode must never write {codex_rules} — that file breaks codex's rule loader"
     )
 
 

paircode-0.8.1/src/paircode/installer.py

@@ -1,183 +0,0 @@
-"""Install paircode's slash command into detected LLM CLIs.
-
-Strategy per CLI:
-  - Claude Code: writes ~/.claude/commands/paircode.md as a real slash command.
-    When the user types `/paircode` in any Claude Code session, this file
-    tells Claude to invoke the paircode CLI via bash.
-  - Codex: no file written. Codex doesn't have a user-facing slash-command
-    system. Users invoke `paircode` from their shell or `codex exec paircode ...`.
-    Previous versions wrote `~/.codex/rules/paircode.rules` — that file is
-    Starlark-formatted and our markdown content broke codex's rule loader.
-    `uninstall` still cleans up that legacy path.
-  - Gemini: no file written. Same reasoning — gemini's custom-command story
-    is `gemini skills install` with a git-repo source, not a markdown drop.
-    That's a v0.9+ stretch goal. For now, gemini users invoke paircode from
-    the shell.
-"""
-from __future__ import annotations
-
-from dataclasses import dataclass
-from importlib import resources
-from pathlib import Path
-
-from paircode.detect import detect_all, CliInfo
-
-
-@dataclass(frozen=True)
-class InstallResult:
-    cli_name: str
-    action: str  # "installed", "skipped", "failed", "noop"
-    path: Path | None
-    message: str
-
-
-def _read_template(name: str) -> str:
-    return resources.files("paircode.templates").joinpath(name).read_text(encoding="utf-8")
-
-
-# ---------------------------------------------------------------------------
-# Per-CLI installers
-# ---------------------------------------------------------------------------
-
-def install_claude(info: CliInfo) -> InstallResult:
-    """Write ~/.claude/commands/paircode.md — a real Claude Code slash command."""
-    if not info.installed:
-        return InstallResult(
-            cli_name="claude",
-            action="skipped",
-            path=None,
-            message=f"claude CLI not on PATH. {info.install_hint}",
-        )
-    commands_dir = info.config_dir / "commands"
-    commands_dir.mkdir(parents=True, exist_ok=True)
-    target = commands_dir / "paircode.md"
-    template = _read_template("claude_slash_command.md")
-    target.write_text(template, encoding="utf-8")
-    return InstallResult(
-        cli_name="claude",
-        action="installed",
-        path=target,
-        message=f"Wrote /paircode slash command to {target}. Use it from any Claude Code session.",
-    )
-
-
-def install_codex(info: CliInfo) -> InstallResult:
-    """Codex has no user-facing slash-command system. No-op, print guidance."""
-    if not info.installed:
-        return InstallResult(
-            cli_name="codex",
-            action="skipped",
-            path=None,
-            message=f"codex CLI not on PATH. {info.install_hint}",
-        )
-    return InstallResult(
-        cli_name="codex",
-        action="noop",
-        path=None,
-        message=(
-            "codex has no slash-command system — nothing to install. "
-            "Invoke paircode from your shell (`paircode status`) or via "
-            "`codex exec 'paircode status'` from inside a codex session."
-        ),
-    )
-
-
-def install_gemini(info: CliInfo) -> InstallResult:
-    """Gemini's custom-command story uses `gemini skills install` with a git
-    repo. That's not an easy installer drop — deferred to v0.9+. No-op."""
-    if not info.installed:
-        return InstallResult(
-            cli_name="gemini",
-            action="skipped",
-            path=None,
-            message=f"gemini CLI not on PATH. {info.install_hint}",
-        )
-    return InstallResult(
-        cli_name="gemini",
-        action="noop",
-        path=None,
-        message=(
-            "gemini uses `gemini skills install` for custom commands — "
-            "proper skill-registration lands in v0.9+. For now, invoke "
-            "paircode from your shell or via `gemini -p 'run paircode status'`."
-        ),
-    )
-
-
-# ---------------------------------------------------------------------------
-# Public entry points
-# ---------------------------------------------------------------------------
-
-def install_all() -> list[InstallResult]:
-    """Run every CLI's installer. Also cleans up legacy broken files first."""
-    _clean_legacy_broken_files()
-    detected = detect_all()
-    installers = {
-        "claude": install_claude,
-        "codex": install_codex,
-        "gemini": install_gemini,
-    }
-    results: list[InstallResult] = []
-    for name, info in detected.items():
-        installer = installers.get(name)
-        if not installer:
-            continue
-        try:
-            results.append(installer(info))
-        except Exception as exc:  # pragma: no cover — defensive
-            results.append(
-                InstallResult(
-                    cli_name=name, action="failed", path=None,
-                    message=f"{type(exc).__name__}: {exc}",
-                )
-            )
-    return results
-
-
-def _clean_legacy_broken_files() -> None:
-    """Remove files that previous versions of paircode installed and which we
-    now know to be broken or misplaced. Silent; best-effort."""
-    for legacy_path in (
-        # v0.1–v0.7 wrote markdown to codex's Starlark rules dir, which broke
-        # codex's rule loader. Always clean this up on any install.
-        Path.home() / ".codex" / "rules" / "paircode.rules",
-        # v0.1–v0.7 also dropped a reference file at ~/.gemini/paircode.md.
-        # Harmless but no longer created; remove to keep the dir clean.
-        Path.home() / ".gemini" / "paircode.md",
-    ):
-        try:
-            if legacy_path.exists():
-                legacy_path.unlink()
-        except OSError:
-            pass
-
-
-def uninstall_all() -> list[InstallResult]:
-    """Remove paircode entries from every CLI config dir (idempotent).
-    Also cleans up legacy broken paths from prior paircode versions."""
-    results: list[InstallResult] = []
-    paths: list[tuple[Path, str]] = [
-        (Path.home() / ".claude" / "commands" / "paircode.md", "claude"),
-        # Legacy paths — older paircode put these here, we still clean them up
-        (Path.home() / ".codex" / "rules" / "paircode.rules", "codex"),
-        (Path.home() / ".gemini" / "paircode.md", "gemini"),
-    ]
-    for path, cli_name in paths:
-        if path.exists():
-            try:
-                path.unlink()
-                results.append(InstallResult(
-                    cli_name=cli_name, action="installed",  # "removed"
-                    path=path, message=f"Removed {path}",
-                ))
-            except OSError as exc:
-                results.append(InstallResult(
-                    cli_name=cli_name, action="failed",
-                    path=path, message=f"Failed to remove {path}: {exc}",
-                ))
-        else:
-            results.append(InstallResult(
-                cli_name=cli_name, action="skipped",
-                path=path, message=f"Nothing to remove at {path}",
-            ))
-    return results