claude-depester 1.3.6 → 1.4.0

package/lib/patcher.js

@@ -46,26 +46,21 @@ const COMPLETION_REPLACEMENT = 'Thought';
  */
 function hasSillyWords(content) {
   const str = Buffer.isBuffer(content) ? content.toString('utf-8') : content;
-
-  // Check for spinner words (need 3+ matches)
-  let spinnerFound = 0;
+  
+  // Check for spinner words
+  let found = 0;
   for (const word of MARKER_WORDS) {
     if (str.includes(`"${word}"`)) {
-      spinnerFound++;
-      if (spinnerFound >= 3) return true;
+      found++;
+      if (found >= 3) 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;
-    }
+  
+  // Also check for completion verbs (only in binary)
+  if (str.includes('["Baked"')) {
+    return true;
   }
-
+  
   return false;
 }
 
@@ -76,12 +71,7 @@ function hasSillyWords(content) {
  */
 function hasCompletionVerbs(content) {
   const str = Buffer.isBuffer(content) ? content.toString('utf-8') : content;
-  
-  let found = 0;
-  for (const word of COMPLETION_VERBS) {
-    if (str.includes(`"${word}"`)) found++;
-  }
-  return found >= 3;
+  return str.includes('["Baked"') && str.includes('"Worked"]');
 }
 
 /**
@@ -90,10 +80,10 @@ function hasCompletionVerbs(content) {
  * @returns {boolean}
  */
 function isPatched(content) {
-  // 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);
+  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;
 }
 
 /**
@@ -102,122 +92,10 @@ function isPatched(content) {
  * @returns {boolean}
  */
 function isCompletionPatched(content) {
-  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
-  };
+  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;
 }
 
 /**
@@ -230,40 +108,45 @@ function patchBinaryContent(buffer) {
 function patchJsContent(jsContent, options = {}) {
   let str = jsContent.toString('utf-8');
   
-  // 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;
+  // 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
+  ];
   
   let spinnerCount = 0;
-  let completionCount = 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;
+    });
+  }
   
-  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) {
+  // 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"')) {
       completionCount++;
       return `${varName}=["${COMPLETION_REPLACEMENT}"]`;
     }
-    
     return match;
   });
   
@@ -393,19 +276,15 @@ function patch(filePath, options = {}) {
     
     if (isBinary) {
       // Native binary - extract JS, patch, repack
-      const extraction = extractClaudeJs(filePath);
+      const claudeJs = extractClaudeJs(filePath);
       
-      if (!extraction) {
+      if (!claudeJs) {
         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 {
@@ -419,23 +298,16 @@ function patch(filePath, options = {}) {
       if (!hasSillyWords(claudeJs)) {
         return {
           success: false,
-          message: 'Could not find silly words array in extracted content.'
+          message: 'Could not find silly words array in extracted JavaScript.'
         };
       }
       
-      // Patch the content
-      // Use binary patching for bytecode to preserve length/offsets
-      let result;
-      if (targetType === 'bytecode') {
-        result = patchBinaryContent(claudeJs);
-      } else {
-        result = patchJsContent(claudeJs);
-      }
-
+      // Patch the JS content
+      const result = patchJsContent(claudeJs);
       if (!result) {
         return {
           success: false,
-          message: 'Could not locate words array pattern in content.'
+          message: 'Could not locate words array pattern in JavaScript.'
         };
       }
       
@@ -453,7 +325,7 @@ function patch(filePath, options = {}) {
       const backupPath = createBackup(filePath);
       
       // Repack binary with patched JS
-      repackNativeInstallation(filePath, result.patched, filePath, targetModuleName, targetType);
+      repackNativeInstallation(filePath, result.patched, filePath);
       
       return {
         success: true,
@@ -540,8 +412,8 @@ function checkStatus(filePath, options = {}) {
     
     let content;
     if (isBinary) {
-      const extraction = extractClaudeJs(filePath);
-      if (!extraction) {
+      content = extractClaudeJs(filePath);
+      if (!content) {
         return {
           patched: false,
           hasSillyWords: false,
@@ -553,7 +425,6 @@ function checkStatus(filePath, options = {}) {
           error: 'Could not extract JavaScript from binary'
         };
       }
-      content = extraction.content;
     } else {
       content = fs.readFileSync(filePath);
     }
@@ -579,113 +450,9 @@ function checkStatus(filePath, options = {}) {
   }
 }
 
-/**
- * Get detailed debug info for troubleshooting
- * @param {string} filePath - Path to cli.js or binary
- * @param {object} options - Options
- * @param {string} options.type - Override type detection: 'binary', 'js', 'webview'
- * @returns {object} Detailed debug information
- */
-function getDebugInfo(filePath, options = {}) {
-  const debug = {
-    filePath,
-    fileExists: false,
-    fileSize: null,
-    fileModified: null,
-    isBinary: false,
-    isWebview: options.type === 'webview',
-    binaryExtractionOk: null,
-    extractedJsSize: null,
-    // Detection details
-    hasReplacementPattern: false,    // =["Thinking"]
-    hasCompletionReplacement: false, // =["Thought"]
-    hasOriginalSpinnerArray: false,  // ["Accomplishing"..."Zigzagging"]
-    hasOriginalCompletionArray: false, // ["Baked"..."Worked"]
-    markerWordsFound: [],
-    completionVerbsFound: [],
-    // Computed status
-    spinnerPatched: false,
-    completionPatched: false,
-    hasSillyWords: false,
-    hasBackup: false,
-    error: null
-  };
-
-  try {
-    // File metadata
-    if (!fs.existsSync(filePath)) {
-      debug.error = 'File does not exist';
-      return debug;
-    }
-    debug.fileExists = true;
-    
-    const stats = fs.statSync(filePath);
-    debug.fileSize = stats.size;
-    debug.fileModified = stats.mtime.toISOString();
-    
-    // Backup check
-    debug.hasBackup = hasBackup(filePath);
-    
-    // Binary detection
-    const { type } = options;
-    debug.isBinary = type !== 'js' && type !== 'webview' && isNativeBinary(filePath);
-    
-    // Get content
-    let content;
-    if (debug.isBinary) {
-      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 {
-      content = fs.readFileSync(filePath);
-    }
-    
-    const str = Buffer.isBuffer(content) ? content.toString('utf-8') : content;
-    
-    // Check for replacement patterns
-    debug.hasReplacementPattern = /=\["Thinking"\]/.test(str);
-    debug.hasCompletionReplacement = /=\["Thought"\]/.test(str);
-    
-    // Check for original arrays
-    debug.hasOriginalSpinnerArray = str.includes('["Accomplishing"') && str.includes('"Zigzagging"]');
-    debug.hasOriginalCompletionArray = str.includes('["Baked"') && str.includes('"Worked"]');
-    
-    // Check for individual marker words
-    for (const word of MARKER_WORDS) {
-      if (str.includes(`"${word}"`)) {
-        debug.markerWordsFound.push(word);
-      }
-    }
-    
-    // Check for individual completion verbs
-    for (const verb of COMPLETION_VERBS) {
-      if (str.includes(`"${verb}"`)) {
-        debug.completionVerbsFound.push(verb);
-      }
-    }
-    
-    // Compute status using existing functions
-    debug.spinnerPatched = isPatched(content);
-    debug.completionPatched = isCompletionPatched(content);
-    debug.hasSillyWords = hasSillyWords(content);
-    
-  } catch (err) {
-    debug.error = err.message;
-  }
-  
-  return debug;
-}
-
 module.exports = {
   patch,
   checkStatus,
-  getDebugInfo,
   restoreBackup,
   hasBackup,
   hasSillyWords,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-depester",
-  "version": "1.3.6",
-  "description": "Patches Claude Code CLI and VS Code extension to show 'Thinking' instead of whimsical words.",
+  "version": "1.4.0",
+  "description": "Remove silly thinking words and completion verbs from Claude Code. Auto-patches and survives updates via SessionStart hook.",
   "main": "lib/patcher.js",
   "bin": {
     "claude-depester": "./bin/claude-depester"
@@ -15,10 +15,7 @@
     "cli",
     "patch",
     "thinking-words",
-    "completion-verbs",
-    "vscode-remote",
-    "cursor",
-    "ssh"
+    "completion-verbs"
   ],
   "author": "Lorenzo Becchi",
   "license": "MIT",
@@ -40,6 +37,6 @@
     "LICENSE"
   ],
   "dependencies": {
-    "node-lief": "^0.1.8"
+    "node-lief": "^1.0.0"
   }
 }