claude-git-hooks 2.33.1 → 2.35.0

package/lib/hooks/pre-commit.js

@@ -33,6 +33,7 @@ import { getVersion } from '../utils/package-info.js';
 import logger from '../utils/logger.js';
 import { getConfig } from '../config.js';
 import { recordMetric } from '../utils/metrics.js';
+import { runLinters, displayLintResults, lintIssuesToAnalysisDetails } from '../utils/linter-runner.js';
 
 /**
  * Configuration loaded from lib/config.js
@@ -144,11 +145,45 @@ const main = async () => {
             process.exit(0);
         }
 
-        // Step 3: Build file data using shared engine
+        // Step 3: Run linters (fast, deterministic — before Claude analysis)
+        // Unfixable lint issues are forwarded to the judge for semantic resolution
+        let unfixableLintDetails = [];
+        if (config.linting?.enabled !== false) {
+            logger.info('🔍 Running linters...');
+            const lintStartTime = Date.now();
+            const filePaths = validFiles.map((f) => (typeof f === 'string' ? f : f.path));
+            const lintResult = await runLinters(filePaths, config, presetName);
+            displayLintResults(lintResult);
+
+            // Record lint metric
+            recordMetric('linting.completed', {
+                preset: presetName,
+                fileCount: filePaths.length,
+                totalErrors: lintResult.totalErrors,
+                totalWarnings: lintResult.totalWarnings,
+                totalFixed: lintResult.totalFixed,
+                toolsRun: lintResult.results.filter((r) => !r.skipped).length,
+                toolsSkipped: lintResult.results.filter((r) => r.skipped).length,
+                duration: Date.now() - lintStartTime
+            }).catch((err) => {
+                logger.debug('pre-commit - main', 'Lint metrics recording failed', err);
+            });
+
+            // Forward all remaining lint issues (errors + warnings) to the judge
+            // The judge decides whether to fix, dismiss, or block — no hard exit here
+            if (lintResult.totalErrors > 0 || lintResult.totalWarnings > 0) {
+                unfixableLintDetails = lintIssuesToAnalysisDetails(lintResult);
+                logger.debug('pre-commit - main', 'Forwarding unfixable lint issues to judge', {
+                    count: unfixableLintDetails.length
+                });
+            }
+        }
+
+        // Step 4: Build file data using shared engine
         logger.debug('pre-commit - main', 'Building file data for analysis');
         const filesData = buildFilesData(validFiles, { staged: true });
 
-        // Step 4: Log analysis configuration
+        // Step 5: Log analysis configuration
         logger.info(`Sending ${filesData.length} files for review...`);
 
         // Display analysis routing hint
@@ -156,51 +191,82 @@ const main = async () => {
             logger.info('⚡ Intelligent orchestration: grouping files and assigning models');
         }
 
-        // Step 5: Run analysis using shared engine
+        // Step 6: Run analysis using shared engine
         const result = await runAnalysis(filesData, config, {
             hook: 'pre-commit',
             saveDebug: config.system.debug
         });
 
-        // Step 6: Display results using shared function
+        // Step 7: Display results using shared function
         displayResults(result);
 
-        // Step 6.5: Judge — auto-fix all issues
+        // Step 8: Merge unfixable lint issues into analysis result for the judge
+        if (unfixableLintDetails.length > 0) {
+            if (!Array.isArray(result.details)) {
+                result.details = [];
+            }
+            result.details.push(...unfixableLintDetails);
+
+            // Update issue counts
+            for (const detail of unfixableLintDetails) {
+                const sev = (detail.severity || 'minor').toLowerCase();
+                if (result.issues[sev] !== undefined) {
+                    result.issues[sev]++;
+                }
+            }
+
+            logger.info(`📋 ${unfixableLintDetails.length} unfixable lint issue(s) forwarded to judge`);
+        }
+
+        // Step 9: Judge — auto-fix all issues (Claude + lint)
         if (config.judge?.enabled !== false && hasAnyIssues(result)) {
+            let judgeModule;
             try {
-                const { judgeAndFix } = await import('../utils/judge.js');
-                const judgeResult = await judgeAndFix(result, filesData, config);
+                judgeModule = await import('../utils/judge.js');
+            } catch (importErr) {
+                logger.warning(`Judge module import failed: ${importErr.message}`);
+                logger.warning('Commit blocked — judge module unavailable');
+                result.QUALITY_GATE = 'FAILED';
+                result.approved = false;
+                judgeModule = null;
+            }
 
-                // Update result with remaining issues (fixed + false positives removed)
-                result.blockingIssues = judgeResult.remainingIssues.filter((i) =>
-                    ['blocker', 'critical'].includes((i.severity || '').toLowerCase())
-                );
-                result.details = judgeResult.remainingIssues;
-
-                // Recalculate quality gate — pass only if ALL issues resolved
-                if (judgeResult.remainingIssues.length === 0) {
-                    result.issues = {
-                        blocker: 0,
-                        critical: 0,
-                        major: 0,
-                        minor: 0,
-                        info: 0
-                    };
-                    result.QUALITY_GATE = 'PASSED';
-                    result.approved = true;
-                } else {
+            if (judgeModule) {
+                try {
+                    const { judgeAndFix } = judgeModule;
+                    const judgeResult = await judgeAndFix(result, filesData, config);
+
+                    // Update result with remaining issues (fixed + false positives removed)
+                    result.blockingIssues = judgeResult.remainingIssues.filter((i) =>
+                        ['blocker', 'critical'].includes((i.severity || '').toLowerCase())
+                    );
+                    result.details = judgeResult.remainingIssues;
+
+                    // Recalculate quality gate — pass only if ALL issues resolved
+                    if (judgeResult.remainingIssues.length === 0) {
+                        result.issues = {
+                            blocker: 0,
+                            critical: 0,
+                            major: 0,
+                            minor: 0,
+                            info: 0
+                        };
+                        result.QUALITY_GATE = 'PASSED';
+                        result.approved = true;
+                    } else {
+                        result.QUALITY_GATE = 'FAILED';
+                        result.approved = false;
+                    }
+                } catch (err) {
+                    logger.warning(`Judge execution failed: ${err.message}`);
+                    logger.warning('Commit blocked — judge could not verify issues');
                     result.QUALITY_GATE = 'FAILED';
                     result.approved = false;
                 }
-            } catch (err) {
-                logger.warning(`Judge failed: ${err.message}`);
-                logger.warning('Commit blocked — judge could not verify issues');
-                result.QUALITY_GATE = 'FAILED';
-                result.approved = false;
             }
         }
 
-        // Step 7: Check quality gate
+        // Step 10: Check quality gate
         const qualityGatePassed = result.QUALITY_GATE === 'PASSED';
         const approved = result.approved !== false;
 

package/lib/utils/judge.js

@@ -182,17 +182,19 @@ const judgeAndFix = async (analysisResult, filesData, config) => {
     const resolvedIndices = new Set();
     const verdicts = [];
 
-    for (let i = 0; i < fixes.length; i++) {
+    // Cap at allIssues.length — LLM may hallucinate extra fixes beyond the input count
+    const fixCount = Math.min(fixes.length, allIssues.length);
+
+    if (fixes.length > allIssues.length) {
+        logger.debug('judge', `LLM returned ${fixes.length} fixes for ${allIssues.length} issues — ignoring ${fixes.length - allIssues.length} extra entries`);
+    }
+
+    for (let i = 0; i < fixCount; i++) {
         const verdict = fixes[i];
         const num = i + 1;
-        // Find matching issue by index or use verdict data if index exceeds allIssues length
-        const matchedIssue = i < allIssues.length ? allIssues[i] : null;
-        const severity = matchedIssue
-            ? (matchedIssue.severity || 'unknown').toUpperCase()
-            : 'UNKNOWN';
-        const desc = matchedIssue
-            ? matchedIssue.description || matchedIssue.message || 'No description'
-            : verdict.explanation || 'Unknown issue';
+        const matchedIssue = allIssues[i];
+        const severity = (matchedIssue.severity || 'unknown').toUpperCase();
+        const desc = matchedIssue.description || matchedIssue.message || 'No description';
 
         if (verdict.assessment === 'FALSE_POSITIVE') {
             falsePositiveCount++;