claude-git-hooks 2.12.0 → 2.13.0

package/CHANGELOG.md

@@ -5,6 +5,21 @@ Todos los cambios notables en este proyecto se documentarán en este archivo.
 El formato está basado en [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 y este proyecto adhiere a [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.13.0] - 2026-02-05
+
+### ✨ Added
+- Interactive analysis command `claude-hooks analyze` - review all issues (INFO to BLOCKER) interactively before committing with auto-commit option
+- Shared analysis engine module (`analysis-engine.js`) - centralized file data building, analysis orchestration, and results display for both pre-commit hooks and interactive analysis
+- Support for version files in subdirectories - automatically searches parent directories when version files not found in repo root
+- Auto-commit functionality after interactive analysis - creates commit with auto-generated message when user confirms
+
+### 🔧 Changed
+- Improved version detection logic for pom.xml files - enhanced reliability of version extraction in Maven projects
+
+### 🐛 Fixed
+- Fixed version search logic for pom.xml files - corrected parsing issues in Maven version detection
+
+
 ## [2.12.0] - 2026-02-03
 
 ### ✨ Added
@@ -43,7 +58,7 @@ y este proyecto adhiere a [Semantic Versioning](https://semver.org/spec/v2.0.0.h
 
 - **New utility modules**:
     - `lib/utils/version-manager.js` - Version detection, parsing, incrementing, validation
-    - `lib/utils/git-tag-manager.js` - Git tag operations (create, list, compare, push)
+    - `lib/utils/git-tag-manager.js` - Git tag operations (create, list, compare, push, isSemverTag)
     - `lib/utils/changelog-generator.js` - CHANGELOG generation with Claude
     - `templates/GENERATE_CHANGELOG.md` - Claude prompt for changelog analysis
 

package/README.md

@@ -60,6 +60,33 @@ export GITHUB_TOKEN="ghp_..."
 
 Create token at https://github.com/settings/tokens with scopes: `repo`, `read:org`
 
+### Analyze Code (Interactive Review)
+
+Run interactive code analysis before committing:
+
+```bash
+# Analyze staged changes (default)
+claude-hooks analyze
+
+# Analyze unstaged changes
+claude-hooks analyze --unstaged
+
+# Analyze all tracked files
+claude-hooks analyze --all
+```
+
+**What it does:**
+- Analyzes selected file scope (staged, unstaged, or all)
+- Shows all issues (INFO, MINOR, MAJOR, CRITICAL, BLOCKER)
+- Interactive prompt with options:
+  - **Continue**: Creates commit automatically with auto-generated message
+  - **Abort**: Generate resolution prompt and fix issues
+  - **View**: Show detailed issue list
+- Executes `git commit -m "auto" --no-verify` on confirmation
+- Works outside git hooks (no stdin limitations)
+
+**Use case:** Complete analysis-to-commit workflow in one command.
+
 ### Analyze Diff (without creating PR)
 
 ```bash
@@ -223,6 +250,7 @@ claude-hooks --help   # Full command reference
 
 | Module | Purpose | Key Exports |
 |--------|---------|-------------|
+| `analysis-engine.js` | **Shared analysis logic** - file data, orchestration, results (v2.13.0) | `buildFilesData()`, `runAnalysis()`, `consolidateResults()`, `displayResults()` |
 | `claude-client.js` | **Claude CLI wrapper** - spawn, retry, parallel execution | `analyzeCode()`, `analyzeCodeParallel()`, `executeClaudeWithRetry()` |
 | `prompt-builder.js` | **Prompt construction** - load templates, replace variables | `buildAnalysisPrompt()`, `loadPrompt()` |
 | `git-operations.js` | **Git abstractions** - staged files, diff, repo root | `getStagedFiles()`, `getDiff()`, `getRepoRoot()` |
@@ -242,12 +270,16 @@ claude-hooks --help   # Full command reference
 ```
 git commit → templates/pre-commit (bash wrapper)
   → lib/hooks/pre-commit.js
-  → getStagedFiles() → filter by preset extensions
-  → buildAnalysisPrompt() → analyzeCode() or analyzeCodeParallel()
-  → parse JSON response → exit 0 (pass) or exit 1 (block)
-  → if blocked: generates claude_resolution_prompt.md
+  → getStagedFiles() → filterFiles() by preset extensions + size
+  → buildFilesData() → runAnalysis() (via analysis-engine.js)
+  → displayResults() → show quality gate status
+  → if blocking issues (critical/blocker):
+      generates claude_resolution_prompt.md → exit 1 (block)
+  → if non-blocking or no issues: exit 0 (pass)
 ```
 
+**Note:** For interactive review of non-blocking issues, use `claude-hooks analyze` before committing.
+
 #### Commit Message Generation
 
 ```

package/bin/claude-hooks

@@ -13,6 +13,7 @@ import { error } from '../lib/commands/helpers.js';
 // Import commands
 import { runInstall } from '../lib/commands/install.js';
 import { runEnable, runDisable, runStatus, runUninstall } from '../lib/commands/hooks.js';
+import { runAnalyze } from '../lib/commands/analyze.js';
 import { runAnalyzeDiff } from '../lib/commands/analyze-diff.js';
 import { runCreatePr } from '../lib/commands/create-pr.js';
 import { runSetupGitHub } from '../lib/commands/setup-github.js';
@@ -51,6 +52,13 @@ async function main() {
         case 'status':
             runStatus();
             break;
+        case 'analyze':
+            await runAnalyze({
+                staged: !args.includes('--unstaged') && !args.includes('--all'),
+                unstaged: args.includes('--unstaged'),
+                all: args.includes('--all')
+            });
+            break;
         case 'analyze-diff':
             await runAnalyzeDiff(args.slice(1));
             break;

package/lib/commands/analyze.js

@@ -0,0 +1,217 @@
+/**
+ * File: analyze.js
+ * Purpose: On-demand code analysis command (interactive, runs outside git hooks)
+ *
+ * Why this exists: Git hooks cannot reliably read stdin for interactive prompts
+ * (stdin is redirected from /dev/null). This command provides interactive analysis
+ * before committing, allowing developers to review all issues and decide whether
+ * to proceed or fix them first.
+ *
+ * Key features:
+ * - Runs outside git hook context (stdin works normally)
+ * - Analyzes staged, unstaged, or all tracked files
+ * - Interactive confirmation with detailed issue view
+ * - Generates resolution prompt on abort
+ *
+ * Usage:
+ *   claude-hooks analyze              # Analyze staged files (default)
+ *   claude-hooks analyze --unstaged   # Analyze unstaged changes
+ *   claude-hooks analyze --all        # Analyze all tracked files
+ */
+
+import { getStagedFiles, getUnstagedFiles, getAllTrackedFiles, createCommit } from '../utils/git-operations.js';
+import { filterFiles } from '../utils/file-operations.js';
+import {
+    buildFilesData,
+    runAnalysis,
+    hasAnyIssues,
+    displayIssueSummary
+} from '../utils/analysis-engine.js';
+import { promptUserConfirmation, promptConfirmation } from '../utils/interactive-ui.js';
+import { generateResolutionPrompt } from '../utils/resolution-prompt.js';
+import { getConfig } from '../config.js';
+import { loadPreset } from '../utils/preset-loader.js';
+import logger from '../utils/logger.js';
+import { error, success, info } from './helpers.js';
+
+/**
+ * Main analyze command
+ * Why: Provides interactive analysis before committing
+ *
+ * @param {Object} options - Command options
+ * @param {boolean} options.staged - Analyze staged files (default: true)
+ * @param {boolean} options.unstaged - Analyze unstaged files
+ * @param {boolean} options.all - Analyze all tracked files
+ */
+export const runAnalyze = async (options = {}) => {
+    const { unstaged = false, all = false } = options;
+
+    try {
+        // Load configuration
+        const config = await getConfig();
+
+        // Enable debug mode from config
+        if (config.system?.debug) {
+            logger.setDebugMode(true);
+        }
+
+        // Load active preset for file extensions
+        const presetName = config.preset || 'default';
+        const { metadata } = await loadPreset(presetName);
+        const allowedExtensions = metadata.fileExtensions;
+
+        // Determine scope
+        let scopeLabel = 'staged changes';
+        if (all) {
+            scopeLabel = 'all tracked files';
+        } else if (unstaged) {
+            scopeLabel = 'unstaged changes';
+        }
+
+        info(`Analyzing ${scopeLabel} with '${metadata.displayName}' preset...`);
+
+        // Get files based on scope
+        let files = [];
+        if (all) {
+            files = getAllTrackedFiles({ extensions: allowedExtensions });
+        } else if (unstaged) {
+            files = getUnstagedFiles({ extensions: allowedExtensions });
+        } else {
+            files = getStagedFiles({ extensions: allowedExtensions });
+        }
+
+        if (files.length === 0) {
+            info(`No files to analyze in ${scopeLabel}.`);
+            process.exit(0);
+        }
+
+        logger.debug('analyze', 'Files found', {
+            scope: scopeLabel,
+            count: files.length,
+            extensions: allowedExtensions
+        });
+
+        // Filter files by size
+        const filteredFiles = await filterFiles(files, {
+            maxSize: config.analysis?.maxFileSize || 1048576,
+            extensions: allowedExtensions
+        });
+
+        const validFiles = filteredFiles.filter(f => f.valid);
+        const invalidFiles = filteredFiles.filter(f => !f.valid);
+
+        // Show warnings for skipped files
+        if (invalidFiles.length > 0) {
+            invalidFiles.forEach(file => {
+                logger.warning(`Skipping ${file.path}: ${file.reason}`);
+            });
+        }
+
+        if (validFiles.length === 0) {
+            info(`No valid files found to analyze in ${scopeLabel}.`);
+            process.exit(0);
+        }
+
+        info(`Sending ${validFiles.length} file(s) for analysis...`);
+
+        // Build file data (diff/content) using shared engine
+        const filesData = buildFilesData(validFiles, { staged: !unstaged && !all });
+
+        if (filesData.length === 0) {
+            info('No file data could be extracted.');
+            process.exit(0);
+        }
+
+        // Run analysis using shared engine
+        const result = await runAnalysis(filesData, config, { hook: 'analyze' });
+
+        // Check results
+        if (!hasAnyIssues(result)) {
+            console.log('');
+            success('No issues found. Code is ready to commit!');
+            console.log('');
+
+            // Prompt user to commit or cancel
+            const shouldCommit = await promptConfirmation('Create commit now?', true);
+
+            if (shouldCommit) {
+                info('Creating commit with auto-generated message...');
+                console.log('');
+
+                const commitResult = createCommit('auto', { noVerify: true });
+
+                if (commitResult.success) {
+                    success('Commit created successfully!');
+                    if (commitResult.output) {
+                        console.log(commitResult.output);
+                    }
+                    console.log('');
+                    process.exit(0);
+                } else {
+                    error(`Commit failed: ${commitResult.error}`);
+                    console.log('');
+                    process.exit(1);
+                }
+            } else {
+                info('Commit cancelled. Staged files remain unchanged.');
+                console.log('');
+                process.exit(0);
+            }
+        }
+
+        // Display summary
+        console.log('');
+        console.log('Analysis complete:');
+        displayIssueSummary(result);
+        console.log('');
+
+        // Interactive confirmation (works outside git hook)
+        const userChoice = await promptUserConfirmation(result);
+
+        if (userChoice === 'abort') {
+            // Generate resolution prompt
+            await generateResolutionPrompt(result, {
+                fileCount: filesData.length
+            });
+            console.log('');
+            success('Resolution prompt generated: claude_resolution_prompt.md');
+            info('Fix issues and run `claude-hooks analyze` again.');
+            console.log('');
+            process.exit(1);
+        } else {
+            // User chose to continue - execute commit automatically
+            console.log('');
+
+            // Safeguard: verify staged files still exist
+            const currentStagedFiles = getStagedFiles({ extensions: allowedExtensions });
+            if (currentStagedFiles.length === 0) {
+                error('No staged files found. Did you unstage changes?');
+                process.exit(1);
+            }
+
+            info('Creating commit with auto-generated message...');
+            console.log('');
+
+            // Execute commit with --no-verify (skip hooks - we already analyzed)
+            const commitResult = createCommit('auto', { noVerify: true });
+
+            if (commitResult.success) {
+                success('Commit created successfully!');
+                if (commitResult.output) {
+                    console.log(commitResult.output);
+                }
+                console.log('');
+                process.exit(0);
+            } else {
+                error(`Commit failed: ${commitResult.error}`);
+                console.log('');
+                process.exit(1);
+            }
+        }
+
+    } catch (err) {
+        logger.error('analyze', 'Analysis failed', err);
+        error(`Analysis failed: ${err.message}`);
+        process.exit(1);
+    }
+};

package/lib/commands/bump-version.js

@@ -20,7 +20,8 @@ import {
     getCurrentVersion,
     incrementVersion,
     updateVersion,
-    parseVersion
+    parseVersion,
+    getDiscoveredPaths
 } from '../utils/version-manager.js';
 import {
     createTag,
@@ -102,7 +103,7 @@ function validatePrerequisites() {
         logger.error('bump-version - validatePrerequisites', 'Validation failed', err);
         return {
             valid: false,
-            errors: ['Validation error: ' + err.message]
+            errors: [`Validation error: ${  err.message}`]
         };
     }
 }
@@ -258,9 +259,23 @@ export async function runBumpVersion(args) {
         console.log('  - package.json (Node.js project)');
         console.log('  - pom.xml (Maven project)');
         console.log('');
+        console.log('Searched in repository root and one level deep in subdirectories.');
+        console.log('');
         process.exit(1);
     }
 
+    // Show discovered paths
+    const paths = getDiscoveredPaths();
+    const repoRoot = getRepoRoot();
+    if (paths.packageJson) {
+        const relativePath = path.relative(repoRoot, paths.packageJson);
+        info(`Found package.json: ${relativePath}`);
+    }
+    if (paths.pomXml) {
+        const relativePath = path.relative(repoRoot, paths.pomXml);
+        info(`Found pom.xml: ${relativePath}`);
+    }
+
     const versions = getCurrentVersion(projectType);
     const currentVersion = versions.resolved;
 
@@ -403,7 +418,7 @@ export async function runBumpVersion(args) {
                     const pushResult = pushTags(null, tagName);
 
                     if (pushResult.success) {
-                        showSuccess(`✓ Tag pushed to remote`);
+                        showSuccess('✓ Tag pushed to remote');
                     } else {
                         showError(`Failed to push tag: ${pushResult.error}`);
                         console.log('');
@@ -435,7 +450,7 @@ export async function runBumpVersion(args) {
         console.log('');
         console.log('Next steps:');
         console.log('  1. Review the changes: git diff');
-        console.log('  2. Commit the version bump: git add . && git commit -m "chore: bump version to ' + newVersion + '"');
+        console.log(`  2. Commit the version bump: git add . && git commit -m "chore: bump version to ${  newVersion  }"`);
         console.log('  3. Create PR: claude-hooks create-pr main');
         console.log('');
 
@@ -445,7 +460,7 @@ export async function runBumpVersion(args) {
         console.log('');
         console.log('The operation was interrupted. You may need to:');
         console.log('  - Revert changes: git checkout .');
-        console.log('  - Delete tag if created: git tag -d ' + tagName);
+        console.log(`  - Delete tag if created: git tag -d ${  tagName}`);
         console.log('');
         process.exit(1);
     }