claude-git-hooks 2.18.0 → 2.19.0

package/lib/utils/claude-diagnostics.js

@@ -76,8 +76,12 @@ export const detectClaudeError = (stdout = '', stderr = '', exitCode = 1) => {
     }
 
     // 3. Authentication failure detection
-    if (stdout.includes('not authenticated') || stderr.includes('not authenticated') ||
-        stdout.includes('authentication failed') || stderr.includes('authentication failed')) {
+    if (
+        stdout.includes('not authenticated') ||
+        stderr.includes('not authenticated') ||
+        stdout.includes('authentication failed') ||
+        stderr.includes('authentication failed')
+    ) {
         return {
             type: ClaudeErrorType.AUTH_FAILED,
             exitCode
@@ -85,8 +89,12 @@ export const detectClaudeError = (stdout = '', stderr = '', exitCode = 1) => {
     }
 
     // 4. Network errors
-    if (stderr.includes('ENOTFOUND') || stderr.includes('ECONNREFUSED') ||
-        stderr.includes('network error') || stderr.includes('connection refused')) {
+    if (
+        stderr.includes('ENOTFOUND') ||
+        stderr.includes('ECONNREFUSED') ||
+        stderr.includes('network error') ||
+        stderr.includes('connection refused')
+    ) {
         return {
             type: ClaudeErrorType.NETWORK,
             exitCode
@@ -150,7 +158,6 @@ const formatTimingInfo = (errorInfo) => {
  * @returns {string} Formatted error message
  */
 export const formatClaudeError = (errorInfo) => {
-
     switch (errorInfo.type) {
     case ClaudeErrorType.EXECUTION_ERROR:
         return formatExecutionError(errorInfo);
@@ -219,7 +226,9 @@ const formatRateLimitError = (errorInfo) => {
         const hours = Math.ceil(minutesUntilReset / 60);
         lines.push(`  Time until reset: ~${hours} hour${hours > 1 ? 's' : ''}`);
     } else if (minutesUntilReset > 0) {
-        lines.push(`  Time until reset: ~${minutesUntilReset} minute${minutesUntilReset !== 1 ? 's' : ''}`);
+        lines.push(
+            `  Time until reset: ~${minutesUntilReset} minute${minutesUntilReset !== 1 ? 's' : ''}`
+        );
     } else {
         lines.push('  Limit should be reset now');
     }
@@ -345,7 +354,8 @@ const formatGenericError = (errorInfo) => {
  * @param {Object} errorInfo - Output from detectClaudeError()
  * @returns {boolean} True if error might resolve with retry
  */
-export const isRecoverableError = (errorInfo) => errorInfo.type === ClaudeErrorType.EXECUTION_ERROR ||
-           errorInfo.type === ClaudeErrorType.RATE_LIMIT ||
-           errorInfo.type === ClaudeErrorType.NETWORK ||
-           errorInfo.type === ClaudeErrorType.TIMEOUT;
+export const isRecoverableError = (errorInfo) =>
+    errorInfo.type === ClaudeErrorType.EXECUTION_ERROR ||
+    errorInfo.type === ClaudeErrorType.RATE_LIMIT ||
+    errorInfo.type === ClaudeErrorType.NETWORK ||
+    errorInfo.type === ClaudeErrorType.TIMEOUT;

package/lib/utils/file-operations.js

@@ -78,11 +78,7 @@ const fileExists = async (filePath) => {
  * @throws {FileOperationError} If file too large or read fails
  */
 const readFile = async (filePath, { maxSize = 100000, encoding = 'utf8' } = {}) => {
-    logger.debug(
-        'file-operations - readFile',
-        'Reading file',
-        { filePath, maxSize, encoding }
-    );
+    logger.debug('file-operations - readFile', 'Reading file', { filePath, maxSize, encoding });
 
     try {
         const size = await getFileSize(filePath);
@@ -97,14 +93,12 @@ const readFile = async (filePath, { maxSize = 100000, encoding = 'utf8' } = {})
 
         const content = await fs.readFile(filePath, encoding);
 
-        logger.debug(
-            'file-operations - readFile',
-            'File read successfully',
-            { filePath, contentLength: content.length }
-        );
+        logger.debug('file-operations - readFile', 'File read successfully', {
+            filePath,
+            contentLength: content.length
+        });
 
         return content;
-
     } catch (error) {
         if (error instanceof FileOperationError) {
             throw error;
@@ -132,15 +126,14 @@ const hasAllowedExtension = (filePath, allowedExtensions = []) => {
     }
 
     const ext = path.extname(filePath).toLowerCase();
-    const isAllowed = allowedExtensions.some(allowed =>
-        ext === allowed.toLowerCase()
-    );
+    const isAllowed = allowedExtensions.some((allowed) => ext === allowed.toLowerCase());
 
-    logger.debug(
-        'file-operations - hasAllowedExtension',
-        'Extension check',
-        { filePath, ext, allowedExtensions, isAllowed }
-    );
+    logger.debug('file-operations - hasAllowedExtension', 'Extension check', {
+        filePath,
+        ext,
+        allowedExtensions,
+        isAllowed
+    });
 
     return isAllowed;
 };
@@ -166,27 +159,19 @@ const hasAllowedExtension = (filePath, allowedExtensions = []) => {
  * ]
  */
 const filterFiles = async (files, { maxSize = 100000, extensions = [] } = {}) => {
-    logger.debug(
-        'file-operations - filterFiles',
-        'Filtering files',
-        {
-            fileCount: files.length,
-            maxSize,
-            extensions,
-            'process.cwd()': process.cwd(),
-            files
-        }
-    );
+    logger.debug('file-operations - filterFiles', 'Filtering files', {
+        fileCount: files.length,
+        maxSize,
+        extensions,
+        'process.cwd()': process.cwd(),
+        files
+    });
 
     const results = await Promise.allSettled(
         files.map(async (filePath) => {
             // Check extension first (fast)
             if (!hasAllowedExtension(filePath, extensions)) {
-                logger.debug(
-                    'file-operations - filterFiles',
-                    'Extension rejected',
-                    { filePath }
-                );
+                logger.debug('file-operations - filterFiles', 'Extension rejected', { filePath });
                 return {
                     path: filePath,
                     size: 0,
@@ -197,11 +182,10 @@ const filterFiles = async (files, { maxSize = 100000, extensions = [] } = {}) =>
 
             // Check if file exists
             const exists = await fileExists(filePath);
-            logger.debug(
-                'file-operations - filterFiles',
-                'File exists check',
-                { filePath, exists }
-            );
+            logger.debug('file-operations - filterFiles', 'File exists check', {
+                filePath,
+                exists
+            });
             if (!exists) {
                 return {
                     path: filePath,
@@ -216,11 +200,13 @@ const filterFiles = async (files, { maxSize = 100000, extensions = [] } = {}) =>
                 const size = await getFileSize(filePath);
 
                 if (size > maxSize) {
-                    logger.debug(
-                        'file-operations - filterFiles',
-                        'File too large',
-                        { filePath, size, maxSize, 'size (KB)': Math.round(size / 1024), 'maxSize (KB)': Math.round(maxSize / 1024) }
-                    );
+                    logger.debug('file-operations - filterFiles', 'File too large', {
+                        filePath,
+                        size,
+                        maxSize,
+                        'size (KB)': Math.round(size / 1024),
+                        'maxSize (KB)': Math.round(maxSize / 1024)
+                    });
                     return {
                         path: filePath,
                         size,
@@ -229,11 +215,12 @@ const filterFiles = async (files, { maxSize = 100000, extensions = [] } = {}) =>
                     };
                 }
 
-                logger.debug(
-                    'file-operations - filterFiles',
-                    'File passed size check',
-                    { filePath, size, maxSize, 'size (KB)': Math.round(size / 1024) }
-                );
+                logger.debug('file-operations - filterFiles', 'File passed size check', {
+                    filePath,
+                    size,
+                    maxSize,
+                    'size (KB)': Math.round(size / 1024)
+                });
 
                 return {
                     path: filePath,
@@ -241,13 +228,11 @@ const filterFiles = async (files, { maxSize = 100000, extensions = [] } = {}) =>
                     valid: true,
                     reason: null
                 };
-
             } catch (error) {
-                logger.debug(
-                    'file-operations - filterFiles',
-                    'Error reading file',
-                    { filePath, error: error.message }
-                );
+                logger.debug('file-operations - filterFiles', 'Error reading file', {
+                    filePath,
+                    error: error.message
+                });
                 return {
                     path: filePath,
                     size: 0,
@@ -259,32 +244,19 @@ const filterFiles = async (files, { maxSize = 100000, extensions = [] } = {}) =>
     );
 
     // Extract successful results
-    const fileMetadata = results
-        .filter(r => r.status === 'fulfilled')
-        .map(r => r.value);
+    const fileMetadata = results.filter((r) => r.status === 'fulfilled').map((r) => r.value);
 
-    const validFiles = fileMetadata.filter(f => f.valid);
-    const invalidFiles = fileMetadata.filter(f => !f.valid);
+    const validFiles = fileMetadata.filter((f) => f.valid);
+    const invalidFiles = fileMetadata.filter((f) => !f.valid);
 
-    logger.debug(
-        'file-operations - filterFiles',
-        'Filtering complete',
-        {
-            totalFiles: files.length,
-            validFiles: validFiles.length,
-            invalidFiles: invalidFiles.length,
-            rejectedFiles: invalidFiles.map(f => ({ path: f.path, reason: f.reason }))
-        }
-    );
+    logger.debug('file-operations - filterFiles', 'Filtering complete', {
+        totalFiles: files.length,
+        validFiles: validFiles.length,
+        invalidFiles: invalidFiles.length,
+        rejectedFiles: invalidFiles.map((f) => ({ path: f.path, reason: f.reason }))
+    });
 
     return fileMetadata;
 };
 
-export {
-    FileOperationError,
-    getFileSize,
-    fileExists,
-    readFile,
-    hasAllowedExtension,
-    filterFiles
-};
+export { FileOperationError, getFileSize, fileExists, readFile, hasAllowedExtension, filterFiles };

package/lib/utils/file-utils.js

@@ -3,7 +3,8 @@
  * Purpose: Utility functions for file system operations
  */
 
-import fs from 'fs/promises';
+import fsPromises from 'fs/promises';
+import fs from 'fs';
 import path from 'path';
 import { getRepoRoot } from './git-operations.js';
 import logger from './logger.js';
@@ -15,12 +16,10 @@ import logger from './logger.js';
  * @returns {Promise<void>}
  */
 export const ensureDir = async (dirPath) => {
-    const absolutePath = path.isAbsolute(dirPath)
-        ? dirPath
-        : path.join(getRepoRoot(), dirPath);
+    const absolutePath = path.isAbsolute(dirPath) ? dirPath : path.join(getRepoRoot(), dirPath);
 
     try {
-        await fs.mkdir(absolutePath, { recursive: true });
+        await fsPromises.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);
@@ -51,14 +50,52 @@ export const ensureOutputDir = async (config) => {
 export const writeOutputFile = async (filePath, content, config) => {
     await ensureOutputDir(config);
 
-    const absolutePath = path.isAbsolute(filePath)
-        ? filePath
-        : path.join(getRepoRoot(), filePath);
+    const absolutePath = path.isAbsolute(filePath) ? filePath : path.join(getRepoRoot(), filePath);
 
-    await fs.writeFile(absolutePath, content, 'utf8');
+    await fsPromises.writeFile(absolutePath, content, 'utf8');
 
     logger.debug('file-utils - writeOutputFile', 'File written', {
         path: absolutePath,
         size: content.length
     });
 };
+
+/**
+ * Walks a directory tree recursively, invoking callbacks for each file
+ * Why: Shared traversal logic for discoverVersionFiles and discoverChangelogFiles
+ *
+ * @param {string} rootDir - Starting directory path
+ * @param {Object} options
+ * @param {number} options.maxDepth - Maximum recursion depth (default: 3)
+ * @param {Set<string>} options.ignoreSet - Directory names to skip
+ * @param {Function} options.onFile - Called as onFile(entry, fullPath) for each file entry
+ * @param {Function} options.onError - Called as onError(dir, error) on readdirSync failures
+ */
+export function walkDirectoryTree(
+    rootDir,
+    { maxDepth = 3, ignoreSet = new Set(), onFile, onError } = {}
+) {
+    function walk(dir, depth) {
+        if (depth > maxDepth) return;
+
+        try {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+            for (const entry of entries) {
+                if (entry.name.startsWith('.') || ignoreSet.has(entry.name)) continue;
+
+                const fullPath = path.join(dir, entry.name);
+
+                if (entry.isDirectory()) {
+                    walk(fullPath, depth + 1);
+                } else if (entry.isFile()) {
+                    onFile?.(entry, fullPath);
+                }
+            }
+        } catch (error) {
+            onError?.(dir, error);
+        }
+    }
+
+    walk(rootDir, 0);
+}