patch-cc 0.1.0__py3-none-any.whl

patch_cc/patches/base.py

@@ -0,0 +1,200 @@
+"""Patch framework: how a single rewrite of the bundle is described and run.
+
+Matcher rules, learned the hard way upstream (see docs/PLAYBOOK.md):
+
+* Never anchor on minified locals (``A_``, ``mET``, ``wg6``); they are
+  regenerated on every upstream build.
+* Anchor on string literals, ``case`` labels, prop names, or control-flow shape.
+* When upstream ships several shapes, add a second narrow branch rather than
+  widening one regex until it over-matches.
+
+Porting rules, for anyone translating more of upstream's JS:
+
+* JS ``.replace(re, fn)`` without ``/g`` replaces **once** -- that is
+  ``re.sub(..., count=1)``. Python's default replaces every occurrence.
+* JS ``.replace("a", "b")`` on plain strings also replaces once --
+  ``str.replace(a, b, 1)``.
+* Compile with :data:`re.ASCII` so ``\\w`` stays ASCII as it is in JS.
+* Always pass a *function* to :func:`re.sub`; a string template would treat
+  backslashes in the replacement as escapes.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable
+from dataclasses import dataclass, field
+
+#: Prefix for every identifier we inject. These are the only reliable
+#: fingerprints of our work -- value flips like ``verbose:!0`` are
+#: indistinguishable from the 11 that upstream already ships.
+SENTINEL = "__cc_"
+
+# Groups, in display order.
+GROUP_OUTPUT = "Output & diffs"
+GROUP_THINKING = "Thinking"
+GROUP_LIVE = "Live thinking (streaming)"
+GROUP_AGENTS = "Subagents"
+GROUP_CHROME = "Chrome & branding"
+
+#: Default brand: the name shown unless the user overrides it. One home so the
+#: field default and the "is it rebranded?" test can never disagree.
+DEFAULT_BRAND = "Claude Code"
+
+#: Default --version marker text.
+DEFAULT_SUFFIX = "(patched)"
+
+
+def derived_brand() -> str:
+    """The branding default: the system username, possessive.
+
+    ``anfreire`` becomes ``anfreire's Code``. Falls back to the unbranded
+    default when no username can be determined.
+    """
+    import getpass
+
+    try:
+        user = getpass.getuser().strip()
+    except OSError:
+        user = ""
+    return f"{user}'s Code" if user else DEFAULT_BRAND
+
+
+@dataclass(slots=True)
+class Options:
+    """User customisation handed to every patch."""
+
+    brand: str = DEFAULT_BRAND
+    version_suffix: str = DEFAULT_SUFFIX
+    subagent_models: dict[str, str] = field(default_factory=dict)
+
+    @property
+    def rebrands(self) -> bool:
+        return self.brand != DEFAULT_BRAND
+
+
+@dataclass(slots=True)
+class Outcome:
+    """What a patch found and what it changed.
+
+    ``candidates`` and ``applied`` describe different failures and must not be
+    collapsed into one number:
+
+    * ``candidates == 0`` -- the anchor is gone. A real regression.
+    * ``candidates > 0, applied == 0`` -- shape found, rewrite was a no-op.
+      Usually means already patched, not broken.
+    """
+
+    candidates: int = 0
+    applied: int = 0
+    notes: list[str] = field(default_factory=list)
+    #: Named sub-steps, for patches built from several independent rewrites.
+    steps: dict[str, "Outcome"] = field(default_factory=dict)
+
+    @property
+    def landed(self) -> bool:
+        return self.applied > 0
+
+    def note(self, message: str) -> None:
+        self.notes.append(message)
+
+    def step(self, name: str) -> "Outcome":
+        """Get (or create) a named sub-outcome.
+
+        A single scalar count cannot distinguish "all twelve rewrites landed"
+        from "six landed and six silently drifted" -- which is exactly how
+        upstream's live-thinking patch hides its own regressions. Recording each
+        rewrite separately turns that into an actionable "reducer.message_stop
+        missed".
+        """
+        return self.steps.setdefault(name, Outcome())
+
+    def finalize(self) -> "Outcome":
+        """Roll sub-step totals up into this outcome."""
+        if self.steps:
+            self.candidates += sum(s.candidates for s in self.steps.values())
+            self.applied += sum(s.applied for s in self.steps.values())
+        return self
+
+    def missed_steps(self) -> list[str]:
+        """Sub-steps whose shape was *found* but which failed to rewrite.
+
+        A step that matched nothing (``candidates == 0``) is usually a shape
+        that simply is not on this build -- most patches carry several
+        mutually-exclusive version variants -- so it is reported separately by
+        :meth:`absent_steps`, not here. A step that found candidates yet applied
+        none is the genuine concern.
+        """
+        return [
+            name
+            for name, sub in self.steps.items()
+            if sub.candidates > 0 and not sub.landed
+        ]
+
+    def absent_steps(self) -> list[str]:
+        """Sub-steps that matched nothing on this build (informational)."""
+        return [name for name, sub in self.steps.items() if sub.candidates == 0]
+
+
+PatchFn = Callable[[str, Options, Outcome], str]
+
+
+@dataclass(slots=True)
+class Patch:
+    id: str
+    title: str
+    summary: str
+    group: str
+    fn: PatchFn
+    default: bool = True
+    #: Anchors to report on when this patch stops matching.
+    anchors: tuple[str, ...] = ()
+
+    def run(self, content: str, options: Options) -> tuple[str, Outcome]:
+        outcome = Outcome()
+        try:
+            content = self.fn(content, options, outcome)
+        except Exception as exc:  # noqa: BLE001 - one bad patch must not abort the run
+            outcome.note(f"raised {type(exc).__name__}: {exc}")
+        return content, outcome.finalize()
+
+
+def compile_js(pattern: str, flags: int = 0) -> re.Pattern[str]:
+    """Compile a matcher with JS-compatible ``\\w`` semantics."""
+    return re.compile(pattern, flags | re.ASCII)
+
+
+# Matches a minified identifier, the JS `[A-Za-z_$][\w$]*` idiom.
+IDENT = r"[A-Za-z_$][\w$]*"
+
+
+def switch_case_end(content: str, start: int) -> int:
+    """End offset of a ``switch`` arm beginning at ``start``.
+
+    Upstream's arms end at the next ``case"`` or ``default:``, whichever comes
+    first. Mirrors the scan every case-based patch does.
+    """
+    nxt_case = content.find('case"', start)
+    nxt_default = content.find("default:", start)
+    ends = [i for i in (nxt_case, nxt_default) if i != -1]
+    return min(ends) if ends else len(content)
+
+
+def iter_segments(content: str, needle: str):
+    """Yield ``(start, end)`` for each switch arm introduced by ``needle``.
+
+    The caller rewrites and the generator is restarted, so this is deliberately
+    a simple finder rather than a stateful cursor.
+    """
+    index = 0
+    while True:
+        start = content.find(needle, index)
+        if start == -1:
+            return
+        end = switch_case_end(content, start + len(needle))
+        yield start, end
+        index = start + len(needle)
+
+
+def splice(content: str, start: int, end: int, replacement: str) -> str:
+    return content[:start] + replacement + content[end:]

patch_cc/patches/chrome.py

@@ -0,0 +1,187 @@
+"""UI chrome: spinner tips, the --version marker, and branding."""
+
+from __future__ import annotations
+
+import re
+
+from .base import (
+    DEFAULT_SUFFIX,
+    GROUP_CHROME,
+    IDENT,
+    Options,
+    Outcome,
+    Patch,
+    compile_js,
+)
+
+# ---------------------------------------------------------- spinner tips
+
+_SPINNER_GUARD = compile_js(rf"if\({IDENT}\(\)\.spinnerTipsEnabled===!1\)return;")
+_SPINNER_EXPR = compile_js(rf"{IDENT}\.spinnerTipsEnabled!==!1")
+
+
+def _disable_spinner_tips(content: str, _options: Options, outcome: Outcome) -> str:
+    """Force spinner tips off through both code paths that can enable them."""
+    guard = outcome.step("guard")
+
+    def kill_guard(_match: re.Match[str]) -> str:
+        guard.candidates += 1
+        guard.applied += 1
+        return "if(!0)return;"
+
+    output = _SPINNER_GUARD.sub(kill_guard, content)
+
+    expr = outcome.step("expr")
+
+    def kill_expr(_match: re.Match[str]) -> str:
+        expr.candidates += 1
+        expr.applied += 1
+        return "!1"
+
+    return _SPINNER_EXPR.sub(kill_expr, output)
+
+
+# ---------------------------------------------------------- version marker
+
+_VERSION_NEEDLE = "}.VERSION} (Claude Code)"
+
+
+def _js_template_escape(text: str) -> str:
+    """Make arbitrary text safe inside a JS template literal."""
+    return text.replace("\\", "\\\\").replace("`", "\\`").replace("${", "\\${")
+
+
+def _version_output(content: str, options: Options, outcome: Outcome) -> str:
+    """Append a marker line to plain ``--version`` output.
+
+    The marker text is the user's ``--suffix`` (default ``(patched)``). The
+    needle sits inside a template literal, so the suffix is escaped for that
+    context.
+    """
+    marker = "\\n" + _js_template_escape(options.version_suffix or DEFAULT_SUFFIX)
+    output = content
+    index = output.find(_VERSION_NEEDLE)
+    while index != -1:
+        outcome.candidates += 1
+        marker_at = index + len(_VERSION_NEEDLE)
+        if output[marker_at : marker_at + len(marker)] == marker:
+            index = output.find(_VERSION_NEEDLE, marker_at + len(marker))
+            continue
+        output = output[:marker_at] + marker + output[marker_at:]
+        outcome.applied += 1
+        index = output.find(_VERSION_NEEDLE, marker_at + len(marker))
+    return output
+
+
+# ---------------------------------------------------------- branding
+
+
+def _branding(content: str, options: Options, outcome: Outcome) -> str:
+    """Rename visible ``Claude Code`` branding to the user's chosen name.
+
+    Only the small set of visible startup/help strings are touched, each as its
+    own step so partial upstream drift is visible.
+    """
+    if not options.rebrands:
+        outcome.note("brand unchanged; nothing to do")
+        return content
+
+    brand = options.brand
+    esc = brand.replace("\\", "\\\\").replace('"', '\\"')
+    output = content
+
+    def swap(step_name: str, pattern: re.Pattern[str], replace) -> None:
+        nonlocal output
+        step = outcome.step(step_name)
+
+        def rewrite(match: re.Match[str]) -> str:
+            step.candidates += 1
+            result = replace(match)
+            if result != match.group(0):
+                step.applied += 1
+            return result
+
+        output = pattern.sub(rewrite, output)
+
+    swap(
+        "bold-text",
+        compile_js(
+            rf'({IDENT})\.createElement\(({IDENT}),\{{bold:!0\}},"Claude Code"\)'
+        ),
+        lambda m: f'{m.group(1)}.createElement({m.group(2)},{{bold:!0}},"{esc}")',
+    )
+    swap(
+        "bold-jsx",
+        compile_js(
+            rf'({IDENT})\.(jsx|jsxs)\(({IDENT}),\{{bold:!0,children:"Claude Code"\}}\)'
+        ),
+        lambda m: (
+            f'{m.group(1)}.{m.group(2)}({m.group(3)},{{bold:!0,children:"{esc}"}})'
+        ),
+    )
+    swap(
+        "help-title",
+        compile_js(
+            r"title:(`Claude Code v\$\{[\s\S]*?\.VERSION\}`),"
+            r'color:"professionalBlue",defaultTab:"general"'
+        ),
+        lambda m: (
+            f'title:{m.group(1)}.replace("Claude Code","{esc}"),'
+            f'color:"professionalBlue",defaultTab:"general"'
+        ),
+    )
+    swap(
+        "welcome-for",
+        compile_js(r'"Welcome to Claude Code for "'),
+        lambda _m: f'"Welcome to {esc} for "',
+    )
+    swap(
+        "welcome",
+        compile_js(r'"Welcome to Claude Code"'),
+        lambda _m: f'"Welcome to {esc}"',
+    )
+    swap(
+        "children-array",
+        compile_js(r'(color:"claude",bold:!0,children:\[)"Claude Code"(," "\])'),
+        lambda m: f'{m.group(1)}"{esc}"{m.group(2)}',
+    )
+    swap(
+        "styled-title",
+        compile_js(rf'({IDENT})\("claude",({IDENT})\)\("Claude Code"\)'),
+        lambda m: f'{m.group(1)}("claude",{m.group(2)})("{esc}")',
+    )
+    swap(
+        "styled-title-padded",
+        compile_js(rf'({IDENT})\("claude",({IDENT})\)\(" Claude Code "\)'),
+        lambda m: f'{m.group(1)}("claude",{m.group(2)})(" {esc} ")',
+    )
+
+    return output
+
+
+PATCHES = [
+    Patch(
+        id="spinner-tips",
+        title="Disable spinner tips",
+        summary="Stop the loading spinner from showing rotating tips.",
+        group=GROUP_CHROME,
+        fn=_disable_spinner_tips,
+        anchors=("spinnerTipsEnabled",),
+    ),
+    Patch(
+        id="version-marker",
+        title="Mark --version as patched",
+        summary="Append a marker line to `claude --version` (custom text via --suffix).",
+        group=GROUP_CHROME,
+        fn=_version_output,
+        anchors=("}.VERSION} (Claude Code)",),
+    ),
+    Patch(
+        id="branding",
+        title="Custom startup name",
+        summary="Rename the startup/help branding (default: your username's Code).",
+        group=GROUP_CHROME,
+        fn=_branding,
+        anchors=('"Welcome to Claude Code"', '{bold:!0},"Claude Code"'),
+    ),
+]

patch_cc/patches/output.py

@@ -0,0 +1,173 @@
+"""Tool-call and diff rendering patches."""
+
+from __future__ import annotations
+
+import re
+
+from .base import (
+    GROUP_OUTPUT,
+    IDENT,
+    Options,
+    Outcome,
+    Patch,
+    compile_js,
+    splice,
+    switch_case_end,
+)
+
+# --------------------------------------------------------------- tool calls
+
+_COLLAPSED_RETURN = compile_js(
+    rf'case"collapsed_read_search":return ({IDENT})\.createElement\(({IDENT}),\{{([^}}]*)\}}\)'
+)
+_COLLAPSED_CALL = compile_js(
+    r"(?:createElement|jsx|jsxs)\("
+    + IDENT
+    + r",\{message:[^}]*inProgressToolUseIDs:[^}]*"
+    r"shouldAnimate:[^}]*verbose:[^,}]+,tools:[^}]*lookups:[^}]*isActiveGroup:[^}]*\}\)"
+)
+_VERBOSE_PROP = compile_js(r"verbose:[^,}]+")
+
+
+def _tool_call_verbose(content: str, _options: Options, outcome: Outcome) -> str:
+    """Render collapsed read/search rows as if verbose mode were on."""
+
+    def rewrite_return(match: re.Match[str]) -> str:
+        ns, component, props = match.group(1), match.group(2), match.group(3)
+        if "verbose:" not in props:
+            return match.group(0)
+        outcome.candidates += 1
+        next_props = _VERBOSE_PROP.sub("verbose:!0", props, count=1)
+        if next_props == props:
+            return match.group(0)
+        outcome.applied += 1
+        return f'case"collapsed_read_search":return {ns}.createElement({component},{{{next_props}}})'
+
+    output = _COLLAPSED_RETURN.sub(rewrite_return, content)
+
+    # Newer builds use a block-form arm with a JSX-runtime call.
+    needle = 'case"collapsed_read_search":{'
+    index = 0
+    while True:
+        start = output.find(needle, index)
+        if start == -1:
+            break
+        end = switch_case_end(output, start + len(needle))
+        segment = output[start:end]
+        index = start + len(needle)
+
+        has_renderer = any(
+            tok in segment for tok in ("createElement(", "jsx(", "jsxs(")
+        )
+        if not has_renderer or "verbose:" not in segment:
+            continue
+        if not _COLLAPSED_CALL.search(segment):
+            continue
+
+        outcome.candidates += 1
+        next_segment = _VERBOSE_PROP.sub("verbose:!0", segment, count=1)
+        if next_segment != segment:
+            outcome.applied += 1
+            output = splice(output, start, end, next_segment)
+            index = start + len(next_segment)
+
+    return output
+
+
+# --------------------------------------------------------------- create diff
+
+_CREATE_RETURN = compile_js(
+    rf"return ({IDENT})\.(createElement|jsx|jsxs)\(({IDENT}),"
+    rf"\{{filePath:({IDENT}),content:({IDENT}),verbose:({IDENT})\}}\)"
+)
+_UPDATE_RENDERER = compile_js(
+    rf"(?:createElement|jsx|jsxs)\(({IDENT}),\{{filePath:[^}}]*structuredPatch:[^}}]*"
+    rf"style:({IDENT}),verbose:{IDENT}"
+)
+_LINE_COUNTER = compile_js(
+    rf"let {IDENT}=({IDENT})\({IDENT}\);return {IDENT}\.(?:createElement|jsxs)"
+    rf"\({IDENT},(?:null,|\{{children:\[)\"Wrote \""
+)
+_ALREADY_CREATE_DIFF = "structuredPatch:[{oldStart:1,oldLines:0,newStart:1"
+
+
+def _create_diff_colors(content: str, _options: Options, outcome: Outcome) -> str:
+    """Render newly-created files through the diff component so lines get ``+``."""
+    output = content
+    index = 0
+    create_needle, update_needle = 'case"create":', 'case"update":'
+
+    while True:
+        create_start = output.find(create_needle, index)
+        if create_start == -1:
+            break
+        update_start = output.find(update_needle, create_start + len(create_needle))
+        if update_start == -1:
+            index = create_start + len(create_needle)
+            continue
+
+        switch_end = switch_case_end(output, update_start + len(update_needle))
+        create_segment = output[create_start:update_start]
+        update_segment = output[update_start:switch_end]
+        index = update_start + len(update_needle)
+
+        if _ALREADY_CREATE_DIFF in create_segment:
+            continue
+
+        create_match = _CREATE_RETURN.search(create_segment)
+        if not create_match:
+            continue
+        update_match = _UPDATE_RENDERER.search(update_segment)
+        if not update_match:
+            continue
+
+        outcome.candidates += 1
+        ns, factory = create_match.group(1), create_match.group(2)
+        file_var, content_var, verbose_var = create_match.group(4, 5, 6)
+        diff_renderer, style_var = update_match.group(1), update_match.group(2)
+
+        counter = _LINE_COUNTER.search(create_segment)
+        line_count = (
+            f"{counter.group(1)}({content_var})"
+            if counter
+            else f'{content_var}===""?0:{content_var}.split(`\\n`).length'
+        )
+
+        before = create_match.group(0)
+        after = (
+            f"return {ns}.{factory}({diff_renderer},{{"
+            f"filePath:{file_var},structuredPatch:[{{oldStart:1,oldLines:0,newStart:1,"
+            f"newLines:{line_count},"
+            f'lines:{content_var}===""?[]:{content_var}.split(`\\n`)'
+            f'.map((__cc_line)=>"+"+__cc_line)}}],'
+            f"firstLine:{content_var}.split(`\\n`)[0]??null,"
+            f'fileContent:"",style:{style_var},verbose:{verbose_var},previewHint:void 0}})'
+        )
+
+        next_segment = create_segment.replace(before, after, 1)
+        if next_segment != create_segment:
+            outcome.applied += 1
+            output = splice(output, create_start, update_start, next_segment)
+            index = create_start + len(next_segment)
+
+    return output
+
+
+PATCHES = [
+    Patch(
+        id="tool-calls",
+        title="Detailed tool calls",
+        summary="Show full read/search tool calls instead of collapsed one-line summaries.",
+        group=GROUP_OUTPUT,
+        fn=_tool_call_verbose,
+        anchors=('case"collapsed_read_search"',),
+    ),
+    Patch(
+        id="create-diff",
+        title="Colour new files as diffs",
+        summary="Render created files through the diff view so added lines keep + and green.",
+        group=GROUP_OUTPUT,
+        fn=_create_diff_colors,
+        anchors=('case"create":', 'case"update":'),
+    ),
+]