claude-git-hooks 2.35.2 → 2.43.0

package/lib/commands/create-pr.js

@@ -1,6 +1,9 @@
 /**
  * File: create-pr.js
  * Purpose: Create pull request with auto-generated metadata and reviewers
+ *
+ * Headless mode (--headless): skips all interactive prompts, uses documented defaults.
+ * JSON output (--format json): emits single JSON line on stdout, all other output to stderr.
  */
 
 import { execSync } from 'child_process';
@@ -22,9 +25,35 @@ import {
 import { getBranchPushStatus, pushBranch } from '../utils/git-operations.js';
 import logger from '../utils/logger.js';
 import { resolveLabels } from '../utils/label-resolver.js';
-import { error, checkGitRepo } from './helpers.js';
+import { CostTracker } from '../utils/cost-tracker.js';
+import { error, fatal, checkGitRepo } from './helpers.js';
 import { recordMetric } from '../utils/metrics.js';
 
+// ─── JSON Helpers ────────────────────────────────────────────────────────
+
+/**
+ * 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`);
+}
+
+// Known flags that should not be treated as branch names
+const KNOWN_FLAGS = new Set(['--headless', '--format']);
+
 /**
  * Detect expected merge strategy from branch naming conventions
  * @param {string} sourceBranch - Source (head) branch name
@@ -45,9 +74,33 @@ function detectMergeStrategy(sourceBranch, targetBranch) {
  * @param {Array<string>} args - Command arguments
  */
 export async function runCreatePr(args) {
-    logger.debug('create-pr', 'Starting create-pr command', { args });
+    // ── Parse headless/format flags ──
+    const headless = args.includes('--headless');
+    const fmtIdx = args.indexOf('--format');
+    const format = fmtIdx >= 0 ? args[fmtIdx + 1] : null;
+    const isJSON = format === 'json';
+    if (format && !isJSON) {
+        logger.warning(`Unknown --format value '${format}'. Only 'json' is supported.`);
+    }
+
+    // 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;
+    let branchWasPushed = false;
+    let pushedTags = [];
+
+    logger.debug('create-pr', 'Starting create-pr command', { args, headless, isJSON });
 
     if (!checkGitRepo()) {
+        if (isJSON) { _emitErrorJSON('Not a git repository'); return; }
         error('You are not in a Git repository.');
         logger.debug('create-pr', 'Not in a git repository, exiting');
         return;
@@ -71,7 +124,7 @@ export async function runCreatePr(args) {
         const { parseGitHubRepo } = await import('../utils/github-client.js');
 
         showInfo('🚀 Creating Pull Request...');
-        console.log('');
+        if (!isJSON) console.log('');
 
         // Step 1: Validate GitHub token
         logger.debug('create-pr', 'Step 1: Validating GitHub token');
@@ -80,6 +133,10 @@ export async function runCreatePr(args) {
             logger.error('create-pr', 'GitHub authentication failed', {
                 error: tokenValidation.error
             });
+            if (isJSON) {
+                _emitErrorJSON('GitHub authentication failed. Run: claude-hooks setup-github', 2);
+                return;
+            }
             showError('GitHub authentication failed');
             console.log('');
             console.log('Please configure your GitHub token:');
@@ -102,39 +159,49 @@ export async function runCreatePr(args) {
             showWarning('Token may lack "repo" scope - PR creation might fail');
         }
 
-        // Step 2: Get or prompt for task-id (with config for pattern)
-        logger.debug('create-pr', 'Step 2: Getting or prompting for task-id');
+        // Step 2: Detect current branch (fail fast before interactive prompts)
+        logger.debug('create-pr', 'Step 2: Getting current branch and repo info');
+        const currentBranch = execSync('git branch --show-current', { encoding: 'utf8' }).trim();
+        if (!currentBranch) {
+            if (isJSON) {
+                _emitErrorJSON('Detached HEAD detected. create-pr requires a named branch.');
+                return;
+            }
+            fatal(
+                'Detached HEAD detected. create-pr requires a named branch.\n' +
+                '  Check out a branch first: git checkout -b <branch-name>\n' +
+                '  Or, if running in CI/container: configure the orchestrator to checkout\n' +
+                '  the branch by name, not by SHA. See CLAUDE.md "Operational Contract".'
+            );
+        }
+
+        const repoInfo = parseGitHubRepo();
+
+        // Step 3: Get or prompt for task-id
+        // Decision #1: headless → prompt:false (null if not auto-detected from branch)
+        logger.debug('create-pr', 'Step 3: Getting or prompting for task-id');
         const taskId = await getOrPromptTaskId({
-            prompt: true, // DO prompt for PRs (unlike commit messages)
-            required: false, // Allow skipping
-            config // Pass config for custom pattern
+            prompt: !headless, // DO prompt for PRs (unless headless)
+            required: false,
+            config
         });
         logger.debug('create-pr', 'Task ID determined', { taskId });
 
-        // Step 3: Parse arguments and determine base branch
-        logger.debug('create-pr', 'Step 3: Parsing arguments and determining base branch', {
+        // Step 4: Parse arguments and determine base branch
+        // Filter out known flags and their values from args before resolving base branch
+        logger.debug('create-pr', 'Step 4: Parsing arguments and determining base branch', {
             args
         });
-        let baseBranchArg = args[0];
+        const cleanArgs = args.filter((a, i) => {
+            if (KNOWN_FLAGS.has(a)) return false;
+            if (i > 0 && args[i - 1] === '--format') return false;
+            return true;
+        });
+        let baseBranchArg = cleanArgs[0];
         if (baseBranchArg && /^[A-Z]{2,10}-\d+$/i.test(baseBranchArg)) {
-            baseBranchArg = args[1];
+            baseBranchArg = cleanArgs[1];
         }
         const baseBranch = baseBranchArg || config.github?.pr?.defaultBase || 'develop';
-        logger.debug('create-pr', 'Base branch determined', {
-            baseBranch,
-            fromConfig: !baseBranchArg
-        });
-
-        // Step 4: Get current branch and repo info
-        logger.debug('create-pr', 'Step 4: Getting current branch and repo info');
-        const currentBranch = execSync('git branch --show-current', { encoding: 'utf8' }).trim();
-        if (!currentBranch) {
-            logger.error('create-pr', 'Could not determine current branch');
-            error('Could not determine current branch');
-            return;
-        }
-
-        const repoInfo = parseGitHubRepo();
         logger.debug('create-pr', 'Repository and branch info', {
             owner: repoInfo.owner,
             repo: repoInfo.repo,
@@ -159,9 +226,24 @@ export async function runCreatePr(args) {
                 prNumber: existingPR.number,
                 prUrl: existingPR.html_url
             });
+            if (isJSON) {
+                _emitJSON({
+                    status: 'exists',
+                    prUrl: existingPR.html_url,
+                    prNumber: existingPR.number,
+                    head: currentBranch,
+                    base: baseBranch,
+                    durationMs: Date.now() - startTime,
+                    costs: costTracker ? costTracker.toJSON() : null
+                });
+                process.exit(0);
+                return;
+            }
             showWarning(`A PR already exists for this branch: #${existingPR.number}`);
-            console.log(`  ${existingPR.html_url}`);
-            console.log('');
+            if (!isJSON) {
+                console.log(`  ${existingPR.html_url}`);
+                console.log('');
+            }
             return;
         }
 
@@ -188,6 +270,10 @@ export async function runCreatePr(args) {
                     branch: currentBranch,
                     upstream: pushStatus.upstreamBranch
                 });
+                if (isJSON) {
+                    _emitErrorJSON(`Branch has diverged from remote. Run: git pull origin ${currentBranch}`);
+                    return;
+                }
                 showError('Branch has diverged from remote');
                 console.log('');
                 console.log('Please resolve conflicts manually:');
@@ -201,6 +287,10 @@ export async function runCreatePr(args) {
                 logger.debug('create-pr', 'Auto-push disabled, aborting', {
                     autoPush: pushConfig?.autoPush
                 });
+                if (isJSON) {
+                    _emitErrorJSON(`Branch not pushed to remote and autoPush is disabled. Run: git push -u origin ${currentBranch}`);
+                    return;
+                }
                 showError('Branch not pushed to remote');
                 console.log('');
                 console.log('Please push your branch first:');
@@ -210,7 +300,7 @@ export async function runCreatePr(args) {
             }
 
             // Show push preview
-            if (pushConfig?.showCommits && pushStatus.unpushedCommits.length > 0) {
+            if (!isJSON && pushConfig?.showCommits && pushStatus.unpushedCommits.length > 0) {
                 console.log('');
                 showInfo('Commits to push:');
                 pushStatus.unpushedCommits.forEach((commit) => {
@@ -218,13 +308,15 @@ export async function runCreatePr(args) {
                 });
             }
 
-            // Confirm with user
+            // Decision #2: headless → skip prompt, proceed with push
             if (pushConfig?.pushConfirm) {
-                console.log('');
-                const shouldPush = await promptConfirmation(
-                    `Push branch '${currentBranch}' to remote?`,
-                    true // default yes
-                );
+                if (!isJSON) console.log('');
+                const shouldPush = headless
+                    ? true
+                    : await promptConfirmation(
+                        `Push branch '${currentBranch}' to remote?`,
+                        true
+                    );
 
                 if (!shouldPush) {
                     logger.debug('create-pr', 'User declined push, aborting');
@@ -234,7 +326,7 @@ export async function runCreatePr(args) {
             }
 
             // Execute push
-            console.log('');
+            if (!isJSON) console.log('');
             showInfo('Pushing branch to remote...');
             logger.debug('create-pr', 'Executing push', {
                 branch: currentBranch,
@@ -250,6 +342,10 @@ export async function runCreatePr(args) {
                     branch: currentBranch,
                     error: pushResult.error
                 });
+                if (isJSON) {
+                    _emitErrorJSON(`Failed to push branch: ${pushResult.error}`);
+                    return;
+                }
                 showError('Failed to push branch');
                 console.error('');
                 console.error(`  ${pushResult.error}`);
@@ -257,9 +353,10 @@ export async function runCreatePr(args) {
                 process.exit(1);
             }
 
+            branchWasPushed = true;
             logger.debug('create-pr', 'Push completed successfully');
             showSuccess('Branch pushed successfully');
-            console.log('');
+            if (!isJSON) console.log('');
         } else {
             logger.debug('create-pr', 'Branch already up-to-date with remote, skipping push');
         }
@@ -271,21 +368,28 @@ export async function runCreatePr(args) {
 
         if (!versionCheck.aligned) {
             showWarning('Version misalignment detected:');
-            console.log('');
-
-            for (const issue of versionCheck.issues) {
-                console.log(`  ${issue.source}: ${issue.version || 'not found'}`);
+            if (!isJSON) {
+                console.log('');
+                for (const issue of versionCheck.issues) {
+                    console.log(`  ${issue.source}: ${issue.version || 'not found'}`);
+                }
+                console.log('');
+                console.log('To fix version alignment:');
+                console.log('  claude-hooks bump-version patch --update-changelog');
+                console.log('');
             }
 
-            console.log('');
-            console.log('To fix version alignment:');
-            console.log('  claude-hooks bump-version patch --update-changelog');
-            console.log('');
+            // Decision #3: headless → continue + log warning
+            const shouldContinue = headless
+                ? true
+                : await promptConfirmation(
+                    'Continue creating PR despite version misalignment?',
+                    false
+                );
 
-            const shouldContinue = await promptConfirmation(
-                'Continue creating PR despite version misalignment?',
-                false // default no
-            );
+            if (headless) {
+                logger.warning('create-pr', 'Continuing despite version misalignment (headless)');
+            }
 
             if (!shouldContinue) {
                 showInfo('PR creation cancelled - please align versions first');
@@ -295,17 +399,22 @@ export async function runCreatePr(args) {
 
         if (versionCheck.aligned && versionCheck.comparison === 'equal') {
             showWarning('Local version equals remote version');
-            console.log(`  Local: ${versionCheck.localVersion}`);
-            console.log(`  Remote: ${versionCheck.remoteVersion}`);
-            console.log('');
-            console.log('To bump version:');
-            console.log('  claude-hooks bump-version patch  # or minor/major');
-            console.log('');
+            if (!isJSON) {
+                console.log(`  Local: ${versionCheck.localVersion}`);
+                console.log(`  Remote: ${versionCheck.remoteVersion}`);
+                console.log('');
+                console.log('To bump version:');
+                console.log('  claude-hooks bump-version patch  # or minor/major');
+                console.log('');
+            }
 
-            const shouldContinue = await promptConfirmation(
-                'Continue creating PR without version bump?',
-                true // default yes (might be non-release PR)
-            );
+            // Decision #4: headless → continue (matches default 'yes')
+            const shouldContinue = headless
+                ? true
+                : await promptConfirmation(
+                    'Continue creating PR without version bump?',
+                    true
+                );
 
             if (!shouldContinue) {
                 showInfo('PR creation cancelled');
@@ -315,16 +424,25 @@ export async function runCreatePr(args) {
 
         if (versionCheck.aligned && versionCheck.comparison === 'less') {
             showError('Local version is less than remote version!');
-            console.log(`  Local: ${versionCheck.localVersion}`);
-            console.log(`  Remote: ${versionCheck.remoteVersion}`);
-            console.log('');
-            console.log('This usually means you need to pull latest changes:');
-            console.log(`  git pull origin ${baseBranch}`);
-            console.log('');
+            if (!isJSON) {
+                console.log(`  Local: ${versionCheck.localVersion}`);
+                console.log(`  Remote: ${versionCheck.remoteVersion}`);
+                console.log('');
+                console.log('This usually means you need to pull latest changes:');
+                console.log(`  git pull origin ${baseBranch}`);
+                console.log('');
+            }
+
+            // Decision #5: headless → ABORT (dangerous; needs human review)
+            if (headless) {
+                const msg = `Local version (${versionCheck.localVersion}) is behind remote (${versionCheck.remoteVersion}). Run: git pull origin ${baseBranch}`;
+                if (isJSON) { _emitErrorJSON(msg); return; }
+                fatal(msg);
+            }
 
             const shouldContinue = await promptConfirmation(
                 'Continue creating PR despite version being behind?',
-                false // default no
+                false
             );
 
             if (!shouldContinue) {
@@ -362,7 +480,7 @@ export async function runCreatePr(args) {
                 unpushedTags: tagComparison.localNewer
             });
 
-            let shouldPush = false;
+            let shouldPushTags = false;
             let userChoice = null;
 
             // Case 1: Local tag > Remote tag → Auto-push
@@ -374,7 +492,7 @@ export async function runCreatePr(args) {
 
                 showInfo(`Local tag ${latestLocalTag} is newer than remote ${latestRemoteTag}`);
                 showInfo('Auto-pushing tag to remote...');
-                shouldPush = true;
+                shouldPushTags = true;
 
                 // Case 2: Local tag = Remote tag → Prompt with warning
             } else if (
@@ -388,27 +506,32 @@ export async function runCreatePr(args) {
                 });
 
                 showWarning('Local and remote tags have the same version:');
-                console.log(`  Local:  ${latestLocalTag} (${localVersion})`);
-                console.log(`  Remote: ${latestRemoteTag} (${remoteVersion})`);
-                console.log('');
-                console.log('This might indicate the tag was already pushed.');
-                console.log('');
+                if (!isJSON) {
+                    console.log(`  Local:  ${latestLocalTag} (${localVersion})`);
+                    console.log(`  Remote: ${latestRemoteTag} (${remoteVersion})`);
+                    console.log('');
+                    console.log('This might indicate the tag was already pushed.');
+                    console.log('');
+                }
 
-                userChoice = await promptMenu(
-                    'What would you like to do?',
-                    [
-                        { key: 'c', label: 'Continue without pushing' },
-                        { key: 'p', label: 'Force push tag' },
-                        { key: 'a', label: 'Abort PR creation' }
-                    ],
-                    'c'
-                );
+                // Decision #6: headless → continue without push (default 'c')
+                userChoice = headless
+                    ? 'c'
+                    : await promptMenu(
+                        'What would you like to do?',
+                        [
+                            { key: 'c', label: 'Continue without pushing' },
+                            { key: 'p', label: 'Force push tag' },
+                            { key: 'a', label: 'Abort PR creation' }
+                        ],
+                        'c'
+                    );
 
                 if (userChoice === 'a') {
                     showInfo('PR creation cancelled');
                     process.exit(0);
                 } else if (userChoice === 'p') {
-                    shouldPush = true;
+                    shouldPushTags = true;
                 }
 
                 // Case 3: Local tag < Remote tag → Prompt with error
@@ -423,12 +546,21 @@ export async function runCreatePr(args) {
                 });
 
                 showError('Local tag is older than remote tag:');
-                console.log(`  Local:  ${latestLocalTag} (${localVersion})`);
-                console.log(`  Remote: ${latestRemoteTag} (${remoteVersion})`);
-                console.log('');
-                console.log('This usually means you need to pull latest tags:');
-                console.log('  git fetch --tags');
-                console.log('');
+                if (!isJSON) {
+                    console.log(`  Local:  ${latestLocalTag} (${localVersion})`);
+                    console.log(`  Remote: ${latestRemoteTag} (${remoteVersion})`);
+                    console.log('');
+                    console.log('This usually means you need to pull latest tags:');
+                    console.log('  git fetch --tags');
+                    console.log('');
+                }
+
+                // Decision #7: headless → ABORT
+                if (headless) {
+                    const msg = `Local tag (${localVersion}) is older than remote (${remoteVersion}). Run: git fetch --tags`;
+                    if (isJSON) { _emitErrorJSON(msg); return; }
+                    fatal(msg);
+                }
 
                 userChoice = await promptMenu(
                     'What would you like to do?',
@@ -454,49 +586,62 @@ export async function runCreatePr(args) {
                 });
 
                 showWarning('Unable to compare tag versions:');
-                console.log(`  Local tag:  ${latestLocalTag || 'none'}`);
-                console.log(`  Remote tag: ${latestRemoteTag || 'none'}`);
-                console.log('');
-                console.log('Unpushed tags:', tagComparison.localNewer.join(', '));
-                console.log('');
+                if (!isJSON) {
+                    console.log(`  Local tag:  ${latestLocalTag || 'none'}`);
+                    console.log(`  Remote tag: ${latestRemoteTag || 'none'}`);
+                    console.log('');
+                    console.log('Unpushed tags:', tagComparison.localNewer.join(', '));
+                    console.log('');
+                }
 
-                userChoice = await promptMenu(
-                    'What would you like to do?',
-                    [
-                        { key: 'p', label: 'Push tags to remote' },
-                        { key: 'c', label: 'Continue without pushing' },
-                        { key: 'a', label: 'Abort PR creation' }
-                    ],
-                    'p'
-                );
+                // Decision #8: headless → continue without push
+                userChoice = headless
+                    ? 'c'
+                    : await promptMenu(
+                        'What would you like to do?',
+                        [
+                            { key: 'p', label: 'Push tags to remote' },
+                            { key: 'c', label: 'Continue without pushing' },
+                            { key: 'a', label: 'Abort PR creation' }
+                        ],
+                        'p'
+                    );
 
                 if (userChoice === 'a') {
                     showInfo('PR creation cancelled');
                     process.exit(0);
                 } else if (userChoice === 'p') {
-                    shouldPush = true;
+                    shouldPushTags = true;
                 }
             }
 
-            // Execute push if decided
-            if (shouldPush) {
-                console.log('');
+            // Execute tag push if decided
+            if (shouldPushTags) {
+                if (!isJSON) console.log('');
                 showInfo('Pushing tags to remote...');
 
                 const pushResult = pushTagsUtil(null, tagComparison.localNewer);
 
                 if (pushResult.success) {
+                    pushedTags = tagComparison.localNewer;
                     showSuccess('✓ Tags pushed successfully');
                     logger.debug('create-pr', 'Tags pushed', {
                         pushed: tagComparison.localNewer
                     });
                 } else {
                     showError(`Failed to push some tags: ${pushResult.error}`);
-                    if (pushResult.failed.length > 0) {
+                    if (!isJSON && pushResult.failed.length > 0) {
                         console.log('Failed tags:');
                         pushResult.failed.forEach((f) => console.log(`  - ${f.tag}: ${f.error}`));
                     }
 
+                    // Decision #9: headless → ABORT
+                    if (headless) {
+                        const msg = `Failed to push tags: ${pushResult.error}`;
+                        if (isJSON) { _emitErrorJSON(msg); return; }
+                        fatal(msg);
+                    }
+
                     const shouldContinue = await promptConfirmation(
                         'Continue creating PR despite push failure?',
                         false
@@ -508,13 +653,12 @@ export async function runCreatePr(args) {
                     }
                 }
 
-                console.log('');
+                if (!isJSON) console.log('');
             } else if (userChoice !== 'c') {
-                // Auto-push failed or user chose to continue
                 logger.debug('create-pr', 'Tag push skipped', {
                     reason: 'user choice or condition'
                 });
-                console.log('');
+                if (!isJSON) console.log('');
             }
         } else {
             logger.debug('create-pr', 'No unpushed tags found, continuing');
@@ -529,11 +673,17 @@ export async function runCreatePr(args) {
             result: analysisResult,
             error: engineError
         } = await analyzeBranchForPR(baseBranch, {
-            hook: 'create-pr'
+            hook: 'create-pr',
+            headless,
+            costTracker
         });
 
         if (!engineSuccess) {
             logger.error('create-pr', 'Failed to generate PR metadata', { error: engineError });
+            if (isJSON) {
+                _emitErrorJSON(engineError || 'Failed to generate PR metadata');
+                return;
+            }
             error(engineError || 'Failed to generate PR metadata');
             return;
         }
@@ -568,18 +718,25 @@ export async function runCreatePr(args) {
 
         if (mergeStrategy === 'unknown') {
             showWarning('Unknown branch pattern — cannot auto-detect merge strategy');
-            console.log('');
-            const strategyChoice = await promptMenu(
-                'Select merge strategy:',
-                [
-                    { key: 's', label: 'Squash merge' },
-                    { key: 'm', label: 'Merge commit' },
-                    { key: 'k', label: 'Skip (no strategy label)' }
-                ],
-                'k'
-            );
-            if (strategyChoice === 's') mergeStrategy = 'squash';
-            else if (strategyChoice === 'm') mergeStrategy = 'merge-commit';
+
+            // Decision #10: headless → default to 'squash'
+            if (headless) {
+                mergeStrategy = 'squash';
+                logger.warning('create-pr', 'Defaulting to squash merge strategy (headless)');
+            } else {
+                if (!isJSON) console.log('');
+                const strategyChoice = await promptMenu(
+                    'Select merge strategy:',
+                    [
+                        { key: 's', label: 'Squash merge' },
+                        { key: 'm', label: 'Merge commit' },
+                        { key: 'k', label: 'Skip (no strategy label)' }
+                    ],
+                    'k'
+                );
+                if (strategyChoice === 's') mergeStrategy = 'squash';
+                else if (strategyChoice === 'm') mergeStrategy = 'merge-commit';
+            }
         }
 
         // Step 9.5: Resolve labels
@@ -633,7 +790,7 @@ export async function runCreatePr(args) {
             reviewers
         };
 
-        showPRPreview(prData);
+        if (!isJSON) showPRPreview(prData);
 
         let strategyLabel;
         if (mergeStrategy === 'squash') {
@@ -646,14 +803,17 @@ export async function runCreatePr(args) {
         showInfo(`Merge strategy: ${strategyLabel} (${currentBranch} → ${baseBranch})`);
 
         // Step 12: Prompt for confirmation
-        const action = await promptMenu(
-            'What would you like to do?',
-            [
-                { key: 'c', label: 'Create PR' },
-                { key: 'x', label: 'Cancel' }
-            ],
-            'c'
-        );
+        // Decision #11: headless → always create
+        const action = headless
+            ? 'c'
+            : await promptMenu(
+                'What would you like to do?',
+                [
+                    { key: 'c', label: 'Create PR' },
+                    { key: 'x', label: 'Cancel' }
+                ],
+                'c'
+            );
 
         if (action === 'x') {
             showInfo('PR creation cancelled');
@@ -710,6 +870,29 @@ export async function runCreatePr(args) {
                 prNumber: result.number
             }).catch(() => {});
 
+            if (isJSON) {
+                _emitJSON({
+                    status: 'created',
+                    prUrl: result.html_url,
+                    prNumber: result.number,
+                    title: prData.title,
+                    body: prData.body,
+                    head: prData.head,
+                    base: prData.base,
+                    mergeStrategy,
+                    labels: prData.labels,
+                    reviewers: prData.reviewers,
+                    taskId: taskId || null,
+                    pushed: branchWasPushed,
+                    tagsPushed: pushedTags,
+                    fileCount: filesArray.length,
+                    durationMs: Date.now() - startTime,
+                    costs: costTracker ? costTracker.toJSON() : null
+                });
+                process.exit(0);
+                return;
+            }
+
             console.log('');
             showSuccess('Pull request created successfully!');
             console.log('');
@@ -724,6 +907,21 @@ export async function runCreatePr(args) {
             }
         } catch (apiError) {
             logger.error('create-pr', 'Failed to create pull request', apiError);
+
+            if (isJSON) {
+                _emitJSON({
+                    status: 'error',
+                    error: apiError.message,
+                    errorName: apiError.name || 'Error',
+                    head: prData.head,
+                    base: prData.base,
+                    durationMs: Date.now() - startTime,
+                    costs: costTracker ? costTracker.toJSON() : null
+                });
+                process.exit(1);
+                return;
+            }
+
             showError('Failed to create pull request');
             console.error('');
             console.error(`  ${apiError.message}`);
@@ -761,6 +959,19 @@ export async function runCreatePr(args) {
         }
     } catch (err) {
         logger.error('create-pr', 'Error creating PR', err);
+
+        if (isJSON) {
+            _emitJSON({
+                status: 'error',
+                error: err.message,
+                errorName: err.name || 'Error',
+                durationMs: Date.now() - startTime,
+                costs: costTracker ? costTracker.toJSON() : null
+            });
+            process.exit(1);
+            return;
+        }
+
         showError(`Error creating PR: ${err.message}`);
 
         if (err.context) {