claude-git-hooks 2.35.2 → 2.43.0

package/lib/commands/analyze.js

@@ -12,19 +12,25 @@
  * - Analyzes staged, unstaged, or all tracked files
  * - Interactive confirmation with detailed issue view
  * - Generates resolution prompt on abort
+ * - Headless mode for CI (--headless): skips prompts, never commits
+ * - JSON output (--format json): single JSON line on stdout
  *
  * Usage:
  *   claude-hooks analyze              # Analyze staged files (default)
  *   claude-hooks analyze --unstaged   # Analyze unstaged changes
  *   claude-hooks analyze --all        # Analyze all tracked files
+ *   claude-hooks analyze --headless --format json  # CI mode with JSON output
  */
 
 import {
     getStagedFiles,
     getUnstagedFiles,
     getAllTrackedFiles,
-    createCommit
+    createCommit,
+    getRepoRoot,
+    getStagedTreeSha
 } from '../utils/git-operations.js';
+import { writeMarker } from '../utils/hooks-verified-marker.js';
 import { filterFiles } from '../utils/file-operations.js';
 import {
     buildFilesData,
@@ -36,9 +42,52 @@ import { promptUserConfirmation, promptConfirmation } from '../utils/interactive
 import { generateResolutionPrompt } from '../utils/resolution-prompt.js';
 import { getConfig } from '../config.js';
 import { loadPreset } from '../utils/preset-loader.js';
+import { CostTracker } from '../utils/cost-tracker.js';
+import { getVersion } from '../utils/package-info.js';
 import logger from '../utils/logger.js';
 import { error, success, info } from './helpers.js';
 
+// ─── JSON Error Helper ────────────────────────────────────────────────────
+
+/**
+ * Emit error JSON to stdout and set exit code
+ * @param {string} message - Error message
+ * @param {number} exitCode - Process exit code (default: 1)
+ * @private
+ */
+function _emitErrorJSON(message, exitCode = 1) {
+    process.stdout.write(`${JSON.stringify({ status: 'error', error: message })}\n`);
+    process.exitCode = exitCode;
+}
+
+/**
+ * Emit JSON result to stdout (does not exit — caller handles exit)
+ * @param {Object} payload - JSON payload
+ * @private
+ */
+function _emitJSON(payload) {
+    process.stdout.write(`${JSON.stringify(payload)}\n`);
+}
+
+/**
+ * Build no-files JSON payload for headless/JSON mode
+ * @private
+ */
+function _buildNoFilesPayload(scope, presetName, startTime, skippedCount, costTracker) {
+    return {
+        status: 'no-files',
+        scope,
+        preset: presetName,
+        fileCount: 0,
+        skippedCount,
+        durationMs: Date.now() - startTime,
+        issueCount: 0,
+        severityCounts: { blocker: 0, critical: 0, major: 0, minor: 0, info: 0 },
+        issues: [],
+        costs: costTracker ? costTracker.toJSON() : null
+    };
+}
+
 /**
  * Main analyze command
  * Why: Provides interactive analysis before committing
@@ -47,9 +96,24 @@ import { error, success, info } from './helpers.js';
  * @param {boolean} options.staged - Analyze staged files (default: true)
  * @param {boolean} options.unstaged - Analyze unstaged files
  * @param {boolean} options.all - Analyze all tracked files
+ * @param {boolean} options.headless - Skip interactive prompts (CI mode)
+ * @param {string} options.format - Output format ('json' or null)
  */
 export const runAnalyze = async (options = {}) => {
-    const { unstaged = false, all = false } = options;
+    const { unstaged = false, all = false, headless = false, format = null } = options;
+    const isJSON = format === 'json';
+
+    // Disallowed combo: --format json without --headless
+    if (isJSON && !headless) {
+        _emitErrorJSON('--format json requires --headless', 2);
+        return;
+    }
+
+    // Activate JSON mode before any output so info/warning route to stderr
+    if (isJSON) logger.setJSONMode(true);
+
+    const startTime = Date.now();
+    const costTracker = headless ? new CostTracker() : null;
 
     try {
         // Load configuration
@@ -66,6 +130,7 @@ export const runAnalyze = async (options = {}) => {
         const allowedExtensions = metadata.fileExtensions;
 
         // Determine scope
+        const scope = all ? 'all' : unstaged ? 'unstaged' : 'staged';
         let scopeLabel = 'staged changes';
         if (all) {
             scopeLabel = 'all tracked files';
@@ -86,8 +151,12 @@ export const runAnalyze = async (options = {}) => {
         }
 
         if (files.length === 0) {
+            if (isJSON) {
+                _emitJSON(_buildNoFilesPayload(scope, presetName, startTime, 0, costTracker));
+            }
             info(`No files to analyze in ${scopeLabel}.`);
             process.exit(0);
+            return; // guard test-mode fallthrough
         }
 
         logger.debug('analyze', 'Files found', {
@@ -113,8 +182,12 @@ export const runAnalyze = async (options = {}) => {
         }
 
         if (validFiles.length === 0) {
+            if (isJSON) {
+                _emitJSON(_buildNoFilesPayload(scope, presetName, startTime, invalidFiles.length, costTracker));
+            }
             info(`No valid files found to analyze in ${scopeLabel}.`);
             process.exit(0);
+            return; // guard test-mode fallthrough
         }
 
         info(`Sending ${validFiles.length} file(s) for analysis...`);
@@ -123,12 +196,83 @@ export const runAnalyze = async (options = {}) => {
         const filesData = buildFilesData(validFiles, { staged: !unstaged && !all });
 
         if (filesData.length === 0) {
+            if (isJSON) {
+                _emitJSON({
+                    status: 'no-files',
+                    scope,
+                    preset: presetName,
+                    fileCount: 0,
+                    skippedCount: invalidFiles.length,
+                    durationMs: Date.now() - startTime,
+                    issueCount: 0,
+                    severityCounts: { blocker: 0, critical: 0, major: 0, minor: 0, info: 0 },
+                    issues: [],
+                    costs: costTracker ? costTracker.toJSON() : null
+                });
+            }
             info('No file data could be extracted.');
             process.exit(0);
+            return;
         }
 
         // Run analysis using shared engine
-        const result = await runAnalysis(filesData, config, { hook: 'analyze' });
+        const result = await runAnalysis(filesData, config, {
+            hook: 'analyze',
+            headless,
+            costTracker
+        });
+
+        // Write hooks-verified marker when analysis completes without critical/blocker issues.
+        // For headless: marker stays for a downstream `git commit` to pick up.
+        // For interactive: prepare-commit-msg reads it when createCommit() fires.
+        const { blocker = 0, critical = 0 } = result.issues || {};
+        const hasCritical = (blocker + critical) > 0;
+
+        if (!hasCritical && scope === 'staged') {
+            try {
+                const repoRoot = getRepoRoot();
+                const treeSha = getStagedTreeSha();
+                const version = await getVersion();
+                writeMarker(repoRoot, treeSha, version);
+                logger.debug('analyze', 'Hooks-verified marker written', { treeSha });
+            } catch (markerErr) {
+                logger.warning(`Could not write hooks-verified marker: ${markerErr.message}`);
+            }
+        }
+
+        // ── Headless path: emit result and exit (never commit) ──
+        if (headless) {
+            const { major = 0, minor = 0, info: infoCount = 0 } = result.issues || {};
+
+            if (isJSON) {
+                _emitJSON({
+                    status: hasCritical ? 'fail' : 'pass',
+                    scope,
+                    preset: presetName,
+                    fileCount: validFiles.length,
+                    skippedCount: invalidFiles.length,
+                    durationMs: Date.now() - startTime,
+                    issueCount: blocker + critical + major + minor + infoCount,
+                    severityCounts: { blocker, critical, major, minor, info: infoCount },
+                    issues: result.details || [],
+                    costs: costTracker ? costTracker.toJSON() : null
+                });
+                process.exit(hasCritical ? 1 : 0);
+                return;
+            }
+
+            // Headless without JSON: print summary to stderr, exit
+            if (hasAnyIssues(result)) {
+                displayIssueSummary(result);
+            } else {
+                success('No issues found. Code is ready to commit!');
+            }
+
+            process.exit(hasCritical ? 1 : 0);
+            return; // guard test-mode fallthrough
+        }
+
+        // ── Interactive path (unchanged) ──
 
         // Check results
         if (!hasAnyIssues(result)) {
@@ -215,6 +359,10 @@ export const runAnalyze = async (options = {}) => {
         }
     } catch (err) {
         logger.error('analyze', 'Analysis failed', err);
+        if (isJSON) {
+            _emitErrorJSON(`Analysis failed: ${err.message}`);
+            return;
+        }
         error(`Analysis failed: ${err.message}`);
         process.exit(1);
     }