claude-git-hooks 2.11.0 → 2.13.0

package/CHANGELOG.md

@@ -5,28 +5,95 @@ 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
+
+- **Automatic version management with `bump-version` command**
+    - Detects project type (Node.js, Maven, or monorepo with both)
+    - Increments version following semantic versioning (major/minor/patch)
+    - Supports version suffixes (SNAPSHOT, RC, custom)
+    - Updates package.json and/or pom.xml automatically
+    - Generates CHANGELOG entries using Claude AI analysis of commits
+    - Creates annotated Git tags with `v` prefix (v2.7.0, v2.7.0-SNAPSHOT)
+    - Automatically pushes tags to remote
+    - CLI options: `--suffix`, `--update-changelog`, `--dry-run`, `--no-tag`, `--no-push`
+
+- **CHANGELOG generation with Claude integration**
+    - Standalone `generate-changelog` command for independent CHANGELOG generation without version bumping
+    - Support for manual version specification in CHANGELOG generation via command argument
+    - Base branch selection for CHANGELOG comparison via `--base-branch` flag
+    - Release marking option via `--release` flag to control [Unreleased] header behavior
+    - Analyzes commits since last final version tag
+    - Categorizes changes by Conventional Commits types
+    - Generates human-readable entries in Keep a Changelog format
+    - Sections: Added, Changed, Fixed, Security, Deprecated, Removed
+    - Places entries in [Unreleased] for suffixed versions, [X.Y.Z] for final versions
+
+- **Version alignment validation in `create-pr`** (#44)
+    - Checks consistency across package.json, pom.xml, CHANGELOG.md, and git tags
+    - Compares local version vs remote version
+    - Shows helpful prompts with fix commands if misalignment detected
+    - Allows user to continue or abort PR creation based on validation results
+
+- **Unpushed tags detection in `create-pr`** (#44)
+    - Detects local tags not pushed to remote
+    - Prompts user to push tags before creating PR
+    - Prevents version inconsistencies between local and remote
+
+- **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, isSemverTag)
+    - `lib/utils/changelog-generator.js` - CHANGELOG generation with Claude
+    - `templates/GENERATE_CHANGELOG.md` - Claude prompt for changelog analysis
+
+### 🔧 Changed
+
+- Improved Windows compatibility by quoting git log format string in changelog-generator.js
+
+### 📚 Documentation
+
+- Updated help.js with bump-version command documentation and examples
+- Added version workflow examples (development → RC → release)
+- Updated CLAUDE.md with new utility modules and exports
+
 ## [2.11.0] - 2026-02-03
 
 ### ✨ Added
 
 - **Auto-push functionality in `create-pr` command** - Automatically detects and pushes unpublished branches before creating PR (#59, #34)
-  - Handles 3 scenarios: unpublished branch, unpushed commits, up-to-date branch
-  - Interactive confirmation prompt before pushing (configurable)
-  - Commit preview showing what will be pushed
-  - Diverged branch detection with helpful error message and resolution steps
-  - Never uses `git push --force` for security
+    - Handles 3 scenarios: unpublished branch, unpushed commits, up-to-date branch
+    - Interactive confirmation prompt before pushing (configurable)
+    - Commit preview showing what will be pushed
+    - Diverged branch detection with helpful error message and resolution steps
+    - Never uses `git push --force` for security
 
 - **New configuration options** under `github.pr`:
-  - `autoPush: true` - Enable/disable auto-push (enabled by default)
-  - `pushConfirm: true` - Prompt for confirmation before push
-  - `showCommits: true` - Show commit preview before push
-  - `verifyRemote: true` - Verify remote exists before push
+    - `autoPush: true` - Enable/disable auto-push (enabled by default)
+    - `pushConfirm: true` - Prompt for confirmation before push
+    - `showCommits: true` - Show commit preview before push
+    - `verifyRemote: true` - Verify remote exists before push
 
 - **New git-operations functions**:
-  - `getRemoteName()` - Get configured remote name (usually 'origin')
-  - `verifyRemoteExists()` - Check if remote is configured
-  - `getBranchPushStatus()` - Detect branch publish status and unpushed commits
-  - `pushBranch()` - Execute git push with upstream tracking
+    - `getRemoteName()` - Get configured remote name (usually 'origin')
+    - `verifyRemoteExists()` - Check if remote is configured
+    - `getBranchPushStatus()` - Detect branch publish status and unpushed commits
+    - `pushBranch()` - Execute git push with upstream tracking
 
 ### 🔧 Fixed
 
@@ -76,13 +143,13 @@ This release implements a **modular, decoupled, reusable** architecture for bett
 
 ### 🎯 Benefits
 
-| Aspect | Before | After |
-|--------|--------|-------|
-| `bin/claude-hooks` size | 2,277 lines | 111 lines |
-| Command modules | 1 (`setup-github.js`) | 13 files |
-| Testability | Hard (monolithic) | Easy (modular) |
-| Finding code | Search entire file | Match filename to command |
-| Adding commands | Edit large file | Create new module |
+| Aspect                  | Before                | After                     |
+| ----------------------- | --------------------- | ------------------------- |
+| `bin/claude-hooks` size | 2,277 lines           | 111 lines                 |
+| Command modules         | 1 (`setup-github.js`) | 13 files                  |
+| Testability             | Hard (monolithic)     | Easy (modular)            |
+| Finding code            | Search entire file    | Match filename to command |
+| Adding commands         | Edit large file       | Create new module         |
 
 ### 📚 Documentation
 
@@ -94,6 +161,7 @@ This release implements a **modular, decoupled, reusable** architecture for bett
 ### 🔧 Technical Details
 
 **New module structure:**
+
 ```
 lib/commands/
 ├── helpers.js        (389 lines) - Shared utilities
@@ -111,6 +179,7 @@ lib/commands/
 ```
 
 **Key patterns implemented:**
+
 - **Command Pattern**: Each CLI command is a self-contained module
 - **Thin Controller**: `bin/claude-hooks` only routes, doesn't implement
 - **Separation of Concerns**: UI helpers in `helpers.js`, business logic in specific modules

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
@@ -67,6 +94,65 @@ claude-hooks analyze-diff develop
 # Generates PR metadata without creating
 ```
 
+### Bump Version
+
+Automatic version management with CHANGELOG generation and Git tagging:
+
+```bash
+# Bump patch version (1.0.0 → 1.0.1)
+claude-hooks bump-version patch
+
+# Bump with suffix
+claude-hooks bump-version minor --suffix SNAPSHOT  # → 1.1.0-SNAPSHOT
+
+# Bump and generate CHANGELOG
+claude-hooks bump-version major --update-changelog
+
+# Preview without applying
+claude-hooks bump-version patch --dry-run
+```
+
+**What it does:**
+- Detects project type (Node.js, Maven, or monorepo with both)
+- Updates `package.json` and/or `pom.xml`
+- Generates CHANGELOG entry with Claude (analyzes commits)
+- Creates annotated Git tag with `v` prefix (e.g., `v2.7.0`)
+- Pushes tag to remote automatically
+
+**Version workflow:**
+```
+2.7.0 → 2.8.0-SNAPSHOT    # Start development
+2.8.0-SNAPSHOT → 2.8.0-RC # Release candidate
+2.8.0-RC → 2.8.0          # Final release
+```
+
+**Integration with create-pr:**
+- Validates version alignment (package.json, pom.xml, CHANGELOG, tags)
+- Detects and prompts to push unpushed tags
+- Warns if local version ≤ remote version
+
+### Generate CHANGELOG
+
+Standalone CHANGELOG generation (without version bump):
+
+```bash
+# Auto-detect version from package.json/pom.xml
+claude-hooks generate-changelog
+
+# Specific version with release marking
+claude-hooks generate-changelog 2.7.0 --release
+
+# Compare against different base branch
+claude-hooks generate-changelog --base-branch develop
+```
+
+**What it does:**
+- Analyzes commits since last tag using Claude
+- Categorizes by Conventional Commits types (feat, fix, refactor, etc.)
+- Generates Keep a Changelog format entries
+- Updates CHANGELOG.md automatically
+- Useful when `bump-version --update-changelog` fails
+
 ### Disable/Enable Hooks
 
 ```bash
@@ -164,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()` |
@@ -183,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';
@@ -22,6 +23,8 @@ import { runMigrateConfig } from '../lib/commands/migrate-config.js';
 import { runSetDebug } from '../lib/commands/debug.js';
 import { runShowTelemetry, runClearTelemetry } from '../lib/commands/telemetry-cmd.js';
 import { runShowHelp, runShowVersion } from '../lib/commands/help.js';
+import { runBumpVersion } from '../lib/commands/bump-version.js';
+import { runGenerateChangelog } from '../lib/commands/generate-changelog.js';
 
 /**
  * Main CLI router
@@ -49,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;
@@ -75,6 +85,12 @@ async function main() {
         case 'migrate-config':
             await runMigrateConfig();
             break;
+        case 'bump-version':
+            await runBumpVersion(args.slice(1));
+            break;
+        case 'generate-changelog':
+            await runGenerateChangelog(args.slice(1));
+            break;
         case 'telemetry':
             // Handle subcommands: telemetry show, telemetry clear
             if (args[1] === 'show' || args[1] === undefined) {

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);
+    }
+};