claude-git-hooks 2.0.0 → 2.3.0

package/lib/utils/claude-client.js

@@ -16,8 +16,10 @@
 
 import { spawn, execSync } from 'child_process';
 import fs from 'fs/promises';
+import path from 'path';
 import os from 'os';
 import logger from './logger.js';
+import config from '../config.js';
 
 /**
  * Custom error for Claude client failures
@@ -53,7 +55,7 @@ const isWSLAvailable = () => {
 
     try {
         // Try to run wsl --version to check if WSL is installed
-        execSync('wsl --version', { stdio: 'ignore', timeout: 3000 });
+        execSync('wsl --version', { stdio: 'ignore', timeout: config.system.wslCheckTimeout });
         return true;
     } catch (error) {
         logger.debug('claude-client - isWSLAvailable', 'WSL not available', error);
@@ -294,15 +296,45 @@ const extractJSON = (response) => {
 };
 
 /**
- * Saves response to debug file
- * Why: Helps troubleshoot issues with Claude responses
+ * Saves prompt and response to debug file
+ * Why: Helps troubleshoot issues with Claude responses and verify prompts
  *
- * @param {string} response - Raw response to save
- * @param {string} filename - Debug filename (default: 'debug-claude-response.json')
+ * @param {string} prompt - Prompt sent to Claude
+ * @param {string} response - Raw response from Claude
+ * @param {string} filename - Debug filename (default: from config)
  */
-const saveDebugResponse = async (response, filename = 'debug-claude-response.json') => {
+const saveDebugResponse = async (prompt, response, filename = config.output.debugFile) => {
     try {
-        await fs.writeFile(filename, response, 'utf8');
+        // Ensure output directory exists
+        const outputDir = path.dirname(filename);
+        await fs.mkdir(outputDir, { recursive: true });
+
+        // Save full debug information
+        const debugData = {
+            timestamp: new Date().toISOString(),
+            promptLength: prompt.length,
+            responseLength: response.length,
+            prompt: prompt,
+            response: response
+        };
+
+        await fs.writeFile(filename, JSON.stringify(debugData, null, 2), 'utf8');
+
+        // Display batch optimization status
+        try {
+            if (prompt.includes('OPTIMIZATION')) {
+                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');
+            }
+        } catch (parseError) {
+            // Ignore parsing errors, just skip the display
+        }
+
+        logger.info(`📝 Debug output saved to ${filename}`);
         logger.debug(
             'claude-client - saveDebugResponse',
             `Debug response saved to ${filename}`
@@ -323,11 +355,11 @@ const saveDebugResponse = async (response, filename = 'debug-claude-response.jso
  * @param {string} prompt - Analysis prompt
  * @param {Object} options - Analysis options
  * @param {number} options.timeout - Timeout in milliseconds
- * @param {boolean} options.saveDebug - Save response to debug file (default: from DEBUG env)
+ * @param {boolean} options.saveDebug - Save response to debug file (default: from config)
  * @returns {Promise<Object>} Parsed analysis result
  * @throws {ClaudeClientError} If analysis fails
  */
-const analyzeCode = async (prompt, { timeout = 120000, saveDebug = process.env.DEBUG === 'true' } = {}) => {
+const analyzeCode = async (prompt, { timeout = 120000, saveDebug = config.system.debug } = {}) => {
     logger.debug(
         'claude-client - analyzeCode',
         'Starting code analysis',
@@ -340,7 +372,7 @@ const analyzeCode = async (prompt, { timeout = 120000, saveDebug = process.env.D
 
         // Save debug if requested
         if (saveDebug) {
-            await saveDebugResponse(response);
+            await saveDebugResponse(prompt, response);
         }
 
         // Extract and parse JSON
@@ -364,10 +396,60 @@ const analyzeCode = async (prompt, { timeout = 120000, saveDebug = process.env.D
     }
 };
 
+/**
+ * Splits array into chunks
+ * @param {Array} array - Array to split
+ * @param {number} size - Chunk size
+ * @returns {Array<Array>} Array of chunks
+ */
+const chunkArray = (array, size) => {
+    const chunks = [];
+    for (let i = 0; i < array.length; i += size) {
+        chunks.push(array.slice(i, i + size));
+    }
+    return chunks;
+};
+
+/**
+ * Runs multiple analyzeCode calls in parallel
+ * @param {Array<string>} prompts - Array of prompts to analyze
+ * @param {Object} options - Same options as analyzeCode
+ * @returns {Promise<Array<Object>>} Array of results
+ */
+const analyzeCodeParallel = async (prompts, options = {}) => {
+    const startTime = Date.now();
+
+    console.log('\n' + '='.repeat(70));
+    console.log(`🚀 PARALLEL EXECUTION: ${prompts.length} Claude processes`);
+    console.log('='.repeat(70));
+
+    logger.info(`Starting parallel analysis: ${prompts.length} prompts`);
+
+    const promises = prompts.map((prompt, index) => {
+        console.log(`  ⚡ Launching batch ${index + 1}/${prompts.length}...`);
+        logger.debug('claude-client - analyzeCodeParallel', `Starting batch ${index + 1}`);
+        return analyzeCode(prompt, options);
+    });
+
+    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');
+
+    logger.info(`Parallel analysis complete: ${results.length} results in ${duration}s`);
+    return results;
+};
+
 export {
     ClaudeClientError,
     executeClaude,
     extractJSON,
     saveDebugResponse,
-    analyzeCode
+    analyzeCode,
+    analyzeCodeParallel,
+    chunkArray
 };

package/lib/utils/file-operations.js

@@ -121,11 +121,21 @@ const readFile = async (filePath, { maxSize = 100000, encoding = 'utf8' } = {})
 };
 
 /**
- * Filters SKIP-ANALYSIS patterns from code content
+ * 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 (excludes next line)
+ * 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
@@ -134,7 +144,7 @@ const readFile = async (filePath, { maxSize = 100000, encoding = 'utf8' } = {})
 const filterSkipAnalysis = (content) => {
     logger.debug(
         'file-operations - filterSkipAnalysis',
-        'Filtering SKIP-ANALYSIS patterns',
+        'Filtering SKIP_ANALYSIS patterns',
         { originalLength: content.length }
     );
 
@@ -145,11 +155,8 @@ const filterSkipAnalysis = (content) => {
     // 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) => {
-        // Detect single-line SKIP-ANALYSIS
-        if (line.includes('// SKIP-ANALYSIS')) {
-            skipNext = true;
-            return ''; // Preserve line number
-        }
+        // 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')) {
@@ -157,12 +164,18 @@ const filterSkipAnalysis = (content) => {
             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
+        // Skip next line after single SKIP_ANALYSIS_LINE
         if (skipNext) {
             skipNext = false;
             return '';
@@ -334,69 +347,6 @@ const filterFiles = async (files, { maxSize = 100000, extensions = [] } = {}) =>
  *   }
  * ]
  */
-const readMultipleFiles = async (files, { maxSize = 100000, applySkipFilter = true } = {}) => {
-    logger.debug(
-        'file-operations - readMultipleFiles',
-        'Reading multiple files',
-        { fileCount: files.length, maxSize, applySkipFilter }
-    );
-
-    const results = await Promise.allSettled(
-        files.map(async (filePath) => {
-            try {
-                let content = await readFile(filePath, { maxSize });
-
-                // Apply SKIP-ANALYSIS filtering if requested
-                if (applySkipFilter) {
-                    content = filterSkipAnalysis(content);
-                }
-
-                const size = await getFileSize(filePath);
-
-                return {
-                    path: filePath,
-                    content,
-                    size,
-                    error: null
-                };
-
-            } catch (error) {
-                logger.error(
-                    'file-operations - readMultipleFiles',
-                    `Failed to read file: ${filePath}`,
-                    error
-                );
-
-                return {
-                    path: filePath,
-                    content: null,
-                    size: 0,
-                    error
-                };
-            }
-        })
-    );
-
-    // Extract all results (both successful and failed)
-    const fileContents = results.map(r =>
-        r.status === 'fulfilled' ? r.value : r.reason
-    );
-
-    const successCount = fileContents.filter(f => f.error === null).length;
-
-    logger.debug(
-        'file-operations - readMultipleFiles',
-        'Reading complete',
-        {
-            totalFiles: files.length,
-            successfulReads: successCount,
-            failedReads: files.length - successCount
-        }
-    );
-
-    return fileContents;
-};
-
 export {
     FileOperationError,
     getFileSize,
@@ -404,6 +354,5 @@ export {
     readFile,
     filterSkipAnalysis,
     hasAllowedExtension,
-    filterFiles,
-    readMultipleFiles
+    filterFiles
 };

package/lib/utils/file-utils.js

@@ -0,0 +1,65 @@
+/**
+ * File: file-utils.js
+ * Purpose: Utility functions for file system operations
+ */
+
+import fs from 'fs/promises';
+import fsSync from 'fs';
+import path from 'path';
+import { getRepoRoot } from './git-operations.js';
+import logger from './logger.js';
+
+/**
+ * Ensures a directory exists (creates if not present)
+ *
+ * @param {string} dirPath - Directory path to ensure
+ * @returns {Promise<void>}
+ */
+export const ensureDir = async (dirPath) => {
+    const absolutePath = path.isAbsolute(dirPath)
+        ? dirPath
+        : path.join(getRepoRoot(), dirPath);
+
+    try {
+        await fs.mkdir(absolutePath, { recursive: true });
+        logger.debug('file-utils - ensureDir', 'Directory ensured', { path: absolutePath });
+    } catch (error) {
+        logger.error('file-utils - ensureDir', 'Failed to create directory', error);
+        throw error;
+    }
+};
+
+/**
+ * Ensures the output directory exists before writing files
+ * Creates .claude/out/ if it doesn't exist
+ *
+ * @param {Object} config - Configuration object with output.outputDir
+ * @returns {Promise<void>}
+ */
+export const ensureOutputDir = async (config) => {
+    const outputDir = config?.output?.outputDir || '.claude/out';
+    await ensureDir(outputDir);
+};
+
+/**
+ * Writes a file ensuring its directory exists
+ *
+ * @param {string} filePath - File path to write
+ * @param {string} content - File content
+ * @param {Object} config - Configuration object
+ * @returns {Promise<void>}
+ */
+export const writeOutputFile = async (filePath, content, config) => {
+    await ensureOutputDir(config);
+
+    const absolutePath = path.isAbsolute(filePath)
+        ? filePath
+        : path.join(getRepoRoot(), filePath);
+
+    await fs.writeFile(absolutePath, content, 'utf8');
+
+    logger.debug('file-utils - writeOutputFile', 'File written', {
+        path: absolutePath,
+        size: content.length
+    });
+};

package/lib/utils/package-info.js

@@ -0,0 +1,75 @@
+/**
+ * File: package-info.js
+ * Purpose: Utility for reading package.json information
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * @typedef {Object} PackageData
+ * @property {string} name - Package name
+ * @property {string} version - Package version
+ * @property {string} [description] - Package description
+ */
+
+/**
+ * Cache for package.json to avoid repeated file reads
+ * @type {PackageData|undefined}
+ */
+let packageCache;
+
+/**
+ * Gets package.json data with caching (async)
+ * @returns {Promise<PackageData>} Package data with name and version
+ * @throws {Error} If package.json cannot be read
+ */
+export const getPackageJson = async () => {
+    // Return cached value if available
+    if (packageCache) {
+        return packageCache;
+    }
+
+    try {
+        const packagePath = path.join(__dirname, '..', '..', 'package.json');
+        const content = await fs.readFile(packagePath, 'utf8');
+        packageCache = JSON.parse(content);
+        return packageCache;
+    } catch (error) {
+        throw new Error(`Failed to read package.json: ${error.message}`);
+    }
+};
+
+/**
+ * Gets package version (async)
+ * @returns {Promise<string>} Package version
+ */
+export const getVersion = async () => {
+    const pkg = await getPackageJson();
+    return pkg.version;
+};
+
+/**
+ * Gets package name (async)
+ * @returns {Promise<string>} Package name
+ */
+export const getPackageName = async () => {
+    const pkg = await getPackageJson();
+    return pkg.name;
+};
+
+/**
+ * Calculates batch information for subagent processing
+ * @param {number} fileCount - Number of files to process
+ * @param {number} batchSize - Size of each batch
+ * @returns {Object} Batch information { numBatches, shouldShowBatches }
+ */
+export const calculateBatches = (fileCount, batchSize) => {
+    const numBatches = Math.ceil(fileCount / batchSize);
+    const shouldShowBatches = fileCount > batchSize;
+    return { numBatches, shouldShowBatches };
+};

package/lib/utils/preset-loader.js

@@ -0,0 +1,209 @@
+/**
+ * File: preset-loader.js
+ * Purpose: Loads preset configurations and metadata
+ *
+ * Key responsibilities:
+ * - Load preset.json (metadata)
+ * - Load config.json (overrides)
+ * - Resolve template paths
+ * - Replace placeholders in templates
+ *
+ * Dependencies:
+ * - fs/promises: Async file operations
+ * - path: Cross-platform path handling
+ * - git-operations: For getRepoRoot()
+ * - logger: Debug and error logging
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { getRepoRoot } from './git-operations.js';
+import logger from './logger.js';
+
+/**
+ * Custom error for preset loading failures
+ */
+class PresetError extends Error {
+    constructor(message, { presetName, cause } = {}) {
+        super(message);
+        this.name = 'PresetError';
+        this.presetName = presetName;
+        this.cause = cause;
+    }
+}
+
+/**
+ * Loads preset metadata + config
+ * @param {string} presetName - Name of preset (backend, frontend, etc.)
+ * @returns {Promise<Object>} { metadata, config, templates }
+ */
+export async function loadPreset(presetName) {
+    logger.debug(
+        'preset-loader - loadPreset',
+        'Loading preset',
+        { presetName }
+    );
+
+    const repoRoot = getRepoRoot();
+
+    // Only try .claude/presets/{name} (installed by claude-hooks install)
+    const presetDir = path.join(repoRoot, '.claude', 'presets', presetName);
+
+    logger.debug('preset-loader - loadPreset', 'Loading preset from', { presetDir });
+
+    try {
+        // Load preset.json (metadata)
+        const presetJsonPath = path.join(presetDir, 'preset.json');
+        const metadataRaw = await fs.readFile(presetJsonPath, 'utf8');
+        const metadata = JSON.parse(metadataRaw);
+
+        // Load config.json (overrides)
+        const configJsonPath = path.join(presetDir, 'config.json');
+        const configRaw = await fs.readFile(configJsonPath, 'utf8');
+        const config = JSON.parse(configRaw);
+
+        // Resolve template paths
+        const templates = {};
+        for (const [key, templatePath] of Object.entries(metadata.templates)) {
+            templates[key] = path.join(presetDir, templatePath);
+        }
+
+        logger.debug(
+            'preset-loader - loadPreset',
+            'Preset loaded successfully',
+            {
+                presetName,
+                displayName: metadata.displayName,
+                fileExtensions: metadata.fileExtensions,
+                templateCount: Object.keys(templates).length
+            }
+        );
+
+        return { metadata, config, templates };
+
+    } catch (error) {
+        logger.error(
+            'preset-loader - loadPreset',
+            `Failed to load preset: ${presetName}`,
+            error
+        );
+
+        throw new PresetError(`Preset "${presetName}" not found or invalid`, {
+            presetName,
+            cause: error
+        });
+    }
+}
+
+/**
+ * Loads a template file and replaces placeholders
+ * @param {string} templatePath - Absolute path to template file
+ * @param {Object} metadata - Preset metadata for placeholder replacement
+ * @returns {Promise<string>} Template content with placeholders replaced
+ */
+export async function loadTemplate(templatePath, metadata) {
+    logger.debug(
+        'preset-loader - loadTemplate',
+        'Loading template',
+        { templatePath }
+    );
+
+    try {
+        let template = await fs.readFile(templatePath, 'utf8');
+
+        // Replace placeholders
+        template = template.replace(
+            /{{TECH_STACK}}/g,
+            metadata.techStack.join(', ')
+        );
+        template = template.replace(
+            /{{FOCUS_AREAS}}/g,
+            metadata.focusAreas.join(', ')
+        );
+        template = template.replace(
+            /{{FILE_EXTENSIONS}}/g,
+            metadata.fileExtensions.join(', ')
+        );
+        template = template.replace(
+            /{{PRESET_NAME}}/g,
+            metadata.name
+        );
+
+        logger.debug(
+            'preset-loader - loadTemplate',
+            'Template loaded and processed',
+            {
+                templatePath,
+                originalLength: template.length
+            }
+        );
+
+        return template;
+
+    } catch (error) {
+        logger.error(
+            'preset-loader - loadTemplate',
+            `Failed to load template: ${templatePath}`,
+            error
+        );
+
+        throw new PresetError(`Template not found: ${templatePath}`, {
+            cause: error
+        });
+    }
+}
+
+/**
+ * Lists all available presets in .claude/presets/
+ * @returns {Promise<Array<Object>>} Array of preset metadata
+ * Returns: [{ name, displayName, description }]
+ */
+export async function listPresets() {
+    logger.debug('preset-loader - listPresets', 'Listing available presets');
+
+    const repoRoot = getRepoRoot();
+    const presets = [];
+
+    // Load all presets from .claude/presets/ (installed by claude-hooks install)
+    const presetsDir = path.join(repoRoot, '.claude', 'presets');
+    try {
+        const presetNames = await fs.readdir(presetsDir);
+
+        for (const name of presetNames) {
+            const presetJsonPath = path.join(presetsDir, name, 'preset.json');
+            try {
+                const metadataRaw = await fs.readFile(presetJsonPath, 'utf8');
+                const metadata = JSON.parse(metadataRaw);
+
+                presets.push({
+                    name: metadata.name,
+                    displayName: metadata.displayName,
+                    description: metadata.description
+                });
+            } catch (error) {
+                logger.debug(
+                    'preset-loader - listPresets',
+                    `Skipping invalid preset: ${name}`,
+                    error
+                );
+            }
+        }
+    } catch (error) {
+        logger.warning('No presets directory found. Run "claude-hooks install" first.');
+        logger.debug(
+            'preset-loader - listPresets',
+            'Failed to read presets directory',
+            error
+        );
+    }
+
+    logger.debug(
+        'preset-loader - listPresets',
+        'Presets listed',
+        { count: presets.length }
+    );
+
+    return presets;
+}
+
+export { PresetError };