patch-cc 0.1.0__py3-none-any.whl

patch_cc/doctor.py

@@ -0,0 +1,116 @@
+"""Health checks over an installed binary and the patch set.
+
+Two different questions, deliberately kept apart:
+
+* **status** -- is the *installed* binary patched right now? Answered by the
+  manifest comment every patched bundle ends with (plus legacy fingerprints),
+  and the bytecode-stripped invariant.
+* **dryrun** -- would our patches still apply to *this* bundle? Answered by
+  running every patch and reporting per-step hits, so a silently drifted
+  matcher shows up as a concrete "reducer.message_stop missed" instead of a
+  lump count.
+
+The dry run feeds every configurable patch a synthetic configuration built
+from the bundle's own discovered agents and models, so branding and the model
+overrides are exercised for real instead of being exempted.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from .bun import Bundle
+from .patcher import is_patched, read_manifest
+from .patches import ALL_PATCHES, Options, Outcome, Patch
+from .patches.agents import INHERIT, BuiltinAgent, discover_agents, discover_models
+
+
+@dataclass(slots=True)
+class Status:
+    patched: bool
+    bytecode_stripped: bool
+    bytecode_size: int
+    #: Parsed manifest for binaries patched by this tool; ``None`` when the
+    #: binary is pristine or predates the manifest.
+    manifest: dict | None
+
+    @property
+    def patch_ids(self) -> list[str]:
+        if not self.manifest:
+            return []
+        patches = self.manifest.get("patches")
+        return (
+            [p for p in patches if isinstance(p, str)]
+            if isinstance(patches, list)
+            else []
+        )
+
+
+def status(bundle: Bundle) -> Status:
+    source = bundle.source
+    return Status(
+        patched=is_patched(source),
+        bytecode_stripped=bundle.bytecode_size == 0,
+        bytecode_size=bundle.bytecode_size,
+        manifest=read_manifest(source),
+    )
+
+
+@dataclass(slots=True)
+class PatchHealth:
+    patch: Patch
+    outcome: Outcome
+
+    @property
+    def ok(self) -> bool:
+        return self.outcome.landed
+
+
+@dataclass(slots=True)
+class DryRun:
+    checks: list[PatchHealth] = field(default_factory=list)
+    anchors: dict[str, dict[str, int]] = field(default_factory=dict)
+    #: What discovery found in this bundle -- the agents and model aliases the
+    #: override patch would offer.
+    agents: list[BuiltinAgent] = field(default_factory=list)
+    models: list[str] = field(default_factory=list)
+
+    @property
+    def broken(self) -> list[PatchHealth]:
+        return [c for c in self.checks if not c.ok]
+
+    @property
+    def partial(self) -> list[PatchHealth]:
+        return [c for c in self.checks if c.ok and c.outcome.missed_steps()]
+
+
+def _synthetic_options(agents: list[BuiltinAgent], models: list[str]) -> Options:
+    """A configuration that forces every configurable patch to do work.
+
+    Each discovered agent is assigned a model different from its current one,
+    so the rewrite (not the already-desired no-op) is what gets tested.
+    """
+    overrides = {}
+    for agent in agents:
+        target = next((m for m in models if m != agent.effective_model), None)
+        if target is not None:
+            overrides[agent.name] = target
+    return Options(brand="patch-cc doctor", subagent_models=overrides)
+
+
+def dryrun(bundle: Bundle) -> DryRun:
+    """Run every patch against the bundle without writing anything."""
+    source = bundle.source
+    result = DryRun(
+        agents=discover_agents(source),
+        models=[INHERIT, *discover_models(source)],
+    )
+    options = _synthetic_options(result.agents, result.models)
+
+    for patch in ALL_PATCHES:
+        _, outcome = patch.run(source, options)
+        result.checks.append(PatchHealth(patch=patch, outcome=outcome))
+        if patch.anchors:
+            result.anchors[patch.id] = {a: source.count(a) for a in patch.anchors}
+
+    return result

patch_cc/locate.py

@@ -0,0 +1,117 @@
+"""Find the installed Claude Code native binary.
+
+Only the native build is supported. The npm package no longer ships ``cli.js``
+-- it is a thin wrapper that downloads the native binary -- so there is nothing
+to patch in a node_modules tree anymore.
+"""
+
+from __future__ import annotations
+
+import re
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+
+_VERSION_DIR = re.compile(r"^(\d+)\.(\d+)\.(\d+)")
+
+
+def _version_sort_key(path: Path) -> tuple[int, int, int]:
+    """Sort key so 2.1.216 ranks above 2.1.9 (lexicographic order would not)."""
+    match = _VERSION_DIR.match(path.name)
+    if match is None:
+        return (-1, -1, -1)
+    major, minor, patch = match.groups()
+    return (int(major), int(minor), int(patch))
+
+
+@dataclass(slots=True)
+class Installation:
+    """A resolved Claude install.
+
+    ``launcher`` is what the user runs (often a symlink); ``binary`` is the real
+    file we patch. When Claude is installed the canonical way they differ, and
+    patching ``binary`` in place means the launcher keeps working.
+    """
+
+    launcher: Path
+    binary: Path
+    version: str | None
+
+    @property
+    def is_symlinked(self) -> bool:
+        return self.launcher != self.binary
+
+
+def _version_of(binary: Path) -> str | None:
+    name = binary.name
+    return name if _VERSION_DIR.match(name) else None
+
+
+def _candidates() -> list[Path]:
+    home = Path.home()
+    found: list[Path] = []
+
+    on_path = shutil.which("claude")
+    if on_path:
+        found.append(Path(on_path))
+
+    # The default native install location, newest version first.
+    versions = home / ".local" / "share" / "claude" / "versions"
+    if versions.is_dir():
+        found.extend(sorted(versions.iterdir(), key=_version_sort_key, reverse=True))
+
+    for extra in (home / ".local" / "bin" / "claude", home / "bin" / "claude"):
+        if extra.exists():
+            found.append(extra)
+
+    return found
+
+
+def _resolve(path: Path) -> Installation | None:
+    if not path.exists():
+        return None
+    real = path.resolve()
+    if not real.is_file():
+        return None
+    return Installation(launcher=path, binary=real, version=_version_of(real))
+
+
+def find() -> Installation | None:
+    """Return the first resolvable installation, or ``None``."""
+    seen: set[Path] = set()
+    for candidate in _candidates():
+        try:
+            real = candidate.resolve()
+        except OSError:
+            continue
+        if real in seen:
+            continue
+        seen.add(real)
+        install = _resolve(candidate)
+        if install:
+            return install
+    return None
+
+
+def find_or_raise() -> Installation:
+    install = find()
+    if install is None:
+        raise FileNotFoundError(
+            "Could not find a Claude Code install. Install the native build with:\n"
+            "  curl -fsSL https://claude.ai/install.sh | bash"
+        )
+    return install
+
+
+def all_versions() -> list[Installation]:
+    """Every version binary found under the native versions directory."""
+    versions = Path.home() / ".local" / "share" / "claude" / "versions"
+    if not versions.is_dir():
+        return []
+    out: list[Installation] = []
+    for entry in sorted(versions.iterdir(), key=_version_sort_key, reverse=True):
+        if entry.is_file():
+            out.append(
+                Installation(launcher=entry, binary=entry, version=_version_of(entry))
+            )
+    return out