claude-code-extensions 0.1.0 → 0.1.2

package/patches/show-file-in-collapsed-read.js

@@ -1,178 +0,0 @@
-/**
- * Show File Paths in Collapsed Read/Search Display
- *
- * Instead of just "Read 3 files", shows the actual file paths:
- *   Read 3 files (src/foo.ts, src/bar.ts, src/baz.ts)
- * Instead of just "Searched for 1 pattern", shows:
- *   Searched for 1 pattern ("handleSubmit")
- *
- * Addresses: https://github.com/anthropics/claude-code/issues/21151 (184 👍)
- *
- * The data is already there — readFilePaths and searchArgs are extracted
- * from the message but only shown during active execution as a hint.
- * This patch adds them to the completed collapsed display.
- */
-
-export default {
-  id: 'show-file-in-collapsed-read',
-  name: 'Show File in Collapsed Read',
-  description: 'Show file paths and search patterns in collapsed tool display',
-
-  apply(ctx) {
-    const { ast, editor, find, index, assert, src, query } = ctx;
-    const { findFirst, findAll } = find;
-
-    // ─── Step 1: Find the collapsed display rendering function ───
-    // Identified by containing key:"read", key:"search", and key:"comma-r" literals.
-    // Use the indexed findFunctionsContainingStrings for O(matches) lookup.
-    const renderFns = query.findFunctionsContainingStrings(ast, 'comma-r', 'read', 'search');
-    const renderFn = renderFns[0];
-    assert(renderFn, 'Could not find collapsed display render function (markers: key:"read", key:"search", key:"comma-r")');
-
-    // ─── Step 2: Discover variable names ───
-    // Find the readFilePaths variable: pattern is X=q.readFilePaths
-    // Find the searchArgs variable: pattern is X=q.searchArgs
-    // Find the getDisplayPath function: pattern is X(Y):M where it's used near readFilePaths
-
-    // Find readFilePaths property access
-    const readFilePathsAccess = findFirst(renderFn, n =>
-      n.type === 'MemberExpression'
-      && n.property.type === 'Identifier'
-      && n.property.name === 'readFilePaths'
-    );
-    assert(readFilePathsAccess, 'Could not find q.readFilePaths access');
-
-    // The assignment: Q = q.readFilePaths — Q is the variable we need
-    const readPathsAssignment = findFirst(renderFn, n =>
-      n.type === 'VariableDeclarator'
-      && n.init === readFilePathsAccess
-    );
-    assert(readPathsAssignment, 'Could not find readFilePaths variable assignment');
-    const readPathsVar = readPathsAssignment.id.name;
-
-    // Find searchArgs variable similarly
-    const searchArgsAccess = findFirst(renderFn, n =>
-      n.type === 'MemberExpression'
-      && n.property.type === 'Identifier'
-      && n.property.name === 'searchArgs'
-    );
-    assert(searchArgsAccess, 'Could not find q.searchArgs access');
-    const searchArgsAssignment = findFirst(renderFn, n =>
-      n.type === 'VariableDeclarator'
-      && n.init === searchArgsAccess
-    );
-    assert(searchArgsAssignment, 'Could not find searchArgs variable assignment');
-    const searchArgsVar = searchArgsAssignment.id.name;
-
-    // Find getDisplayPath function name by looking for its call pattern:
-    // It's called like: F5(X6) right after readFilePaths is accessed,
-    // in the pattern: X!==void 0?F5(X):M
-    // The call is on a variable that came from Q?.at(-1)
-    const getDisplayPathCall = findFirst(renderFn, n => {
-      if (n.type !== 'ConditionalExpression') return false;
-      // Look for: X!==void 0 ? CALL(X) : Y
-      // where CALL is a single-argument function call
-      if (n.consequent.type !== 'CallExpression') return false;
-      if (n.consequent.arguments.length !== 1) return false;
-      // The callee should be an Identifier (the getDisplayPath function)
-      if (n.consequent.callee.type !== 'Identifier') return false;
-      // This should appear after readFilePaths is used
-      return n.start > readFilePathsAccess.start;
-    });
-    assert(getDisplayPathCall, 'Could not find getDisplayPath call pattern');
-    const displayPathFn = getDisplayPathCall.consequent.callee.name;
-
-    // ─── Step 3: Find the React library reference ───
-    // Look for createElement calls in the function — C4.default.createElement(...)
-    // Find the pattern: X.default.createElement(Y, {key:"read"}, ...)
-    const readElement = findFirst(renderFn, n => {
-      if (n.type !== 'CallExpression') return false;
-      // Check for: X.default.createElement
-      const callee = n.callee;
-      if (callee.type !== 'MemberExpression') return false;
-      if (callee.property.name !== 'createElement') return false;
-      // Check args for key:"read"
-      return n.arguments.some(arg =>
-        arg.type === 'ObjectExpression'
-        && arg.properties?.some(p =>
-          p.key?.name === 'key' && p.value?.value === 'read'
-        )
-      );
-    });
-    assert(readElement, 'Could not find createElement with key:"read"');
-
-    // Extract the React reference (e.g., C4) from C4.default.createElement
-    const reactRef = src(readElement.callee.object.object);
-
-    // ─── Step 4: Find the Text component reference ───
-    // The readElement is: createElement(T, {key:"read"}, M6, " ", createElement(T, {bold:!0}, b), ...)
-    // The first argument (index 0) is the Text component reference.
-    const textComponent = src(readElement.arguments[0]);
-
-    // ─── Step 5: Find the "Searched for" element and inject search pattern ───
-    // Pattern: z6.push(createElement(T, {key:"search"}, M6, " ", createElement(T, {bold:true}, I), " ", I===1?"pattern":"patterns"))
-    // We want to add the search pattern text after "patterns")
-    const searchElement = findFirst(renderFn, n => {
-      if (n.type !== 'CallExpression') return false;
-      if (n.callee.type !== 'MemberExpression') return false;
-      if (n.callee.property.name !== 'createElement') return false;
-      return n.arguments.some(arg =>
-        arg.type === 'ObjectExpression'
-        && arg.properties?.some(p =>
-          p.key?.name === 'key' && p.value?.value === 'search'
-        )
-      );
-    });
-    assert(searchElement, 'Could not find createElement with key:"search"');
-
-    // Find the push() call that contains this search element
-    const searchPush = findFirst(renderFn, n =>
-      n.type === 'CallExpression'
-      && n.callee.type === 'MemberExpression'
-      && n.callee.property.name === 'push'
-      && n.arguments.length === 1
-      && n.arguments[0] === searchElement
-    );
-    assert(searchPush, 'Could not find push() call for search element');
-
-    // After the search push, inject a conditional that shows the search patterns
-    // Show: (pattern1, pattern2, ...)
-    const searchPathCode = `;if(${searchArgsVar}&&${searchArgsVar}.length>0){` +
-      `z6.push(${reactRef}.default.createElement(${textComponent},{key:"search-args",dimColor:!0},` +
-      `" (",${searchArgsVar}.map(function(p){return\'"\\'\\'"+p+\'"\\'\\'\'}).join(", "),")"))` +
-      `}`;
-
-    // Wait — the array variable name might not be z6. Let's find it.
-    // The push() callee object is the array variable.
-    const elemArrayVar = src(searchPush.callee.object);
-
-    const searchPathCodeFinal = `;if(${searchArgsVar}&&${searchArgsVar}.length>0){` +
-      `${elemArrayVar}.push(${reactRef}.default.createElement(${textComponent},{key:"search-args",dimColor:!0},` +
-      `" (",${searchArgsVar}.map(function(p){return '"'+p+'"'}).join(", "),")"))` +
-      `}`;
-
-    // Find the enclosing if-block for the search element by walking up the parent chain
-    const searchIfBlock = index.ancestor(searchElement, 'IfStatement');
-    assert(searchIfBlock, 'Could not find if block containing search element');
-
-    editor.insertAt(searchIfBlock.end, searchPathCodeFinal);
-
-    // ─── Step 6: Find the "Read" element and inject file paths ───
-    // After the if(b>0){...} block, inject file path display
-    const readIfBlock = index.ancestor(readElement, 'IfStatement');
-    assert(readIfBlock, 'Could not find if block containing read element');
-
-    // Inject after the read if-block:
-    // Show file paths: " (src/foo.ts, src/bar.ts)" for up to 3 files,
-    // or " (src/foo.ts… +2 more)" for >3 files
-    const readPathCode = `;if(${readPathsVar}&&${readPathsVar}.length>0){` +
-      `var __paths=${readPathsVar}.length<=3?` +
-        `${readPathsVar}.map(${displayPathFn}).join(", "):` +
-        `${displayPathFn}(${readPathsVar}[${readPathsVar}.length-1])+"… +"+(${readPathsVar}.length-1)+" more";` +
-      `${elemArrayVar}.push(${reactRef}.default.createElement(${textComponent},{key:"read-paths",dimColor:!0},` +
-      `" (",__paths,")"))` +
-      `}`;
-
-    editor.insertAt(readIfBlock.end, readPathCode);
-  },
-};

package/patches/swap-enter-submit.js

@@ -1,188 +0,0 @@
-/**
- * Swap Enter / Meta+Enter
- *
- * Makes Enter insert a newline and Meta+Enter (Option+Enter on macOS) submit.
- *
- * Addresses: https://github.com/anthropics/claude-code/issues/2054 (72 reactions)
- *
- * CJK users, SSH users, and anyone with Slack-style muscle memory constantly
- * submit half-written prompts by accident. This patch swaps the default
- * bindings so Enter is safe (newline) and Meta+Enter is deliberate (submit).
- *
- * Why keybinding changes alone aren't enough:
- *
- * The Enter key's submit behavior is hard-coded in useTextInput.ts's
- * handleEnter() function — it directly calls onSubmit() for plain Enter
- * and cursor.insert('\n') for Meta/Shift+Enter, bypassing the keybinding
- * system entirely.
- *
- * This patch modifies THREE layers:
- *   1. DEFAULT_BINDINGS — so shortcut hints and the help menu show correctly
- *   2. handleEnter() — so the actual key behavior is swapped
- *   3. Tip/help text — so instructions match the new behavior
- */
-
-export default {
-  id: 'swap-enter-submit',
-  name: 'Swap Enter / Meta+Enter',
-  description: 'Enter inserts newline, Option/Alt+Enter submits',
-  defaultEnabled: false,
-
-  apply(ctx) {
-    const { ast, editor, query, find, src, assert } = ctx;
-    const { findObjectWithStringProps } = query;
-    const { findFirst, findAll } = find;
-
-    // ── Patch 1: DEFAULT_BINDINGS ────────────────────────────────────
-
-    const obj = findObjectWithStringProps(ast, [
-      ['enter', 'chat:submit'],
-      ['up', 'history:previous'],
-    ]);
-    assert(obj, 'Could not find DEFAULT_BINDINGS object');
-
-    const enterProp = obj.properties.find(p =>
-      p.type === 'Property' &&
-      ((p.key.type === 'Identifier' && p.key.name === 'enter') ||
-       (p.key.type === 'Literal' && p.key.value === 'enter')));
-    assert(enterProp, 'Could not find "enter" property in DEFAULT_BINDINGS');
-
-    assert(
-      enterProp.value.type === 'Literal' && enterProp.value.value === 'chat:submit',
-      'enter property value is not "chat:submit"',
-    );
-    editor.replaceRange(enterProp.value.start, enterProp.value.end, '"chat:newline"');
-    editor.insertAt(enterProp.end, ',"meta+enter":"chat:submit"');
-
-    // ── Patch 2: handleEnter() in useTextInput ───────────────────────
-    //
-    // Original handleEnter:
-    //   if (backslash) → backslash+newline (keep)
-    //   if (key.meta || key.shift) → cursor.insert('\n')
-    //   if (Apple_Terminal && shift) → cursor.insert('\n')
-    //   onSubmit?.(originalValue)
-    //
-    // After patch:
-    //   if (backslash) → backslash+newline (unchanged)
-    //   if (key.meta) → onSubmit (Meta/Option+Enter submits)
-    //   if (key.shift) → cursor.insert('\n') (Shift+Enter still inserts newline)
-    //   (Apple_Terminal block removed — not needed; Meta works via Option key,
-    //    and plain Enter newlines go through keybinding system)
-    //   return cursor (plain Enter = no-op; keybinding system handles
-    //                  Enter → chat:newline → handleNewline in PromptInput)
-
-    // Find handleEnter by stable markers. Take the SMALLEST matching
-    // function (handleEnter is nested inside useTextInput).
-    const isHandleEnterCandidate = node => {
-      if (node.type !== 'FunctionDeclaration' && node.type !== 'FunctionExpression') return false;
-      if (!findFirst(node, n => n.type === 'Literal' && n.value === 'Apple_Terminal')) return false;
-      if (!findFirst(node, n =>
-        n.type === 'CallExpression' && n.callee.type === 'MemberExpression' &&
-        n.callee.property.name === 'backspace')) return false;
-      return findFirst(node, n =>
-        n.type === 'LogicalExpression' && n.operator === '||' &&
-        n.left.type === 'MemberExpression' && n.left.property.name === 'meta' &&
-        n.right.type === 'MemberExpression' && n.right.property.name === 'shift') !== null;
-    };
-    const candidates = findAll(ast, isHandleEnterCandidate);
-    assert(candidates.length >= 1, 'Could not find handleEnter function');
-    candidates.sort((a, b) => (a.end - a.start) - (b.end - b.start));
-    const handleEnterFn = candidates[0];
-
-    // Discover minified variable names
-
-    // key variable: from key.meta || key.shift
-    const metaOrShift = findFirst(handleEnterFn, n =>
-      n.type === 'LogicalExpression' && n.operator === '||' &&
-      n.left.type === 'MemberExpression' && n.left.property.name === 'meta' &&
-      n.right.type === 'MemberExpression' && n.right.property.name === 'shift');
-    const keyVar = src(metaOrShift.left.object);
-
-    // if-statement that tests meta||shift
-    const metaShiftIf = findFirst(handleEnterFn, n => {
-      if (n.type !== 'IfStatement') return false;
-      const t = n.test;
-      return t.type === 'LogicalExpression' && t.operator === '||' &&
-        t.left.type === 'MemberExpression' && t.left.property.name === 'meta' &&
-        t.right.type === 'MemberExpression' && t.right.property.name === 'shift';
-    });
-    assert(metaShiftIf, 'Could not find if-statement for meta||shift');
-
-    // cursor variable: from cursor.insert('\n') (where cursor is a plain Identifier)
-    const isNewlineArg = (n) =>
-      (n.type === 'Literal' && n.value === '\n') ||
-      (n.type === 'TemplateLiteral' && n.expressions.length === 0 &&
-       n.quasis.length === 1 && n.quasis[0].value.cooked === '\n');
-    const cursorInserts = findAll(handleEnterFn, n =>
-      n.type === 'CallExpression' &&
-      n.callee.type === 'MemberExpression' &&
-      n.callee.object.type === 'Identifier' &&
-      n.callee.property.name === 'insert' &&
-      n.arguments.length === 1 && isNewlineArg(n.arguments[0]));
-    assert(cursorInserts.length >= 1, 'Could not find cursor.insert("\\n") in handleEnter');
-    const cursorVar = cursorInserts[0].callee.object.name;
-
-    // onSubmit?.(originalValue): last statement in handleEnter body
-    const bodyStmts = handleEnterFn.body.body;
-    const lastStmt = bodyStmts[bodyStmts.length - 1];
-    assert(
-      lastStmt.type === 'ExpressionStatement',
-      'Last statement of handleEnter is not an ExpressionStatement',
-    );
-    const onSubmitCallSrc = src(lastStmt.expression);
-
-    // Apple Terminal if-block
-    const appleTerminalIf = findFirst(handleEnterFn, n => {
-      if (n.type !== 'IfStatement') return false;
-      return findFirst(n.test, t => t.type === 'Literal' && t.value === 'Apple_Terminal') !== null;
-    });
-
-    // ── Apply edits (editor applies in reverse position order) ───────
-
-    // 2d: Replace fallthrough onSubmit with return cursor (no-op).
-    editor.replaceRange(lastStmt.start, lastStmt.end, `return ${cursorVar}`);
-
-    // 2c: Remove Apple Terminal if-block — no longer needed.
-    //     Meta/Option works natively in Apple Terminal (sends ESC+CR when
-    //     "Use Option as Meta Key" is enabled via /terminal-setup).
-    //     Plain Enter newlines go through the keybinding system.
-    if (appleTerminalIf) {
-      editor.replaceRange(appleTerminalIf.start, appleTerminalIf.end, '');
-    }
-
-    // 2b: Replace meta||shift block. Now: Meta+Enter (Option+Enter) → submit,
-    //     Shift+Enter → newline (for CSI u terminals), plain Enter → no-op.
-    //     Meta+Enter is the only reliable modifier+Enter across all terminals
-    //     because it sends ESC+CR — a distinct sequence. Ctrl+Enter and
-    //     Shift+Enter send the same byte as plain Enter in most terminals.
-    editor.replaceRange(metaShiftIf.start, metaShiftIf.end,
-      `if(${keyVar}.meta){${onSubmitCallSrc};return}` +
-      `if(${keyVar}.shift)return ${cursorVar}.insert("\\n");`);
-
-    // ── Patch 3: Tip text ────────────────────────────────────────────
-
-    const shiftEnterTip = findFirst(ast, n =>
-      n.type === 'Literal' && n.value === 'Press Shift+Enter to send a multi-line message');
-    if (shiftEnterTip) {
-      editor.replaceRange(shiftEnterTip.start, shiftEnterTip.end,
-        '"Press Option+Enter to submit your message"');
-    }
-
-    const optionEnterTip = findFirst(ast, n =>
-      n.type === 'Literal' && n.value === 'Press Option+Enter to send a multi-line message');
-    if (optionEnterTip) {
-      editor.replaceRange(optionEnterTip.start, optionEnterTip.end,
-        '"Press Option+Enter to submit your message"');
-    }
-
-    // ── Patch 4: Help menu newline instructions ──────────────────────
-
-    for (const val of ['shift + ⏎ for newline', '\\⏎ for newline',
-                        'backslash (\\) + return (⏎) for newline']) {
-      const nodes = findAll(ast, n => n.type === 'Literal' && n.value === val);
-      for (const node of nodes) {
-        editor.replaceRange(node.start, node.end, '"option + ⏎ to send"');
-      }
-    }
-  },
-};

package/setup.js

@@ -1,222 +0,0 @@
-/**
- * Interactive patch configurator.
- * Toggle patches on/off with a keyboard-driven TUI.
- *
- * Called by `cx setup` — not meant to be run directly.
- */
-
-import { readFileSync, writeFileSync, existsSync, 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');
-
-// ── Config persistence ────────────────────────────────────────────────────
-
-function loadConfig() {
-  if (!existsSync(CONFIG_PATH)) return {};
-  try { return JSON.parse(readFileSync(CONFIG_PATH, 'utf-8')); } catch { return {}; }
-}
-
-function saveConfig(patches) {
-  writeFileSync(CONFIG_PATH, JSON.stringify({ patches }, null, 2) + '\n');
-}
-
-// ── Themed groups ────────────────────────────────────────────────────────
-
-const groups = [
-  { label: 'Display', ids: [
-    'always-show-thinking', 'disable-paste-collapse',
-    'show-file-in-collapsed-read', 'cx-badge',
-    'cx-resume-commands', 'random-clawd',
-  ]},
-  { label: 'Input', ids: [
-    'queue', 'swap-enter-submit', 'reload',
-  ]},
-  { label: 'Behavior', ids: [
-    'persist-max-effort', 'no-npm-warning',
-  ]},
-];
-
-// ── State ─────────────────────────────────────────────────────────────────
-
-const patchMap = Object.fromEntries(listPatches().map(p => [p.id, p]));
-
-// Patches that are always on and should not appear in the setup TUI
-const hidden = new Set(['banner']);
-
-// Build ordered list from groups, append any ungrouped patches at the end
-const groupedIds = new Set(groups.flatMap(g => g.ids));
-const ungrouped = listPatches().filter(p => !groupedIds.has(p.id) && !hidden.has(p.id));
-if (ungrouped.length) groups.push({ label: 'Other', ids: ungrouped.map(p => p.id) });
-
-const allPatches = groups.flatMap(g => g.ids.map(id => patchMap[id]).filter(Boolean));
-// sectionStarts[i] = label if patch i starts a new section
-const sectionStarts = {};
-let idx = 0;
-for (const g of groups) {
-  const valid = g.ids.filter(id => patchMap[id]);
-  if (valid.length) { sectionStarts[idx] = g.label; idx += valid.length; }
-}
-
-const config = loadConfig();
-const states = allPatches.map(p =>
-  config.patches?.[p.id] !== undefined ? config.patches[p.id] : (p.defaultEnabled !== false)
-);
-let cursor = 0;
-let dirty = false;
-
-// ── Rendering ─────────────────────────────────────────────────────────────
-
-const ESC = '\x1b';
-const CLEAR = `${ESC}[2J${ESC}[H`;
-const HIDE_CURSOR = `${ESC}[?25l`;
-const SHOW_CURSOR = `${ESC}[?25h`;
-const BOLD = `${ESC}[1m`;
-const DIM = `${ESC}[2m`;
-const RESET = `${ESC}[0m`;
-const GREEN = `${ESC}[32m`;
-const YELLOW = `${ESC}[33m`;
-const CYAN = `${ESC}[36m`;
-const WHITE = `${ESC}[37m`;
-const BG_HIGHLIGHT = `${ESC}[48;5;236m`;
-
-const maxId = Math.max(...allPatches.map(p => p.id.length));
-
-function render() {
-  const rows = process.stdout.rows || 24;
-  const lines = [];
-  const patchLineIndex = [];
-
-  // Header
-  lines.push('');
-  lines.push(`  ${BOLD}${CYAN}cx setup${RESET}  ${DIM}— toggle patches on/off${RESET}`);
-
-  // Patch list with section headers
-  for (let i = 0; i < allPatches.length; i++) {
-    if (sectionStarts[i]) {
-      lines.push('');
-      lines.push(`  ${DIM}${sectionStarts[i]}${RESET}`);
-    }
-
-    const p = allPatches[i];
-    const on = states[i];
-    const sel = i === cursor;
-
-    const bg = sel ? BG_HIGHLIGHT : '';
-    const pointer = sel ? `${bg}${WHITE}❯ ` : `${bg}  `;
-    const checkbox = on ? `${GREEN}✔${RESET}${bg}` : `${DIM}○${RESET}${bg}`;
-    const name = sel ? `${BOLD}${WHITE}${p.id}${RESET}${bg}` : p.id;
-    const pad = ' '.repeat(maxId - p.id.length + 2);
-    const desc = `${DIM}${p.description}${RESET}`;
-
-    patchLineIndex[i] = lines.length;
-    lines.push(`${pointer}${checkbox} ${name}${pad}${desc}${RESET}`);
-  }
-
-  // Footer
-  lines.push('');
-  let footer = `  ${DIM}↑↓${RESET} navigate  ${DIM}space${RESET} toggle  ${DIM}enter${RESET} save  ${DIM}esc${RESET} cancel`;
-  if (dirty) {
-    footer += `    ${YELLOW}● unsaved${RESET}`;
-  }
-  lines.push(footer);
-
-  const prefix = CLEAR + HIDE_CURSOR;
-
-  // Everything fits — render as-is
-  if (lines.length <= rows) {
-    process.stdout.write(prefix + lines.join('\n') + '\n');
-    return;
-  }
-
-  // Scrolling — reserve 2 lines for indicators
-  const usable = Math.max(1, rows - 2);
-  const target = patchLineIndex[cursor];
-  let scrollTop = Math.max(0, target - Math.floor(usable / 2));
-  scrollTop = Math.min(scrollTop, lines.length - usable);
-
-  const visible = lines.slice(scrollTop, scrollTop + usable);
-  const top = scrollTop > 0 ? `  ${DIM}↑ more${RESET}` : '';
-  const bottom = scrollTop + usable < lines.length ? `  ${DIM}↓ more${RESET}` : '';
-
-  process.stdout.write(prefix + top + '\n' + visible.join('\n') + '\n' + bottom + '\n');
-}
-
-// ── Input handling ────────────────────────────────────────────────────────
-
-function cleanup() {
-  process.stdout.write(SHOW_CURSOR + CLEAR);
-  process.stdin.setRawMode(false);
-  process.stdin.pause();
-}
-
-export default function setup() {
-  if (!process.stdin.isTTY) {
-    console.error('cx setup requires an interactive terminal.');
-    process.exit(1);
-  }
-
-  process.stdin.setRawMode(true);
-  process.stdin.resume();
-  process.stdin.setEncoding('utf8');
-
-  process.stdout.on('resize', render);
-  render();
-
-  process.stdin.on('data', (key) => {
-    // Ctrl+C
-    if (key === '\x03') {
-      cleanup();
-      process.exit(0);
-    }
-
-    // ESC
-    if (key === '\x1b' || key === 'q') {
-      cleanup();
-      console.log('  Cancelled — no changes saved.\n');
-      process.exit(0);
-    }
-
-    // Arrow up / k
-    if (key === '\x1b[A' || key === 'k') {
-      cursor = Math.max(0, cursor - 1);
-    }
-
-    // Arrow down / j
-    if (key === '\x1b[B' || key === 'j') {
-      cursor = Math.min(allPatches.length - 1, cursor + 1);
-    }
-
-    // Space — toggle
-    if (key === ' ') {
-      states[cursor] = !states[cursor];
-      dirty = true;
-    }
-
-    // Enter — save and exit
-    if (key === '\r' || key === '\n') {
-      const patches = {};
-      for (let i = 0; i < allPatches.length; i++) {
-        patches[allPatches[i].id] = states[i];
-      }
-      saveConfig(patches);
-      cleanup();
-
-      // Delete cache so next run re-transforms
-      try { rmSync(resolve(__dirname, '.cache'), { recursive: true, force: true }); } catch { /* ok */ }
-
-      console.log(`  ${GREEN}✔${RESET} Config saved to .cx-patches.json\n`);
-      const enabled = allPatches.filter((_, i) => states[i]).map(p => p.id);
-      const disabled = allPatches.filter((_, i) => !states[i]).map(p => p.id);
-      if (enabled.length) console.log(`  ${GREEN}enabled${RESET}  ${enabled.join(', ')}`);
-      if (disabled.length) console.log(`  ${DIM}disabled${RESET} ${disabled.join(', ')}`);
-      console.log(`\n  Run ${BOLD}cx${RESET} to start with these patches.\n`);
-      process.exit(0);
-    }
-
-    render();
-  });
-}

package/transform-worker.js

@@ -1,38 +0,0 @@
-/**
- * Single worker that does all heavy work: parse, index, apply patches.
- * Sends progress messages so the main thread can update the UI.
- *
- * Receives: { source, patchIds, patchesDir }
- * Sends:    { type: 'ready' }             — parse + index done
- *           { type: 'done', id }          — one patch applied
- *           { type: 'complete', patched } — final result
- */
-
-import { workerData, parentPort } from 'worker_threads';
-import * as acorn from 'acorn';
-import { ASTIndex, SourceEditor, buildContext } from './ast.js';
-
-const { source, patchIds, patchesDir } = workerData;
-
-try {
-  const ast = acorn.parse(source, { ecmaVersion: 'latest', sourceType: 'module', allowHashBang: true });
-  const index = new ASTIndex(ast);
-  parentPort.postMessage({ type: 'ready' });
-
-  const editor = new SourceEditor();
-  const ctx = buildContext(source, index, editor);
-
-  for (const id of patchIds) {
-    const mod = await import(`${patchesDir}/${id}.js`);
-    try {
-      mod.default.apply(ctx);
-    } catch (err) {
-      throw new Error(`Patch "${id}" failed: ${err.message}`);
-    }
-    parentPort.postMessage({ type: 'done', id });
-  }
-
-  parentPort.postMessage({ type: 'complete', patched: editor.apply(source) });
-} catch (err) {
-  parentPort.postMessage({ type: 'error', error: err.message });
-}