claude-code-extensions 0.1.0 → 0.1.1

package/cx-setup

@@ -1,101 +0,0 @@
-#!/usr/bin/env node
-/**
- * cx-setup — Configure Claude Code Extensions
- *
- * Standalone tool for managing which patches cx applies.
- *
- * Usage:
- *   cx-setup                  Interactive TUI
- *   cx-setup list             Show patch status
- *   cx-setup enable <id>      Enable a patch
- *   cx-setup disable <id>     Disable a patch
- *   cx-setup reset            Re-enable all patches
- */
-
-import { existsSync, readFileSync, writeFileSync, rmSync } from 'fs';
-import { resolve, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { listPatches } from './transform.js';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const CONFIG_PATH = resolve(__dirname, '.cx-patches.json');
-const CACHE_DIR = resolve(__dirname, '.cache');
-
-const DIM = '\x1b[2m', BOLD = '\x1b[1m', GREEN = '\x1b[32m', YELLOW = '\x1b[33m', RED = '\x1b[31m', RESET = '\x1b[0m';
-
-// ── Config helpers ────────────────────────────────────────────────────────
-
-function loadConfig() {
-  if (!existsSync(CONFIG_PATH)) return {};
-  try { return JSON.parse(readFileSync(CONFIG_PATH, 'utf-8')).patches || {}; } catch { return {}; }
-}
-
-function saveConfig(patches) {
-  writeFileSync(CONFIG_PATH, JSON.stringify({ patches }, null, 2) + '\n');
-  invalidateCache();
-}
-
-function invalidateCache() {
-  try { rmSync(CACHE_DIR, { recursive: true, force: true }); } catch { /* ok */ }
-}
-
-// ── Commands ──────────────────────────────────────────────────────────────
-
-const cmd = process.argv[2];
-const arg = process.argv[3];
-
-if (!cmd) {
-  // Interactive TUI
-  const { default: setup } = await import('./setup.js');
-  setup();
-
-} else if (cmd === 'list') {
-  const config = loadConfig();
-  const all = listPatches();
-  console.log(`\n  ${BOLD}cx patches${RESET}\n`);
-  for (const p of all) {
-    const on = config[p.id] !== false;
-    const icon = on ? `${GREEN}✔${RESET}` : `${DIM}○${RESET}`;
-    console.log(`  ${icon} ${p.id.padEnd(16)}${DIM}${p.description}${RESET}`);
-  }
-  console.log(`\n  Run ${BOLD}cx-setup${RESET} to toggle interactively.\n`);
-
-} else if (cmd === 'enable') {
-  if (!arg) { console.error('Usage: cx-setup enable <patch-id>'); process.exit(1); }
-  const all = listPatches();
-  if (!all.find(p => p.id === arg)) {
-    console.error(`Unknown patch: "${arg}". Available: ${all.map(p => p.id).join(', ')}`);
-    process.exit(1);
-  }
-  const config = loadConfig();
-  config[arg] = true;
-  saveConfig(config);
-  console.log(`  ${GREEN}✔${RESET} ${BOLD}${arg}${RESET} enabled`);
-
-} else if (cmd === 'disable') {
-  if (!arg) { console.error('Usage: cx-setup disable <patch-id>'); process.exit(1); }
-  const all = listPatches();
-  if (!all.find(p => p.id === arg)) {
-    console.error(`Unknown patch: "${arg}". Available: ${all.map(p => p.id).join(', ')}`);
-    process.exit(1);
-  }
-  const config = loadConfig();
-  config[arg] = false;
-  saveConfig(config);
-  console.log(`  ${DIM}○${RESET} ${BOLD}${arg}${RESET} disabled`);
-
-} else if (cmd === 'reset') {
-  try { rmSync(CONFIG_PATH, { force: true }); } catch { /* ok */ }
-  invalidateCache();
-  console.log(`  ${GREEN}✔${RESET} Config reset — all patches enabled.`);
-
-} else {
-  console.error(`Unknown command: ${cmd}`);
-  console.error(`\nUsage:`);
-  console.error(`  cx-setup              Interactive configurator`);
-  console.error(`  cx-setup list         Show patch status`);
-  console.error(`  cx-setup enable <id>  Enable a patch`);
-  console.error(`  cx-setup disable <id> Disable a patch`);
-  console.error(`  cx-setup reset        Re-enable all patches`);
-  process.exit(1);
-}

package/patch-worker.js

@@ -1,31 +0,0 @@
-/**
- * Worker thread that runs a single patch and returns its edits.
- * Receives: { source, patchId, patchesDir }
- * Returns:  { edits: [{pos, deleteCount, text}] } or { error: string }
- */
-
-import { workerData, parentPort } from 'worker_threads';
-import * as acorn from 'acorn';
-import { ASTIndex, buildContext } from './ast.js';
-
-const { source, patchId, patchesDir } = workerData;
-
-try {
-  const ast = acorn.parse(source, { ecmaVersion: 'latest', sourceType: 'module', allowHashBang: true });
-  const index = new ASTIndex(ast);
-  parentPort.postMessage({ type: 'ready' });
-
-  const edits = [];
-  const editor = {
-    insertAt(pos, text) { edits.push({ pos, deleteCount: 0, text }); },
-    replaceRange(start, end, text) { edits.push({ pos: start, deleteCount: end - start, text }); },
-  };
-
-  const ctx = buildContext(source, index, editor);
-  const patchModule = await import(`${patchesDir}/${patchId}.js`);
-  patchModule.default.apply(ctx);
-
-  parentPort.postMessage({ type: 'done', edits });
-} catch (err) {
-  parentPort.postMessage({ type: 'error', error: err.message });
-}

package/patches/always-show-context.js

@@ -1,123 +0,0 @@
-/**
- * Always Show Context
- *
- * Shows context usage percentage at all times, not just when approaching
- * the limit. The built-in TokenWarning only fires within 20k tokens of
- * the threshold — on a 1M context window, that's ~98% full, far too late.
- *
- * Addresses: https://github.com/anthropics/claude-code/issues/18456 (51 👍)
- *
- * Strategy:
- * 1. Find TokenWarning by its unique "Context low" string
- * 2. Remove the isAboveWarningThreshold gate so the indicator always renders
- * 3. Fix the warning color to be neutral when below threshold
- * 4. Soften "Context low" label to "Context" for always-on display
- *
- * For auto-compact users (the default): shows a dim "X% context used"
- * line at all times. For manual-compact users: shows "Context (X% remaining)"
- * in neutral color when below threshold, escalating to warning/error colors
- * as context fills up.
- */
-
-export default {
-  id: 'always-show-context',
-  name: 'Always Show Context',
-  description: 'Always display context usage percentage, not just when near limit',
-
-  apply(ctx) {
-    const { ast, editor, find, index, assert, src } = ctx;
-    const { findFirst } = find;
-
-    // Find TokenWarning function via its unique "Context low" marker.
-    // Check indexed literals first (string concat), then template elements.
-    let marker = null;
-    for (const [value, nodes] of index.literalsByValue) {
-      if (typeof value === 'string' && value.includes('Context low')) {
-        marker = nodes[0];
-        break;
-      }
-    }
-    if (!marker) {
-      marker = findFirst(ast, n =>
-        n.type === 'TemplateElement' &&
-        n.value?.raw?.includes('Context low')
-      );
-    }
-    assert(marker, 'Could not find "Context low" marker in bundle');
-
-    const fn = index.enclosingFunction(marker);
-    assert(fn, 'Could not find TokenWarning function');
-
-    // Find the early-return gate:
-    //   if (!isAboveWarningThreshold || suppressWarning) { return null; }
-    // Pattern: IfStatement → test: !X || Y, consequent: return null,
-    // and it must appear before the "Context low" string.
-    const gate = findFirst(fn, n => {
-      if (n.type !== 'IfStatement' || n.start >= marker.start) return false;
-      const t = n.test;
-      if (t.type !== 'LogicalExpression' || t.operator !== '||') return false;
-      if (t.left.type !== 'UnaryExpression' || t.left.operator !== '!') return false;
-      return findFirst(n.consequent, r =>
-        r.type === 'ReturnStatement' &&
-        r.argument?.type === 'Literal' &&
-        r.argument.value === null
-      ) !== null;
-    });
-    assert(gate, 'Could not find early-return gate: if(!X||Y){return null}');
-
-    // Save the minified name for isAboveWarningThreshold before editing
-    const warnVar = gate.test.left.argument;
-    assert(warnVar.type === 'Identifier',
-      'Expected Identifier for isAboveWarningThreshold');
-
-    // Edit 1: Remove threshold check from gate, keep suppress check.
-    // !isAboveWarningThreshold || suppressWarning → suppressWarning
-    editor.replaceRange(gate.test.start, gate.test.end, src(gate.test.right));
-
-    // Edit 2: Neutral color when below warning threshold.
-    // Find: isAboveErrorThreshold ? "error" : "warning"
-    // Replace "warning" with: isAboveWarningThreshold ? "warning" : void 0
-    // This makes text render in default color when context usage is low.
-    const colorTernary = findFirst(fn, n =>
-      n.type === 'ConditionalExpression' &&
-      n.consequent.type === 'Literal' && n.consequent.value === 'error' &&
-      n.alternate.type === 'Literal' && n.alternate.value === 'warning'
-    );
-    if (colorTernary) {
-      editor.replaceRange(
-        colorTernary.alternate.start,
-        colorTernary.alternate.end,
-        `${warnVar.name}?"warning":void 0`
-      );
-    }
-
-    // Edit 3: Soften "Context low" → "Context" for neutral always-on display.
-    const fnSrc = src(fn);
-    const needle = 'Context low';
-    let pos = 0;
-    while ((pos = fnSrc.indexOf(needle, pos)) !== -1) {
-      editor.replaceRange(
-        fn.start + pos,
-        fn.start + pos + needle.length,
-        'Context'
-      );
-      pos += needle.length;
-    }
-
-    // Edit 4: Change "X% until auto-compact" → "X% context used"
-    // The bundle has: reactiveOnlyMode ? `${100-var}% context used` : `${var}% until auto-compact`
-    // reactiveOnlyMode is always false, so patch the alternate branch to also show context used.
-    const autocompactTpl = findFirst(fn, n =>
-      n.type === 'TemplateLiteral' &&
-      n.quasis.some(q => q.value?.raw?.includes('% until auto-compact'))
-    );
-    if (autocompactTpl) {
-      const varName = src(autocompactTpl.expressions[0]);
-      editor.replaceRange(
-        autocompactTpl.start,
-        autocompactTpl.end,
-        `\`\${100-${varName}}% context used\``
-      );
-    }
-  },
-};

package/patches/always-show-thinking.js

@@ -1,65 +0,0 @@
-/**
- * Always Show Thinking Patch
- *
- * Makes Claude's thinking blocks always display expanded instead of
- * collapsed behind "∴ Thinking (ctrl+o to expand)".
- *
- * Addresses: https://github.com/anthropics/claude-code/issues/8477 (195 👍)
- *
- * In AssistantThinkingMessage, the gate is:
- *   const shouldShowFullThinking = isTranscriptMode || verbose;
- *   if (!shouldShowFullThinking) { return <collapsed view> }
- *
- * We find the function by its unique "∴ Thinking" string and replace
- * the negated OR gate with `false` so the expanded view always renders.
- */
-
-export default {
-  id: 'always-show-thinking',
-  name: 'Always Show Thinking',
-  description: 'Show thinking block content inline instead of collapsed',
-
-  apply(ctx) {
-    const { ast, editor, find, index, assert, src } = ctx;
-    const { findFirst } = find;
-
-    // Find the AssistantThinkingMessage function by its unique string literal.
-    // The "∴" character (U+2234, "therefore") only appears in this component.
-    // Use the literal index to find the marker, then walk up to its enclosing function.
-    let thinkingMarker = null;
-    for (const [value, nodes] of index.literalsByValue) {
-      if (typeof value === 'string' && value.includes('\u2234 Thinking')) {
-        thinkingMarker = nodes[0];
-        break;
-      }
-    }
-    assert(thinkingMarker, 'Could not find "∴ Thinking" literal');
-    const thinkingFn = index.enclosingFunction(thinkingMarker);
-    assert(thinkingFn, 'Could not find AssistantThinkingMessage function (marker: "∴ Thinking")');
-
-    // Find the gate: if(!(Y||O)) where Y=isTranscriptMode, O=verbose.
-    // Structure: IfStatement whose test is UnaryExpression(!) wrapping LogicalExpression(||)
-    // This is the FIRST such pattern in the function, appearing before the "∴ Thinking" strings.
-    const gate = findFirst(thinkingFn, n =>
-      n.type === 'IfStatement'
-      && n.test.type === 'UnaryExpression'
-      && n.test.operator === '!'
-      && n.test.argument.type === 'LogicalExpression'
-      && n.test.argument.operator === '||'
-    );
-    assert(gate, 'Could not find thinking display gate: if(!(X||Y))');
-
-    // Verify this is the right gate by checking it appears before the "∴ Thinking" string
-    const firstThinkingLiteral = findFirst(thinkingFn, n =>
-      n.type === 'Literal' && typeof n.value === 'string'
-      && n.value.includes('\u2234 Thinking'));
-    assert(
-      gate.start < firstThinkingLiteral.start,
-      'Gate should appear before "∴ Thinking" literal'
-    );
-
-    // Replace the test expression with `false` so the collapsed branch is never taken.
-    // This makes thinking always display in expanded mode.
-    editor.replaceRange(gate.test.start, gate.test.end, 'false');
-  },
-};

package/patches/banner.js

@@ -1,58 +0,0 @@
-/**
- * Attribution Banner Patch
- *
- * Changes "Claude Code" to "Claude Code · @wormcoffee" on the title line.
- * Targets the bold <Text> in the condensed layout and the border title
- * in the boxed layout. No extra elements, no layout changes.
- */
-
-export default {
-  id: 'banner',
-  name: 'Attribution Banner',
-  description: 'Show "@wormcoffee" on the Claude Code title line',
-
-  apply(ctx) {
-    const { ast, editor, find, index, src, assert } = ctx;
-    const { findFirst } = find;
-
-    // ── Condensed layout: createElement(T, {bold:true}, "Claude Code") ──
-    // Use literal index to find "Claude Code", then walk up to the createElement call.
-
-    const claudeCodeLiterals = index.literalsByValue.get('Claude Code') || [];
-    let boldTextCall = null;
-    for (const lit of claudeCodeLiterals) {
-      const call = index.ancestor(lit, 'CallExpression');
-      if (!call || call.callee.type !== 'MemberExpression' || call.callee.property.name !== 'createElement') continue;
-      const hasBold = call.arguments.some(a =>
-        a?.type === 'ObjectExpression' &&
-        a.properties.some(p => p.key?.type === 'Identifier' && p.key.name === 'bold'));
-      if (hasBold) { boldTextCall = call; break; }
-    }
-    assert(boldTextCall, 'Could not find createElement(T, {bold}, "Claude Code")');
-
-    const textLiteral = boldTextCall.arguments.find(a =>
-      a.type === 'Literal' && a.value === 'Claude Code');
-    editor.replaceRange(textLiteral.start, textLiteral.end,
-      '"Claude Code Extensions (cx) by x.com/@wormcoffee"');
-
-    // ── Boxed layout: b7("claude",o)("Claude Code") in the border title ──
-
-    // ── Boxed layout: b7("claude",o)("Claude Code") ──
-    // Find "Claude Code" literal whose parent CallExpression's callee is another call with "claude"
-    let titleCall = null;
-    for (const lit of claudeCodeLiterals) {
-      const call = index.parentMap.get(lit);
-      if (!call || call.type !== 'CallExpression' || call.arguments.length !== 1) continue;
-      if (call.callee.type === 'CallExpression' &&
-          call.callee.arguments[0]?.type === 'Literal' &&
-          call.callee.arguments[0].value === 'claude') {
-        titleCall = call;
-        break;
-      }
-    }
-    if (titleCall) {
-      editor.replaceRange(titleCall.arguments[0].start, titleCall.arguments[0].end,
-        '"Claude Code Extensions (cx) by x.com/@wormcoffee"');
-    }
-  },
-};

package/patches/cd-command.js

@@ -1,104 +0,0 @@
-/**
- * /cd Command Patch
- *
- * Adds a /cd <path> slash command to change the working directory
- * mid-session without losing conversation context.
- *
- * Addresses: https://github.com/anthropics/claude-code/issues/3473 (54 👍)
- *
- * AST strategy: find the bundled setCwd function (via its "tengu_shell_set_cwd"
- * telemetry string) and getCwdState (via its named export mapping), then inject
- * a new LocalCommand into the memoized COMMANDS array. The command calls setCwd
- * and reports the new working directory.
- */
-
-export default {
-  id: 'cd-command',
-  name: '/cd Command',
-  description: '/cd <path> — change where bash commands run (same as shell cd, keeps project settings)',
-
-  apply(ctx) {
-    const { ast, editor, find, query, index, src, assert } = ctx;
-
-    // ── 1. Find setCwd function via telemetry string ─────────────────
-    // setCwd logs "tengu_shell_set_cwd" on success. The shell exec function
-    // also logs it on failure, but inside an async arrow — setCwd is the
-    // only sync FunctionDeclaration containing this string.
-    const setCwdFns = query.findFunctionsContainingStrings(
-      ast, 'tengu_shell_set_cwd',
-    );
-    assert(setCwdFns.length >= 1, 'Could not find functions with tengu_shell_set_cwd');
-    const setCwdFn = setCwdFns.find(fn =>
-      fn.type === 'FunctionDeclaration' && !fn.async);
-    assert(setCwdFn, 'Could not find setCwd (sync FunctionDeclaration)');
-    const setCwdName = ctx.getFunctionName(setCwdFn);
-    assert(setCwdName, 'Could not determine setCwd function name');
-
-    // ── 2. Find getCwdState via export mapping ───────────────────────
-    // The state module exports: getCwdState:()=>XX
-    // This is a Property with Identifier key and zero-param ArrowFunction value.
-    const getCwdProp = find.findFirst(ast, n =>
-      n.type === 'Property' &&
-      n.key?.type === 'Identifier' && n.key.name === 'getCwdState' &&
-      n.value?.type === 'ArrowFunctionExpression' &&
-      n.value.params.length === 0 &&
-      n.value.body?.type === 'Identifier');
-    assert(getCwdProp, 'Could not find getCwdState export mapping');
-    const getCwdName = getCwdProp.value.body.name;
-
-    // ── 3. Find the COMMANDS array ───────────────────────────────────
-    // Locate via the compact command: find its definition object, trace to
-    // the exported variable, then find the large array containing it.
-    const compactObj = query.findObjectWithStringProps(ast, [
-      ['name', 'compact'],
-      ['type', 'local'],
-    ]);
-    assert(compactObj, 'Could not find compact command definition');
-
-    // Walk up to: localVar = {name:"compact",...}
-    let assignNode = index.parentMap.get(compactObj);
-    while (assignNode && assignNode.type !== 'AssignmentExpression') {
-      assignNode = index.parentMap.get(assignNode);
-    }
-    assert(
-      assignNode?.type === 'AssignmentExpression' &&
-      assignNode.left?.type === 'Identifier',
-      'Could not find compact assignment',
-    );
-    const localVar = assignNode.left.name;
-
-    // Find re-export: exportVar = localVar
-    const reExport = find.findFirst(ast, n =>
-      n.type === 'AssignmentExpression' &&
-      n.right?.type === 'Identifier' && n.right.name === localVar &&
-      n.left?.type === 'Identifier' && n.left.name !== localVar);
-    assert(reExport, 'Could not find compact re-export');
-    const exportVar = reExport.left.name;
-
-    // Find the array containing exportVar (COMMANDS has 40+ elements)
-    const commandsArr = find.findFirst(ast, n => {
-      if (n.type !== 'ArrayExpression') return false;
-      if (n.elements.length < 20) return false;
-      return n.elements.some(el =>
-        el?.type === 'Identifier' && el.name === exportVar);
-    });
-    assert(commandsArr, 'Could not find COMMANDS array');
-
-    // ── 4. Inject /cd command ────────────────────────────────────────
-    // Insert as last concrete element, before the closing bracket.
-    // The command calls setCwd (which validates path, resolves symlinks,
-    // updates internal state) and returns the new CWD.
-    const lastEl = commandsArr.elements[commandsArr.elements.length - 1];
-    const cdCmd =
-      `,{type:"local",name:"cd",description:"Change working directory"` +
-      `,argumentHint:"<path>",supportsNonInteractive:true` +
-      `,load:()=>Promise.resolve({call:async(q)=>{` +
-        `let p=q.trim();` +
-        `if(!p)return{type:"text",value:"Current directory: "+${getCwdName}()};` +
-        `if(p.startsWith("~"))p=(process.env.HOME||"")+p.slice(1);` +
-        `try{${setCwdName}(p);return{type:"text",value:"Changed to "+${getCwdName}()}}` +
-        `catch(e){return{type:"text",value:e.message||"Failed to change directory"}}` +
-      `}})}`;
-    editor.insertAt(lastEl.end, cdCmd);
-  },
-};

package/patches/cx-badge.js

@@ -1,112 +0,0 @@
-/**
- * CX Badge Patch
- *
- * Adds a small "cx" indicator to the left of the permission mode text
- * (e.g. "bypass permissions on", "accept edits on") in the footer.
- * When no mode is active, the badge still shows on the footer line.
- */
-
-export default {
-  id: 'cx-badge',
-  name: 'CX Badge',
-  description: 'Show a persistent "cx" indicator in the prompt footer',
-
-  apply(ctx) {
-    const { ast, editor, find, src, assert } = ctx;
-    const { findFirst } = find;
-
-    // Find the ModeIndicator function via the unique "? for shortcuts" string.
-    // Then locate the final return that builds <Box height={1} overflow="hidden">
-    // which contains modePart, tasksPart, and parts.
-
-    // Strategy: find the string "? for shortcuts" — it's inside a JSX element
-    // in ModeIndicator. Then find the enclosing function.
-    const shortcutsHint = findFirst(ast, n =>
-      n.type === 'Literal' && n.value === '? for shortcuts');
-    assert(shortcutsHint, 'Could not find "? for shortcuts" literal');
-
-    // Walk up to find the function containing this
-    const modeIndicatorFn = findFirst(ast, node => {
-      if (node.type !== 'FunctionDeclaration' && node.type !== 'FunctionExpression') return false;
-      // Check if the "? for shortcuts" literal is inside this function
-      let found = false;
-      const check = n => {
-        if (n === shortcutsHint) { found = true; return; }
-        if (found) return;
-        for (const key of Object.keys(n)) {
-          if (key === 'type' || key === 'start' || key === 'end') continue;
-          const val = n[key];
-          if (val && typeof val === 'object') {
-            if (Array.isArray(val)) {
-              for (const item of val) {
-                if (item && typeof item.type === 'string') check(item);
-                if (found) return;
-              }
-            } else if (typeof val.type === 'string') {
-              check(val);
-              if (found) return;
-            }
-          }
-        }
-      };
-      check(node);
-      return found;
-    });
-    assert(modeIndicatorFn, 'Could not find ModeIndicator function');
-
-    // Find the createElement call with height:1 and overflow:"hidden" props
-    // This is the final return: <Box height={1} overflow="hidden">
-    const boxWithHeight1 = findFirst(modeIndicatorFn, n => {
-      if (n.type !== 'CallExpression') return false;
-      // Look for an object argument with height:1 and overflow:"hidden"
-      return n.arguments.some(arg => {
-        if (arg?.type !== 'ObjectExpression') return false;
-        let hasHeight = false;
-        let hasOverflow = false;
-        for (const p of arg.properties) {
-          if (p.key?.name === 'height' && p.value?.value === 1) hasHeight = true;
-          if (p.key?.name === 'overflow' && p.value?.value === 'hidden') hasOverflow = true;
-        }
-        return hasHeight && hasOverflow;
-      });
-    });
-    assert(boxWithHeight1, 'Could not find <Box height={1} overflow="hidden">');
-
-    // Get the React namespace from the createElement call
-    // The call looks like: R.createElement(Box, {height:1, overflow:"hidden"}, ...children)
-    const callee = boxWithHeight1.callee;
-    let R;
-    if (callee.type === 'MemberExpression') {
-      R = src(callee.object);
-    } else {
-      // Could be jsxs or jsx direct call
-      R = src(callee);
-    }
-
-    // Find the Box component reference (first argument to createElement)
-    const BoxRef = src(boxWithHeight1.arguments[0]);
-
-    // Find the Text component — look for a createElement call with " · " string
-    const separatorCall = findFirst(modeIndicatorFn, n => {
-      if (n.type !== 'CallExpression') return false;
-      return n.arguments.some(a => a?.type === 'Literal' && a.value === ' · ');
-    });
-    assert(separatorCall, 'Could not find separator " · " createElement');
-    const TextRef = src(separatorCall.arguments[0]);
-
-    // Insert a CX badge as the first child of the Box.
-    // The children start after the props object.
-    // Find the props object position
-    const propsArg = boxWithHeight1.arguments.find(a =>
-      a?.type === 'ObjectExpression' &&
-      a.properties.some(p => p.key?.name === 'height'));
-
-    // Insert right after the props argument (before the first child)
-    const insertPos = propsArg.end;
-
-    // CX badge: inverse claude orange
-    const cxBadge = `,${R}.createElement(${BoxRef},{flexShrink:0},${R}.createElement(${TextRef},{inverse:true,color:"claude"},"cx"),${R}.createElement(${TextRef},null," "))`;
-
-    editor.insertAt(insertPos, cxBadge);
-  },
-};

package/patches/cx-resume-commands.js

@@ -1,58 +0,0 @@
-/**
- * cx Resume Commands Patch
- *
- * Rewrites user-facing resume/continue command hints so they point at
- * the cx wrapper instead of bare claude.
- *
- * AST strategy: scan string literals and template chunks for the stable
- * command snippets that Claude prints to users, then replace only those
- * substrings in-place. This covers shutdown hints, cross-project resume
- * commands, and resume tips without relying on minified variable names.
- */
-
-export default {
-  id: 'cx-resume-commands',
-  name: 'cx Resume Commands',
-  description: 'Show cx instead of claude in resume/continue command hints',
-
-  apply(ctx) {
-    const { ast, editor, find, src, assert } = ctx;
-    const { findAll } = find;
-
-    const replacements = [
-      ['claude --continue', 'cx --continue'],
-      ['claude --resume', 'cx --resume'],
-      ['claude -p --resume', 'cx -p --resume'],
-    ];
-
-    let changed = 0;
-    const rewrite = (node, text) => {
-      let next = text;
-      for (const [from, to] of replacements) {
-        next = next.split(from).join(to);
-      }
-      if (next !== text) {
-        editor.replaceRange(node.start, node.end, JSON.stringify(next));
-        changed++;
-      }
-    };
-
-    for (const node of findAll(ast, n => n.type === 'Literal' && typeof n.value === 'string')) {
-      rewrite(node, node.value);
-    }
-
-    for (const node of findAll(ast, n => n.type === 'TemplateElement' && typeof n.value?.raw === 'string')) {
-      const raw = src(node);
-      let nextRaw = raw;
-      for (const [from, to] of replacements) {
-        nextRaw = nextRaw.split(from).join(to);
-      }
-      if (nextRaw !== raw) {
-        editor.replaceRange(node.start, node.end, nextRaw);
-        changed++;
-      }
-    }
-
-    assert(changed >= 4, `Expected at least 4 resume/continue command rewrites, found ${changed}`);
-  },
-};