claude-depester 1.3.3 → 1.3.5

package/README.md

@@ -4,17 +4,26 @@
 [![npm downloads](https://img.shields.io/npm/dm/claude-depester.svg)](https://www.npmjs.com/package/claude-depester)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-Remove silly thinking words from Claude Code.
+Patches Claude Code CLI and VS Code extension to replace whimsical loading words with simple 'Thinking'.
 
 Instead of seeing "Flibbertigibbeting", "Discombobulating", "Clauding", etc., you'll see a clean "Thinking".
 
-> **Last updated:** 2026-01-18 | **Tested with:** Claude Code 2.1.4 - 2.1.12 | **Platforms:** Linux, macOS, Windows
+> **Last updated:** 2026-01-22 | **Tested with:** Claude Code 2.1.15 | **Platforms:** Linux, macOS, Windows
 >
-> v1.3.3: Added `--debug` and `--log` flags for troubleshooting auto-patch issues ([#3](https://github.com/ominiverdi/claude-depester/issues/3))
+> v1.3.5: Fix VS Code binary completion verbs patching for new bytecode array structure
+
+**CLI - Spinner:**
+
+![Thinking... instead of whimsical words](img/thinking.png)
+
+**CLI - Completion:**
 
-![Thinking... instead of silly words](img/thinking.png)
 ![Thought for Xs instead of Baked/Brewed/etc](img/thought.png)
 
+**VS Code Extension:**
+
+![VS Code extension also patched](img/vscode.png)
+
 ## The Problem
 
 Claude Code displays random silly words while thinking:
@@ -45,12 +54,20 @@ npx claude-depester --dry-run
 
 # Patch Claude Code
 npx claude-depester
+```
 
-# Auto-patch after updates (recommended)
-npx claude-depester --install-hook
+Restart Claude Code for changes to take effect.
+
+### Auto-patch after updates (recommended)
+
+Add a shell wrapper that patches before each invocation:
+
+```bash
+# Add to your .bashrc or .zshrc
+cl() { npx claude-depester --all --silent --log ; claude "$@" ; }
 ```
 
-That's it! Restart Claude Code for changes to take effect.
+Then use `cl` instead of `claude`. This ensures patching happens *before* Claude loads.
 
 ## Features
 
@@ -60,7 +77,7 @@ That's it! Restart Claude Code for changes to take effect.
 - **Patches VS Code/VSCodium extension webview** (the UI that shows spinner text)
 - Auto-detects your Claude Code installation
 - Creates backup before patching (can restore anytime)
-- Optional SessionStart hook for auto-patching after updates
+- Shell wrapper for reliable auto-patching before Claude loads
 - Content-based detection survives version updates
 - Cross-platform: Linux, macOS, Windows (WSL/Git Bash)
 
@@ -117,7 +134,7 @@ The tool auto-detects your installation. Use `--list` to see all found installat
 
 ## After Claude Code Updates
 
-With the hook installed (`--install-hook`), patching happens automatically on startup.
+If you're using the shell wrapper (recommended), patching happens automatically before each session.
 
 Otherwise, just run `npx claude-depester` again after updating.
 
@@ -129,7 +146,9 @@ npx claude-depester --restore
 
 This restores from the backup created during patching.
 
-## How the Hook Works
+## SessionStart Hook (Alternative)
+
+> **Note:** The shell wrapper is the recommended approach. The SessionStart hook has a limitation: it runs *after* Claude is already loaded into memory, so the patch only takes effect on the *next* session after an update.
 
 The `--install-hook` command adds a SessionStart hook to `~/.claude/settings.json`:
 
@@ -150,11 +169,11 @@ The `--install-hook` command adds a SessionStart hook to `~/.claude/settings.jso
 }
 ```
 
-Every time Claude Code starts, it checks and re-applies the patch if needed. The `--log` flag writes results to `~/.claude/depester.log` (keeps last 50 entries) for troubleshooting.
+This patches the file on disk at session start, but the current session may still show silly words until you restart. The `--log` flag writes results to `~/.claude/depester.log` (keeps last 50 entries) for troubleshooting.
 
-> **Note:** If you installed the hook with an older version, reinstall it to get logging:
-> ```bash
-> npx claude-depester --remove-hook && npx claude-depester --install-hook
+To install or update the hook:
+```bash
+npx claude-depester --install-hook
 > ```
 
 ## Troubleshooting
@@ -206,7 +225,8 @@ If the patch fails:
 
 ```bash
 npx claude-depester --restore --all  # Restore all installations
-npx claude-depester --remove-hook    # Remove auto-patch hook
+npx claude-depester --remove-hook    # Remove hook (if installed)
+# Remove the shell wrapper from your .bashrc/.zshrc if added
 ```
 
 ## Technical Details
@@ -269,6 +289,12 @@ This project builds upon work by:
 - [vemv's gist](https://gist.github.com/vemv/c6333d53ede16198a23eb95425051b7b) - Original simple patch idea
 - [heromantf's bun extractor](https://gist.github.com/heromantf/7db88edcb7b1c0c35067244584a01afc) - Bun binary structure documentation
 
+## Donors
+
+Thanks to these generous supporters:
+
+- [@gyohng](https://github.com/gyohng)
+
 ## License
 
 MIT - see [LICENSE](LICENSE)

package/lib/bun-binary.js

@@ -261,14 +261,32 @@ function extractClaudeJs(binaryPath) {
     const binary = LIEF.parse(binaryPath);
     const { bunOffsets, bunData } = getBunData(binary);
     
-    const result = mapModules(bunData, bunOffsets, (module, moduleName) => {
-      if (!isClaudeModule(moduleName)) return undefined;
-      
+    let target = null;
+    
+    mapModules(bunData, bunOffsets, (module, moduleName) => {
+      // Check contents
       const moduleContents = getStringPointerContent(bunData, module.contents);
-      return moduleContents.length > 0 ? moduleContents : undefined;
+      if (moduleContents.includes('Flibbertigibbeting')) {
+        target = { content: moduleContents, moduleName, type: 'contents' };
+        return true;
+      }
+      
+      // Check bytecode (for new versions where source is embedded in bytecode)
+      const moduleBytecode = getStringPointerContent(bunData, module.bytecode);
+      if (moduleBytecode.includes('Flibbertigibbeting')) {
+        target = { content: moduleBytecode, moduleName, type: 'bytecode' };
+        return true;
+      }
+      
+      // Fallback
+      if (isClaudeModule(moduleName) && !target) {
+        target = { content: moduleContents, moduleName, type: 'contents' };
+      }
+      
+      return undefined;
     });
     
-    return result || null;
+    return target;
   } catch (error) {
     return null;
   }
@@ -277,7 +295,7 @@ function extractClaudeJs(binaryPath) {
 /**
  * Rebuild Bun data with modified claude.js
  */
-function rebuildBunData(bunData, bunOffsets, modifiedClaudeJs) {
+function rebuildBunData(bunData, bunOffsets, modifiedClaudeJs, targetModuleName, targetType) {
   // Collect all string data and module metadata
   const stringsData = [];
   const modulesMetadata = [];
@@ -285,16 +303,18 @@ function rebuildBunData(bunData, bunOffsets, modifiedClaudeJs) {
   mapModules(bunData, bunOffsets, (module, moduleName) => {
     const nameBytes = getStringPointerContent(bunData, module.name);
     
-    // Use modified contents for claude module
-    let contentsBytes;
-    if (modifiedClaudeJs && isClaudeModule(moduleName)) {
-      contentsBytes = modifiedClaudeJs;
-    } else {
-      contentsBytes = getStringPointerContent(bunData, module.contents);
+    let contentsBytes = getStringPointerContent(bunData, module.contents);
+    let bytecodeBytes = getStringPointerContent(bunData, module.bytecode);
+    
+    if (modifiedClaudeJs && moduleName === targetModuleName) {
+      if (targetType === 'bytecode') {
+        bytecodeBytes = modifiedClaudeJs;
+      } else {
+        contentsBytes = modifiedClaudeJs;
+      }
     }
     
     const sourcemapBytes = getStringPointerContent(bunData, module.sourcemap);
-    const bytecodeBytes = getStringPointerContent(bunData, module.bytecode);
     
     modulesMetadata.push({
       name: nameBytes,
@@ -503,12 +523,13 @@ function repackPE(peBinary, binaryPath, newBunBuffer, outputPath, sectionHeaderS
 /**
  * Repack native installation with modified claude.js
  */
-function repackNativeInstallation(binaryPath, modifiedClaudeJs, outputPath) {
+function repackNativeInstallation(binaryPath, modifiedClaudeJs, outputPath, targetModuleName, targetType) {
   LIEF.logging.disable();
   const binary = LIEF.parse(binaryPath);
   
   const { bunOffsets, bunData, sectionHeaderSize } = getBunData(binary);
-  const newBuffer = rebuildBunData(bunData, bunOffsets, modifiedClaudeJs);
+  // Pass targetModuleName and targetType
+  const newBuffer = rebuildBunData(bunData, bunOffsets, modifiedClaudeJs, targetModuleName, targetType);
   
   switch (binary.format) {
     case 'MachO':

package/lib/patcher.js

@@ -46,21 +46,26 @@ const COMPLETION_REPLACEMENT = 'Thought';
  */
 function hasSillyWords(content) {
   const str = Buffer.isBuffer(content) ? content.toString('utf-8') : content;
-  
-  // Check for spinner words
-  let found = 0;
+
+  // Check for spinner words (need 3+ matches)
+  let spinnerFound = 0;
   for (const word of MARKER_WORDS) {
     if (str.includes(`"${word}"`)) {
-      found++;
-      if (found >= 3) return true;
+      spinnerFound++;
+      if (spinnerFound >= 3) return true;
     }
   }
-  
-  // Also check for completion verbs (only in binary)
-  if (str.includes('["Baked"')) {
-    return true;
+
+  // Also check for completion verbs (need 3+ matches)
+  // Uses same approach as hasCompletionVerbs for consistency
+  let completionFound = 0;
+  for (const word of COMPLETION_VERBS) {
+    if (str.includes(`"${word}"`)) {
+      completionFound++;
+      if (completionFound >= 3) return true;
+    }
   }
-  
+
   return false;
 }
 
@@ -71,7 +76,12 @@ function hasSillyWords(content) {
  */
 function hasCompletionVerbs(content) {
   const str = Buffer.isBuffer(content) ? content.toString('utf-8') : content;
-  return str.includes('["Baked"') && str.includes('"Worked"]');
+  
+  let found = 0;
+  for (const word of COMPLETION_VERBS) {
+    if (str.includes(`"${word}"`)) found++;
+  }
+  return found >= 3;
 }
 
 /**
@@ -80,10 +90,10 @@ function hasCompletionVerbs(content) {
  * @returns {boolean}
  */
 function isPatched(content) {
-  const str = Buffer.isBuffer(content) ? content.toString('utf-8') : content;
-  const hasReplacement = /=\["Thinking"\]/.test(str);
-  const hasOriginalArray = str.includes('["Accomplishing"') && str.includes('"Zigzagging"]');
-  return hasReplacement && !hasOriginalArray;
+  // If silly words are gone, it's patched.
+  // We don't check for ["Thinking"] presence because newer versions 
+  // include it natively even when unpatched.
+  return !hasSillyWords(content);
 }
 
 /**
@@ -92,10 +102,122 @@ function isPatched(content) {
  * @returns {boolean}
  */
 function isCompletionPatched(content) {
-  const str = Buffer.isBuffer(content) ? content.toString('utf-8') : content;
-  const hasReplacement = /=\["Thought"\]/.test(str);
-  const hasOriginalArray = str.includes('["Baked"') && str.includes('"Worked"]');
-  return hasReplacement && !hasOriginalArray;
+  return !hasCompletionVerbs(content);
+}
+
+/**
+ * Find array boundaries around a marker word in binary content
+ * @param {Buffer} buffer - Binary content
+ * @param {string} markerWord - Word to search for as anchor
+ * @param {string[]} validationWords - Words that should be present in the array
+ * @param {number} minValidationCount - Minimum number of validation words required
+ * @returns {{ startIdx: number, endIdx: number } | null}
+ */
+function findArrayBoundaries(buffer, markerWord, validationWords, minValidationCount) {
+  const marker = Buffer.from(markerWord);
+  const idx = buffer.indexOf(marker);
+
+  if (idx === -1) return null;
+
+  // Scan back for '['
+  let startIdx = idx;
+  const START_LIMIT = 5000;
+  let steps = 0;
+  while (startIdx > 0 && buffer[startIdx] !== 0x5B && steps < START_LIMIT) {
+    startIdx--;
+    steps++;
+  }
+  if (steps >= START_LIMIT || buffer[startIdx] !== 0x5B) return null;
+
+  // Scan forward for ']'
+  let endIdx = idx;
+  const END_LIMIT = 20000;
+  steps = 0;
+  while (endIdx < buffer.length && buffer[endIdx] !== 0x5D && steps < END_LIMIT) {
+    endIdx++;
+    steps++;
+  }
+  if (steps >= END_LIMIT || buffer[endIdx] !== 0x5D) return null;
+
+  // Verify validation words in range
+  const range = buffer.subarray(startIdx, endIdx + 1);
+  const rangeStr = range.toString('utf-8');
+
+  let foundCount = 0;
+  for (const word of validationWords) {
+    if (rangeStr.includes(`"${word}"`)) foundCount++;
+  }
+
+  if (foundCount < minValidationCount) return null;
+
+  return { startIdx, endIdx };
+}
+
+/**
+ * Replace array in buffer with padded replacement, preserving length
+ * @param {Buffer} buffer - Binary content
+ * @param {number} startIdx - Start index of array
+ * @param {number} endIdx - End index of array (inclusive)
+ * @param {string} replacement - Replacement string (e.g. '["Thinking"]')
+ * @returns {Buffer | null}
+ */
+function replaceArrayInBuffer(buffer, startIdx, endIdx, replacement) {
+  const originalLen = endIdx - startIdx + 1;
+  const replacementBuf = Buffer.from(replacement);
+
+  if (replacementBuf.length > originalLen) return null;
+
+  const padding = Buffer.alloc(originalLen - replacementBuf.length, 0x20); // Space
+  const newContent = Buffer.concat([replacementBuf, padding]);
+
+  return Buffer.concat([
+    buffer.subarray(0, startIdx),
+    newContent,
+    buffer.subarray(endIdx + 1)
+  ]);
+}
+
+/**
+ * Patch binary content by finding array boundaries around marker words
+ * Preserves exact length by padding with spaces.
+ * Safe for patching bytecode sections where offset preservation is critical.
+ * @param {Buffer} buffer - Binary content
+ * @returns {{ patched: Buffer, count: number, spinnerCount: number, completionCount: number } | null}
+ */
+function patchBinaryContent(buffer) {
+  let patched = buffer;
+  let spinnerCount = 0;
+  let completionCount = 0;
+
+  // Patch spinner words array (anchor: "Flibbertigibbeting")
+  const spinnerBounds = findArrayBoundaries(patched, 'Flibbertigibbeting', MARKER_WORDS, 3);
+  if (spinnerBounds) {
+    const result = replaceArrayInBuffer(patched, spinnerBounds.startIdx, spinnerBounds.endIdx, `["${REPLACEMENT_WORD}"]`);
+    if (result) {
+      patched = result;
+      spinnerCount = 1;
+    }
+  }
+
+  // Patch completion verbs array (anchor: "Cogitated")
+  const completionBounds = findArrayBoundaries(patched, 'Cogitated', COMPLETION_VERBS, 3);
+  if (completionBounds) {
+    const result = replaceArrayInBuffer(patched, completionBounds.startIdx, completionBounds.endIdx, `["${COMPLETION_REPLACEMENT}"]`);
+    if (result) {
+      patched = result;
+      completionCount = 1;
+    }
+  }
+
+  const count = spinnerCount + completionCount;
+  if (count === 0) return null;
+
+  return {
+    patched,
+    count,
+    spinnerCount,
+    completionCount
+  };
 }
 
 /**
@@ -108,45 +230,40 @@ function isCompletionPatched(content) {
 function patchJsContent(jsContent, options = {}) {
   let str = jsContent.toString('utf-8');
   
-  // Pattern to match the array assignment: varName=["Accomplishing",...,"LastWord"]
-  // Different versions may end with different words:
-  // - CLI binary: ends with "Zigzagging"
-  // - Webview: ends with "Wrangling"
-  // We need to find arrays that contain our marker words
-  // Note: Webview uses longer var names like "Tte", binaries use shorter like "ouI"
-  const spinnerPatterns = [
-    /([a-zA-Z_$][a-zA-Z0-9_$]*)=\["Accomplishing"[^\]]*"Zigzagging"\]/g,  // CLI binary
-    /([a-zA-Z_$][a-zA-Z0-9_$]*)=\["Accomplishing"[^\]]*"Wrangling"\]/g,   // Webview
-  ];
+  // Generic pattern to match any string array assignment: varName=["str","str"...]
+  // Capture group 1: varName
+  // Capture group 2: array content including brackets
+  const arrayPattern = /([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*(\[[^\]]+\])/g;
   
   let spinnerCount = 0;
-  for (const arrayPattern of spinnerPatterns) {
-    str = str.replace(arrayPattern, (match, varName) => {
-      // Verify it contains marker words
-      let markerCount = 0;
-      for (const marker of MARKER_WORDS) {
-        if (match.includes(`"${marker}"`)) markerCount++;
-      }
-      
-      if (markerCount >= 3) {
-        spinnerCount++;
-        return `${varName}=["${REPLACEMENT_WORD}"]`;
-      }
-      return match;
-    });
-  }
-  
-  // Pattern to match the completion verbs array: varName=["Baked",...,"Worked"]
-  // This array only exists in the binary, not in the webview
-  const completionPattern = /([a-zA-Z_$][a-zA-Z0-9_$]*)=\["Baked"[^\]]*"Worked"\]/g;
-  
   let completionCount = 0;
-  str = str.replace(completionPattern, (match, varName) => {
-    // Verify it contains expected completion verbs
-    if (match.includes('"Brewed"') || match.includes('"Churned"')) {
+  
+  str = str.replace(arrayPattern, (match, varName, arrayContent) => {
+    // Check for spinner words in this array
+    let markerCount = 0;
+    for (const marker of MARKER_WORDS) {
+      if (arrayContent.includes(`"${marker}"`)) markerCount++;
+    }
+    
+    // If we found enough marker words, this is the spinner array
+    if (markerCount >= 3) {
+      spinnerCount++;
+      return `${varName}=["${REPLACEMENT_WORD}"]`;
+    }
+    
+    // Check for completion verbs in this array
+    // (Only exists in the binary, not in the webview)
+    let completionMarkerCount = 0;
+    for (const verb of COMPLETION_VERBS) {
+      if (arrayContent.includes(`"${verb}"`)) completionMarkerCount++;
+    }
+    
+    // If we found enough completion verbs, this is the completion array
+    if (completionMarkerCount >= 3) {
       completionCount++;
       return `${varName}=["${COMPLETION_REPLACEMENT}"]`;
     }
+    
     return match;
   });
   
@@ -276,15 +393,19 @@ function patch(filePath, options = {}) {
     
     if (isBinary) {
       // Native binary - extract JS, patch, repack
-      const claudeJs = extractClaudeJs(filePath);
+      const extraction = extractClaudeJs(filePath);
       
-      if (!claudeJs) {
+      if (!extraction) {
         return {
           success: false,
           message: 'Could not extract claude.js from binary. Binary format may not be supported.'
         };
       }
       
+      const claudeJs = extraction.content;
+      const targetModuleName = extraction.moduleName;
+      const targetType = extraction.type;
+      
       // Check if already patched
       if (isPatched(claudeJs)) {
         return {
@@ -298,16 +419,23 @@ function patch(filePath, options = {}) {
       if (!hasSillyWords(claudeJs)) {
         return {
           success: false,
-          message: 'Could not find silly words array in extracted JavaScript.'
+          message: 'Could not find silly words array in extracted content.'
         };
       }
       
-      // Patch the JS content
-      const result = patchJsContent(claudeJs);
+      // Patch the content
+      // Use binary patching for bytecode to preserve length/offsets
+      let result;
+      if (targetType === 'bytecode') {
+        result = patchBinaryContent(claudeJs);
+      } else {
+        result = patchJsContent(claudeJs);
+      }
+
       if (!result) {
         return {
           success: false,
-          message: 'Could not locate words array pattern in JavaScript.'
+          message: 'Could not locate words array pattern in content.'
         };
       }
       
@@ -325,7 +453,7 @@ function patch(filePath, options = {}) {
       const backupPath = createBackup(filePath);
       
       // Repack binary with patched JS
-      repackNativeInstallation(filePath, result.patched, filePath);
+      repackNativeInstallation(filePath, result.patched, filePath, targetModuleName, targetType);
       
       return {
         success: true,
@@ -412,8 +540,8 @@ function checkStatus(filePath, options = {}) {
     
     let content;
     if (isBinary) {
-      content = extractClaudeJs(filePath);
-      if (!content) {
+      const extraction = extractClaudeJs(filePath);
+      if (!extraction) {
         return {
           patched: false,
           hasSillyWords: false,
@@ -425,6 +553,7 @@ function checkStatus(filePath, options = {}) {
           error: 'Could not extract JavaScript from binary'
         };
       }
+      content = extraction.content;
     } else {
       content = fs.readFileSync(filePath);
     }
@@ -504,12 +633,13 @@ function getDebugInfo(filePath, options = {}) {
     // Get content
     let content;
     if (debug.isBinary) {
-      content = extractClaudeJs(filePath);
-      if (!content) {
+      const extraction = extractClaudeJs(filePath);
+      if (!extraction) {
         debug.binaryExtractionOk = false;
         debug.error = 'Could not extract JavaScript from binary';
         return debug;
       }
+      content = extraction.content;
       debug.binaryExtractionOk = true;
       debug.extractedJsSize = content.length;
     } else {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-depester",
-  "version": "1.3.3",
-  "description": "Remove silly thinking words and completion verbs from Claude Code. Auto-patches and survives updates via SessionStart hook.",
+  "version": "1.3.5",
+  "description": "Patches Claude Code CLI and VS Code extension to show 'Thinking' instead of whimsical words.",
   "main": "lib/patcher.js",
   "bin": {
     "claude-depester": "./bin/claude-depester"