claude-git-hooks 2.35.3 → 2.43.0

package/lib/commands/analyze-pr.js

@@ -24,15 +24,30 @@ import {
     getGitHubToken
 } from '../utils/github-api.js';
 import { executeClaudeWithRetry, extractJSON } from '../utils/claude-client.js';
+import { flush as langfuseFlush } from '../utils/langfuse-tracer.js';
 import { loadPrompt } from '../utils/prompt-builder.js';
 import { loadPreset, listPresets } from '../utils/preset-loader.js';
 import { extractLinearTicketFromTitle, fetchTicket } from '../utils/linear-connector.js';
 import { recordPRAnalysis } from '../utils/pr-statistics.js';
 import { promptConfirmation, promptMenu } from '../utils/interactive-ui.js';
-import { colors, error, info, warning, checkGitRepo } from './helpers.js';
+import { CostTracker } from '../utils/cost-tracker.js';
+import { colors, error, fatal, info, warning, checkGitRepo } from './helpers.js';
 import logger from '../utils/logger.js';
 import path from 'path';
 
+// ─── 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;
+}
+
 // ─── Category Normalization ─────────────────────────────────────────────────
 
 /**
@@ -239,20 +254,35 @@ const displayComment = (comment, index, isInline) => {
  * @param {Array<string>} args - Command arguments [pr-url, ...flags]
  */
 export async function runAnalyzePr(args) {
-    if (!checkGitRepo()) {
-        error('You are not in a Git repository.');
-        return;
-    }
-
     // Parse arguments
     const prUrl = args.find((a) => !a.startsWith('--'));
     const cliPreset = args.includes('--preset') ? args[args.indexOf('--preset') + 1] : null;
     const cliModel = args.includes('--model') ? args[args.indexOf('--model') + 1] : null;
     const dryRun = args.includes('--dry-run');
+    const headless = args.includes('--headless');
+    const fmtIdx = args.indexOf('--format');
+    const format = fmtIdx >= 0 ? args[fmtIdx + 1] : null;
+    const isJSON = format === 'json';
+
+    // Validation: --format json requires --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);
+
+    if (!checkGitRepo()) {
+        if (isJSON) { _emitErrorJSON('Not a git repository'); return; }
+        error('You are not in a Git repository.');
+        return;
+    }
 
     if (!prUrl) {
+        if (isJSON) { _emitErrorJSON('No PR URL provided'); return; }
         error(
-            'Usage: claude-hooks analyze-pr <pr-url> [--preset <name>] [--model <model>] [--dry-run]'
+            'Usage: claude-hooks analyze-pr <pr-url> [--preset <name>] [--model <model>] [--dry-run] [--headless] [--format json]'
         );
         return;
     }
@@ -260,6 +290,7 @@ export async function runAnalyzePr(args) {
     // Step 1: Parse URL
     const parsed = parseGitHubPRUrl(prUrl);
     if (!parsed) {
+        if (isJSON) { _emitErrorJSON(`Invalid GitHub PR URL: ${prUrl}`); return; }
         error(`Invalid GitHub PR URL: ${prUrl}`);
         return;
     }
@@ -277,6 +308,7 @@ export async function runAnalyzePr(args) {
     try {
         getGitHubToken();
     } catch {
+        if (isJSON) { _emitErrorJSON('GitHub token not configured. Run: claude-hooks setup-github'); return; }
         error('GitHub token not configured. Run: claude-hooks setup-github');
         return;
     }
@@ -397,12 +429,20 @@ export async function runAnalyzePr(args) {
 
         // Step 9: Call Claude
         info('Running analysis...');
+        const costTracker = headless ? new CostTracker() : null;
         const response = await executeClaudeWithRetry(prompt, {
             timeout,
             model,
+            headless,
+            costTracker,
             telemetryContext: { hook: 'analyze-pr', fileCount: prFiles.length }
         });
 
+        // Flush Langfuse traces after headless SDK call (no-op when disabled)
+        if (headless) {
+            await langfuseFlush().catch(() => {});
+        }
+
         logger.debug('analyze-pr - runAnalyzePr', 'Claude response received', {
             responseLength: response.length,
             responsePreview: response.substring(0, 300)
@@ -430,147 +470,155 @@ export async function runAnalyzePr(args) {
             category: normalizeCategory(c.category, allCategories, CATEGORY_ALIASES)
         }));
 
-        // Step 11: Display results
-        const elapsed = Date.now() - startTime;
-        const seconds = (elapsed / 1000).toFixed(1);
-
-        console.log('');
-        console.log('================================================================');
-        console.log('                      PR ANALYSIS RESULTS                        ');
-        console.log('================================================================');
-        console.log('');
-        console.log(`${colors.blue}Verdict:${colors.reset} ${result.verdict || 'comment'}`);
-        console.log(`${colors.blue}Summary:${colors.reset} ${result.summary || 'No summary.'}`);
-        console.log(`${colors.blue}Preset:${colors.reset} ${presetName}`);
-        console.log(`${colors.blue}Model:${colors.reset} ${model}`);
-        console.log(
-            `${colors.blue}Issues:${colors.reset} ${inlineComments.length} inline, ${generalComments.length} general`
-        );
-        console.log('');
+        // Step 11: Display results (skip in JSON mode — output is the JSON document)
+        if (!isJSON) {
+            const elapsed = Date.now() - startTime;
+            const seconds = (elapsed / 1000).toFixed(1);
 
-        if (inlineComments.length > 0) {
-            console.log(`${colors.green}--- Inline Comments ---${colors.reset}`);
             console.log('');
-            inlineComments.forEach((c, i) => displayComment(c, i + 1, true));
-        }
-
-        if (generalComments.length > 0) {
-            console.log(`${colors.green}--- General Comments ---${colors.reset}`);
+            console.log('================================================================');
+            console.log('                      PR ANALYSIS RESULTS                        ');
+            console.log('================================================================');
+            console.log('');
+            console.log(`${colors.blue}Verdict:${colors.reset} ${result.verdict || 'comment'}`);
+            console.log(`${colors.blue}Summary:${colors.reset} ${result.summary || 'No summary.'}`);
+            console.log(`${colors.blue}Preset:${colors.reset} ${presetName}`);
+            console.log(`${colors.blue}Model:${colors.reset} ${model}`);
+            console.log(
+                `${colors.blue}Issues:${colors.reset} ${inlineComments.length} inline, ${generalComments.length} general`
+            );
             console.log('');
-            generalComments.forEach((c, i) => displayComment(c, i + 1, false));
-        }
 
-        if (inlineComments.length === 0 && generalComments.length === 0) {
-            console.log(`${colors.green}No issues found. This PR looks good!${colors.reset}`);
-        }
+            if (inlineComments.length > 0) {
+                console.log(`${colors.green}--- Inline Comments ---${colors.reset}`);
+                console.log('');
+                inlineComments.forEach((c, i) => displayComment(c, i + 1, true));
+            }
 
-        console.log(`${colors.blue}Analysis completed in ${seconds}s${colors.reset}`);
-        console.log('');
+            if (generalComments.length > 0) {
+                console.log(`${colors.green}--- General Comments ---${colors.reset}`);
+                console.log('');
+                generalComments.forEach((c, i) => displayComment(c, i + 1, false));
+            }
 
-        // Step 12: Interactive comment workflow
-        if (dryRun) {
-            info('Dry run mode: skipping comment posting.');
-            recordStats({
-                prUrl,
-                number,
-                owner,
-                repo,
-                presetName,
-                result,
-                inlineComments,
-                generalComments,
-                commentsPosted: 0,
-                commentsSkipped: inlineComments.length + generalComments.length
-            });
-            return;
-        }
+            if (inlineComments.length === 0 && generalComments.length === 0) {
+                console.log(`${colors.green}No issues found. This PR looks good!${colors.reset}`);
+            }
 
-        if (inlineComments.length === 0 && generalComments.length === 0) {
-            info('No comments to post.');
-            recordStats({
-                prUrl,
-                number,
-                owner,
-                repo,
-                presetName,
-                result,
-                inlineComments,
-                generalComments,
-                commentsPosted: 0,
-                commentsSkipped: 0
-            });
-            return;
+            console.log(`${colors.blue}Analysis completed in ${seconds}s${colors.reset}`);
+            console.log('');
         }
 
-        // Ask user to confirm posting
-        const postChoice = await promptMenu(
-            'What would you like to do with the review?',
-            [
-                { key: 'a', label: 'Post all comments as a review' },
-                { key: 's', label: 'Select which comments to post' },
-                { key: 'n', label: 'Skip posting (analysis only)' }
-            ],
-            'a'
-        );
-
-        let confirmedInline = [];
-        let confirmedGeneral = [];
+        // Step 12: Determine confirmed comments (interactive vs headless)
+        let confirmedInline;
+        let confirmedGeneral;
+        let posted = false;
 
-        if (postChoice === 'n') {
-            info('Skipping comment posting.');
-            recordStats({
-                prUrl,
-                number,
-                owner,
-                repo,
-                presetName,
-                result,
-                inlineComments,
-                generalComments,
-                commentsPosted: 0,
-                commentsSkipped: inlineComments.length + generalComments.length
-            });
-            return;
-        }
-
-        if (postChoice === 'a') {
+        if (headless) {
+            // Headless: post all comments (no interactive selection)
             confirmedInline = inlineComments;
             confirmedGeneral = generalComments;
-        } else if (postChoice === 's') {
-            // Select inline comments
-            for (const comment of inlineComments) {
-                displayComment(comment, inlineComments.indexOf(comment) + 1, true);
-                const keep = await promptConfirmation('Post this inline comment?', true);
-                if (keep) confirmedInline.push(comment);
+        } else {
+            // Interactive: existing prompt-driven workflow
+            if (dryRun) {
+                info('Dry run mode: skipping comment posting.');
+                recordStats({
+                    prUrl,
+                    number,
+                    owner,
+                    repo,
+                    presetName,
+                    result,
+                    inlineComments,
+                    generalComments,
+                    commentsPosted: 0,
+                    commentsSkipped: inlineComments.length + generalComments.length
+                });
+                return;
             }
 
-            // Select general comments
-            for (const comment of generalComments) {
-                displayComment(comment, generalComments.indexOf(comment) + 1, false);
-                const keep = await promptConfirmation('Include this general comment?', true);
-                if (keep) confirmedGeneral.push(comment);
+            if (inlineComments.length === 0 && generalComments.length === 0) {
+                info('No comments to post.');
+                recordStats({
+                    prUrl,
+                    number,
+                    owner,
+                    repo,
+                    presetName,
+                    result,
+                    inlineComments,
+                    generalComments,
+                    commentsPosted: 0,
+                    commentsSkipped: 0
+                });
+                return;
             }
-        }
 
-        // Step 13: Post review
-        if (confirmedInline.length === 0 && confirmedGeneral.length === 0) {
-            info('No comments selected for posting.');
-            recordStats({
-                prUrl,
-                number,
-                owner,
-                repo,
-                presetName,
-                result,
-                inlineComments,
-                generalComments,
-                commentsPosted: 0,
-                commentsSkipped: inlineComments.length + generalComments.length
-            });
-            return;
+            const postChoice = await promptMenu(
+                'What would you like to do with the review?',
+                [
+                    { key: 'a', label: 'Post all comments as a review' },
+                    { key: 's', label: 'Select which comments to post' },
+                    { key: 'n', label: 'Skip posting (analysis only)' }
+                ],
+                'a'
+            );
+
+            confirmedInline = [];
+            confirmedGeneral = [];
+
+            if (postChoice === 'n') {
+                info('Skipping comment posting.');
+                recordStats({
+                    prUrl,
+                    number,
+                    owner,
+                    repo,
+                    presetName,
+                    result,
+                    inlineComments,
+                    generalComments,
+                    commentsPosted: 0,
+                    commentsSkipped: inlineComments.length + generalComments.length
+                });
+                return;
+            }
+
+            if (postChoice === 'a') {
+                confirmedInline = inlineComments;
+                confirmedGeneral = generalComments;
+            } else if (postChoice === 's') {
+                for (const comment of inlineComments) {
+                    displayComment(comment, inlineComments.indexOf(comment) + 1, true);
+                    const keep = await promptConfirmation('Post this inline comment?', true);
+                    if (keep) confirmedInline.push(comment);
+                }
+                for (const comment of generalComments) {
+                    displayComment(comment, generalComments.indexOf(comment) + 1, false);
+                    const keep = await promptConfirmation('Include this general comment?', true);
+                    if (keep) confirmedGeneral.push(comment);
+                }
+            }
+
+            if (confirmedInline.length === 0 && confirmedGeneral.length === 0) {
+                info('No comments selected for posting.');
+                recordStats({
+                    prUrl,
+                    number,
+                    owner,
+                    repo,
+                    presetName,
+                    result,
+                    inlineComments,
+                    generalComments,
+                    commentsPosted: 0,
+                    commentsSkipped: inlineComments.length + generalComments.length
+                });
+                return;
+            }
         }
 
-        // Build review body from general comments
+        // Step 13: Build review body from general comments
         let reviewBody = `## PR Analysis (${presetName} preset)\n\n`;
         reviewBody += `**Verdict:** ${result.verdict || 'comment'}\n\n`;
 
@@ -603,17 +651,85 @@ export async function runAnalyzePr(args) {
             };
         });
 
-        info('Posting review...');
-        await createPullRequestReview(owner, repo, number, reviewBody, apiComments, event);
+        // Post review (unless dry-run)
+        if (!dryRun && (confirmedInline.length > 0 || confirmedGeneral.length > 0)) {
+            info('Posting review...');
+            await createPullRequestReview(owner, repo, number, reviewBody, apiComments, event);
+            posted = true;
+        }
 
-        const totalPosted = confirmedInline.length + confirmedGeneral.length;
+        const totalPosted = posted ? confirmedInline.length + confirmedGeneral.length : 0;
         const totalSkipped = inlineComments.length + generalComments.length - totalPosted;
 
-        console.log(
-            `${colors.green}Review posted: ${confirmedInline.length} inline comments, ${confirmedGeneral.length} general observations${colors.reset}`
-        );
+        // Step 14: JSON output
+        if (isJSON) {
+            const severityCounts = { critical: 0, major: 0, minor: 0, info: 0 };
+            const categoryCounts = {};
+            [...inlineComments, ...generalComments].forEach((c) => {
+                if (severityCounts[c.severity] !== undefined) severityCounts[c.severity]++;
+                categoryCounts[c.category] = (categoryCounts[c.category] || 0) + 1;
+            });
+
+            const verdict = result.verdict || 'comment';
+            const isFail = severityCounts.critical > 0 || verdict === 'request_changes';
+
+            const payload = {
+                status: isFail ? 'fail' : 'pass',
+                verdict,
+                summary: result.summary || '',
+                preset: presetName,
+                model,
+                durationMs: Date.now() - startTime,
+                issueCount: inlineComments.length + generalComments.length,
+                severityCounts,
+                categoryCounts,
+                inlineComments: inlineComments.map((c) => ({
+                    path: c.path,
+                    line: c.line,
+                    side: c.side || 'RIGHT',
+                    severity: c.severity,
+                    category: c.category,
+                    body: c.body,
+                    ...(c.suggestion ? { suggestion: c.suggestion } : {})
+                })),
+                generalComments: generalComments.map((c) => ({
+                    severity: c.severity,
+                    category: c.category,
+                    body: c.body
+                })),
+                reviewBody,
+                posted,
+                costs: costTracker ? costTracker.toJSON() : null
+            };
+
+            process.stdout.write(`${JSON.stringify(payload)}\n`);
+            process.exitCode = isFail ? 1 : 0;
+
+            recordStats({
+                prUrl,
+                number,
+                owner,
+                repo,
+                presetName,
+                result,
+                inlineComments,
+                generalComments,
+                commentsPosted: totalPosted,
+                commentsSkipped: totalSkipped
+            });
+            return;
+        }
+
+        // Non-JSON display output
+        if (posted) {
+            console.log(
+                `${colors.green}Review posted: ${confirmedInline.length} inline comments, ${confirmedGeneral.length} general observations${colors.reset}`
+            );
+        } else if (dryRun) {
+            info('Dry run mode: skipping comment posting.');
+        }
 
-        // Step 14: Record statistics
+        // Record statistics
         recordStats({
             prUrl,
             number,
@@ -627,16 +743,25 @@ export async function runAnalyzePr(args) {
             commentsSkipped: totalSkipped
         });
     } catch (e) {
+        if (isJSON) {
+            process.stdout.write(
+                `${JSON.stringify({ status: 'error', error: e.message, errorName: e.name })}\n`
+            );
+            process.exitCode = 1;
+            return;
+        }
+
+        logger.debug('analyze-pr - runAnalyzePr', 'Full error details', {
+            name: e.name,
+            message: e.message,
+            context: e.context ? JSON.stringify(e.context).substring(0, 500) : undefined,
+            stack: e.stack
+        });
+
         if (e.name === 'GitHubAPIError') {
-            error(`GitHub API error: ${e.message}`);
+            fatal(`GitHub API error: ${e.message}`);
         } else {
-            error(`Error analyzing PR: ${e.message}`);
-            logger.debug('analyze-pr - runAnalyzePr', 'Full error details', {
-                name: e.name,
-                message: e.message,
-                context: e.context ? JSON.stringify(e.context).substring(0, 500) : undefined,
-                stack: e.stack
-            });
+            fatal(`Error analyzing PR: ${e.message}`);
         }
     }
 }