claude-code-extensions 0.1.0

package/ast.js

@@ -0,0 +1,276 @@
+/**
+ * AST indexing and query helpers for cx patches.
+ *
+ * ASTIndex builds lookup tables in a single walk so that subsequent
+ * queries are O(matches) instead of O(all nodes). The generator-based
+ * walkAST is retained for backward compat — some patches iterate it
+ * directly over subtrees.
+ */
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Walk (generator, for direct use by patches)
+// ═══════════════════════════════════════════════════════════════════════════
+
+export function* walkAST(node) {
+  if (!node || typeof node !== 'object') return;
+  if (node.type) yield node;
+  for (const key of Object.keys(node)) {
+    if (key === 'type' || key === 'start' || key === 'end' || key === 'raw') continue;
+    const child = node[key];
+    if (Array.isArray(child)) {
+      for (const item of child) {
+        if (item && typeof item === 'object' && item.type) yield* walkAST(item);
+      }
+    } else if (child && typeof child === 'object' && child.type) {
+      yield* walkAST(child);
+    }
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Index
+// ═══════════════════════════════════════════════════════════════════════════
+
+export class ASTIndex {
+  constructor(ast) {
+    this.ast = ast;
+    this.nodesByType = new Map();
+    this.literalsByValue = new Map();
+    this.parentMap = new WeakMap();
+    /** Pre-order flat list — sorted by start position. */
+    this.allNodes = [];
+    this._build(ast, null);
+  }
+
+  _build(node, parent) {
+    if (!node || typeof node !== 'object' || !node.type) return;
+
+    this.allNodes.push(node);
+    if (parent) this.parentMap.set(node, parent);
+
+    let byType = this.nodesByType.get(node.type);
+    if (!byType) { byType = []; this.nodesByType.set(node.type, byType); }
+    byType.push(node);
+
+    if (node.type === 'Literal' && node.value != null) {
+      let byVal = this.literalsByValue.get(node.value);
+      if (!byVal) { byVal = []; this.literalsByValue.set(node.value, byVal); }
+      byVal.push(node);
+    }
+
+    for (const key of Object.keys(node)) {
+      if (key === 'type' || key === 'start' || key === 'end' || key === 'raw') continue;
+      const child = node[key];
+      if (Array.isArray(child)) {
+        for (const item of child) this._build(item, node);
+      } else {
+        this._build(child, node);
+      }
+    }
+  }
+
+  // ── Generic queries ────────────────────────────────────────────────────
+
+  findFirst(root, predicate) {
+    if (!root || root === this.ast) {
+      for (const n of this.allNodes) if (predicate(n)) return n;
+      return null;
+    }
+    const lo = this._lowerBound(root.start);
+    for (let i = lo; i < this.allNodes.length; i++) {
+      const n = this.allNodes[i];
+      if (n.start >= root.end) break;
+      if (n.end <= root.end && predicate(n)) return n;
+    }
+    return null;
+  }
+
+  findAll(root, predicate) {
+    const results = [];
+    if (!root || root === this.ast) {
+      for (const n of this.allNodes) if (predicate(n)) results.push(n);
+      return results;
+    }
+    const lo = this._lowerBound(root.start);
+    for (let i = lo; i < this.allNodes.length; i++) {
+      const n = this.allNodes[i];
+      if (n.start >= root.end) break;
+      if (n.end <= root.end && predicate(n)) results.push(n);
+    }
+    return results;
+  }
+
+  // ── Specialized queries (indexed) ──────────────────────────────────────
+
+  findArrayWithConsecutiveStrings(root, str1, str2) {
+    for (const lit of this._inRange(this.literalsByValue.get(str1), root)) {
+      const parent = this.parentMap.get(lit);
+      if (!parent || parent.type !== 'ArrayExpression') continue;
+      const idx = parent.elements.indexOf(lit);
+      if (idx >= 0 && idx < parent.elements.length - 1) {
+        const next = parent.elements[idx + 1];
+        if (next?.type === 'Literal' && next.value === str2) return parent;
+      }
+    }
+    return null;
+  }
+
+  findObjectWithStringProps(root, propPairs) {
+    let bestVal = propPairs[0][1], bestCount = Infinity;
+    for (const [, v] of propPairs) {
+      const c = (this.literalsByValue.get(v) || []).length;
+      if (c < bestCount) { bestVal = v; bestCount = c; }
+    }
+    for (const lit of this._inRange(this.literalsByValue.get(bestVal), root)) {
+      let obj = this.parentMap.get(lit);
+      if (obj?.type === 'Property') obj = this.parentMap.get(obj);
+      if (!obj || obj.type !== 'ObjectExpression') continue;
+      if (propPairs.every(([key, value]) =>
+        obj.properties.some(prop => {
+          if (prop.type !== 'Property') return false;
+          const kMatch = (prop.key.type === 'Identifier' && prop.key.name === key) ||
+                         (prop.key.type === 'Literal' && prop.key.value === key);
+          return kMatch && prop.value.type === 'Literal' && prop.value.value === value;
+        })
+      )) return obj;
+    }
+    return null;
+  }
+
+  findHookCallWithObjectKeys(root, hookName, keys) {
+    for (const node of this._inRange(this.nodesByType.get('CallExpression'), root)) {
+      const c = node.callee;
+      if (c.type !== 'MemberExpression' || c.property.name !== hookName) continue;
+      const firstArg = node.arguments[0];
+      if (!firstArg) continue;
+      for (const obj of this._inRange(this.nodesByType.get('ObjectExpression'), firstArg)) {
+        if (keys.every(k => obj.properties.some(p =>
+          p.type === 'Property' &&
+          ((p.key.type === 'Literal' && p.key.value === k) || (p.key.type === 'Identifier' && p.key.name === k))
+        ))) return node;
+      }
+    }
+    return null;
+  }
+
+  findFunctionsContainingStrings(root, ...strings) {
+    let rarest = strings[0];
+    let rarestCount = (this.literalsByValue.get(rarest) || []).length;
+    for (let i = 1; i < strings.length; i++) {
+      const count = (this.literalsByValue.get(strings[i]) || []).length;
+      if (count < rarestCount) { rarest = strings[i]; rarestCount = count; }
+    }
+    const seen = new Set();
+    const results = [];
+    for (const lit of this._inRange(this.literalsByValue.get(rarest), root)) {
+      const fn = this.enclosingFunction(lit);
+      if (!fn || seen.has(fn)) continue;
+      seen.add(fn);
+      if (strings.every(s =>
+        (this.literalsByValue.get(s) || []).some(l => l.start >= fn.start && l.end <= fn.end)
+      )) results.push(fn);
+    }
+    return results;
+  }
+
+  getDestructuredName(objPattern, propKey) {
+    for (const prop of objPattern.properties) {
+      if (prop.type === 'RestElement') continue;
+      const k = prop.key;
+      if ((k.type === 'Identifier' && k.name === propKey) || (k.type === 'Literal' && k.value === propKey)) {
+        if (prop.value.type === 'Identifier') return prop.value.name;
+        if (prop.value.type === 'AssignmentPattern' && prop.value.left.type === 'Identifier') return prop.value.left.name;
+      }
+    }
+    return null;
+  }
+
+  // ── Internal helpers ───────────────────────────────────────────────────
+
+  _inRange(nodes, root) {
+    if (!nodes) return [];
+    if (!root || root === this.ast) return nodes;
+    return nodes.filter(n => n.start >= root.start && n.end <= root.end);
+  }
+
+  _lowerBound(target) {
+    let lo = 0, hi = this.allNodes.length;
+    while (lo < hi) {
+      const mid = (lo + hi) >> 1;
+      if (this.allNodes[mid].start < target) lo = mid + 1; else hi = mid;
+    }
+    return lo;
+  }
+
+  /** Walk up the parent chain to find the nearest ancestor of a given type. */
+  ancestor(node, type) {
+    let current = this.parentMap.get(node);
+    while (current) {
+      if (current.type === type) return current;
+      current = this.parentMap.get(current);
+    }
+    return null;
+  }
+
+  enclosingFunction(node) {
+    let current = this.parentMap.get(node);
+    while (current) {
+      if (current.type === 'FunctionDeclaration' || current.type === 'FunctionExpression' || current.type === 'ArrowFunctionExpression') return current;
+      current = this.parentMap.get(current);
+    }
+    return null;
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Source Editor
+// ═══════════════════════════════════════════════════════════════════════════
+
+export class SourceEditor {
+  constructor() { this.edits = []; }
+  insertAt(pos, text) { this.edits.push({ pos, deleteCount: 0, text }); }
+  replaceRange(start, end, text) { this.edits.push({ pos: start, deleteCount: end - start, text }); }
+  apply(src) {
+    const sorted = [...this.edits].sort((a, b) => b.pos - a.pos);
+    let result = src;
+    for (const edit of sorted) {
+      result = result.slice(0, edit.pos) + edit.text + result.slice(edit.pos + edit.deleteCount);
+    }
+    return result;
+  }
+}
+
+/**
+ * Build the standard patch context from source + AST index + editor.
+ * Shared by transform.js (sequential) and patch-worker.js (parallel).
+ */
+export function buildContext(source, index, editor) {
+  return {
+    ast: index.ast,
+    source,
+    editor,
+    index,
+    find: {
+      findFirst: (root, pred) => index.findFirst(root, pred),
+      findAll: (root, pred) => index.findAll(root, pred),
+      walkAST,
+    },
+    query: {
+      findArrayWithConsecutiveStrings: (root, s1, s2) => index.findArrayWithConsecutiveStrings(root, s1, s2),
+      findObjectWithStringProps: (root, pp) => index.findObjectWithStringProps(root, pp),
+      findHookCallWithObjectKeys: (root, hn, keys) => index.findHookCallWithObjectKeys(root, hn, keys),
+      findFunctionsContainingStrings: (root, ...strings) => index.findFunctionsContainingStrings(root, ...strings),
+      getDestructuredName: (obj, key) => index.getDestructuredName(obj, key),
+    },
+    src: node => source.slice(node.start, node.end),
+    assert(cond, msg) {
+      if (!cond) throw new Error(`transform: ${msg}`);
+    },
+    getFunctionName(fn) {
+      if (fn.type === 'FunctionDeclaration' && fn.id) return fn.id.name;
+      const before = source.slice(Math.max(0, fn.start - 100), fn.start);
+      const m = before.match(/(?:^|[,;{}\s])(\w+)\s*=\s*$/);
+      return m ? m[1] : null;
+    },
+  };
+}

package/cx

@@ -0,0 +1,228 @@
+#!/usr/bin/env node
+/**
+ * cx — Claude Code Extensions
+ *
+ * Drop-in replacement for `claude`. Applies enabled patches at runtime
+ * via AST transformation. The original cli.js is never modified.
+ * All arguments pass through to claude untouched.
+ *
+ * Subcommands:
+ *   cx setup    — interactive patch configurator
+ *   cx list     — show patch status
+ *   cx reload   — signal a running cx instance to reload Claude
+ *   cx [args]   — run patched Claude (with auto-reload support)
+ *
+ * Reload: type `! cx reload` inside Claude to restart the session
+ * with fresh patches applied. The conversation resumes via --continue.
+ */
+
+import { existsSync, readFileSync, writeFileSync, statSync, mkdirSync, unlinkSync } from 'fs';
+import { execSync, spawn as nodeSpawn } from 'child_process';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { transformAsync, listPatches } from './transform.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const CONFIG_PATH = resolve(__dirname, '.cx-patches.json');
+const cacheDir = resolve(__dirname, '.cache');
+const cachedCliPath = resolve(cacheDir, 'cli.mjs');
+const metaPath = resolve(cacheDir, 'meta.json');
+const PID_FILE = resolve(__dirname, '.cx-pid');
+const RELOAD_EXIT_CODE = 75;
+
+// ── Subcommands (fast path, before any heavy work) ───────────────────────
+
+const sub = process.argv[2];
+
+if (sub === 'reload') {
+  try {
+    const pid = parseInt(readFileSync(PID_FILE, 'utf-8').trim(), 10);
+    process.kill(pid, 'SIGUSR1');
+    process.stderr.write('\x1b[2mcx: reload signal sent\x1b[0m\n');
+  } catch (e) {
+    const msg = e.code === 'ENOENT' ? 'no cx instance running'
+      : e.code === 'ESRCH' ? 'cx process not running'
+      : e.message;
+    process.stderr.write(`cx reload: ${msg}\n`);
+    process.exit(1);
+  }
+  process.exit(0);
+}
+
+// ── Config ───────────────────────────────────────────────────────────────
+
+function loadConfig() {
+  if (!existsSync(CONFIG_PATH)) return null;
+  try { return JSON.parse(readFileSync(CONFIG_PATH, 'utf-8')); } catch { return null; }
+}
+
+function getEnabledPatches() {
+  const config = loadConfig();
+  const all = listPatches();
+  if (!config?.patches) return all.map(p => p.id);
+  return all.filter(p => {
+    if (p.id in config.patches) return config.patches[p.id] !== false;
+    return p.defaultEnabled !== false;
+  }).map(p => p.id);
+}
+
+if (sub === 'list') {
+  const all = listPatches();
+  const enabled = getEnabledPatches();
+  for (const p of all) {
+    const on = enabled.includes(p.id);
+    process.stdout.write(`  ${on ? '\x1b[32m✓\x1b[0m' : '\x1b[90m✗\x1b[0m'} ${p.id} — ${p.description ?? p.name}\n`);
+  }
+  process.exit(0);
+}
+
+if (sub === 'setup') {
+  await import('./setup.js');
+  process.exit(0);
+}
+
+// ── First run ────────────────────────────────────────────────────────────
+
+if (!existsSync(CONFIG_PATH)) {
+  process.stderr.write('\x1b[2mcx: first run — all patches enabled. run cx setup to configure.\x1b[0m\n');
+}
+
+// ── Locate cli.js ────────────────────────────────────────────────────────
+
+let cliPath;
+try {
+  const npmRoot = execSync('npm root -g', { encoding: 'utf-8' }).trim();
+  cliPath = resolve(npmRoot, '@anthropic-ai/claude-code/cli.js');
+} catch { /* fallthrough */ }
+
+if (!cliPath || !existsSync(cliPath)) {
+  console.error('cx: could not find @anthropic-ai/claude-code. Install it:');
+  console.error('  npm install -g @anthropic-ai/claude-code');
+  process.exit(1);
+}
+
+// ── Cache ────────────────────────────────────────────────────────────────
+
+async function ensureCache() {
+  const enabled = getEnabledPatches();
+  const stat = statSync(cliPath);
+  const key = `${stat.size}:${stat.mtimeMs}:${[...enabled].sort().join(',')}`;
+
+  let valid = false;
+  if (existsSync(cachedCliPath) && existsSync(metaPath)) {
+    try { valid = JSON.parse(readFileSync(metaPath, 'utf-8')).key === key; } catch {}
+  }
+
+  if (!valid) {
+    const t0 = performance.now();
+    const total = enabled.length;
+
+    // Line 0: prepare with elapsed timer, Lines 1..N: patch checklist
+    process.stderr.write(`\x1b[2m  ◇ preparing (0s)\x1b[0m\n`);
+    for (const id of enabled) {
+      process.stderr.write(`\x1b[2m  ◻ ${id}\x1b[0m\n`);
+    }
+
+    const timer = setInterval(() => {
+      const elapsed = ((performance.now() - t0) / 1000).toFixed(1);
+      const up = total + 1;
+      process.stderr.write(`\x1b[${up}A\r\x1b[2m  ◇ preparing (${elapsed}s)\x1b[0m\x1b[K\x1b[${up}B\r`);
+    }, 100);
+
+    const original = readFileSync(cliPath, 'utf-8');
+    const patched = await transformAsync(original, enabled, {
+      onReady() {
+        clearInterval(timer);
+        const up = total + 1;
+        const elapsed = ((performance.now() - t0) / 1000).toFixed(1);
+        process.stderr.write(`\x1b[${up}A\r\x1b[2m  ◇ ready (${elapsed}s)\x1b[0m\x1b[K\x1b[${up}B\r`);
+      },
+      onDone(id) {
+        const idx = enabled.indexOf(id);
+        const up = total - idx;
+        process.stderr.write(`\x1b[${up}A\r\x1b[32m  ✔ ${id}\x1b[0m\x1b[K\x1b[${up}B\r`);
+      },
+    });
+
+    // Replace prepare line with summary
+    const up = total + 1;
+    process.stderr.write(`\x1b[${up}A\r\x1b[2m  ◆ ${total} patches applied (${((performance.now() - t0) / 1000).toFixed(1)}s)\x1b[0m\x1b[K\x1b[${up}B\r`);
+
+    mkdirSync(cacheDir, { recursive: true });
+    writeFileSync(cachedCliPath, patched);
+    writeFileSync(metaPath, JSON.stringify({ key, ts: new Date().toISOString() }));
+  }
+}
+
+// ── PID file ─────────────────────────────────────────────────────────────
+
+writeFileSync(PID_FILE, String(process.pid));
+function cleanPid() { try { unlinkSync(PID_FILE); } catch {} }
+process.on('exit', cleanPid);
+
+// ── Reload loop ──────────────────────────────────────────────────────────
+
+let child = null;
+let shouldReload = false;
+
+process.on('SIGUSR1', () => {
+  shouldReload = true;
+  if (child) child.kill('SIGTERM');
+});
+
+// Let child handle Ctrl+C — don't let it kill the wrapper
+process.on('SIGINT', () => {
+  if (!child) { cleanPid(); process.exit(130); }
+});
+
+process.on('SIGTERM', () => {
+  if (child) child.kill('SIGTERM');
+  cleanPid();
+  process.exit(143);
+});
+
+/**
+ * Build args for a reload: strip --continue/--resume, prepend --continue.
+ */
+function reloadArgs(original) {
+  const skip = new Set(['--continue', '-c', '--resume', '-r']);
+  const result = ['--continue'];
+  for (let i = 0; i < original.length; i++) {
+    if (skip.has(original[i])) {
+      // --resume/-r may have an optional value; skip it too
+      if ((original[i] === '--resume' || original[i] === '-r') &&
+          i + 1 < original.length && !original[i + 1].startsWith('-')) {
+        i++;
+      }
+      continue;
+    }
+    result.push(original[i]);
+  }
+  return result;
+}
+
+const userArgs = process.argv.slice(2);
+let isReload = false;
+
+while (true) {
+  await ensureCache();
+
+  const args = isReload ? reloadArgs(userArgs) : userArgs;
+
+  child = nodeSpawn(process.execPath, [cachedCliPath, ...args], {
+    stdio: 'inherit',
+    env: process.env,
+  });
+
+  const code = await new Promise(r => child.on('close', (c) => r(c)));
+  child = null;
+
+  if (shouldReload || code === RELOAD_EXIT_CODE) {
+    shouldReload = false;
+    isReload = true;
+    process.stderr.write('\n\x1b[2mcx: reloading…\x1b[0m\n');
+    continue;
+  }
+
+  process.exit(code ?? 0);
+}

package/cx-setup

@@ -0,0 +1,101 @@
+#!/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/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "claude-code-extensions",
+  "version": "0.1.0",
+  "description": "Modular, opt-in patches for @anthropic-ai/claude-code applied at runtime via AST transformation",
+  "type": "module",
+  "bin": {
+    "cx": "./cx",
+    "cx-setup": "./cx-setup"
+  },
+  "files": [
+    "cx",
+    "cx-setup",
+    "ast.js",
+    "transform.js",
+    "transform-worker.js",
+    "patch-worker.js",
+    "setup.js",
+    "patches/"
+  ],
+  "dependencies": {
+    "acorn": "^8.16.0"
+  },
+  "peerDependencies": {
+    "@anthropic-ai/claude-code": "*"
+  },
+  "peerDependenciesMeta": {
+    "@anthropic-ai/claude-code": {
+      "optional": true
+    }
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "extensions",
+    "patches"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  }
+}

package/patch-worker.js

@@ -0,0 +1,31 @@
+/**
+ * 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 });
+}