claude-depester 1.3.2 → 1.3.3

package/README.md

@@ -1,13 +1,16 @@
 # claude-depester
 
 [![npm version](https://img.shields.io/npm/v/claude-depester.svg)](https://www.npmjs.com/package/claude-depester)
+[![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.
 
 Instead of seeing "Flibbertigibbeting", "Discombobulating", "Clauding", etc., you'll see a clean "Thinking".
 
-> **Last updated:** 2026-01-13 | **Tested with:** Claude Code 2.1.4, 2.1.5
+> **Last updated:** 2026-01-18 | **Tested with:** Claude Code 2.1.4 - 2.1.12 | **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))
 
 ![Thinking... instead of silly words](img/thinking.png)
 ![Thought for Xs instead of Baked/Brewed/etc](img/thought.png)
@@ -72,6 +75,8 @@ That's it! Restart Claude Code for changes to take effect.
 | `npx claude-depester --check` | Check patch status |
 | `npx claude-depester --restore` | Restore original from backup |
 | `npx claude-depester --verbose` | Show detailed info |
+| `npx claude-depester --debug` | Show detailed debug info (for troubleshooting) |
+| `npx claude-depester --log` | Write results to `~/.claude/depester.log` |
 | `npx claude-depester --install-hook` | Auto-patch after updates |
 | `npx claude-depester --remove-hook` | Remove auto-patch hook |
 | `npx claude-depester --hook-status` | Check hook status |
@@ -136,7 +141,7 @@ The `--install-hook` command adds a SessionStart hook to `~/.claude/settings.jso
         "hooks": [
           {
             "type": "command",
-            "command": "npx claude-depester --silent"
+            "command": "npx claude-depester --all --silent --log"
           }
         ]
       }
@@ -145,7 +150,12 @@ 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.
+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.
+
+> **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
+> ```
 
 ## Troubleshooting
 
@@ -188,8 +198,9 @@ Then **fully restart VS Code** (not just reload window).
 
 The detection uses content-based matching, so it should survive version updates.
 If the patch fails:
-1. Open an issue with your Claude Code version (`claude --version`)
-2. Include the output of `npx claude-depester --dry-run --verbose`
+1. Run `npx claude-depester --debug` to see detailed diagnostics
+2. Open an issue with your Claude Code version (`claude --version`)
+3. Include the output of `npx claude-depester --debug`
 
 ### Want to undo everything
 
@@ -216,6 +227,7 @@ npx claude-depester --remove-hook    # Remove auto-patch hook
 
 - **Backup**: `<original-file>.depester.backup`
 - **Hook config**: `~/.claude/settings.json`
+- **Debug log**: `~/.claude/depester.log` (when using `--log`)
 
 ## Requirements
 

package/bin/claude-depester

@@ -9,8 +9,8 @@
  */
 
 const { findCliJs, findAllClaudeCode, getSearchedPaths } = require('../lib/detector');
-const { patch, checkStatus, restoreBackup } = require('../lib/patcher');
-const { installHook, removeHook, getHookStatus } = require('../lib/hooks');
+const { patch, checkStatus, getDebugInfo, restoreBackup } = require('../lib/patcher');
+const { installHook, removeHook, getHookStatus, searchHookLogs, appendLog, readLog, LOG_PATH } = require('../lib/hooks');
 
 const VERSION = require('../package.json').version;
 
@@ -27,6 +27,8 @@ const flags = {
   hookStatus: args.includes('--hook-status'),
   silent: args.includes('--silent') || args.includes('-s'),
   verbose: args.includes('--verbose'),
+  debug: args.includes('--debug') || args.includes('-d'),
+  log: args.includes('--log'),
   all: args.includes('--all') || args.includes('-a'),
   list: args.includes('--list') || args.includes('-l')
 };
@@ -76,6 +78,8 @@ OPTIONS:
   
   -s, --silent      Suppress output (for hook use)
   --verbose         Show detailed information
+  -d, --debug       Show detailed debug info (for troubleshooting)
+  --log             Write results to ~/.claude/depester.log (keeps last 50 entries)
   -v, --version     Show version
   -h, --help        Show this help
 
@@ -86,6 +90,7 @@ EXAMPLES:
   npx claude-depester --check         # Check status
   npx claude-depester --install-hook  # Auto-patch after updates
   npx claude-depester --restore       # Undo patch
+  npx claude-depester --debug         # Troubleshoot issues
 
 MORE INFO:
   https://github.com/ominiverdi/claude-depester
@@ -164,6 +169,9 @@ async function main() {
     const installations = findAllClaudeCode();
     if (installations.length === 0) {
       error('No Claude Code installations found.');
+      if (flags.log) {
+        appendLog('No installations found', { action: 'patch-all' });
+      }
       if (flags.verbose) {
         showSearchedPaths();
       }
@@ -175,6 +183,7 @@ async function main() {
     let successCount = 0;
     let skipCount = 0;
     let failCount = 0;
+    const logResults = [];
     
     for (const inst of installations) {
       log(`${inst.method}:`);
@@ -185,28 +194,55 @@ async function main() {
         if (success) {
           log('  -> Restored from backup\n');
           successCount++;
+          logResults.push({ path: inst.path, method: inst.method, result: 'restored' });
         } else {
           log('  -> No backup found\n');
           skipCount++;
+          logResults.push({ path: inst.path, method: inst.method, result: 'no-backup' });
         }
       } else {
+        // Get debug info before patching for the log
+        const debugBefore = flags.log ? getDebugInfo(inst.path, { type: inst.type }) : null;
+        
         const result = patch(inst.path, { dryRun: flags.dryRun, type: inst.type });
         if (result.success) {
           if (result.alreadyPatched) {
             log('  -> Already patched\n');
             skipCount++;
+            logResults.push({ 
+              path: inst.path, 
+              method: inst.method, 
+              result: 'already-patched',
+              debug: debugBefore
+            });
           } else if (result.dryRun) {
             const details = formatPatchDetails(result);
             log(`  -> Would patch${details}\n`);
             successCount++;
+            logResults.push({ path: inst.path, method: inst.method, result: 'dry-run' });
           } else {
             const details = formatPatchDetails(result);
             log(`  -> Patched${details}\n`);
             successCount++;
+            logResults.push({ 
+              path: inst.path, 
+              method: inst.method, 
+              result: 'patched',
+              spinnerCount: result.spinnerCount,
+              completionCount: result.completionCount,
+              debug: debugBefore
+            });
           }
         } else {
           log(`  -> Failed: ${result.message}\n`);
           failCount++;
+          logResults.push({ 
+            path: inst.path, 
+            method: inst.method, 
+            result: 'failed', 
+            error: result.message,
+            debug: debugBefore
+          });
         }
       }
     }
@@ -215,6 +251,18 @@ async function main() {
     if (!flags.dryRun && successCount > 0) {
       log('Restart Claude Code for changes to take effect.');
     }
+    
+    if (flags.log) {
+      appendLog('Patch all completed', {
+        action: 'patch-all',
+        found: installations.length,
+        patched: successCount,
+        skipped: skipCount,
+        failed: failCount,
+        results: logResults
+      });
+    }
+    
     process.exit(failCount > 0 ? 1 : 0);
   }
   
@@ -238,6 +286,118 @@ async function main() {
     log(`Detection method: ${cliInfo.method}`);
   }
   
+  // Handle debug
+  if (flags.debug) {
+    log('=== DEPESTER DEBUG INFO ===\n');
+    
+    // Get debug info for all installations
+    const installations = findAllClaudeCode();
+    if (installations.length === 0) {
+      log('No installations found.\n');
+    } else {
+      for (const inst of installations) {
+        const debug = getDebugInfo(inst.path, { type: inst.type });
+        
+        log(`--- ${inst.method} ---`);
+        log(`Path: ${debug.filePath}`);
+        log(`File exists: ${debug.fileExists}`);
+        if (debug.fileExists) {
+          log(`File size: ${debug.fileSize} bytes`);
+          log(`File modified: ${debug.fileModified}`);
+          log(`Is binary: ${debug.isBinary}`);
+          log(`Is webview: ${debug.isWebview}`);
+          if (debug.isBinary) {
+            log(`Binary extraction OK: ${debug.binaryExtractionOk}`);
+            if (debug.extractedJsSize) {
+              log(`Extracted JS size: ${debug.extractedJsSize} bytes`);
+            }
+          }
+          log(`Has backup: ${debug.hasBackup}`);
+          log('');
+          log('Detection checks:');
+          log(`  Has =["Thinking"]: ${debug.hasReplacementPattern}`);
+          log(`  Has =["Thought"]: ${debug.hasCompletionReplacement}`);
+          log(`  Has original spinner array: ${debug.hasOriginalSpinnerArray}`);
+          log(`  Has original completion array: ${debug.hasOriginalCompletionArray}`);
+          log(`  Marker words found: ${debug.markerWordsFound.length > 0 ? debug.markerWordsFound.join(', ') : 'none'}`);
+          log(`  Completion verbs found: ${debug.completionVerbsFound.length > 0 ? debug.completionVerbsFound.join(', ') : 'none'}`);
+          log('');
+          log('Computed status:');
+          log(`  Spinner patched: ${debug.spinnerPatched}`);
+          log(`  Completion patched: ${debug.completionPatched}`);
+          log(`  Has silly words: ${debug.hasSillyWords}`);
+        }
+        if (debug.error) {
+          log(`Error: ${debug.error}`);
+        }
+        log('');
+      }
+    }
+    
+    // Hook status
+    const hookStatus = getHookStatus();
+    log('--- Hook Status ---');
+    log(`Hook installed: ${hookStatus.installed}`);
+    log(`Settings file: ${hookStatus.settingsPath}`);
+    log('');
+    
+    // Search Claude debug logs for hook activity
+    log('--- Recent Hook Activity (from Claude logs) ---');
+    const hookLogs = searchHookLogs(5);
+    if (hookLogs.length === 0) {
+      log('No hook activity found in recent Claude debug logs.');
+    } else {
+      for (const logFile of hookLogs) {
+        log(`\nLog: ${logFile.file} (${logFile.timestamp})`);
+        for (const entry of logFile.entries) {
+          log(`  ${entry.time}: ${entry.message}`);
+        }
+      }
+    }
+    log('');
+    
+    // Show depester's own log
+    log('--- Depester Log (last 10 entries) ---');
+    log(`Log file: ${LOG_PATH}`);
+    const depesterLogs = readLog();
+    if (depesterLogs.length === 0) {
+      log('No entries. Enable logging with --log flag.');
+    } else {
+      const recent = depesterLogs.slice(-10);
+      for (const entry of recent) {
+        log(`\n${entry.timestamp}: ${entry.message}`);
+        if (entry.data) {
+          if (entry.data.found !== undefined) {
+            log(`  Found: ${entry.data.found}, Patched: ${entry.data.patched}, Skipped: ${entry.data.skipped}, Failed: ${entry.data.failed}`);
+          }
+          // Only show per-installation details if there was a failure or unexpected result
+          if (entry.data.results) {
+            const hasIssue = entry.data.results.some(r => 
+              r.result === 'failed' || 
+              (r.result === 'already-patched' && r.debug?.markerWordsFound?.length > 0)
+            );
+            if (hasIssue) {
+              for (const r of entry.data.results) {
+                log(`  - ${r.method}: ${r.result}`);
+                if (r.debug) {
+                  log(`    File modified: ${r.debug.fileModified}`);
+                  log(`    Has =["Thinking"]: ${r.debug.hasReplacementPattern}`);
+                  log(`    Marker words: ${r.debug.markerWordsFound?.length > 0 ? r.debug.markerWordsFound.join(', ') : 'none'}`);
+                }
+                if (r.error) {
+                  log(`    Error: ${r.error}`);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    log('');
+    
+    process.exit(0);
+  }
+  
   // Handle check
   if (flags.check) {
     const status = checkStatus(cliInfo.path, { type: cliInfo.type });

package/lib/hooks.js

@@ -15,8 +15,13 @@ const HOME = os.homedir();
 // (on Windows, ~ expands to %USERPROFILE%)
 const SETTINGS_PATH = path.join(HOME, '.claude', 'settings.json');
 
+// Log file for debugging hook execution
+const LOG_PATH = path.join(HOME, '.claude', 'depester.log');
+const MAX_LOG_ENTRIES = 50;
+
 // Use --all to patch all installations (CLI + VS Code binary + webview)
-const HOOK_COMMAND = 'npx claude-depester --all --silent';
+// Use --log to write results to ~/.claude/depester.log for debugging
+const HOOK_COMMAND = 'npx claude-depester --all --silent --log';
 
 /**
  * Read Claude Code settings
@@ -179,11 +184,146 @@ function getHookStatus() {
   };
 }
 
+/**
+ * Search Claude debug logs for hook-related entries
+ * @param {number} maxFiles - Maximum number of log files to search (default 5)
+ * @returns {Array<{file: string, timestamp: string, entries: Array<{time: string, message: string}>}>}
+ */
+function searchHookLogs(maxFiles = 5) {
+  const debugDir = path.join(HOME, '.claude', 'debug');
+  const results = [];
+  
+  try {
+    if (!fs.existsSync(debugDir)) {
+      return results;
+    }
+    
+    // Get log files sorted by modification time (newest first)
+    const files = fs.readdirSync(debugDir)
+      .filter(f => f.endsWith('.txt') && f !== 'latest')
+      .map(f => ({
+        name: f,
+        path: path.join(debugDir, f),
+        mtime: fs.statSync(path.join(debugDir, f)).mtime
+      }))
+      .sort((a, b) => b.mtime - a.mtime)
+      .slice(0, maxFiles);
+    
+    for (const file of files) {
+      const content = fs.readFileSync(file.path, 'utf-8');
+      const lines = content.split('\n');
+      const hookEntries = [];
+      
+      for (const line of lines) {
+        // Look for SessionStart hook entries only (not repo URLs containing "depester")
+        if (line.includes('SessionStart') || 
+            line.includes('Hook output')) {
+          // Parse timestamp from log line: 2026-01-18T09:07:34.119Z [DEBUG] ...
+          const match = line.match(/^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z)\s+\[.*?\]\s+(.*)$/);
+          if (match) {
+            hookEntries.push({
+              time: match[1],
+              message: match[2]
+            });
+          }
+        }
+      }
+      
+      if (hookEntries.length > 0) {
+        results.push({
+          file: file.name,
+          timestamp: file.mtime.toISOString(),
+          entries: hookEntries
+        });
+      }
+    }
+  } catch (e) {
+    // Ignore errors reading logs
+  }
+  
+  return results;
+}
+
+/**
+ * Append entry to depester log file, keeping only last MAX_LOG_ENTRIES
+ * @param {string} message - Log message
+ * @param {object} data - Additional data to log
+ */
+function appendLog(message, data = null) {
+  try {
+    const timestamp = new Date().toISOString();
+    const entry = {
+      timestamp,
+      message,
+      ...(data && { data })
+    };
+    
+    // Read existing entries
+    let entries = [];
+    if (fs.existsSync(LOG_PATH)) {
+      const content = fs.readFileSync(LOG_PATH, 'utf-8');
+      const lines = content.trim().split('\n').filter(l => l);
+      entries = lines.map(line => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      }).filter(e => e !== null);
+    }
+    
+    // Add new entry
+    entries.push(entry);
+    
+    // Keep only last MAX_LOG_ENTRIES
+    if (entries.length > MAX_LOG_ENTRIES) {
+      entries = entries.slice(-MAX_LOG_ENTRIES);
+    }
+    
+    // Write back
+    const dir = path.dirname(LOG_PATH);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(LOG_PATH, entries.map(e => JSON.stringify(e)).join('\n') + '\n', 'utf-8');
+    
+  } catch (e) {
+    // Silently ignore logging errors
+  }
+}
+
+/**
+ * Read depester log entries
+ * @returns {Array<{timestamp: string, message: string, data?: object}>}
+ */
+function readLog() {
+  try {
+    if (!fs.existsSync(LOG_PATH)) {
+      return [];
+    }
+    const content = fs.readFileSync(LOG_PATH, 'utf-8');
+    const lines = content.trim().split('\n').filter(l => l);
+    return lines.map(line => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter(e => e !== null);
+  } catch (e) {
+    return [];
+  }
+}
+
 module.exports = {
   installHook,
   removeHook,
   isHookInstalled,
   getHookStatus,
+  searchHookLogs,
+  appendLog,
+  readLog,
   SETTINGS_PATH,
-  HOOK_COMMAND
+  HOOK_COMMAND,
+  LOG_PATH
 };

package/lib/patcher.js

@@ -450,9 +450,112 @@ 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) {
+      content = extractClaudeJs(filePath);
+      if (!content) {
+        debug.binaryExtractionOk = false;
+        debug.error = 'Could not extract JavaScript from binary';
+        return debug;
+      }
+      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,6 +1,6 @@
 {
   "name": "claude-depester",
-  "version": "1.3.2",
+  "version": "1.3.3",
   "description": "Remove silly thinking words and completion verbs from Claude Code. Auto-patches and survives updates via SessionStart hook.",
   "main": "lib/patcher.js",
   "bin": {