claude-code-extensions 0.1.0 → 0.1.1

package/patches/disable-paste-collapse.js

@@ -1,52 +0,0 @@
-/**
- * Disable Paste Collapse
- *
- * Prevents pasted text from being collapsed into "[Pasted text #N +X lines]"
- * placeholders. All pasted content is inserted inline so you can review and
- * edit it before submitting.
- *
- * Addresses: https://github.com/anthropics/claude-code/issues/23134 (77 👍)
- *
- * Strategy: find the paste-collapse condition in onTextPaste() — identified
- * by the call to formatPastedTextRef (Xd8) which contains the stable string
- * literal "Pasted text #" — and replace the guard condition with `false`.
- */
-
-export default {
-  id: 'disable-paste-collapse',
-  name: 'Disable Paste Collapse',
-  description: 'Show pasted text inline instead of collapsing into [Pasted text #N]',
-
-  apply(ctx) {
-    const { ast, editor, find, src, assert } = ctx;
-    const { findFirst } = find;
-
-    // Find the formatPastedTextRef function by its "Pasted text #" template literal.
-    const fmtFn = findFirst(ast, n =>
-      n.type === 'FunctionDeclaration' &&
-      src(n).includes('Pasted text #'));
-    assert(fmtFn, 'Could not find formatPastedTextRef function');
-    const fmtName = fmtFn.id.name; // e.g. "Xd8"
-
-    // Find the onTextPaste function: contains a call to formatPastedTextRef
-    // and an if-statement whose consequent calls it.
-    // We look for the IfStatement whose consequent block contains a call
-    // to fmtName — that's the collapse gate.
-    const collapseIf = findFirst(ast, n => {
-      if (n.type !== 'IfStatement') return false;
-      // The consequent must contain a call to fmtName
-      const hasFmtCall = findFirst(n.consequent, c =>
-        c.type === 'CallExpression' &&
-        c.callee.type === 'Identifier' &&
-        c.callee.name === fmtName);
-      if (!hasFmtCall) return false;
-      // The alternate should insert text directly (else branch)
-      return n.alternate !== null;
-    });
-    assert(collapseIf, 'Could not find paste-collapse if-statement');
-
-    // Replace the test expression with `false`
-    const test = collapseIf.test;
-    editor.replaceRange(test.start, test.end, 'false');
-  },
-};

package/patches/disable-telemetry.js

@@ -1,84 +0,0 @@
-/**
- * Disable Telemetry Patch
- *
- * Strips Datadog and 1P (first-party) analytics calls.
- *
- * Three surgical cuts:
- * 1. Kill the analytics sink — logEvent() queues forever, nothing drains
- * 2. Noop Datadog HTTP flush + blank endpoint — no POST to Datadog
- * 3. Noop 1P event logging init — prevents exporter + retry of old events
- */
-
-export default {
-  id: 'disable-telemetry',
-  name: 'Disable Telemetry',
-  description: 'Strip Datadog and 1P analytics calls',
-
-  apply(ctx) {
-    const { ast, editor, find, query, assert } = ctx;
-    const { findFirst } = find;
-
-    // ── 1. Kill the analytics sink ───────────────────────────────────────
-    // initializeAnalyticsSink() calls attachAnalyticsSink({logEvent, logEventAsync}).
-    // Replace that call with void 0 so the sink never attaches. Without a
-    // sink, logEvent() just pushes to an internal queue that never drains —
-    // neither Datadog nor 1P receives anything.
-    //
-    // Marker: object literal with preserved keys "logEvent" + "logEventAsync"
-    // passed as sole argument to a call expression.
-
-    const sinkCall = findFirst(ast, n => {
-      if (n.type !== 'CallExpression' || n.arguments.length !== 1) return false;
-      const arg = n.arguments[0];
-      if (arg.type !== 'ObjectExpression') return false;
-      const keys = arg.properties
-        .filter(p => p.type === 'Property')
-        .map(p => p.key.name || p.key.value);
-      return keys.includes('logEvent') && keys.includes('logEventAsync');
-    });
-    assert(sinkCall, 'Could not find attachAnalyticsSink({logEvent, logEventAsync})');
-    editor.replaceRange(sinkCall.start, sinkCall.end, 'void 0');
-
-    // ── 2. Noop Datadog HTTP flush + blank endpoint ─────────────────────
-    // shutdownDatadog() calls flushLogs() on exit, which would POST
-    // whatever's in logBatch. Insert early return to prevent any HTTP call.
-    //
-    // Marker: "DD-API-KEY" header string. Take the smallest zero-param
-    // function containing it (flushLogs, not a module wrapper).
-
-    const ddCandidates = query.findFunctionsContainingStrings(ast, 'DD-API-KEY');
-    const flushFns = ddCandidates
-      .filter(fn => fn.params.length === 0)
-      .sort((a, b) => (a.end - a.start) - (b.end - b.start));
-    assert(flushFns.length >= 1, 'Could not find Datadog flushLogs function');
-    const flushBody = flushFns[0].body;
-    assert(flushBody.type === 'BlockStatement', 'flushLogs: expected block body');
-    editor.insertAt(flushBody.start + 1, 'return;');
-
-    // Blank the endpoint URL as extra safety (token is not a plain literal
-    // in the bundle, so we target the URL instead).
-    const endpointLit = findFirst(ast, n =>
-      n.type === 'Literal' &&
-      n.value === 'https://http-intake.logs.us5.datadoghq.com/api/v2/logs');
-    assert(endpointLit, 'Could not find Datadog endpoint URL');
-    editor.replaceRange(endpointLit.start, endpointLit.end, '""');
-
-    // ── 3. Noop 1P event logging init ───────────────────────────────────
-    // Prevents the OpenTelemetry exporter from being created, which also
-    // stops retryPreviousBatches from re-sending old failed events.
-    //
-    // Marker: "com.anthropic.claude_code.events" instrumentation scope.
-    // Take the smallest zero-param function containing it.
-
-    const init1PCandidates = query.findFunctionsContainingStrings(
-      ast, 'com.anthropic.claude_code.events');
-    const init1PFns = init1PCandidates
-      .filter(fn => fn.params.length === 0)
-      .sort((a, b) => (a.end - a.start) - (b.end - b.start));
-    assert(init1PFns.length >= 1, 'Could not find initialize1PEventLogging');
-    const init1PBody = init1PFns[0].body;
-    assert(init1PBody.type === 'BlockStatement',
-      'initialize1PEventLogging: expected block body');
-    editor.insertAt(init1PBody.start + 1, 'return;');
-  },
-};

package/patches/no-attribution.js

@@ -1,55 +0,0 @@
-/**
- * No Attribution Patch
- *
- * Strips all Claude Code attribution from commits and PRs:
- *   - Removes "Co-Authored-By: <model> <noreply@anthropic.com>" from commits
- *   - Removes "🤖 Generated with Claude Code" from PR descriptions
- *   - Removes enhanced attribution ("X% N-shotted by ...") from PRs
- *
- * Works by patching getAttributionTexts() and getEnhancedPRAttribution()
- * to return empty strings, which the prompt templates already handle
- * gracefully via ternary guards.
- */
-
-export default {
-  id: 'no-attribution',
-  name: 'No Attribution',
-  description: 'Strip Claude Code attribution from commits and PRs',
-
-  apply(ctx) {
-    const { ast, editor, find, index, assert } = ctx;
-
-    // ── getAttributionTexts ──────────────────────────────────────────
-    // Returns { commit: "Co-Authored-By: ...", pr: "🤖 Generated..." }
-    // Find via TemplateLiteral quasis containing "noreply@anthropic.com"
-
-    const noreplyQuasi = find.findFirst(ast, n =>
-      n.type === 'TemplateElement' &&
-      n.value?.cooked?.includes('noreply@anthropic.com'));
-    assert(noreplyQuasi, 'Could not find TemplateElement with noreply@anthropic.com');
-
-    const getAttrTexts = index.enclosingFunction(noreplyQuasi);
-    assert(getAttrTexts, 'Could not find enclosing function for noreply quasi');
-    assert(getAttrTexts.body.type === 'BlockStatement',
-      'getAttributionTexts body is not a BlockStatement');
-
-    // Insert early return at start of function body
-    editor.insertAt(getAttrTexts.body.start + 1, 'return{commit:"",pr:""};');
-
-    // ── getEnhancedPRAttribution ─────────────────────────────────────
-    // Returns "🤖 Generated with Claude Code (X% N-shotted by ...)"
-    // Find via the unique debug string literal it contains
-
-    const enhancedFns = index.findFunctionsContainingStrings(
-      ast, 'PR Attribution: returning default (no data)');
-    assert(enhancedFns.length >= 1,
-      'Could not find getEnhancedPRAttribution (PR Attribution debug string)');
-
-    const getEnhanced = enhancedFns[0];
-    assert(getEnhanced.body.type === 'BlockStatement',
-      'getEnhancedPRAttribution body is not a BlockStatement');
-
-    // Insert early return (async fn, so return "" resolves to Promise<"">)
-    editor.insertAt(getEnhanced.body.start + 1, 'return"";');
-  },
-};

package/patches/no-npm-warning.js

@@ -1,32 +0,0 @@
-/**
- * No NPM Warning Patch
- *
- * Suppresses the "Claude Code has switched from npm to native installer"
- * notification that appears on every startup for npm installs.
- */
-
-export default {
-  id: 'no-npm-warning',
-  name: 'No NPM Warning',
-  description: 'Suppress the "switched from npm to native installer" nag',
-
-  apply(ctx) {
-    const { ast, editor, find, assert } = ctx;
-    const { findFirst } = find;
-
-    // Find the ReturnStatement that returns {key:"npm-deprecation-warning",...}
-    const ret = findFirst(ast, n => {
-      if (n.type !== 'ReturnStatement') return false;
-      const arg = n.argument;
-      if (!arg || arg.type !== 'ObjectExpression') return false;
-      return arg.properties.some(p =>
-        p.type === 'Property' &&
-        p.key?.type === 'Identifier' && p.key.name === 'key' &&
-        p.value?.type === 'Literal' && p.value.value === 'npm-deprecation-warning');
-    });
-    assert(ret, 'Could not find return with key:"npm-deprecation-warning"');
-
-    // Replace the entire return statement with `return null`
-    editor.replaceRange(ret.start, ret.end, 'return null');
-  },
-};

package/patches/no-tips.js

@@ -1,29 +0,0 @@
-/**
- * No Tips Patch
- *
- * Removes the "Tip: ..." messages shown in the spinner while Claude
- * is thinking. Neutralises the effectiveTip variable so neither the
- * scheduled tips nor the time-based /clear and /btw tips appear.
- */
-
-export default {
-  id: 'no-tips',
-  name: 'No Tips',
-  description: 'Hide spinner tips',
-
-  apply(ctx) {
-    const { index, editor, assert } = ctx;
-
-    // The effectiveTip computation contains this unique string literal.
-    // Find it and walk up to the VariableDeclarator to replace the init.
-    const marker = 'Use /clear to start fresh when switching topics and free up context';
-    const hits = index.literalsByValue.get(marker) || [];
-    assert(hits.length > 0, `Could not find "${marker}" literal`);
-
-    const lit = hits[0];
-    const decl = index.ancestor(lit, 'VariableDeclarator');
-    assert(decl && decl.init, 'Could not find enclosing VariableDeclarator');
-
-    editor.replaceRange(decl.init.start, decl.init.end, 'void 0');
-  },
-};

package/patches/persist-max-effort.js

@@ -1,70 +0,0 @@
-/**
- * Persist Max Effort Patch
- *
- * The public build strips "max" from toPersistableEffort(), so `/effort max`
- * only lasts for the current session. This patch restores the "max" check
- * so it persists to settings.json and survives restarts.
- *
- * Source (effort.ts):
- *   if (value === 'low' || value === 'medium' || value === 'high' || value === 'max')
- * Bundle (stripped):
- *   if (q === "low" || q === "medium" || q === "high")
- */
-
-export default {
-  id: 'persist-max-effort',
-  name: 'Persist Max Effort',
-  description: 'Save "max" effort to settings so it survives restarts',
-
-  apply(ctx) {
-    const { ast, editor, find, src, assert } = ctx;
-    const { findFirst, findAll } = find;
-
-    // Find the toPersistableEffort function. It's a function whose body has
-    // exactly the pattern: q==="low"||q==="medium"||q==="high"
-    // This is a unique 3-way string comparison in the bundle.
-    const persistFn = findFirst(ast, n => {
-      if (n.type !== 'FunctionDeclaration' && n.type !== 'FunctionExpression' && n.type !== 'ArrowFunctionExpression') return false;
-      // Find the LogicalExpression chain: q==="low" || q==="medium" || q==="high"
-      return findFirst(n, inner => {
-        if (inner.type !== 'LogicalExpression' || inner.operator !== '||') return false;
-        // The rightmost comparison should be q==="high"
-        if (inner.right.type !== 'BinaryExpression') return false;
-        if (inner.right.operator !== '===') return false;
-        if (inner.right.right?.type !== 'Literal' || inner.right.right.value !== 'high') return false;
-        // The left side should be another || with "medium"
-        if (inner.left.type !== 'LogicalExpression' || inner.left.operator !== '||') return false;
-        if (inner.left.right?.type !== 'BinaryExpression') return false;
-        if (inner.left.right.right?.type !== 'Literal' || inner.left.right.right.value !== 'medium') return false;
-        return true;
-      }) !== null;
-    });
-    assert(persistFn, 'Could not find toPersistableEffort function (low||medium||high pattern)');
-
-    // Find the "high" literal in the comparison chain
-    const highLiteral = findFirst(persistFn, n => {
-      if (n.type !== 'BinaryExpression' || n.operator !== '===') return false;
-      return n.right?.type === 'Literal' && n.right.value === 'high';
-    });
-    assert(highLiteral, 'Could not find q==="high" comparison');
-
-    // Get the parameter name (e.g., 'q') from the left side
-    const paramName = highLiteral.left.type === 'Identifier' ? highLiteral.left.name : src(highLiteral.left);
-
-    // Insert ||q==="max" after the q==="high" comparison
-    editor.insertAt(highLiteral.end, `||${paramName}==="max"`);
-
-    // Fix ["low","medium","high"] arrays (Zod schema + EFFORT_LEVELS) that also
-    // strip "max". Without this, settings.json validation silently drops "max"
-    // on read via .catch(undefined).
-    const effortArrays = findAll(ast, n => {
-      if (n.type !== 'ArrayExpression' || n.elements.length !== 3) return false;
-      const vals = n.elements.map(e => e?.type === 'Literal' ? e.value : null);
-      return vals[0] === 'low' && vals[1] === 'medium' && vals[2] === 'high';
-    });
-    assert(effortArrays.length > 0, 'Could not find ["low","medium","high"] arrays to patch');
-    for (const arr of effortArrays) {
-      editor.insertAt(arr.elements[2].end, ',"max"');
-    }
-  },
-};

package/patches/queue.js

@@ -1,215 +0,0 @@
-/**
- * Ctrl+Q Message Queue Patch
- *
- * Adds a "queue" feature: pressing Ctrl+Q enqueues the current input
- * with priority 'later', so it executes FIFO after the current turn
- * completes (one queued command per turn).
- */
-
-export default {
-  id: 'queue',
-  name: 'Ctrl+Q Message Queue',
-  description: 'Queue messages with Ctrl+Q to run sequentially after current turn',
-
-  apply(ctx) {
-    const { ast, editor, find, query, src, assert } = ctx;
-    const { findFirst, findAll } = find;
-    const {
-      findArrayWithConsecutiveStrings,
-      findObjectWithStringProps,
-      findHookCallWithObjectKeys,
-      findFunctionsContainingStrings,
-      getDestructuredName,
-    } = query;
-
-    // ── Variable Discovery ────────────────────────────────────────────
-
-    // chatHandlers useMemo (by string keys in its object)
-    const chatHandlersMemo = findHookCallWithObjectKeys(ast, 'useMemo', [
-      'chat:undo', 'chat:newline', 'chat:stash', 'chat:imagePaste',
-    ]);
-    assert(chatHandlersMemo, 'Could not find chatHandlers useMemo');
-    const R = src(chatHandlersMemo.callee.object); // React namespace
-
-    const handlersObject = findFirst(chatHandlersMemo.arguments[0], n =>
-      n.type === 'ObjectExpression' &&
-      n.properties.some(p => p.type === 'Property' && p.key.type === 'Literal' && p.key.value === 'chat:undo'));
-    assert(handlersObject, 'Could not find handlers object in useMemo');
-
-    const depsArray = chatHandlersMemo.arguments[1];
-    assert(depsArray?.type === 'ArrayExpression', 'Could not find deps array');
-
-    // PromptInput function (by ObjectPattern param with known prop keys)
-    const promptInputFn = findFirst(ast, node => {
-      if (node.type !== 'FunctionDeclaration' && node.type !== 'FunctionExpression') return false;
-      const p = node.params[0];
-      if (!p || p.type !== 'ObjectPattern') return false;
-      return getDestructuredName(p, 'input') !== null &&
-             getDestructuredName(p, 'mode') !== null &&
-             getDestructuredName(p, 'pastedContents') !== null;
-    });
-    assert(promptInputFn, 'Could not find PromptInput component function');
-    const propsPattern = promptInputFn.params[0];
-
-    // Props from destructured parameter (keys preserved in minified code)
-    const v = {};
-    for (const name of ['input', 'mode', 'pastedContents', 'setPastedContents', 'onInputChange']) {
-      v[name] = getDestructuredName(propsPattern, name);
-      assert(v[name], `Could not find "${name}" in props destructuring`);
-    }
-
-    // setCursorOffset — from useState(input.length)
-    const useStateCandidates = findAll(promptInputFn, node => {
-      if (node.type !== 'VariableDeclarator' || node.id.type !== 'ArrayPattern' || node.id.elements.length < 2) return false;
-      const init = node.init;
-      if (!init || init.type !== 'CallExpression' || init.callee.type !== 'MemberExpression' || init.callee.property.name !== 'useState') return false;
-      const arg = init.arguments[0];
-      return arg?.type === 'MemberExpression' && arg.property.name === 'length' && arg.object.name === v.input;
-    });
-    assert(useStateCandidates.length === 1, `Expected 1 useState(${v.input}.length), found ${useStateCandidates.length}`);
-    v.setCursorOffset = useStateCandidates[0].id.elements[1].name;
-
-    // trackAndSetInput — useCallback with deps=[onInputChange]
-    const trackCandidates = findAll(promptInputFn, node => {
-      if (node.type !== 'VariableDeclarator' || node.id.type !== 'Identifier') return false;
-      const init = node.init;
-      if (!init || init.type !== 'CallExpression' || init.callee.type !== 'MemberExpression' || init.callee.property.name !== 'useCallback') return false;
-      const deps = init.arguments[1];
-      if (!deps || deps.type !== 'ArrayExpression' || deps.elements.length !== 1) return false;
-      return deps.elements[0]?.name === v.onInputChange;
-    });
-    assert(trackCandidates.length === 1, `Expected 1 useCallback with deps=[${v.onInputChange}]`);
-    v.trackAndSetInput = trackCandidates[0].id.name;
-
-    // clearBuffer — from useInputBuffer destructuring (key preserved)
-    const clearBufDecls = findAll(promptInputFn, node => {
-      if (node.type !== 'VariableDeclarator' || node.id.type !== 'ObjectPattern') return false;
-      return node.id.properties.some(p => p.type === 'Property' &&
-        ((p.key.type === 'Identifier' && p.key.name === 'clearBuffer') ||
-         (p.key.type === 'Literal' && p.key.value === 'clearBuffer')));
-    });
-    assert(clearBufDecls.length >= 1, 'Could not find clearBuffer destructuring');
-    v.clearBuffer = getDestructuredName(clearBufDecls[0].id, 'clearBuffer');
-
-    // enqueue — function with push({...spread, priority: ?? "next"}) + "enqueue" string
-    const enqueueCandidates = findFunctionsContainingStrings(ast, 'enqueue');
-    const enqueueMatches = enqueueCandidates.filter(fn =>
-      findFirst(fn, n => {
-        if (n.type !== 'CallExpression' || n.callee.type !== 'MemberExpression' || n.callee.property.name !== 'push') return false;
-        const arg = n.arguments[0];
-        if (!arg || arg.type !== 'ObjectExpression') return false;
-        if (!arg.properties.some(p => p.type === 'SpreadElement')) return false;
-        const pp = arg.properties.find(p => p.type === 'Property' && p.key.name === 'priority');
-        return pp?.value.type === 'LogicalExpression' && pp.value.operator === '??' &&
-               pp.value.right.type === 'Literal' && pp.value.right.value === 'next';
-      }) !== null);
-    assert(enqueueMatches.length === 1, `Expected 1 enqueue function, found ${enqueueMatches.length}`);
-    v.enqueue = ctx.getFunctionName(enqueueMatches[0]);
-    assert(v.enqueue, 'Could not determine enqueue function name');
-
-    // expandPastedTextRefs — backward loop + .slice + .type/"text" + .index + .match
-    const expandCandidates = findFunctionsContainingStrings(ast, 'text');
-    const expandMatches = expandCandidates.filter(fn => {
-      if (fn.params.length !== 2) return false;
-      if (!findFirst(fn, n => n.type === 'ForStatement' && n.update?.type === 'UpdateExpression' && n.update.operator === '--')) return false;
-      if (findAll(fn, n => n.type === 'CallExpression' && n.callee.type === 'MemberExpression' && n.callee.property.name === 'slice').length < 2) return false;
-      if (!findFirst(fn, n => n.type === 'MemberExpression' && n.property.name === 'index')) return false;
-      if (!findFirst(fn, n => n.type === 'MemberExpression' && n.property.name === 'match')) return false;
-      return findFirst(fn, n => {
-        if (n.type !== 'BinaryExpression' || (n.operator !== '!==' && n.operator !== '===')) return false;
-        const unwrap = x => x.type === 'ChainExpression' ? x.expression : x;
-        const l = unwrap(n.left), r = unwrap(n.right);
-        return (l.type === 'MemberExpression' && l.property.name === 'type' && n.right.value === 'text') ||
-               (r.type === 'MemberExpression' && r.property.name === 'type' && n.left.value === 'text');
-      }) !== null;
-    });
-    assert(expandMatches.length === 1, `Expected 1 expandPastedTextRefs, found ${expandMatches.length}`);
-    v.expandPastedTextRefs = ctx.getFunctionName(expandMatches[0]);
-    assert(v.expandPastedTextRefs, 'Could not determine expandPastedTextRefs name');
-
-    // ── Patch 1: KEYBINDING_ACTIONS ───────────────────────────────────
-
-    const arr = findArrayWithConsecutiveStrings(ast, 'chat:submit', 'chat:newline');
-    assert(arr, 'Could not find KEYBINDING_ACTIONS array');
-    const el = arr.elements.find(e => e.type === 'Literal' && e.value === 'chat:submit');
-    editor.insertAt(el.end, ',"chat:queue"');
-
-    // ── Patch 2: 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')));
-    editor.insertAt(enterProp.end, ',"ctrl+q":"chat:queue"');
-
-    // ── Patch 3: handleQueue callback + chatHandlers ──────────────────
-
-    const qH = '__qH';
-    const code =
-      `let ${qH}=${R}.useCallback(()=>{` +
-      `let __t=${v.input}.trimEnd();if(__t==="")return;` +
-      `let __f=${v.expandPastedTextRefs}(__t,${v.pastedContents});` +
-      `${v.enqueue}({value:__f,preExpansionValue:__t,mode:${v.mode},` +
-      `priority:"later",pastedContents:Object.values(${v.pastedContents})` +
-      `.some(c=>c.type==="image")?${v.pastedContents}:void 0});` +
-      `${v.trackAndSetInput}(""),${v.setCursorOffset}(0),` +
-      `${v.setPastedContents}({}),${v.clearBuffer}()` +
-      `},[${v.input},${v.pastedContents},${v.mode},${v.trackAndSetInput},` +
-      `${v.setCursorOffset},${v.setPastedContents},${v.clearBuffer}]);`;
-
-    const memoDecl = findFirst(ast, n => n.type === 'VariableDeclaration' && n.declarations.some(d => d.init === chatHandlersMemo));
-    assert(memoDecl, 'Could not find VariableDeclaration for chatHandlers useMemo');
-    editor.insertAt(memoDecl.start, code);
-
-    const lastProp = handlersObject.properties[handlersObject.properties.length - 1];
-    editor.insertAt(lastProp.end, `,"chat:queue":${qH}`);
-
-    const lastDep = depsArray.elements[depsArray.elements.length - 1];
-    editor.insertAt(lastDep.end, `,${qH}`);
-
-    // ── Patch 4: processQueueIfReady ──────────────────────────────────
-
-    const processQueueFn = findFirst(ast, node => {
-      if (node.type !== 'FunctionDeclaration' && node.type !== 'FunctionExpression' && node.type !== 'ArrowFunctionExpression') return false;
-      if (findAll(node, n => n.type === 'Property' && n.key.type === 'Identifier' && n.key.name === 'processed').length < 2) return false;
-      return findFirst(node, n => n.type === 'BinaryExpression' && n.operator === '===' && n.right.type === 'Literal' && n.right.value === 'bash') !== null;
-    });
-    assert(processQueueFn, 'Could not find processQueueIfReady function');
-
-    const ifStmt = findFirst(processQueueFn, node => {
-      if (node.type !== 'IfStatement') return false;
-      return findFirst(node.test, n => n.type === 'BinaryExpression' && n.operator === '===' &&
-        n.left.type === 'MemberExpression' && n.left.property.name === 'mode' &&
-        n.right.type === 'Literal' && n.right.value === 'bash') !== null;
-    });
-    assert(ifStmt, 'Could not find if-statement with .mode === "bash"');
-
-    const bashCheck = findFirst(ifStmt.test, n => n.type === 'BinaryExpression' && n.operator === '===' &&
-      n.left.type === 'MemberExpression' && n.left.property.name === 'mode' && n.right.value === 'bash');
-    const nextVar = src(bashCheck.left.object);
-    editor.insertAt(ifStmt.test.end, `||${nextVar}.priority==="later"`);
-
-    const targetModeDecl = findFirst(processQueueFn, node => {
-      if (node.type !== 'VariableDeclarator' || node.start <= ifStmt.end) return false;
-      return node.init?.type === 'MemberExpression' && node.init.property.name === 'mode' && src(node.init.object) === nextVar;
-    });
-    assert(targetModeDecl, 'Could not find targetMode = next.mode');
-    const targetModeVar = targetModeDecl.id.name;
-    editor.insertAt(targetModeDecl.end, `,__p=${nextVar}.priority??"next"`);
-
-    const dqamCallback = findFirst(processQueueFn, node => {
-      if (node.type !== 'ArrowFunctionExpression' && node.type !== 'FunctionExpression') return false;
-      if (node.start <= ifStmt.end) return false;
-      return findFirst(node, n => n.type === 'BinaryExpression' && n.operator === '===' &&
-        n.left.type === 'MemberExpression' && n.left.property.name === 'mode' &&
-        n.right.type === 'Identifier' && n.right.name === targetModeVar) !== null;
-    });
-    assert(dqamCallback, 'Could not find dequeueAllMatching callback');
-
-    const modeComparison = findFirst(dqamCallback, n => n.type === 'BinaryExpression' && n.operator === '===' &&
-      n.left.type === 'MemberExpression' && n.left.property.name === 'mode' &&
-      n.right.type === 'Identifier' && n.right.name === targetModeVar);
-    const cbParam = dqamCallback.params[0].name;
-    editor.insertAt(modeComparison.end, `&&(${cbParam}.priority??"next")===__p`);
-  },
-};

package/patches/random-clawd.js

@@ -1,52 +0,0 @@
-/**
- * Random Clawd Color Patch
- *
- * Picks a random color for the Clawd mascot on each startup
- * instead of the default orange theme color.
- */
-
-export default {
-  id: 'random-clawd',
-  name: 'Random Clawd Color',
-  description: 'Randomize the Clawd mascot color on each startup',
-
-  apply(ctx) {
-    const { ast, editor, find, assert } = ctx;
-    const { findFirst, findAll } = find;
-
-    // Find the Clawd component: function oM6(q) { ... }
-    // Identified by containing the strings "clawd_body" and "clawd_background"
-    // and the feet characters "▘▘ ▝▝".
-    const clawdFn = findFirst(ast, n => {
-      if (n.type !== 'FunctionDeclaration') return false;
-      let hasClawd = false, hasFeet = false;
-      for (const child of find.walkAST(n.body)) {
-        if (child.type === 'Literal') {
-          if (child.value === 'clawd_body') hasClawd = true;
-          if (child.value === '▘▘ ▝▝') hasFeet = true;
-        }
-      }
-      return hasClawd && hasFeet;
-    });
-    assert(clawdFn, 'Could not find Clawd component function');
-
-    // Inject a random color picker before the function
-    const colors = [
-      '#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4', '#FFEAA7',
-      '#DDA0DD', '#98D8C8', '#F7DC6F', '#BB8FCE', '#85C1E9',
-      '#E74C3C', '#2ECC71', '#3498DB', '#E67E22', '#1ABC9C',
-      '#9B59B6', '#F39C12', '#00BCD4', '#FF5722', '#8BC34A',
-    ];
-    const colorArray = JSON.stringify(colors);
-    editor.insertAt(clawdFn.start,
-      `var __rc=${colorArray}[Math.floor(Math.random()*${colors.length})];`);
-
-    // Replace all "clawd_body" literals within the function with __rc
-    const clawdBodyLiterals = findAll(clawdFn, n =>
-      n.type === 'Literal' && n.value === 'clawd_body');
-
-    for (const lit of clawdBodyLiterals) {
-      editor.replaceRange(lit.start, lit.end, '__rc');
-    }
-  },
-};