claude-git-hooks 2.4.1 → 2.5.0

package/lib/utils/claude-client.js

@@ -125,16 +125,24 @@ const getClaudeCommand = () => {
  * @returns {Promise<string>} Claude's response
  * @throws {ClaudeClientError} If execution fails or times out
  */
-const executeClaude = (prompt, { timeout = 120000 } = {}) => {
+const executeClaude = (prompt, { timeout = 120000, allowedTools = [] } = {}) => {
     return new Promise((resolve, reject) => {
         // Get platform-specific command
         const { command, args } = getClaudeCommand();
-        const fullCommand = args.length > 0 ? `${command} ${args.join(' ')}` : command;
+
+        // 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 fullCommand = finalArgs.length > 0 ? `${command} ${finalArgs.join(' ')}` : command;
 
         logger.debug(
             'claude-client - executeClaude',
             'Executing Claude CLI',
-            { promptLength: prompt.length, timeout, command: fullCommand, isWindows: isWindows() }
+            { promptLength: prompt.length, timeout, command: fullCommand, isWindows: isWindows(), allowedTools }
         );
 
         const startTime = Date.now();
@@ -142,7 +150,7 @@ const executeClaude = (prompt, { timeout = 120000 } = {}) => {
         // 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, {
+        const claude = spawn(command, finalArgs, {
             stdio: ['pipe', 'pipe', 'pipe'], // stdin, stdout, stderr
             shell: true // Required for Windows to find .cmd/.bat files
         });
@@ -247,6 +255,97 @@ const executeClaude = (prompt, { timeout = 120000 } = {}) => {
     });
 };
 
+/**
+ * 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 } = {}) => {
+    return 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
  * Why: Claude may include markdown formatting or explanatory text around JSON
@@ -485,9 +584,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
 };