claude-git-hooks 2.1.0 → 2.3.1

package/lib/config.js

@@ -0,0 +1,164 @@
+/**
+ * File: config.js
+ * Purpose: Centralized configuration management
+ *
+ * Priority: preset config > .claude/config.json > defaults
+ *
+ * Key features:
+ * - Single source of truth for all configurable values
+ * - No environment variables (except OS for platform detection)
+ * - Preset-aware (allowedExtensions come from preset templates)
+ * - User config (.claude/config.json) provides general preferences per project
+ * - Preset config provides tech-stack-specific overrides (highest priority)
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Default configuration
+ * All values can be overridden via .claude/config.json
+ */
+const defaults = {
+    // Analysis configuration
+    analysis: {
+        maxFileSize: 100000,              // 100KB - max file size to analyze
+        maxFiles: 10,                      // Max number of files per commit
+        timeout: 120000,                   // 2 minutes - Claude analysis timeout
+        contextLines: 3,                   // Git diff context lines
+        ignoreExtensions: [],              // Extensions to exclude (e.g., ['.min.js', '.lock'])
+        // NOTE: allowedExtensions comes from preset/template, not here
+    },
+
+    // Commit message generation
+    commitMessage: {
+        autoKeyword: 'auto',               // Keyword to trigger auto-generation
+        timeout: 180000,                   
+    },
+
+    // Subagent configuration (parallel analysis)
+    subagents: {
+        enabled: true,                     // Enable parallel file analysis
+        model: 'haiku',                    // haiku (fast), sonnet (balanced), opus (thorough)
+        batchSize: 3,                      // Parallel subagents per batch
+    },
+
+    // Template paths
+    templates: {
+        baseDir: '.claude',                                    // Base directory for all templates
+        analysis: 'CLAUDE_ANALYSIS_PROMPT_SONAR.md',          // Pre-commit analysis prompt
+        guidelines: 'CLAUDE_PRE_COMMIT_SONAR.md',             // Analysis guidelines
+        commitMessage: 'COMMIT_MESSAGE.md',                   // Commit message prompt
+        analyzeDiff: 'ANALYZE_DIFF.md',                       // PR analysis prompt
+        resolution: 'CLAUDE_RESOLUTION_PROMPT.md',            // Issue resolution prompt
+        subagentInstruction: 'SUBAGENT_INSTRUCTION.md',       // Parallel analysis instruction
+    },
+
+    // Output file paths (relative to repo root)
+    output: {
+        outputDir: '.claude/out',                                    // Output directory for all generated files
+        debugFile: '.claude/out/debug-claude-response.json',         // Debug response dump
+        resolutionFile: '.claude/out/claude_resolution_prompt.md',   // Generated resolution prompt
+        prAnalysisFile: '.claude/out/pr-analysis.json',              // PR analysis result
+    },
+
+    // System behavior
+    system: {
+        debug: false,                      // Enable debug logging and file dumps
+        wslCheckTimeout: 3000,             // 3 seconds - quick WSL availability check
+    },
+
+    // Git operations
+    git: {
+        diffFilter: 'ACM',                 // Added, Copied, Modified (excludes Deleted)
+    },
+};
+
+/**
+ * Loads user configuration from .claude/config.json
+ * Merges with defaults and preset config (preset takes highest priority)
+ *
+ * Priority: defaults < user config < preset config
+ *
+ * @param {string} baseDir - Base directory to search for config (default: cwd)
+ * @returns {Promise<Object>} Merged configuration
+ */
+const loadUserConfig = async (baseDir = process.cwd()) => {
+    const configPath = path.join(baseDir, '.claude', 'config.json');
+
+    let userConfig = {};
+    try {
+        if (fs.existsSync(configPath)) {
+            userConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        }
+    } catch (error) {
+        console.warn(`⚠️  Warning: Could not load .claude/config.json: ${error.message}`);
+        console.warn('Using default configuration');
+    }
+
+    // Load preset if specified
+    let presetConfig = {};
+    if (userConfig.preset) {
+        try {
+            // Dynamic import to avoid circular dependency
+            const { loadPreset } = await import('./utils/preset-loader.js');
+            const { config } = await loadPreset(userConfig.preset);
+            presetConfig = config;
+        } catch (error) {
+            console.warn(`⚠️  Warning: Preset "${userConfig.preset}" not found, using defaults`);
+        }
+    }
+
+    // Merge: defaults < user < preset
+    return deepMerge(deepMerge(defaults, userConfig), presetConfig);
+};
+
+/**
+ * Deep merge two objects (user config overrides defaults)
+ *
+ * @param {Object} target - Target object (defaults)
+ * @param {Object} source - Source object (user overrides)
+ * @returns {Object} Merged object
+ */
+const deepMerge = (target, source) => {
+    const result = { ...target };
+
+    for (const key in source) {
+        if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+            result[key] = deepMerge(target[key] || {}, source[key]);
+        } else {
+            result[key] = source[key];
+        }
+    }
+
+    return result;
+};
+
+/**
+ * Get configuration instance
+ * Loads once, caches result
+ *
+ * Usage:
+ *   import { getConfig } from './lib/config.js';
+ *   const config = await getConfig();
+ *   const maxFiles = config.analysis.maxFiles;
+ */
+let configInstance = null;
+
+const getConfig = async () => {
+    if (!configInstance) {
+        configInstance = await loadUserConfig();
+    }
+    return configInstance;
+};
+
+// Export async loader
+export { getConfig, loadUserConfig, defaults };
+
+// Export a sync default for backwards compatibility (loads without preset)
+// NOTE: This will be deprecated - prefer using getConfig() directly
+export default defaults;

package/lib/hooks/pre-commit.js

@@ -30,57 +30,28 @@ import {
     filterSkipAnalysis,
     readFile
 } from '../utils/file-operations.js';
-import { analyzeCode } from '../utils/claude-client.js';
+import { analyzeCode, analyzeCodeParallel, chunkArray } from '../utils/claude-client.js';
 import { buildAnalysisPrompt } from '../utils/prompt-builder.js';
 import {
     generateResolutionPrompt,
     shouldGeneratePrompt
 } from '../utils/resolution-prompt.js';
+import { loadPreset } from '../utils/preset-loader.js';
+import { getVersion, calculateBatches } from '../utils/package-info.js';
 import logger from '../utils/logger.js';
+import { getConfig } from '../config.js';
 
-// Configuration constants
 /**
- * TOKEN USAGE ANALYSIS (200k token context window)
+ * Configuration loaded from lib/config.js
+ * Override via .claude/config.json
  *
- * Conversión aproximada: 1 token ≈ 4 caracteres, 1 KB ≈ 256 tokens
- *
- * Overhead fijo por análisis:
- * - Template análisis: 2KB ≈ 512 tokens
- * - Guidelines: 2KB ≈ 512 tokens
- * - Metadata: 0.2KB ≈ 50 tokens
- * - Total overhead: 4.2KB ≈ 1,074 tokens
- *
- * Escenarios con límites actuales:
- *
- * 1) 10 archivos modificados (solo diffs):
- *    - Diff promedio: 4KB/archivo × 10 = 40KB ≈ 10,240 tokens
- *    - Total: 44.2KB ≈ 11,314 tokens (5.6% de 200k) ✅
- *
- * 2) 10 archivos nuevos (contenido completo):
- *    - Archivo promedio: 30KB × 10 = 300KB ≈ 76,800 tokens
- *    - Total: 304.2KB ≈ 77,874 tokens (38.9% de 200k) ✅
- *
- * 3) Máximo permitido (10 × 100KB):
- *    - Total: 1,004KB ≈ 257,074 tokens (128.5% de 200k) ⚠️ EXCEDE
- *
- * Con SUBAGENTES (análisis paralelo):
- * - Cada archivo analizado independientemente con su propio overhead
- * - Batch size default: 3 archivos en paralelo
- * - Uso máximo por subagente: ~26,265 tokens (13% de 200k) ✅
- *
- * Recomendaciones:
- * - Límites actuales seguros para archivos modificados (diffs)
- * - Con subagentes: escala bien hasta 15-20 archivos
- * - Sin subagentes: limitar a 5-7 archivos grandes
- * - Considerar MAX_NEW_FILE_SIZE menor si se analizan muchos archivos nuevos
+ * TOKEN USAGE ANALYSIS (200k context window):
+ * - 1 token ≈ 4 chars, 1KB ≈ 256 tokens
+ * - Overhead: template(512) + guidelines(512) + metadata(50) ≈ 1,074 tokens
+ * - 10 modified files (diffs): ~11,314 tokens (5.6%) ✅
+ * - 10 new files (100KB each): ~257,074 tokens (128%) ⚠️ EXCEEDS
+ * - With subagents (batch=3): ~26,265 tokens per batch (13%) ✅
  */
-const CONFIG = {
-    MAX_FILE_SIZE: 100000, // 100KB
-    MAX_FILES: 10,
-    ALLOWED_EXTENSIONS: ['.java', '.xml', '.properties', '.yml', '.yaml'],
-    TEMPLATE_NAME: 'CLAUDE_ANALYSIS_PROMPT_SONAR.md',
-    GUIDELINES_NAME: 'CLAUDE_PRE_COMMIT_SONAR.md'
-};
 
 /**
  * Displays SonarQube-style analysis results
@@ -150,6 +121,56 @@ const displayResults = (result) => {
     }
 };
 
+/**
+ * Consolidates multiple analysis results into one
+ * @param {Array<Object>} results - Array of analysis results
+ * @returns {Object} - Consolidated result
+ */
+const consolidateResults = (results) => {
+    const consolidated = {
+        QUALITY_GATE: 'PASSED',
+        approved: true,
+        score: 10,
+        metrics: { reliability: 'A', security: 'A', maintainability: 'A', coverage: 100, duplications: 0, complexity: 0 },
+        issues: { blocker: 0, critical: 0, major: 0, minor: 0, info: 0 },
+        details: [],
+        blockingIssues: [],
+        securityHotspots: 0
+    };
+
+    for (const result of results) {
+        // Worst-case quality gate
+        if (result.QUALITY_GATE === 'FAILED') consolidated.QUALITY_GATE = 'FAILED';
+        if (result.approved === false) consolidated.approved = false;
+        if (result.score < consolidated.score) consolidated.score = result.score;
+
+        // Worst-case metrics
+        if (result.metrics) {
+            const metricOrder = { 'A': 5, 'B': 4, 'C': 3, 'D': 2, 'E': 1 };
+            ['reliability', 'security', 'maintainability'].forEach(m => {
+                const current = metricOrder[consolidated.metrics[m]] || 5;
+                const incoming = metricOrder[result.metrics[m]] || 5;
+                if (incoming < current) consolidated.metrics[m] = result.metrics[m];
+            });
+            if (result.metrics.coverage !== undefined) consolidated.metrics.coverage = Math.min(consolidated.metrics.coverage, result.metrics.coverage);
+            if (result.metrics.duplications !== undefined) consolidated.metrics.duplications = Math.max(consolidated.metrics.duplications, result.metrics.duplications);
+            if (result.metrics.complexity !== undefined) consolidated.metrics.complexity = Math.max(consolidated.metrics.complexity, result.metrics.complexity);
+        }
+
+        // Sum issue counts
+        if (result.issues) {
+            Object.keys(consolidated.issues).forEach(s => consolidated.issues[s] += (result.issues[s] || 0));
+        }
+
+        // Merge arrays
+        if (Array.isArray(result.details)) consolidated.details.push(...result.details);
+        if (Array.isArray(result.blockingIssues)) consolidated.blockingIssues.push(...result.blockingIssues);
+        if (result.securityHotspots) consolidated.securityHotspots += result.securityHotspots;
+    }
+
+    return consolidated;
+};
+
 /**
  * Main pre-commit hook execution
  */
@@ -157,18 +178,43 @@ const main = async () => {
     const startTime = Date.now();
 
     try {
+        // Load configuration
+        const config = await getConfig();
+
+        // Display configuration info
+        const version = await getVersion();
+        console.log(`\n🤖 claude-git-hooks v${version}`);
+
         logger.info('Starting code quality analysis...');
 
         logger.debug(
             'pre-commit - main',
             'Configuration',
-            { ...CONFIG }
+            { ...config }
         );
 
-        // Step 1: Get staged files
+        // Load active preset
+        const presetName = config.preset || 'default';
+        const { metadata } = await loadPreset(presetName);
+
+        logger.info(`🎯 Analyzing with '${metadata.displayName}' preset`);
+        logger.debug(
+            'pre-commit - main',
+            'Preset loaded',
+            {
+                preset: presetName,
+                fileExtensions: metadata.fileExtensions,
+                techStack: metadata.techStack
+            }
+        );
+
+        // Use preset's file extensions
+        const allowedExtensions = metadata.fileExtensions;
+
+        // Step 1: Get staged files with preset extensions
         logger.debug('pre-commit - main', 'Getting staged files');
         const stagedFiles = getStagedFiles({
-            extensions: CONFIG.ALLOWED_EXTENSIONS
+            extensions: allowedExtensions
         });
 
         if (stagedFiles.length === 0) {
@@ -177,12 +223,17 @@ const main = async () => {
         }
 
         logger.info(`Files to review: ${stagedFiles.length}`);
+        logger.debug(
+            'pre-commit - main',
+            'Files matched by preset',
+            { count: stagedFiles.length, extensions: allowedExtensions }
+        );
 
         // Step 2: Filter files by size
         logger.debug('pre-commit - main', 'Filtering files by size');
         const filteredFiles = await filterFiles(stagedFiles, {
-            maxSize: CONFIG.MAX_FILE_SIZE,
-            extensions: CONFIG.ALLOWED_EXTENSIONS
+            maxSize: config.analysis.maxFileSize,
+            extensions: allowedExtensions
         });
 
         const validFiles = filteredFiles.filter(f => f.valid);
@@ -192,7 +243,7 @@ const main = async () => {
             process.exit(0);
         }
 
-        if (validFiles.length > CONFIG.MAX_FILES) {
+        if (validFiles.length > config.analysis.maxFiles) {
             logger.warning(`Too many files to review (${validFiles.length})`);
             logger.warning('Consider splitting the commit into smaller parts');
             process.exit(0);
@@ -245,29 +296,91 @@ const main = async () => {
 
         // Step 4: Build analysis prompt
         logger.info(`Sending ${filesData.length} files for review...`);
-        logger.debug('pre-commit - main', 'Building analysis prompt');
-
-        const prompt = await buildAnalysisPrompt({
-            templateName: CONFIG.TEMPLATE_NAME,
-            guidelinesName: CONFIG.GUIDELINES_NAME,
-            files: filesData,
-            metadata: {
-                REPO_NAME: getRepoName(),
-                BRANCH_NAME: getCurrentBranch()
+
+        // Display subagent configuration
+        const subagentsEnabled = config.subagents?.enabled || false;
+        const subagentModel = config.subagents?.model || 'haiku';
+        const batchSize = config.subagents?.batchSize || 3;
+
+        if (subagentsEnabled && filesData.length >= 3) {
+            const { numBatches, shouldShowBatches } = calculateBatches(filesData.length, batchSize);
+            console.log(`⚡ Batch optimization: ${subagentModel} model, ${batchSize} files per batch`);
+            if (shouldShowBatches) {
+                console.log(`📊 Analyzing ${filesData.length} files in ${numBatches} batch${numBatches > 1 ? 'es' : ''}`);
             }
-        });
+        }
 
-        // Step 5: Analyze with Claude
-        logger.debug(
-            'pre-commit - main',
-            'Sending prompt to Claude',
-            { promptLength: prompt.length }
-        );
+        // Step 5: Analyze with Claude (parallel or single)
+        let result;
+            // TODO: This can be refactored so no conditional is needed. 
+            // Lists can have 0...N items, e.g. iterating a list of 1 element is akin to single execution.
+        if (subagentsEnabled && filesData.length >= 3) {
+            // Parallel execution: split files into batches
+            logger.info(`Using parallel execution with batch size ${batchSize}`);
+
+            const fileBatches = chunkArray(filesData, batchSize);
+            logger.debug('pre-commit - main', `Split into ${fileBatches.length} batches`);
+
+            // Build one prompt per batch
+            const prompts = await Promise.all(
+                fileBatches.map(async (batch) => {
+                    return await buildAnalysisPrompt({
+                        templateName: config.templates.analysis,
+                        guidelinesName: config.templates.guidelines,
+                        files: batch,
+                        metadata: {
+                            REPO_NAME: getRepoName(),
+                            BRANCH_NAME: getCurrentBranch()
+                        },
+                        subagentConfig: null  // Don't add subagent instruction for parallel
+                    });
+                })
+            );
+
+            // Execute in parallel
+            const results = await analyzeCodeParallel(prompts, {
+                timeout: config.analysis.timeout,
+                saveDebug: false  // Don't save debug for individual batches
+            });
+
+            // Simple consolidation: merge all results
+            result = consolidateResults(results);
+
+            // Save consolidated debug if enabled
+            if (config.system.debug) {
+                const { saveDebugResponse } = await import('../utils/claude-client.js');
+                await saveDebugResponse(
+                    `PARALLEL ANALYSIS: ${fileBatches.length} batches`,
+                    JSON.stringify(result, null, 2)
+                );
+            }
 
-        const result = await analyzeCode(prompt, {
-            timeout: 120000,
-            saveDebug: process.env.DEBUG === 'true'
-        });
+        } else {
+            // Single execution: original behavior
+            logger.debug('pre-commit - main', 'Building analysis prompt');
+
+            const prompt = await buildAnalysisPrompt({
+                templateName: config.templates.analysis,
+                guidelinesName: config.templates.guidelines,
+                files: filesData,
+                metadata: {
+                    REPO_NAME: getRepoName(),
+                    BRANCH_NAME: getCurrentBranch()
+                },
+                subagentConfig: config.subagents
+            });
+
+            logger.debug(
+                'pre-commit - main',
+                'Sending prompt to Claude',
+                { promptLength: prompt.length }
+            );
+
+            result = await analyzeCode(prompt, {
+                timeout: config.analysis.timeout,
+                saveDebug: config.system.debug
+            });
+        }
 
         // Step 6: Display results
         displayResults(result);

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

@@ -21,13 +21,10 @@ 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';
-
-// Configuration
-const CONFIG = {
-    MAX_FILE_SIZE: 100000, // 100KB
-    AUTO_KEYWORD: 'auto'
-};
+import { getConfig } from '../config.js';
 
 /**
  * Builds commit message generation prompt
@@ -35,49 +32,36 @@ const CONFIG = {
  *
  * @param {Array<Object>} filesData - Array of file change data
  * @param {Object} stats - Staging statistics
- * @returns {string} Complete prompt
+ * @returns {Promise<string>} Complete prompt
  */
-const buildCommitPrompt = (filesData, stats) => {
+const buildCommitPrompt = async (filesData, stats) => {
     logger.debug(
         'prepare-commit-msg - buildCommitPrompt',
         'Building commit message prompt',
         { fileCount: filesData.length }
     );
 
-    let prompt = `Analyze the following changes and generate a commit message following the Conventional Commits format.
-
-Respond ONLY with a valid JSON:
-
-{
-  "type": "feat|fix|docs|style|refactor|test|chore|ci|perf",
-  "scope": "optional scope (e.g.: api, frontend, db)",
-  "title": "short description in present tense (max 50 chars)",
-  "body": "optional detailed description"
-}
-
-CHANGES TO ANALYZE:
-
-`;
-
-    // Add file list
-    prompt += '\nModified files:\n';
-    filesData.forEach(({ path }) => {
-        prompt += `${path}\n`;
-    });
-
-    // Add statistics
-    prompt += `\nSummary of changes:\n`;
-    prompt += `Files changed: ${stats.totalFiles || filesData.length}\n`;
-    prompt += `Insertions: ${stats.insertions || 0}, Deletions: ${stats.deletions || 0}\n`;
+    // Build file list
+    const fileList = filesData.map(({ path }) => path).join('\n');
 
-    // Add diffs
+    // Build file diffs
+    let fileDiffs = '';
     filesData.forEach(({ path, diff }) => {
         if (diff) {
-            prompt += `\n--- Diff of ${path} ---\n`;
-            prompt += diff;
+            fileDiffs += `\n--- Diff of ${path} ---\n`;
+            fileDiffs += diff;
         }
     });
 
+    // Load prompt from template
+    const prompt = await loadPrompt('COMMIT_MESSAGE.md', {
+        FILE_LIST: fileList,
+        FILE_COUNT: stats.totalFiles || filesData.length,
+        INSERTIONS: stats.insertions || 0,
+        DELETIONS: stats.deletions || 0,
+        FILE_DIFFS: fileDiffs
+    });
+
     return prompt;
 };
 
@@ -133,6 +117,9 @@ const formatCommitMessage = (json) => {
 const main = async () => {
     const startTime = Date.now();
 
+    // Load configuration (includes preset + user overrides)
+    const config = await getConfig();
+
     try {
         // Get hook arguments
         const args = process.argv.slice(2);
@@ -166,7 +153,7 @@ const main = async () => {
         );
 
         // Check if message is "auto"
-        if (firstLine !== CONFIG.AUTO_KEYWORD) {
+        if (firstLine !== config.commitMessage.autoKeyword) {
             logger.debug(
                 'prepare-commit-msg - main',
                 'Not generating: message is not "auto"'
@@ -174,6 +161,17 @@ const main = async () => {
             process.exit(0);
         }
 
+        // Display configuration info
+        const version = await getVersion();
+        const subagentsEnabled = config.subagents?.enabled || false;
+        const subagentModel = config.subagents?.model || 'haiku';
+        const batchSize = config.subagents?.batchSize || 3;
+
+        console.log(`\n🤖 claude-git-hooks v${version}`);
+        if (subagentsEnabled) {
+            console.log(`⚡ Parallel analysis: ${subagentModel} model, batch size ${batchSize}`);
+        }
+
         logger.info('Generating commit message automatically...');
 
         // Get staged files
@@ -203,7 +201,7 @@ const main = async () => {
 
                     // Only include diff for small files
                     let diff = null;
-                    if (fileStats.size < CONFIG.MAX_FILE_SIZE) {
+                    if (fileStats.size < config.analysis.maxFileSize) {
                         diff = getFileDiff(filePath);
                         diff = filterSkipAnalysis(diff);
                     }
@@ -231,7 +229,7 @@ const main = async () => {
         );
 
         // Build prompt
-        const prompt = buildCommitPrompt(filesData, stats);
+        const prompt = await buildCommitPrompt(filesData, stats);
 
         logger.debug(
             'prepare-commit-msg - main',
@@ -239,12 +237,20 @@ const main = async () => {
             { promptLength: prompt.length }
         );
 
+        // Calculate batches if subagents enabled and applicable
+        if (subagentsEnabled && filesData.length >= 3) {
+            const { numBatches, shouldShowBatches } = calculateBatches(filesData.length, batchSize);
+            if (shouldShowBatches) {
+                console.log(`📊 Analyzing ${filesData.length} files in ${numBatches} batch${numBatches > 1 ? 'es' : ''}`);
+            }
+        }
+
         // Generate message with Claude
         logger.info('Sending to Claude...');
 
         const response = await analyzeCode(prompt, {
-            timeout: 60000, // 1 minute timeout
-            saveDebug: false
+            timeout: config.commitMessage.timeout,
+            saveDebug: config.system.debug
         });
 
         logger.debug(