claude-git-hooks 2.18.0 → 2.19.0

package/lib/utils/claude-client.js

@@ -21,7 +21,12 @@ import path from 'path';
 import os from 'os';
 import logger from './logger.js';
 import config from '../config.js';
-import { detectClaudeError, formatClaudeError, ClaudeErrorType, isRecoverableError } from './claude-diagnostics.js';
+import {
+    detectClaudeError,
+    formatClaudeError,
+    ClaudeErrorType,
+    isRecoverableError
+} from './claude-diagnostics.js';
 import { which } from './which-command.js';
 import { recordJsonParseFailure, recordBatchSuccess, rotateTelemetry } from './telemetry.js';
 
@@ -79,7 +84,9 @@ const getClaudeCommand = () => {
         // Node 24: Use which() instead of execSync to get absolute path
         const nativePath = which('claude');
         if (nativePath) {
-            logger.debug('claude-client - getClaudeCommand', 'Using native Windows Claude CLI', { path: nativePath });
+            logger.debug('claude-client - getClaudeCommand', 'Using native Windows Claude CLI', {
+                path: nativePath
+            });
             return { command: nativePath, args: [] };
         }
 
@@ -87,15 +94,18 @@ const getClaudeCommand = () => {
 
         // Fallback to WSL
         if (!isWSLAvailable()) {
-            throw new ClaudeClientError('Claude CLI not found. Install Claude CLI natively on Windows or via WSL', {
-                context: {
-                    platform: 'Windows',
-                    suggestions: [
-                        'Native Windows: npm install -g @anthropic-ai/claude-cli',
-                        'WSL: wsl --install, then install Claude in WSL'
-                    ]
+            throw new ClaudeClientError(
+                'Claude CLI not found. Install Claude CLI natively on Windows or via WSL',
+                {
+                    context: {
+                        platform: 'Windows',
+                        suggestions: [
+                            'Native Windows: npm install -g @anthropic-ai/claude-cli',
+                            'WSL: wsl --install, then install Claude in WSL'
+                        ]
+                    }
                 }
-            });
+            );
         }
 
         // Check if Claude is available in WSL
@@ -106,8 +116,13 @@ const getClaudeCommand = () => {
                 // Verify Claude exists in WSL
                 // Increased timeout from 5s to 15s to handle system load better
                 const wslCheckTimeout = config.system.wslCheckTimeout || 15000;
-                execSync(`"${wslPath}" claude --version`, { stdio: 'ignore', timeout: wslCheckTimeout });
-                logger.debug('claude-client - getClaudeCommand', 'Using WSL Claude CLI', { wslPath });
+                execSync(`"${wslPath}" claude --version`, {
+                    stdio: 'ignore',
+                    timeout: wslCheckTimeout
+                });
+                logger.debug('claude-client - getClaudeCommand', 'Using WSL Claude CLI', {
+                    wslPath
+                });
                 return { command: wslPath, args: ['claude'] };
             } catch (wslError) {
                 // Differentiate error types for accurate user feedback
@@ -116,15 +131,19 @@ const getClaudeCommand = () => {
 
                 // Timeout: Transient system load issue
                 if (errorMsg.includes('ETIMEDOUT')) {
-                    throw new ClaudeClientError('Timeout connecting to WSL - system under heavy load', {
-                        context: {
-                            platform: 'Windows',
-                            wslPath,
-                            error: 'ETIMEDOUT',
-                            timeoutValue: wslCheckTimeout,
-                            suggestion: 'System is busy. Wait a moment and try again, or skip analysis: git commit --no-verify'
+                    throw new ClaudeClientError(
+                        'Timeout connecting to WSL - system under heavy load',
+                        {
+                            context: {
+                                platform: 'Windows',
+                                wslPath,
+                                error: 'ETIMEDOUT',
+                                timeoutValue: wslCheckTimeout,
+                                suggestion:
+                                    'System is busy. Wait a moment and try again, or skip analysis: git commit --no-verify'
+                            }
                         }
-                    });
+                    );
                 }
 
                 // Not found: Claude CLI missing in WSL
@@ -134,7 +153,8 @@ const getClaudeCommand = () => {
                             platform: 'Windows',
                             wslPath,
                             error: 'ENOENT',
-                            suggestion: 'Install Claude in WSL: wsl -e bash -c "npm install -g @anthropic-ai/claude-cli"'
+                            suggestion:
+                                'Install Claude in WSL: wsl -e bash -c "npm install -g @anthropic-ai/claude-cli"'
                         }
                     });
                 }
@@ -145,7 +165,8 @@ const getClaudeCommand = () => {
                         platform: 'Windows',
                         wslPath,
                         error: errorMsg,
-                        suggestion: 'Check WSL is functioning: wsl --version, or skip analysis: git commit --no-verify'
+                        suggestion:
+                            'Check WSL is functioning: wsl --version, or skip analysis: git commit --no-verify'
                     }
                 });
             }
@@ -170,7 +191,9 @@ const getClaudeCommand = () => {
     }
 
     // Fallback to 'claude' if which fails (will error later if not found)
-    logger.debug('claude-client - getClaudeCommand', 'which() failed, using fallback', { command: 'claude' });
+    logger.debug('claude-client - getClaudeCommand', 'which() failed, using fallback', {
+        command: 'claude'
+    });
     return { command: 'claude', args: [] };
 };
 
@@ -185,259 +208,277 @@ const getClaudeCommand = () => {
  * @returns {Promise<string>} Claude's response
  * @throws {ClaudeClientError} If execution fails or times out
  */
-const executeClaude = (prompt, { timeout = 120000, allowedTools = [] } = {}) => new Promise((resolve, reject) => {
-    // Get platform-specific command
-    const { command, args } = getClaudeCommand();
-
-    // Add allowed tools if specified (for MCP tools)
-    const finalArgs = [...args];
-    if (allowedTools.length > 0) {
-        // Format: --allowedTools "mcp__github__create_pull_request,mcp__github__get_file_contents"
-        finalArgs.push('--allowedTools', allowedTools.join(','));
-    }
+const executeClaude = (prompt, { timeout = 120000, allowedTools = [] } = {}) =>
+    new Promise((resolve, reject) => {
+        // Get platform-specific command
+        const { command, args } = getClaudeCommand();
+
+        // Add allowed tools if specified (for MCP tools)
+        const finalArgs = [...args];
+        if (allowedTools.length > 0) {
+            // Format: --allowedTools "mcp__github__create_pull_request,mcp__github__get_file_contents"
+            finalArgs.push('--allowedTools', allowedTools.join(','));
+        }
 
-    // CRITICAL FIX: Windows .cmd/.bat file handling
-    // Why: spawn() cannot execute .cmd/.bat files directly on Windows (ENOENT error)
-    // Solution: Wrap with cmd.exe /c when command ends with .cmd or .bat
-    // Impact: Only affects Windows npm-installed CLI tools, no impact on other platforms
-    let spawnCommand = command;
-    let spawnArgs = finalArgs;
-
-    if (isWindows() && (command.endsWith('.cmd') || command.endsWith('.bat'))) {
-        logger.debug('claude-client - executeClaude', 'Wrapping .cmd/.bat with cmd.exe', {
-            originalCommand: command,
-            originalArgs: finalArgs
+        // CRITICAL FIX: Windows .cmd/.bat file handling
+        // Why: spawn() cannot execute .cmd/.bat files directly on Windows (ENOENT error)
+        // Solution: Wrap with cmd.exe /c when command ends with .cmd or .bat
+        // Impact: Only affects Windows npm-installed CLI tools, no impact on other platforms
+        let spawnCommand = command;
+        let spawnArgs = finalArgs;
+
+        if (isWindows() && (command.endsWith('.cmd') || command.endsWith('.bat'))) {
+            logger.debug('claude-client - executeClaude', 'Wrapping .cmd/.bat with cmd.exe', {
+                originalCommand: command,
+                originalArgs: finalArgs
+            });
+            spawnCommand = 'cmd.exe';
+            spawnArgs = ['/c', command, ...finalArgs];
+        }
+
+        const fullCommand =
+            spawnArgs.length > 0 ? `${spawnCommand} ${spawnArgs.join(' ')}` : spawnCommand;
+
+        logger.debug('claude-client - executeClaude', 'Executing Claude CLI', {
+            promptLength: prompt.length,
+            timeout,
+            command: fullCommand,
+            isWindows: isWindows(),
+            allowedTools
         });
-        spawnCommand = 'cmd.exe';
-        spawnArgs = ['/c', command, ...finalArgs];
-    }
 
-    const fullCommand = spawnArgs.length > 0 ? `${spawnCommand} ${spawnArgs.join(' ')}` : spawnCommand;
+        const startTime = Date.now();
 
-    logger.debug(
-        'claude-client - executeClaude',
-        'Executing Claude CLI',
-        { promptLength: prompt.length, timeout, command: fullCommand, isWindows: isWindows(), allowedTools }
-    );
+        // Why: Use spawn instead of exec to handle large prompts and responses
+        // spawn streams data, exec buffers everything in memory
+        // Node 24 Fix: Removed shell: true to avoid DEP0190 deprecation warning
+        // We now use absolute paths from which(), so shell is not needed
+        // Windows .cmd/.bat fix: Wrapped with cmd.exe /c (see above)
+        const claude = spawn(spawnCommand, spawnArgs, {
+            stdio: ['pipe', 'pipe', 'pipe'] // stdin, stdout, stderr
+        });
 
-    const startTime = Date.now();
+        let stdout = '';
+        let stderr = '';
 
-    // Why: Use spawn instead of exec to handle large prompts and responses
-    // spawn streams data, exec buffers everything in memory
-    // Node 24 Fix: Removed shell: true to avoid DEP0190 deprecation warning
-    // We now use absolute paths from which(), so shell is not needed
-    // Windows .cmd/.bat fix: Wrapped with cmd.exe /c (see above)
-    const claude = spawn(spawnCommand, spawnArgs, {
-        stdio: ['pipe', 'pipe', 'pipe'] // stdin, stdout, stderr
-    });
+        // Collect stdout
+        claude.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
 
-    let stdout = '';
-    let stderr = '';
+        // Collect stderr
+        claude.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
 
-    // Collect stdout
-    claude.stdout.on('data', (data) => {
-        stdout += data.toString();
-    });
+        // Handle process completion
+        claude.on('close', (code) => {
+            clearTimeout(timeoutId);
+            const elapsedTime = Date.now() - startTime;
+
+            // Check for "Execution error" even when exit code is 0
+            // Why: Claude CLI sometimes returns "Execution error" with exit code 0
+            // This occurs during API rate limiting or temporary backend issues
+            // IMPORTANT: Only check for EXACT match to avoid false positives
+            if (stdout.trim() === 'Execution error') {
+                const errorInfo = detectClaudeError(stdout, stderr, code);
+
+                logger.error(
+                    'claude-client - executeClaude',
+                    `Claude CLI returned execution error (exit ${code})`,
+                    new ClaudeClientError(`Claude CLI error: ${errorInfo.type}`, {
+                        output: { stdout, stderr },
+                        context: {
+                            exitCode: code,
+                            elapsedTime,
+                            timeoutValue: timeout,
+                            errorType: errorInfo.type
+                        }
+                    })
+                );
 
-    // Collect stderr
-    claude.stderr.on('data', (data) => {
-        stderr += data.toString();
-    });
+                // Merge timing info into errorInfo for formatting
+                const errorInfoWithTiming = {
+                    ...errorInfo,
+                    elapsedTime,
+                    timeoutValue: timeout
+                };
+
+                // Show formatted error to user
+                const formattedError = formatClaudeError(errorInfoWithTiming);
+                console.error(`\n${formattedError}\n`);
+
+                reject(
+                    new ClaudeClientError(`Claude CLI error: ${errorInfo.type}`, {
+                        output: { stdout, stderr },
+                        context: {
+                            exitCode: code,
+                            elapsedTime,
+                            timeoutValue: timeout,
+                            errorInfo
+                        }
+                    })
+                );
+                return;
+            }
+
+            if (code === 0) {
+                logger.debug('claude-client - executeClaude', 'Claude CLI execution successful', {
+                    elapsedTime,
+                    outputLength: stdout.length
+                });
+                resolve(stdout);
+            } else {
+                // Detect specific error type
+                const errorInfo = detectClaudeError(stdout, stderr, code);
+
+                logger.error(
+                    'claude-client - executeClaude',
+                    `Claude CLI failed: ${errorInfo.type}`,
+                    new ClaudeClientError(`Claude CLI error: ${errorInfo.type}`, {
+                        output: { stdout, stderr },
+                        context: {
+                            exitCode: code,
+                            elapsedTime,
+                            timeoutValue: timeout,
+                            errorType: errorInfo.type
+                        }
+                    })
+                );
 
-    // Handle process completion
-    claude.on('close', (code) => {
-        clearTimeout(timeoutId);
-        const elapsedTime = Date.now() - startTime;
+                // Merge timing info into errorInfo for formatting
+                const errorInfoWithTiming = {
+                    ...errorInfo,
+                    elapsedTime,
+                    timeoutValue: timeout
+                };
 
-        // Check for "Execution error" even when exit code is 0
-        // Why: Claude CLI sometimes returns "Execution error" with exit code 0
-        // This occurs during API rate limiting or temporary backend issues
-        // IMPORTANT: Only check for EXACT match to avoid false positives
-        if (stdout.trim() === 'Execution error') {
-            const errorInfo = detectClaudeError(stdout, stderr, code);
+                // Show formatted error to user
+                const formattedError = formatClaudeError(errorInfoWithTiming);
+                console.error(`\n${formattedError}\n`);
+
+                reject(
+                    new ClaudeClientError(`Claude CLI error: ${errorInfo.type}`, {
+                        output: { stdout, stderr },
+                        context: {
+                            exitCode: code,
+                            elapsedTime,
+                            timeoutValue: timeout,
+                            errorInfo
+                        }
+                    })
+                );
+            }
+        });
+
+        // Handle errors
+        claude.on('error', (error) => {
+            clearTimeout(timeoutId);
+            const elapsedTime = Date.now() - startTime;
 
             logger.error(
                 'claude-client - executeClaude',
-                `Claude CLI returned execution error (exit ${code})`,
-                new ClaudeClientError(`Claude CLI error: ${errorInfo.type}`, {
-                    output: { stdout, stderr },
+                'Failed to spawn Claude CLI process',
+                error
+            );
+
+            reject(
+                new ClaudeClientError('Failed to spawn Claude CLI', {
+                    cause: error,
                     context: {
-                        exitCode: code,
+                        command,
+                        args,
                         elapsedTime,
-                        timeoutValue: timeout,
-                        errorType: errorInfo.type
+                        timeoutValue: timeout
                     }
                 })
             );
+        });
 
-            // Merge timing info into errorInfo for formatting
-            const errorInfoWithTiming = {
-                ...errorInfo,
-                elapsedTime,
-                timeoutValue: timeout
-            };
-
-            // Show formatted error to user
-            const formattedError = formatClaudeError(errorInfoWithTiming);
-            console.error(`\n${  formattedError  }\n`);
-
-            reject(new ClaudeClientError(`Claude CLI error: ${errorInfo.type}`, {
-                output: { stdout, stderr },
-                context: {
-                    exitCode: code,
-                    elapsedTime,
-                    timeoutValue: timeout,
-                    errorInfo
-                }
-            }));
-            return;
-        }
+        // Set up timeout
+        const timeoutId = setTimeout(() => {
+            const elapsedTime = Date.now() - startTime;
+            claude.kill();
 
-        if (code === 0) {
-            logger.debug(
+            logger.error(
                 'claude-client - executeClaude',
-                'Claude CLI execution successful',
-                { elapsedTime, outputLength: stdout.length }
+                'Claude CLI execution timed out',
+                new ClaudeClientError('Claude CLI timeout', {
+                    context: {
+                        elapsedTime,
+                        timeoutValue: timeout
+                    }
+                })
             );
-            resolve(stdout);
-        } else {
-            // Detect specific error type
-            const errorInfo = detectClaudeError(stdout, stderr, code);
 
-            logger.error(
-                'claude-client - executeClaude',
-                `Claude CLI failed: ${errorInfo.type}`,
-                new ClaudeClientError(`Claude CLI error: ${errorInfo.type}`, {
-                    output: { stdout, stderr },
+            reject(
+                new ClaudeClientError('Claude CLI execution timed out', {
                     context: {
-                        exitCode: code,
                         elapsedTime,
                         timeoutValue: timeout,
-                        errorType: errorInfo.type
+                        errorInfo: {
+                            type: ClaudeErrorType.TIMEOUT,
+                            elapsedTime,
+                            timeoutValue: timeout
+                        }
                     }
                 })
             );
+        }, timeout);
 
-            // Merge timing info into errorInfo for formatting
-            const errorInfoWithTiming = {
-                ...errorInfo,
-                elapsedTime,
-                timeoutValue: timeout
-            };
-
-            // Show formatted error to user
-            const formattedError = formatClaudeError(errorInfoWithTiming);
-            console.error(`\n${  formattedError  }\n`);
-
-            reject(new ClaudeClientError(`Claude CLI error: ${errorInfo.type}`, {
-                output: { stdout, stderr },
-                context: {
-                    exitCode: code,
-                    elapsedTime,
-                    timeoutValue: timeout,
-                    errorInfo
-                }
-            }));
-        }
-    });
-
-    // Handle errors
-    claude.on('error', (error) => {
-        clearTimeout(timeoutId);
-        const elapsedTime = Date.now() - startTime;
-
-        logger.error(
-            'claude-client - executeClaude',
-            'Failed to spawn Claude CLI process',
-            error
-        );
-
-        reject(new ClaudeClientError('Failed to spawn Claude CLI', {
-            cause: error,
-            context: {
-                command,
-                args,
-                elapsedTime,
-                timeoutValue: timeout
-            }
-        }));
-    });
-
-    // Set up timeout
-    const timeoutId = setTimeout(() => {
-        const elapsedTime = Date.now() - startTime;
-        claude.kill();
+        // Write prompt to stdin
+        // Why: Claude CLI reads prompt from stdin, not command arguments
 
-        logger.error(
-            'claude-client - executeClaude',
-            'Claude CLI execution timed out',
-            new ClaudeClientError('Claude CLI timeout', {
-                context: {
-                    elapsedTime,
-                    timeoutValue: timeout
-                }
-            })
-        );
-
-        reject(new ClaudeClientError('Claude CLI execution timed out', {
-            context: {
-                elapsedTime,
-                timeoutValue: timeout,
-                errorInfo: {
-                    type: ClaudeErrorType.TIMEOUT,
-                    elapsedTime,
-                    timeoutValue: timeout
+        // Handle stdin errors (e.g., EOF when process terminates unexpectedly)
+        // Why: write() failures can emit 'error' events asynchronously
+        // Common in parallel execution with large prompts
+        claude.stdin.on('error', (error) => {
+            clearTimeout(timeoutId);
+            logger.error(
+                'claude-client - executeClaude',
+                'stdin stream error (process may have terminated early)',
+                {
+                    error: error.message,
+                    code: error.code,
+                    promptLength: prompt.length,
+                    duration: Date.now() - startTime
                 }
-            }
-        }));
-    }, timeout);
-
-    // Write prompt to stdin
-    // Why: Claude CLI reads prompt from stdin, not command arguments
-
-    // Handle stdin errors (e.g., EOF when process terminates unexpectedly)
-    // Why: write() failures can emit 'error' events asynchronously
-    // Common in parallel execution with large prompts
-    claude.stdin.on('error', (error) => {
-        clearTimeout(timeoutId);
-        logger.error(
-            'claude-client - executeClaude',
-            'stdin stream error (process may have terminated early)',
-            {
-                error: error.message,
-                code: error.code,
-                promptLength: prompt.length,
-                duration: Date.now() - startTime
-            }
-        );
+            );
 
-        reject(new ClaudeClientError('Failed to write to Claude stdin - process terminated unexpectedly', {
-            cause: error,
-            context: {
-                promptLength: prompt.length,
-                errorCode: error.code,
-                errorMessage: error.message,
-                suggestion: 'Try reducing batch size or number of files per commit'
-            }
-        }));
-    });
+            reject(
+                new ClaudeClientError(
+                    'Failed to write to Claude stdin - process terminated unexpectedly',
+                    {
+                        cause: error,
+                        context: {
+                            promptLength: prompt.length,
+                            errorCode: error.code,
+                            errorMessage: error.message,
+                            suggestion: 'Try reducing batch size or number of files per commit'
+                        }
+                    }
+                )
+            );
+        });
 
-    try {
-        claude.stdin.write(prompt);
-        claude.stdin.end();
-    } catch (error) {
-        clearTimeout(timeoutId);
-        logger.error(
-            'claude-client - executeClaude',
-            'Failed to write prompt to Claude CLI stdin (synchronous error)',
-            error
-        );
+        try {
+            claude.stdin.write(prompt);
+            claude.stdin.end();
+        } catch (error) {
+            clearTimeout(timeoutId);
+            logger.error(
+                'claude-client - executeClaude',
+                'Failed to write prompt to Claude CLI stdin (synchronous error)',
+                error
+            );
 
-        reject(new ClaudeClientError('Failed to write prompt', {
-            cause: error
-        }));
-    }
-});
+            reject(
+                new ClaudeClientError('Failed to write prompt', {
+                    cause: error
+                })
+            );
+        }
+    });
 
 /**
  * Executes Claude CLI fully interactively
@@ -448,85 +489,94 @@ const executeClaude = (prompt, { timeout = 120000, allowedTools = [] } = {}) =>
  * @returns {Promise<string>} - Returns 'interactive' since we can't capture output
  * @throws {ClaudeClientError} If execution fails
  */
-const executeClaudeInteractive = (prompt, { timeout = 300000 } = {}) => new Promise((resolve, reject) => {
-    const { command, args } = getClaudeCommand();
-    const { spawnSync } = require('child_process');
-    const fs = require('fs');
-    const path = require('path');
-    const os = require('os');
+const executeClaudeInteractive = (prompt, { timeout = 300000 } = {}) =>
+    new Promise((resolve, reject) => {
+        const { command, args } = getClaudeCommand();
+        const { spawnSync } = require('child_process');
+        const fs = require('fs');
+        const path = require('path');
+        const os = require('os');
+
+        // Save prompt to temp file that Claude can read
+        const tempDir = os.tmpdir();
+        const tempFile = path.join(tempDir, 'claude-pr-instructions.md');
 
-    // Save prompt to temp file that Claude can read
-    const tempDir = os.tmpdir();
-    const tempFile = path.join(tempDir, 'claude-pr-instructions.md');
+        try {
+            fs.writeFileSync(tempFile, prompt);
+        } catch (err) {
+            logger.error(
+                'claude-client - executeClaudeInteractive',
+                'Failed to write temp file',
+                err
+            );
+            reject(new ClaudeClientError('Failed to write prompt file', { cause: err }));
+            return;
+        }
 
-    try {
-        fs.writeFileSync(tempFile, prompt);
-    } catch (err) {
-        logger.error('claude-client - executeClaudeInteractive', 'Failed to write temp file', err);
-        reject(new ClaudeClientError('Failed to write prompt file', { cause: err }));
-        return;
-    }
+        logger.debug(
+            'claude-client - executeClaudeInteractive',
+            'Starting interactive Claude session',
+            { promptLength: prompt.length, tempFile, command, args }
+        );
 
-    logger.debug(
-        'claude-client - executeClaudeInteractive',
-        'Starting interactive Claude session',
-        { promptLength: prompt.length, tempFile, command, args }
-    );
+        console.log('');
+        console.log('╔══════════════════════════════════════════════════════════════════╗');
+        console.log('║  🤖 INTERACTIVE CLAUDE SESSION                                   ║');
+        console.log('╠══════════════════════════════════════════════════════════════════╣');
+        console.log('║                                                                  ║');
+        console.log('║  Instructions saved to:                                          ║');
+        console.log(`║  ${tempFile.padEnd(62)}║`);
+        console.log('║                                                                  ║');
+        console.log('║  When Claude starts, tell it:                                    ║');
+        console.log('║  "Read and execute the instructions in the file above"           ║');
+        console.log('║                                                                  ║');
+        console.log('║  • Type "y" if prompted for MCP permissions                      ║');
+        console.log('║  • Type "/exit" when done                                        ║');
+        console.log('║                                                                  ║');
+        console.log('╚══════════════════════════════════════════════════════════════════╝');
+        console.log('');
+        console.log('Starting Claude...');
+        console.log('');
 
-    console.log('');
-    console.log('╔══════════════════════════════════════════════════════════════════╗');
-    console.log('║  🤖 INTERACTIVE CLAUDE SESSION                                   ║');
-    console.log('╠══════════════════════════════════════════════════════════════════╣');
-    console.log('║                                                                  ║');
-    console.log('║  Instructions saved to:                                          ║');
-    console.log(`║  ${tempFile.padEnd(62)}║`);
-    console.log('║                                                                  ║');
-    console.log('║  When Claude starts, tell it:                                    ║');
-    console.log('║  "Read and execute the instructions in the file above"           ║');
-    console.log('║                                                                  ║');
-    console.log('║  • Type "y" if prompted for MCP permissions                      ║');
-    console.log('║  • Type "/exit" when done                                        ║');
-    console.log('║                                                                  ║');
-    console.log('╚══════════════════════════════════════════════════════════════════╝');
-    console.log('');
-    console.log('Starting Claude...');
-    console.log('');
-
-    // Run Claude fully interactively (no flags - pure interactive mode)
-    const result = spawnSync(command, args, {
-        stdio: 'inherit',  // Full terminal access
-        shell: true,
-        timeout
-    });
+        // Run Claude fully interactively (no flags - pure interactive mode)
+        const result = spawnSync(command, args, {
+            stdio: 'inherit', // Full terminal access
+            shell: true,
+            timeout
+        });
 
-    // Clean up temp file
-    try {
-        fs.unlinkSync(tempFile);
-    } catch (e) {
-        logger.debug('claude-client - executeClaudeInteractive', 'Temp file cleanup', { error: e.message });
-    }
+        // Clean up temp file
+        try {
+            fs.unlinkSync(tempFile);
+        } catch (e) {
+            logger.debug('claude-client - executeClaudeInteractive', 'Temp file cleanup', {
+                error: e.message
+            });
+        }
 
-    if (result.error) {
-        logger.error('claude-client - executeClaudeInteractive', 'Spawn error', result.error);
-        reject(new ClaudeClientError('Failed to start Claude', { cause: result.error }));
-        return;
-    }
+        if (result.error) {
+            logger.error('claude-client - executeClaudeInteractive', 'Spawn error', result.error);
+            reject(new ClaudeClientError('Failed to start Claude', { cause: result.error }));
+            return;
+        }
 
-    if (result.status === 0 || result.status === null) {
-        console.log('');
-        resolve('interactive-session-completed');
-    } else if (result.signal === 'SIGTERM') {
-        reject(new ClaudeClientError('Claude session timed out', { context: { timeout } }));
-    } else {
-        logger.error('claude-client - executeClaudeInteractive', 'Claude exited with error', {
-            status: result.status,
-            signal: result.signal
-        });
-        reject(new ClaudeClientError(`Claude exited with code ${result.status}`, {
-            context: { exitCode: result.status, signal: result.signal }
-        }));
-    }
-});
+        if (result.status === 0 || result.status === null) {
+            console.log('');
+            resolve('interactive-session-completed');
+        } else if (result.signal === 'SIGTERM') {
+            reject(new ClaudeClientError('Claude session timed out', { context: { timeout } }));
+        } else {
+            logger.error('claude-client - executeClaudeInteractive', 'Claude exited with error', {
+                status: result.status,
+                signal: result.signal
+            });
+            reject(
+                new ClaudeClientError(`Claude exited with code ${result.status}`, {
+                    context: { exitCode: result.status, signal: result.signal }
+                })
+            );
+        }
+    });
 
 /**
  * Extracts JSON from Claude's response
@@ -538,11 +588,9 @@ const executeClaudeInteractive = (prompt, { timeout = 300000 } = {}) => new Prom
  * @throws {ClaudeClientError} If no valid JSON found
  */
 const extractJSON = (response) => {
-    logger.debug(
-        'claude-client - extractJSON',
-        'Extracting JSON from response',
-        { responseLength: response.length }
-    );
+    logger.debug('claude-client - extractJSON', 'Extracting JSON from response', {
+        responseLength: response.length
+    });
 
     // Why: Try multiple patterns to find JSON
     // Pattern 1: JSON in markdown code block
@@ -590,7 +638,10 @@ const extractJSON = (response) => {
                 const jsonText = jsonLines.join('\n');
                 try {
                     const json = JSON.parse(jsonText);
-                    logger.debug('claude-client - extractJSON', 'JSON extracted using line matching');
+                    logger.debug(
+                        'claude-client - extractJSON',
+                        'JSON extracted using line matching'
+                    );
                     return json;
                 } catch (error) {
                     // Try next occurrence
@@ -651,28 +702,21 @@ const saveDebugResponse = async (prompt, response, filename = config.output.debu
         // Display batch optimization status
         try {
             if (prompt.includes('OPTIMIZATION')) {
-                console.log(`\n${  '='.repeat(70)}`);
+                console.log(`\n${'='.repeat(70)}`);
                 console.log('✅ BATCH OPTIMIZATION ENABLED');
                 console.log('='.repeat(70));
                 console.log('Multi-file analysis organized for efficient processing');
                 console.log('Check debug file for full prompt and response details');
-                console.log(`${'='.repeat(70)  }\n`);
+                console.log(`${'='.repeat(70)}\n`);
             }
         } catch (parseError) {
             // Ignore parsing errors, just skip the display
         }
 
         logger.info(`📝 Debug output saved to ${filename}`);
-        logger.debug(
-            'claude-client - saveDebugResponse',
-            `Debug response saved to ${filename}`
-        );
+        logger.debug('claude-client - saveDebugResponse', `Debug response saved to ${filename}`);
     } catch (error) {
-        logger.error(
-            'claude-client - saveDebugResponse',
-            'Failed to save debug response',
-            error
-        );
+        logger.error('claude-client - saveDebugResponse', 'Failed to save debug response', error);
     }
 };
 
@@ -690,7 +734,16 @@ const saveDebugResponse = async (prompt, response, filename = config.output.debu
  * @returns {Promise<any>} Result from fn
  * @throws {Error} If fn fails after all retries
  */
-const withRetry = async (fn, { maxRetries = 3, baseRetryDelay = 2000, retryCount = 0, operationName = 'operation', telemetryContext = null } = {}) => {
+const withRetry = async (
+    fn,
+    {
+        maxRetries = 3,
+        baseRetryDelay = 2000,
+        retryCount = 0,
+        operationName = 'operation',
+        telemetryContext = null
+    } = {}
+) => {
     const retryDelay = baseRetryDelay * Math.pow(2, retryCount);
     const startTime = Date.now();
 
@@ -705,8 +758,12 @@ const withRetry = async (fn, { maxRetries = 3, baseRetryDelay = 2000, retryCount
                 duration,
                 retryAttempt: retryCount,
                 totalRetries: maxRetries
-            }).catch(err => {
-                logger.debug('claude-client - withRetry', 'Failed to record success telemetry', err);
+            }).catch((err) => {
+                logger.debug(
+                    'claude-client - withRetry',
+                    'Failed to record success telemetry',
+                    err
+                );
             });
         }
 
@@ -725,8 +782,12 @@ const withRetry = async (fn, { maxRetries = 3, baseRetryDelay = 2000, retryCount
                 totalRetries: maxRetries,
                 responseLength: error.context?.response?.length || 0,
                 responsePreview: error.context?.response?.substring(0, 100) || ''
-            }).catch(err => {
-                logger.debug('claude-client - withRetry', 'Failed to record failure telemetry', err);
+            }).catch((err) => {
+                logger.debug(
+                    'claude-client - withRetry',
+                    'Failed to record failure telemetry',
+                    err
+                );
             });
         }
 
@@ -736,20 +797,16 @@ const withRetry = async (fn, { maxRetries = 3, baseRetryDelay = 2000, retryCount
         const isRecoverable = hasErrorInfo ? isRecoverableError(error.context.errorInfo) : false;
         const canRetry = retryCount < maxRetries;
 
-        logger.debug(
-            'claude-client - withRetry',
-            `Retry check for ${operationName}`,
-            {
-                retryCount,
-                maxRetries,
-                hasContext,
-                hasErrorInfo,
-                isRecoverable,
-                canRetry,
-                errorType: error.context?.errorInfo?.type,
-                errorName: error.name
-            }
-        );
+        logger.debug('claude-client - withRetry', `Retry check for ${operationName}`, {
+            retryCount,
+            maxRetries,
+            hasContext,
+            hasErrorInfo,
+            isRecoverable,
+            canRetry,
+            errorType: error.context?.errorInfo?.type,
+            errorName: error.name
+        });
 
         const shouldRetry = canRetry && hasContext && hasErrorInfo && isRecoverable;
 
@@ -760,13 +817,21 @@ const withRetry = async (fn, { maxRetries = 3, baseRetryDelay = 2000, retryCount
                 { errorType: error.context.errorInfo.type }
             );
 
-            console.log(`\n⏳ Retrying in ${retryDelay / 1000} seconds due to ${error.context.errorInfo.type}...\n`);
+            console.log(
+                `\n⏳ Retrying in ${retryDelay / 1000} seconds due to ${error.context.errorInfo.type}...\n`
+            );
 
             // Wait before retry
-            await new Promise(resolve => setTimeout(resolve, retryDelay));
+            await new Promise((resolve) => setTimeout(resolve, retryDelay));
 
             // Retry with incremented count and same telemetry context
-            return withRetry(fn, { maxRetries, baseRetryDelay, retryCount: retryCount + 1, operationName, telemetryContext });
+            return withRetry(fn, {
+                maxRetries,
+                baseRetryDelay,
+                retryCount: retryCount + 1,
+                operationName,
+                telemetryContext
+            });
         }
 
         // Add retry attempt to error context if not already present
@@ -794,13 +859,10 @@ const withRetry = async (fn, { maxRetries = 3, baseRetryDelay = 2000, retryCount
 const executeClaudeWithRetry = async (prompt, options = {}) => {
     const { telemetryContext = {}, ...executeOptions } = options;
 
-    return withRetry(
-        () => executeClaude(prompt, executeOptions),
-        {
-            operationName: 'executeClaude',
-            telemetryContext
-        }
-    );
+    return withRetry(() => executeClaude(prompt, executeOptions), {
+        operationName: 'executeClaude',
+        telemetryContext
+    });
 };
 
 /**
@@ -815,17 +877,20 @@ const executeClaudeWithRetry = async (prompt, options = {}) => {
  * @returns {Promise<Object>} Parsed analysis result
  * @throws {ClaudeClientError} If analysis fails
  */
-const analyzeCode = async (prompt, { timeout = 120000, saveDebug = config.system.debug, telemetryContext = {} } = {}) => {
+const analyzeCode = async (
+    prompt,
+    { timeout = 120000, saveDebug = config.system.debug, telemetryContext = {} } = {}
+) => {
     const startTime = Date.now();
 
-    logger.debug(
-        'claude-client - analyzeCode',
-        'Starting code analysis',
-        { promptLength: prompt.length, timeout, saveDebug }
-    );
+    logger.debug('claude-client - analyzeCode', 'Starting code analysis', {
+        promptLength: prompt.length,
+        timeout,
+        saveDebug
+    });
 
     // Rotate telemetry files periodically
-    rotateTelemetry().catch(err => {
+    rotateTelemetry().catch((err) => {
         logger.debug('claude-client - analyzeCode', 'Failed to rotate telemetry', err);
     });
 
@@ -845,16 +910,12 @@ const analyzeCode = async (prompt, { timeout = 120000, saveDebug = config.system
 
             const duration = Date.now() - startTime;
 
-            logger.debug(
-                'claude-client - analyzeCode',
-                'Analysis complete',
-                {
-                    hasApproved: 'approved' in result,
-                    hasQualityGate: 'QUALITY_GATE' in result,
-                    blockingIssuesCount: result.blockingIssues?.length ?? 0,
-                    duration
-                }
-            );
+            logger.debug('claude-client - analyzeCode', 'Analysis complete', {
+                hasApproved: 'approved' in result,
+                hasQualityGate: 'QUALITY_GATE' in result,
+                blockingIssuesCount: result.blockingIssues?.length ?? 0,
+                duration
+            });
 
             // Telemetry is now recorded by withRetry wrapper
             return result;
@@ -893,7 +954,7 @@ const chunkArray = (array, size) => {
 const analyzeCodeParallel = async (prompts, options = {}) => {
     const startTime = Date.now();
 
-    console.log(`\n${  '='.repeat(70)}`);
+    console.log(`\n${'='.repeat(70)}`);
     console.log(`🚀 PARALLEL EXECUTION: ${prompts.length} Claude processes`);
     console.log('='.repeat(70));
 
@@ -923,7 +984,7 @@ const analyzeCodeParallel = async (prompts, options = {}) => {
 
     console.log('='.repeat(70));
     console.log(`✅ PARALLEL EXECUTION COMPLETE: ${results.length} results in ${duration}s`);
-    console.log(`${'='.repeat(70)  }\n`);
+    console.log(`${'='.repeat(70)}\n`);
 
     logger.info(`Parallel analysis complete: ${results.length} results in ${duration}s`);
     return results;