claude-code-extensions 0.1.0 → 0.1.1

package/dist/types.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Core type definitions for cx — Claude Code Extensions.
+ *
+ * All types used across the framework are defined here to avoid
+ * circular dependencies between modules.
+ */
+import type { ASTIndex } from './ast.js';
+/**
+ * Loose AST node type for patch authors.
+ * Extends acorn positional info with an index signature so ESTree
+ * properties (value, elements, properties, callee, etc.) are
+ * accessible without casts.
+ */
+export interface ASTNode {
+    type: string;
+    start: number;
+    end: number;
+    [key: string]: any;
+}
+/** Possible values of a JS Literal node. */
+export type LiteralValue = string | number | boolean | null | RegExp;
+export interface SourceEdit {
+    pos: number;
+    deleteCount: number;
+    text: string;
+}
+/** Minimal editor interface exposed to patches. */
+export interface PatchEditor {
+    insertAt(pos: number, text: string): void;
+    replaceRange(start: number, end: number, text: string): void;
+}
+export interface FindHelpers {
+    findFirst(root: ASTNode, predicate: (node: ASTNode) => boolean): ASTNode | null;
+    findAll(root: ASTNode, predicate: (node: ASTNode) => boolean): ASTNode[];
+    walkAST: (node: ASTNode) => Generator<ASTNode>;
+}
+export interface QueryHelpers {
+    findArrayWithConsecutiveStrings(root: ASTNode, str1: string, str2: string): ASTNode | null;
+    findObjectWithStringProps(root: ASTNode, propPairs: [string, string][]): ASTNode | null;
+    findHookCallWithObjectKeys(root: ASTNode, hookName: string, keys: string[]): ASTNode | null;
+    findFunctionsContainingStrings(root: ASTNode, ...strings: string[]): ASTNode[];
+    getDestructuredName(objPattern: ASTNode, propKey: string): string | null;
+}
+export interface PatchContext {
+    ast: ASTNode;
+    source: string;
+    editor: PatchEditor;
+    index: ASTIndex;
+    find: FindHelpers;
+    query: QueryHelpers;
+    src(node: ASTNode): string;
+    assert(condition: unknown, message: string): void;
+    getFunctionName(fn: ASTNode): string | null;
+}
+export interface Patch {
+    id: string;
+    name: string;
+    description: string;
+    defaultEnabled?: boolean;
+    apply(ctx: PatchContext): void;
+}
+export interface PatchInfo {
+    id: string;
+    name: string;
+    description: string;
+    defaultEnabled?: boolean;
+}
+export interface WorkerData {
+    source: string;
+    patchIds: string[];
+    patchesDir: string;
+}
+export interface PatchWorkerData {
+    source: string;
+    patchId: string;
+    patchesDir: string;
+}
+export type WorkerMessage = {
+    type: 'ready';
+} | {
+    type: 'done';
+    id: string;
+} | {
+    type: 'complete';
+    patched: string;
+} | {
+    type: 'error';
+    error: string;
+};
+export type PatchWorkerMessage = {
+    type: 'ready';
+} | {
+    type: 'done';
+    edits: SourceEdit[];
+} | {
+    type: 'error';
+    error: string;
+};
+export interface CxConfig {
+    patches: Record<string, boolean>;
+}
+export interface TransformCallbacks {
+    onReady?(): void;
+    onDone?(id: string): void;
+}

package/dist/types.js

@@ -0,0 +1,8 @@
+/**
+ * Core type definitions for cx — Claude Code Extensions.
+ *
+ * All types used across the framework are defined here to avoid
+ * circular dependencies between modules.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/package.json

@@ -1,25 +1,26 @@
 {
   "name": "claude-code-extensions",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "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"
+    "cx": "./dist/cli.js",
+    "cx-setup": "./dist/cli-setup.js"
   },
   "files": [
-    "cx",
-    "cx-setup",
-    "ast.js",
-    "transform.js",
-    "transform-worker.js",
-    "patch-worker.js",
-    "setup.js",
-    "patches/"
+    "dist/"
   ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
   "dependencies": {
     "acorn": "^8.16.0"
   },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  },
   "peerDependencies": {
     "@anthropic-ai/claude-code": "*"
   },
@@ -34,6 +35,10 @@
     "extensions",
     "patches"
   ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/magidandrew/cx"
+  },
   "license": "MIT",
   "engines": {
     "node": ">=18"

package/ast.js

@@ -1,276 +0,0 @@
-/**
- * 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

@@ -1,228 +0,0 @@
-#!/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);
-}