patch-cc 0.2.4__tar.gz → 0.3.0__tar.gz

{patch_cc-0.2.4 → patch_cc-0.3.0}/AGENTS.md

@@ -16,3 +16,10 @@ Verify with `uv run patch-cc doctor` (every patch against a clean bundle;
 point it at the pristine copies in `~/.local/share/patch-cc/backups/` to sweep
 older builds). There is no test suite by design — doctor against real bundles
 is the check.
+
+Be exact about what that covers: doctor runs the **matchers** and parses the
+bundle they produce. It never runs the gateway, the translator, the OAuth flow
+or the menu, so a change under `src/patch_cc/codex/` (the bridge — all of it
+runtime, none of it a patch; the Codex *patch* is `patches/codex.py`, which the
+sweep does cover) or in `menu.py` is checked by exercising it — a real `codex
+serve` against a real turn — and a green sweep says nothing about it.

{patch_cc-0.2.4 → patch_cc-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: patch-cc
-Version: 0.2.4
+Version: 0.3.0
 Summary: Interactive patcher for the Claude Code native binary
 Project-URL: Homepage, https://github.com/anfreire/patch-cc
 Project-URL: Repository, https://github.com/anfreire/patch-cc
@@ -25,6 +25,8 @@ Requires-Python: >=3.11
 Requires-Dist: blessed>=1.47.0
 Requires-Dist: lief>=0.15; sys_platform == 'darwin'
 Requires-Dist: rich>=13.7
+Requires-Dist: tree-sitter-javascript>=0.23
+Requires-Dist: tree-sitter>=0.25
 Description-Content-Type: text/markdown
 
 # patch-cc
@@ -37,7 +39,7 @@ you want — inline and live thinking, detailed tool calls, subagent model
 overrides, your own startup name, your **ChatGPT/Codex-plan GPT models as
 native models** — and apply them to your installed `claude` in one keystroke.
 Fully reversible: a pristine backup is kept, `patch-cc restore` puts it back.
-Pure Python; no Node, no Bun.
+No Node, no Bun.
 
 ```bash
 uvx patch-cc                   # fullscreen menu, no install needed
@@ -92,7 +94,7 @@ patch-cc                       # then just run it
 | Chrome & branding | Disable spinner tips | No rotating tips on the spinner |
 | | Mark `--version` | Appends `(patched)` — or any marker you choose |
 | | Custom startup name | Defaults to `<your username>'s Code` |
-| | Startup org/email label | Replace the org/email on the welcome screen — or hide it |
+| | Startup org/email label | Replace the org/email on the welcome screen — or hide it (demo mode keeps the stock line) |
 
 ## Usage
 
@@ -197,9 +199,13 @@ startup name / `--version` marker are visible tells too.
 
 Claude Code now ships only as a Bun single-file executable; the npm package is a
 wrapper that downloads it. patch-cc edits the JavaScript bundle embedded in the
-binary's `.bun` section in place. It also drops the module's 154 MB of stale
-precompiled bytecode — editing the source invalidates it anyway — so a patched
-binary is *smaller* than the original (≈113 MB vs 267 MB), not larger.
+binary's `.bun` section in place. It also drops the entry module's stale
+precompiled bytecode — editing the source invalidates it anyway, and it is more
+than half the download — so on Linux, where the ELF section is rewritten in
+place, a patched binary is *smaller* than the original, not larger. (On macOS
+the freed bytes are not yet reclaimed, so the file keeps its size; it still runs
+correctly.) [docs/INTERNALS.md](docs/INTERNALS.md#the-bytecode-and-why-we-drop-it)
+has the measurements; `patch-cc status` has yours.
 
 See [docs/INTERNALS.md](docs/INTERNALS.md) for the container format and
 [docs/PLAYBOOK.md](docs/PLAYBOOK.md) for repairing a patch after an update.

{patch_cc-0.2.4 → patch_cc-0.3.0}/README.md

@@ -8,7 +8,7 @@ you want — inline and live thinking, detailed tool calls, subagent model
 overrides, your own startup name, your **ChatGPT/Codex-plan GPT models as
 native models** — and apply them to your installed `claude` in one keystroke.
 Fully reversible: a pristine backup is kept, `patch-cc restore` puts it back.
-Pure Python; no Node, no Bun.
+No Node, no Bun.
 
 ```bash
 uvx patch-cc                   # fullscreen menu, no install needed
@@ -63,7 +63,7 @@ patch-cc                       # then just run it
 | Chrome & branding | Disable spinner tips | No rotating tips on the spinner |
 | | Mark `--version` | Appends `(patched)` — or any marker you choose |
 | | Custom startup name | Defaults to `<your username>'s Code` |
-| | Startup org/email label | Replace the org/email on the welcome screen — or hide it |
+| | Startup org/email label | Replace the org/email on the welcome screen — or hide it (demo mode keeps the stock line) |
 
 ## Usage
 
@@ -168,9 +168,13 @@ startup name / `--version` marker are visible tells too.
 
 Claude Code now ships only as a Bun single-file executable; the npm package is a
 wrapper that downloads it. patch-cc edits the JavaScript bundle embedded in the
-binary's `.bun` section in place. It also drops the module's 154 MB of stale
-precompiled bytecode — editing the source invalidates it anyway — so a patched
-binary is *smaller* than the original (≈113 MB vs 267 MB), not larger.
+binary's `.bun` section in place. It also drops the entry module's stale
+precompiled bytecode — editing the source invalidates it anyway, and it is more
+than half the download — so on Linux, where the ELF section is rewritten in
+place, a patched binary is *smaller* than the original, not larger. (On macOS
+the freed bytes are not yet reclaimed, so the file keeps its size; it still runs
+correctly.) [docs/INTERNALS.md](docs/INTERNALS.md#the-bytecode-and-why-we-drop-it)
+has the measurements; `patch-cc status` has yours.
 
 See [docs/INTERNALS.md](docs/INTERNALS.md) for the container format and
 [docs/PLAYBOOK.md](docs/PLAYBOOK.md) for repairing a patch after an update.

{patch_cc-0.2.4 → patch_cc-0.3.0}/docs/CONDUCT.md

@@ -30,26 +30,44 @@ shape that already absorbs every case, found rather than bolted on.
 
 - **Explicit invocations are hermetic.** A non-interactive command's arguments
   are its whole input; no saved state may *silently* change what it does.
-  Persisted choices pre-fill the interactive UI and never act on their own — the
-  lone exception is `apply --from-cache`, which takes the cache as its *named*
-  input, so the state it reads is declared in the arguments, not hidden behind a
-  default. Absent that flag, the same command still always yields the same result.
+  Persisted choices pre-fill the interactive UI and never act on their own. Two
+  flags do read state, and each *names* the state it reads: `apply --from-cache`
+  takes the remembered selection, and `apply --codex` takes your plan's
+  catalogue — asking for a Codex model is asking for the plan that describes it,
+  so the display name and context window are read from there rather than
+  invented. Neither is hidden behind a default, and absent both, the same command
+  always yields the same result. Asking for a Codex model is also the one thing
+  whose *output* can differ between two identical invocations — under either flag
+  that does it, `--codex` naming ids directly or `--from-cache` replaying a
+  remembered set that holds them (both re-read the plan at bake time): a plan
+  that cannot be reached is not an error, so the id still bakes, on its
+  fallbacks. That is the price of not guessing a context window, and it is paid
+  under flags that say so.
 
-- **Anchor matchers on meaning.** String literals, `case` labels, prop names,
-  control-flow shape — never a minified local that changes every build. A new
-  upstream shape earns a narrow new branch, not a looser regex. Full rules and
-  the repair loop: [PLAYBOOK.md](PLAYBOOK.md).
+- **Find by the name upstream wrote; edit the grammar node.** The authored
+  names — string literals, `case` labels, property names — and the shape of the
+  tree are what a build keeps. Never describe the syntax between them, and never
+  anchor on a minified local: that is the half a minifier regenerates. A new
+  upstream *shape* earns a narrow new branch; a new *spelling* of one shape
+  should already cost nothing. Full rules and the repair loop:
+  [PLAYBOOK.md](PLAYBOOK.md).
 
 - **Report absent apart from broken.** A matcher that finds nothing may be a
   shape this build simply lacks — most patches carry several — not a regression.
   Keep "gone", "already applied", and "not on this build" as distinct signals;
   never collapse them into one number. Which one a sub-step's silence means is
-  not guesswork: declare it (`expect=True`, or a variant group) so a green tick
-  cannot cover a dead feature. See [PLAYBOOK.md](PLAYBOOK.md).
+  not guesswork: declare it (`expect=True`) so a green tick cannot cover a dead
+  feature. A step nobody declared is a step that cannot report its own death:
+  `branding` carried none, so a name badge that stopped being a bold render was
+  a green run, an unchanged banner, and a manifest asserting the new name. See
+  [PLAYBOOK.md](PLAYBOOK.md).
 
-- **Port faithfully.** When you change a patch, verify its output against the
-  upstream reference on a real bundle — byte-identical where behaviour must not
-  change. The JS→Python porting traps are in [PLAYBOOK.md](PLAYBOOK.md).
+- **Port faithfully.** When you change a patch, verify its output against a real
+  bundle — byte-identical where behaviour must not change. `doctor` over the
+  archived corpus is that check, and the *diff* between two sweeps is the half
+  that matters: a red build is loud on its own, but a widened locator shows up
+  only as an old build's counts quietly moving. Be able to say what every moved
+  number means. The sweep is in [PLAYBOOK.md](PLAYBOOK.md).
 
 - **The user controls commits and releases.** Don't commit, push, or publish
   unless asked.

{patch_cc-0.2.4 → patch_cc-0.3.0}/docs/INTERNALS.md

@@ -1,6 +1,6 @@
 # Internals
 
-How patch-cc gets from a 267 MB binary to a patched, smaller one.
+How patch-cc gets from a Claude binary to a patched, smaller one.
 
 ## The shape of a native Claude binary
 
@@ -35,32 +35,52 @@ A module record (new 52-byte format) is six such pairs — `name`, `contents`,
 `sourcemap`, `bytecode`, `moduleInfo`, `bytecodeOriginPath` — followed by four
 `u8` flags (`encoding`, `loader`, `moduleFormat`, `side`).
 
-The module we patch is the entrypoint, named `/$bunfs/root/src/entrypoints/cli.js`
-(or `claude` / `claude.exe` on other builds). Its `contents` is the JS we edit.
+The module we patch is the entrypoint, which the offsets struct names by index
+(`entry_point_id`) — the same index Bun itself resolves it by. Its `contents` is
+the JS we edit. Its *name* is upstream's to change and we never read it:
+2.1.229 renamed it `/$bunfs/root/src/entrypoints/cli.js` → `/$bunfs/root/cli`.
 
 Code: `src/patch_cc/bun/blob.py`.
 
-## The 154 MB bytecode, and why we drop it
+## The bytecode, and why we drop it
 
-The entry module also carries ~154 MB of precompiled Bun **bytecode** — more
-than half the binary. Every other module has none.
+The entry module also carries precompiled Bun **bytecode** — more than half the
+binary. Every other module has none.
 
 Any edit to `contents` invalidates that bytecode; Bun detects the mismatch and
 recompiles from source at launch. So keeping it buys nothing:
 
 | binary | size | startup |
 |---|---|---|
-| original (valid bytecode) | 267 MB | ~100 ms |
-| patched, bytecode kept | 267 MB | ~650 ms |
-| patched, bytecode dropped | **113 MB** | ~650 ms |
+| original (valid bytecode) | 323 MB | ~100 ms |
+| patched, bytecode kept | 323 MB | ~650 ms |
+| patched, bytecode dropped | **125 MB** | ~650 ms |
 
 Patching pays the recompile cost either way, so patch-cc drops the entry
 module's bytecode (`rebuild(..., drop_bytecode=True)`). The result runs source,
-guaranteeing our edits are authoritative, and is ~154 MB smaller.
-
-`doctor` asserts the patched binary has `bytecode == 0`. If a future Bun build
-makes bytecode authoritative over source, that assert is the tripwire — every
-patch would silently no-op otherwise.
+guaranteeing our edits are authoritative, and — on Linux — is smaller by
+exactly the bytecode.
+
+The size figures are the **ELF** path: the `.bun` section is rewritten in place,
+so the dropped bytecode is genuinely reclaimed (`container.verify` refuses a
+Linux write that did not shrink). On **macOS** the file keeps its original size:
+`macho.py` grows a segment but never shrinks one, so the freed bytes stay as
+dead space. The binary still runs correctly (the bytecode is gone), it is just
+not smaller — reclaiming it means shrinking the Mach-O segment and re-laying
+`__LINKEDIT`, which is not done yet.
+
+Those are **2.1.232's** Linux numbers, and they are a measurement rather than a
+promise: the same table read 267 / 113 MB against 2.1.216, because the bytecode
+grew from 154 MB to 198 MB in the fifteen builds between them (2.1.230 was
+never published). Read the current pair off any
+binary with `patch-cc status` rather than off this table.
+
+Every write asserts the binary it produced carries `bytecode == 0`
+(`container.verify`, beside the round-trip check), and `patch-cc status` reports
+the field for an installed one. `doctor` cannot: a dry run is handed a *clean*
+bundle, which still has its bytecode by definition. If a future Bun build makes
+bytecode authoritative over source, that assert is the tripwire — every patch
+would silently no-op otherwise.
 
 ## Writing it back without ballooning
 
@@ -92,20 +112,23 @@ Every patched bundle ends with a single comment line — the one description of
 its shape; [PLAYBOOK.md](PLAYBOOK.md) covers what it means for matcher health:
 
 ```
-//patch-cc {"v":1,"tool":"<version>","patches":[...],"brand":...,"models":{...},
-            "org":...,"codex":{"port":8817,"models":["gpt-5.6-sol", ...]}}
+//patch-cc {"v":1,"tool":"<version>","patches":[...],"brand":...,"suffix":...,
+            "models":{...},"org":...,"codex":{"port":8817,"models":["gpt-5.6-sol"]}}
 ```
 
+Every key after `patches` is a configurable patch's own, declared in one place
+(`Patch.setting`) so the manifest here, the cache, and the menu cannot spell it
+three ways. Each is written only when *that* patch landed **and** has a value
+worth recording, so `status` can never assert a name, marker, or model the
+bundle does not contain — and so this is the *widest* the line gets, not its
+fixed shape.
+
 That line is why `patch-cc status` can name exactly what is applied: several
 patches are value flips (`verbose:!0`) that leave no other trace. A comment
 can't collide with code and travels with the bundle through extract/repack.
 The menu also reads it to pre-select the current patch set — the binary is the
 state.
 
-Every key after `patches` belongs to a patch and is written only when *that*
-patch landed, so `status` can never assert a name, marker, or model the bundle
-does not contain.
-
 Each key records what was *asked for*, never what was derived from it. `codex`
 carries model ids and a port and nothing else: a Codex model's display name and
 context window are already baked into the bundle, and repeating them here would
@@ -120,9 +143,19 @@ rather than from a store of their own.
   `~/.local/share/patch-cc/backups/`. `restore` copies it back — never an
   inverse patch (insertions cascade, so a reverse diff is meaningless).
 - Patching always starts from that pristine copy, so re-applying never stacks
-  edits on edits, and an apply where **no** patch changes anything leaves the
-  binary untouched entirely (stripping bytecode for nothing would only slow
-  startup).
+  edits on edits, and an apply where **nothing lands** — every selected patch
+  broken, so the manifest would claim nothing — leaves the binary untouched
+  entirely (stripping bytecode for nothing would only slow startup). A patch
+  that *lands* still writes even where it changed no bytes, because landing
+  includes an override the build already satisfies: the manifest records what
+  was asked and verified present, so `status` can report it.
+- The bundle is parsed, and any syntax error aborts before the binary or the
+  backup is touched — the two checks below answer "did we write what we meant
+  to", which a corrupt splice satisfies perfectly. The parse is the same one
+  the patches locate with, so it costs nothing extra and sits at *every* batch
+  of edits as well as on the final bytes: a patch that produces rubble is named
+  and dropped rather than aborting the run. See
+  [PLAYBOOK.md](PLAYBOOK.md#the-syntax-gate).
 - Every write is verified: patch-cc re-extracts the JS from the binary it just
   wrote and asserts it equals what it meant to write.
 - Patching a binary that is already marked, when no pristine backup exists, is