claude-git-hooks 2.4.0 → 2.5.0

package/lib/hooks/prepare-commit-msg.js

@@ -20,11 +20,11 @@
 import fs from 'fs/promises';
 import { getStagedFiles, getStagedStats, getFileDiff } from '../utils/git-operations.js';
 import { analyzeCode } from '../utils/claude-client.js';
-import { filterSkipAnalysis } from '../utils/file-operations.js';
 import { loadPrompt } from '../utils/prompt-builder.js';
 import { getVersion, calculateBatches } from '../utils/package-info.js';
 import logger from '../utils/logger.js';
 import { getConfig } from '../config.js';
+import { getOrPromptTaskId, formatWithTaskId } from '../utils/task-id.js';
 
 /**
  * Builds commit message generation prompt
@@ -179,7 +179,21 @@ const main = async () => {
 
         logger.info('Generating commit message automatically...');
 
-        // Get staged files
+        // Step 1: Auto-detect task ID from branch (no prompt)
+        logger.debug('prepare-commit-msg - main', 'Detecting task ID from branch');
+        const taskId = await getOrPromptTaskId({
+            prompt: false,  // Don't prompt - just detect from branch
+            required: false,
+            config: config  // Pass config for custom pattern
+        });
+
+        if (taskId) {
+            logger.info(`📋 Task ID detected: ${taskId}`);
+        } else {
+            logger.debug('prepare-commit-msg - main', 'No task ID found in branch, continuing without it');
+        }
+
+        // Step 2: Get staged files
         const stagedFiles = getStagedFiles();
 
         if (stagedFiles.length === 0) {
@@ -208,7 +222,6 @@ const main = async () => {
                     let diff = null;
                     if (fileStats.size < config.analysis.maxFileSize) {
                         diff = getFileDiff(filePath);
-                        diff = filterSkipAnalysis(diff);
                     }
 
                     return {
@@ -265,7 +278,17 @@ const main = async () => {
         );
 
         // Format message
-        const message = formatCommitMessage(response);
+        let message = formatCommitMessage(response);
+
+        // Add task ID prefix if available
+        if (taskId) {
+            message = formatWithTaskId(message, taskId);
+            logger.debug(
+                'prepare-commit-msg - main',
+                'Task ID added to message',
+                { taskId, message: message.split('\n')[0] }
+            );
+        }
 
         // Write to commit message file
         await fs.writeFile(commitMsgFile, message + '\n', 'utf8');

package/lib/utils/claude-client.js

@@ -67,22 +67,49 @@ const isWSLAvailable = () => {
 
 /**
  * Get Claude command configuration for current platform
- * Why: On Windows, Claude CLI runs in WSL, so we need 'wsl' as command and 'claude' as arg
+ * Why: On Windows, try native Claude first, then WSL as fallback
  *
  * @returns {Object} { command, args } - Command and base arguments
- * @throws {ClaudeClientError} If Windows without WSL
+ * @throws {ClaudeClientError} If Claude not available on any method
  */
 const getClaudeCommand = () => {
     if (isWindows()) {
-        if (!isWSLAvailable()) {
-            throw new ClaudeClientError('WSL is required on Windows but not found', {
-                context: {
-                    platform: 'Windows',
-                    suggestion: 'Install WSL: https://docs.microsoft.com/en-us/windows/wsl/install'
-                }
-            });
+        // 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'
+                        ]
+                    }
+                });
+            }
+
+            // Check if Claude is available in WSL
+            try {
+                execSync('wsl claude --version', { stdio: 'ignore', timeout: 5000 });
+                logger.debug('claude-client - getClaudeCommand', 'Using WSL Claude CLI');
+                return { command: 'wsl', args: ['claude'] };
+            } catch (wslError) {
+                throw new ClaudeClientError('Claude CLI not found in Windows or WSL', {
+                    context: {
+                        platform: 'Windows',
+                        nativeError: nativeError.message,
+                        wslError: wslError.message
+                    }
+                });
+            }
         }
-        return { command: 'wsl', args: ['claude'] };
     }
     return { command: 'claude', args: [] };
 };
@@ -98,24 +125,34 @@ 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();
 
         // Why: Use spawn instead of exec to handle large prompts and responses
         // spawn streams data, exec buffers everything in memory
-        const claude = spawn(command, args, {
-            stdio: ['pipe', 'pipe', 'pipe'] // stdin, stdout, stderr
+        // shell: true needed on Windows to resolve .cmd/.bat executables
+        const claude = spawn(command, finalArgs, {
+            stdio: ['pipe', 'pipe', 'pipe'], // stdin, stdout, stderr
+            shell: true // Required for Windows to find .cmd/.bat files
         });
 
         let stdout = '';
@@ -218,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
@@ -456,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
 };