claude-git-hooks 2.4.1 → 2.6.0

package/lib/utils/claude-client.js

@@ -22,6 +22,7 @@ import os from 'os';
 import logger from './logger.js';
 import config from '../config.js';
 import { detectClaudeError, formatClaudeError, ClaudeErrorType } from './claude-diagnostics.js';
+import { which } from './which-command.js';
 
 /**
  * Custom error for Claude client failures
@@ -40,9 +41,7 @@ class ClaudeClientError extends Error {
  * Detect if running on Windows
  * Why: Need to use 'wsl claude' instead of 'claude' on Windows
  */
-const isWindows = () => {
-    return os.platform() === 'win32' || process.env.OS === 'Windows_NT';
-};
+const isWindows = () => os.platform() === 'win32' || process.env.OS === 'Windows_NT';
 
 /**
  * Check if WSL is available on Windows
@@ -68,6 +67,7 @@ const isWSLAvailable = () => {
 /**
  * Get Claude command configuration for current platform
  * Why: On Windows, try native Claude first, then WSL as fallback
+ * Node 24 Fix: Uses which() to resolve absolute paths, avoiding shell: true
  *
  * @returns {Object} { command, args } - Command and base arguments
  * @throws {ClaudeClientError} If Claude not available on any method
@@ -75,42 +75,68 @@ const isWSLAvailable = () => {
 const getClaudeCommand = () => {
     if (isWindows()) {
         // Try native Windows Claude first (e.g., installed via npm/scoop/choco)
-        try {
-            execSync('claude --version', { stdio: 'ignore', timeout: 3000 });
-            logger.debug('claude-client - getClaudeCommand', 'Using native Windows Claude CLI');
-            return { command: 'claude', args: [] };
-        } catch (nativeError) {
-            logger.debug('claude-client - getClaudeCommand', 'Native Claude not found, trying WSL');
-
-            // 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'
-                        ]
-                    }
-                });
-            }
+        // 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 });
+            return { command: nativePath, args: [] };
+        }
+
+        logger.debug('claude-client - getClaudeCommand', 'Native Claude not found, trying WSL');
+
+        // 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'
+                    ]
+                }
+            });
+        }
 
-            // Check if Claude is available in WSL
+        // Check if Claude is available in WSL
+        // Node 24: Resolve wsl.exe absolute path to avoid shell: true
+        const wslPath = which('wsl');
+        if (wslPath) {
             try {
-                execSync('wsl claude --version', { stdio: 'ignore', timeout: 5000 });
-                logger.debug('claude-client - getClaudeCommand', 'Using WSL Claude CLI');
-                return { command: 'wsl', args: ['claude'] };
+                // Verify Claude exists in WSL
+                execSync(`"${wslPath}" claude --version`, { stdio: 'ignore', timeout: 5000 });
+                logger.debug('claude-client - getClaudeCommand', 'Using WSL Claude CLI', { wslPath });
+                return { command: wslPath, args: ['claude'] };
             } catch (wslError) {
-                throw new ClaudeClientError('Claude CLI not found in Windows or WSL', {
+                throw new ClaudeClientError('Claude CLI not found in WSL', {
                     context: {
                         platform: 'Windows',
-                        nativeError: nativeError.message,
+                        wslPath,
                         wslError: wslError.message
                     }
                 });
             }
         }
+
+        throw new ClaudeClientError('Claude CLI not found in Windows or WSL', {
+            context: {
+                platform: 'Windows',
+                suggestions: [
+                    'Install Claude CLI: npm install -g @anthropic-ai/claude-cli',
+                    'Or install WSL and Claude in WSL'
+                ]
+            }
+        });
+    }
+
+    // Unix (Linux, macOS): Use which() to get absolute path
+    const claudePath = which('claude');
+    if (claudePath) {
+        logger.debug('claude-client - getClaudeCommand', 'Using Claude CLI', { path: claudePath });
+        return { command: claudePath, args: [] };
     }
+
+    // Fallback to 'claude' if which fails (will error later if not found)
+    logger.debug('claude-client - getClaudeCommand', 'which() failed, using fallback', { command: 'claude' });
     return { command: 'claude', args: [] };
 };
 
@@ -125,127 +151,222 @@ const getClaudeCommand = () => {
  * @returns {Promise<string>} Claude's response
  * @throws {ClaudeClientError} If execution fails or times out
  */
-const executeClaude = (prompt, { timeout = 120000 } = {}) => {
-    return new Promise((resolve, reject) => {
-        // Get platform-specific command
-        const { command, args } = getClaudeCommand();
-        const fullCommand = args.length > 0 ? `${command} ${args.join(' ')}` : command;
+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(','));
+    }
 
-        logger.debug(
-            'claude-client - executeClaude',
-            'Executing Claude CLI',
-            { promptLength: prompt.length, timeout, command: fullCommand, isWindows: isWindows() }
-        );
+    const fullCommand = finalArgs.length > 0 ? `${command} ${finalArgs.join(' ')}` : command;
 
-        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
-        // shell: true needed on Windows to resolve .cmd/.bat executables
-        const claude = spawn(command, args, {
-            stdio: ['pipe', 'pipe', 'pipe'], // stdin, stdout, stderr
-            shell: true // Required for Windows to find .cmd/.bat files
-        });
+    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
+    const claude = spawn(command, finalArgs, {
+        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) => {
-            const duration = Date.now() - startTime;
-
-            if (code === 0) {
-                logger.debug(
-                    'claude-client - executeClaude',
-                    'Claude CLI execution successful',
-                    { duration, 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, duration, errorType: errorInfo.type }
-                    })
-                );
-
-                // Show formatted error to user
-                const formattedError = formatClaudeError(errorInfo);
-                console.error('\n' + formattedError + '\n');
-
-                reject(new ClaudeClientError(`Claude CLI error: ${errorInfo.type}`, {
-                    output: { stdout, stderr },
-                    context: { exitCode: code, duration, errorInfo }
-                }));
-            }
-        });
+    // Collect stderr
+    claude.stderr.on('data', (data) => {
+        stderr += data.toString();
+    });
 
-        // Handle errors
-        claude.on('error', (error) => {
-            logger.error(
+    // Handle process completion
+    claude.on('close', (code) => {
+        const duration = Date.now() - startTime;
+
+        if (code === 0) {
+            logger.debug(
                 'claude-client - executeClaude',
-                'Failed to spawn Claude CLI process',
-                error
+                'Claude CLI execution successful',
+                { duration, outputLength: stdout.length }
             );
+            resolve(stdout);
+        } else {
+            // Detect specific error type
+            const errorInfo = detectClaudeError(stdout, stderr, code);
 
-            reject(new ClaudeClientError('Failed to spawn Claude CLI', {
-                cause: error,
-                context: { command, args }
-            }));
-        });
-
-        // Set up timeout
-        const timeoutId = setTimeout(() => {
-            claude.kill();
             logger.error(
                 'claude-client - executeClaude',
-                'Claude CLI execution timed out',
-                new ClaudeClientError('Claude CLI timeout', {
-                    context: { timeout }
+                `Claude CLI failed: ${errorInfo.type}`,
+                new ClaudeClientError(`Claude CLI error: ${errorInfo.type}`, {
+                    output: { stdout, stderr },
+                    context: { exitCode: code, duration, errorType: errorInfo.type }
                 })
             );
 
-            reject(new ClaudeClientError('Claude CLI execution timed out', {
-                context: { timeout }
+            // Show formatted error to user
+            const formattedError = formatClaudeError(errorInfo);
+            console.error(`\n${  formattedError  }\n`);
+
+            reject(new ClaudeClientError(`Claude CLI error: ${errorInfo.type}`, {
+                output: { stdout, stderr },
+                context: { exitCode: code, duration, errorInfo }
             }));
-        }, timeout);
+        }
+    });
 
-        // Clear timeout if process completes
-        claude.on('close', () => clearTimeout(timeoutId));
+    // Handle errors
+    claude.on('error', (error) => {
+        logger.error(
+            'claude-client - executeClaude',
+            'Failed to spawn Claude CLI process',
+            error
+        );
 
-        // Write prompt to stdin
-        // Why: Claude CLI reads prompt from stdin, not command arguments
-        try {
-            claude.stdin.write(prompt);
-            claude.stdin.end();
-        } catch (error) {
-            logger.error(
-                'claude-client - executeClaude',
-                'Failed to write prompt to Claude CLI stdin',
-                error
-            );
+        reject(new ClaudeClientError('Failed to spawn Claude CLI', {
+            cause: error,
+            context: { command, args }
+        }));
+    });
 
-            reject(new ClaudeClientError('Failed to write prompt', {
-                cause: error
-            }));
-        }
+    // Set up timeout
+    const timeoutId = setTimeout(() => {
+        claude.kill();
+        logger.error(
+            'claude-client - executeClaude',
+            'Claude CLI execution timed out',
+            new ClaudeClientError('Claude CLI timeout', {
+                context: { timeout }
+            })
+        );
+
+        reject(new ClaudeClientError('Claude CLI execution timed out', {
+            context: { timeout }
+        }));
+    }, timeout);
+
+    // Clear timeout if process completes
+    claude.on('close', () => clearTimeout(timeoutId));
+
+    // Write prompt to stdin
+    // Why: Claude CLI reads prompt from stdin, not command arguments
+    try {
+        claude.stdin.write(prompt);
+        claude.stdin.end();
+    } catch (error) {
+        logger.error(
+            'claude-client - executeClaude',
+            'Failed to write prompt to Claude CLI stdin',
+            error
+        );
+
+        reject(new ClaudeClientError('Failed to write prompt', {
+            cause: error
+        }));
+    }
+});
+
+/**
+ * Executes Claude CLI fully interactively
+ * Why: Allows user to interact with Claude and approve MCP permissions
+ *
+ * @param {string} prompt - Prompt text to send to Claude
+ * @param {Object} options - Execution options
+ * @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');
+
+    // 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;
+    }
+
+    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('');
+
+    // 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 });
+    }
+
+    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 }
+        }));
+    }
+});
 
 /**
  * Extracts JSON from Claude's response
@@ -352,8 +473,8 @@ const saveDebugResponse = async (prompt, response, filename = config.output.debu
             timestamp: new Date().toISOString(),
             promptLength: prompt.length,
             responseLength: response.length,
-            prompt: prompt,
-            response: response
+            prompt,
+            response
         };
 
         await fs.writeFile(filename, JSON.stringify(debugData, null, 2), 'utf8');
@@ -361,12 +482,12 @@ 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
@@ -457,7 +578,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));
 
@@ -469,14 +590,14 @@ const analyzeCodeParallel = async (prompts, options = {}) => {
         return analyzeCode(prompt, options);
     });
 
-    console.log(`  ⏳ Waiting for all batches to complete...\n`);
+    console.log('  ⏳ Waiting for all batches to complete...\n');
     const results = await Promise.all(promises);
 
     const duration = ((Date.now() - startTime) / 1000).toFixed(2);
 
     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;
@@ -485,9 +606,13 @@ const analyzeCodeParallel = async (prompts, options = {}) => {
 export {
     ClaudeClientError,
     executeClaude,
+    executeClaudeInteractive,
     extractJSON,
     saveDebugResponse,
     analyzeCode,
     analyzeCodeParallel,
-    chunkArray
+    chunkArray,
+    isWindows,
+    isWSLAvailable,
+    getClaudeCommand
 };

package/lib/utils/file-operations.js

@@ -4,7 +4,6 @@
  *
  * Key responsibilities:
  * - Read files with size validation
- * - Filter SKIP-ANALYSIS patterns from code
  * - Validate file extensions
  * - Check file sizes
  *
@@ -15,7 +14,6 @@
  */
 
 import fs from 'fs/promises';
-import fsSync from 'fs';
 import path from 'path';
 import logger from './logger.js';
 
@@ -120,85 +118,6 @@ const readFile = async (filePath, { maxSize = 100000, encoding = 'utf8' } = {})
     }
 };
 
-/**
- * Filters SKIP_ANALYSIS patterns from code content
- * Why: Allows developers to exclude specific code from analysis
- *
- * ⚠️ KNOWN ISSUE (EXPERIMENTAL/BROKEN):
- * This feature does NOT work reliably. The pre-commit hook analyzes git diff
- * instead of full file content. Markers added in previous commits are NOT
- * present in subsequent diffs, so they are not detected.
- *
- * Example of failure:
- * - Commit 1: Add // SKIP_ANALYSIS_BLOCK markers
- * - Commit 2: Modify line inside block
- * - Result: Diff only shows modified line, NOT the markers → filter fails
- *
- * Supports two patterns:
- * 1. Single line: // SKIP_ANALYSIS_LINE (excludes next line)
- * 2. Block: // SKIP_ANALYSIS_BLOCK ... // SKIP_ANALYSIS_BLOCK (excludes block)
- *
- * @param {string} content - File content to filter
- * @returns {string} Filtered content
- */
-const filterSkipAnalysis = (content) => {
-    logger.debug(
-        'file-operations - filterSkipAnalysis',
-        'Filtering SKIP_ANALYSIS patterns',
-        { originalLength: content.length }
-    );
-
-    const lines = content.split('\n');
-    let skipNext = false;
-    let inSkipBlock = false;
-
-    // Why: Use map instead of filter to preserve line numbers for error reporting
-    // Empty lines maintain original line number mapping
-    const filteredLines = lines.map((line) => {
-        // IMPORTANT: Check specific pattern first (SKIP_ANALYSIS_BLOCK)
-        // before general pattern (SKIP_ANALYSIS_LINE) to avoid substring match issues
-
-        // Detect SKIP_ANALYSIS_BLOCK (toggle block state)
-        if (line.includes('// SKIP_ANALYSIS_BLOCK')) {
-            inSkipBlock = !inSkipBlock;
-            return ''; // Preserve line number
-        }
-
-        // Detect single-line SKIP_ANALYSIS_LINE (must check AFTER block check)
-        if (line.includes('// SKIP_ANALYSIS_LINE')) {
-            skipNext = true;
-            return ''; // Preserve line number
-        }
-
-        // Skip lines inside block
-        if (inSkipBlock) {
-            return '';
-        }
-
-        // Skip next line after single SKIP_ANALYSIS_LINE
-        if (skipNext) {
-            skipNext = false;
-            return '';
-        }
-
-        return line;
-    });
-
-    const filtered = filteredLines.join('\n');
-
-    logger.debug(
-        'file-operations - filterSkipAnalysis',
-        'Filtering complete',
-        {
-            originalLength: content.length,
-            filteredLength: filtered.length,
-            linesRemoved: lines.length - filteredLines.filter(l => l !== '').length
-        }
-    );
-
-    return filtered;
-};
-
 /**
  * Validates file extension against allowed list
  * Why: Pre-commit hook should only analyze specific file types
@@ -361,32 +280,11 @@ const filterFiles = async (files, { maxSize = 100000, extensions = [] } = {}) =>
     return fileMetadata;
 };
 
-/**
- * Reads multiple files in parallel with filtering
- * Why: Efficiently loads file contents for analysis
- *
- * @param {Array<string>} files - Array of file paths
- * @param {Object} options - Read options
- * @param {number} options.maxSize - Max file size
- * @param {boolean} options.applySkipFilter - Apply SKIP-ANALYSIS filtering
- * @returns {Promise<Array<Object>>} Files with content
- *
- * Returned object structure:
- * [
- *   {
- *     path: string,           // File path
- *     content: string,        // File content (filtered if requested)
- *     size: number,           // Original size in bytes
- *     error: Error            // Error if read failed
- *   }
- * ]
- */
 export {
     FileOperationError,
     getFileSize,
     fileExists,
     readFile,
-    filterSkipAnalysis,
     hasAllowedExtension,
     filterFiles
 };