@camaradesuk/git-worktree-tools 1.9.0 → 1.11.0

package/dist/cli/newpr.js

@@ -6,9 +6,11 @@
  */
 import path from 'path';
 import fs from 'fs';
+import { printDeprecationNotice } from '../lib/deprecation.js';
 import * as git from '../lib/git.js';
 import * as github from '../lib/github.js';
-import * as colors from '../lib/colors.js';
+import { setColorEnabled } from '../lib/colors.js';
+import { logger, initializeLogger, setAuditContext } from '../lib/logger.js';
 import { promptChoiceIndex, promptConfirm, withSpinner } from '../lib/prompts.js';
 import { getEnabledFiles } from '../lib/wtlink/config-manifest.js';
 import { run as runWtlink } from '../lib/wtlink/link-configs.js';
@@ -17,10 +19,7 @@ import { analyzeGitState, detectScenario } from '../lib/state-detection.js';
 import { parseArgs, getHelpText, getScenarioContext, isPrWorktreeScenario, isExistingBranchAction, executeStateAction, getBranchPoint, getScenarioMessageLevel, createHookRunner, createActionDeps, } from '../lib/newpr/index.js';
 import { createSuccessResult, createErrorResult, formatJsonResult, ErrorCode, getErrorCodeFromError, getErrorSuggestion, } from '../lib/json-output.js';
 import { shouldGeneratePlan, resolvePlanPath, buildPathTemplateVars, generatePlanDocument, } from '../lib/newpr/plan-generator.js';
-/**
- * Debug logging - enabled with DEBUG=newpr or DEBUG=*
- */
-const DEBUG_ENABLED = process.env.DEBUG === 'newpr' || process.env.DEBUG === '*' || process.env.DEBUG === '1';
+import { printStatus, printDim, printSummaryBox, printNextSteps, printError, errorToDisplay, setJsonMode, } from '../lib/ui/index.js';
 /**
  * Error class for non-interactive mode failures
  */
@@ -32,47 +31,26 @@ class NonInteractiveError extends Error {
         this.name = 'NonInteractiveError';
     }
 }
-function debug(message, data) {
-    if (!DEBUG_ENABLED)
-        return;
-    const timestamp = new Date().toISOString();
-    console.error(colors.dim(`[DEBUG ${timestamp}] ${message}`));
-    if (data) {
-        for (const [key, value] of Object.entries(data)) {
-            console.error(colors.dim(`  ${key}: ${JSON.stringify(value)}`));
-        }
-    }
-}
-/**
- * Progress logging - suppressed in JSON mode for clean output
- */
-function progress(options, ...args) {
-    if (!options.json) {
-        console.log(...args);
-    }
-}
-/**
- * Progress error logging - suppressed in JSON mode
- */
-function progressError(options, ...args) {
-    if (!options.json) {
-        console.error(...args);
-    }
-}
 /**
  * Check prerequisites
  */
 function checkPrerequisites() {
-    console.log(colors.info('Checking prerequisites...'));
+    printStatus('info', 'Checking prerequisites...');
     if (!github.isGhInstalled()) {
-        console.error(colors.error('GitHub CLI (gh) is required. See: https://cli.github.com'));
+        printError({
+            title: 'GitHub CLI (gh) is required.',
+            hint: 'Install: https://cli.github.com',
+        });
         process.exit(1);
     }
     if (!github.isAuthenticated()) {
-        console.error(colors.error('GitHub CLI not authenticated. Run: gh auth login'));
+        printError({
+            title: 'GitHub CLI not authenticated.',
+            hint: 'Run: gh auth login',
+        });
         process.exit(1);
     }
-    console.log(colors.success('Prerequisites OK'));
+    printStatus('success', 'Prerequisites OK');
 }
 /**
  * Show local commits not in base branch
@@ -136,7 +114,7 @@ async function handleScenario(state, baseBranch, options) {
             // In non-interactive mode, cannot proceed from PR worktree
             throw new NonInteractiveError('Cannot create PR from a PR worktree in non-interactive mode. Switch to the main worktree first.', ErrorCode.INVALID_ARGUMENT);
         }
-        console.log(colors.warning('You are in a PR worktree, not the main worktree.'));
+        printStatus('warning', 'You are in a PR worktree, not the main worktree.');
         console.log();
         console.log('Creating a new PR is best done from the main worktree.');
         const choice = await promptChoiceIndex('How would you like to proceed?', [
@@ -181,10 +159,10 @@ async function handleScenario(state, baseBranch, options) {
     // Interactive mode: display info and prompt
     const level = getScenarioMessageLevel(scenario);
     if (level === 'warning') {
-        console.log(colors.warning(context.message));
+        printStatus('warning', context.message);
     }
     else {
-        console.log(colors.info(context.message));
+        printStatus('info', context.message);
     }
     if (context.subMessage) {
         console.log();
@@ -243,7 +221,7 @@ async function setupWorktree(worktreePath, config, options, repoRoot) {
     const parentDir = path.dirname(repoRoot);
     // Create symlinks for shared repos
     if (config.sharedRepos.length > 0) {
-        progress(options, colors.info('Creating symlinks for shared repositories...'));
+        printStatus('info', 'Creating symlinks for shared repositories...');
         for (const repo of config.sharedRepos) {
             const target = path.join(parentDir, repo);
             const link = path.join(worktreePath, repo);
@@ -251,18 +229,18 @@ async function setupWorktree(worktreePath, config, options, repoRoot) {
                 if (!fs.existsSync(link)) {
                     try {
                         fs.symlinkSync(target, link, 'dir');
-                        progress(options, colors.success(`Linked ${repo}`));
+                        printStatus('success', `Linked ${repo}`);
                     }
                     catch (error) {
-                        progress(options, colors.warning(`Failed to link ${repo}: ${error}`));
+                        printStatus('warning', `Failed to link ${repo}: ${error}`);
                     }
                 }
                 else {
-                    progress(options, colors.warning(`${repo} already exists in worktree`));
+                    printStatus('warning', `${repo} already exists in worktree`);
                 }
             }
             else {
-                progress(options, colors.warning(`${repo} not found at ${target}`));
+                printStatus('warning', `${repo} not found at ${target}`);
             }
         }
     }
@@ -273,7 +251,7 @@ async function setupWorktree(worktreePath, config, options, repoRoot) {
     }
     catch {
         // If we can't determine main worktree, skip linking
-        debug('Could not determine main worktree root, skipping config file linking');
+        logger.debug('Could not determine main worktree root, skipping config file linking');
         return;
     }
     const enabledFiles = getEnabledFiles(mainWorktreeRoot);
@@ -281,29 +259,28 @@ async function setupWorktree(worktreePath, config, options, repoRoot) {
         let shouldLink = false;
         if (config.linkConfigFiles === false) {
             // Explicitly disabled - skip
-            debug('linkConfigFiles is false, skipping auto-link');
+            logger.debug('linkConfigFiles is false, skipping auto-link');
         }
         else if (config.linkConfigFiles === true) {
             // Explicitly enabled - auto-link
             shouldLink = true;
-            debug('linkConfigFiles is true, auto-linking');
+            logger.debug('linkConfigFiles is true, auto-linking');
         }
         else if (!options.nonInteractive && !options.json) {
             // Not configured - prompt user
-            progress(options, '');
-            progress(options, colors.info(`Found ${enabledFiles.length} config file(s) to link:`));
+            printStatus('info', `Found ${enabledFiles.length} config file(s) to link:`);
             for (const file of enabledFiles.slice(0, 5)) {
-                progress(options, colors.dim(`  - ${file}`));
+                printDim(`  - ${file}`);
             }
             if (enabledFiles.length > 5) {
-                progress(options, colors.dim(`  ... and ${enabledFiles.length - 5} more`));
+                printDim(`  ... and ${enabledFiles.length - 5} more`);
             }
             shouldLink = await promptConfirm('Link these config files from the main worktree?', true);
         }
         else {
             // Non-interactive/JSON mode - default to linking
             shouldLink = true;
-            debug('Non-interactive mode, defaulting to auto-link');
+            logger.debug('Non-interactive mode, defaulting to auto-link');
         }
         if (shouldLink) {
             try {
@@ -315,11 +292,11 @@ async function setupWorktree(worktreePath, config, options, repoRoot) {
                     type: 'hard',
                     yes: true,
                 });
-                progress(options, colors.success(`Linked ${enabledFiles.length} config file(s)`));
+                printStatus('success', `Linked ${enabledFiles.length} config file(s)`);
             }
             catch (error) {
                 const errorMessage = error instanceof Error ? error.message : String(error);
-                progress(options, colors.warning(`Failed to link config files: ${errorMessage}`));
+                printStatus('warning', `Failed to link config files: ${errorMessage}`);
             }
         }
     }
@@ -341,20 +318,16 @@ function printSummary(prNumber, branchName, worktreePath, prUrl, options, extra)
         console.log(formatJsonResult(createSuccessResult('newpr', data)));
         return;
     }
-    console.log();
-    console.log(colors.green('════════════════════════════════════════════════════════════'));
-    console.log(colors.green(`  PR #${prNumber} worktree ready!`));
-    console.log(colors.green('════════════════════════════════════════════════════════════'));
-    console.log();
-    console.log(`  Branch:    ${branchName}`);
-    console.log(`  Worktree:  ${worktreePath}`);
-    console.log(`  PR URL:    ${prUrl}`);
-    console.log();
-    console.log(colors.dim('  Next steps:'));
-    console.log(colors.dim(`    cd ${worktreePath}`));
-    console.log(colors.dim(`    gh pr view ${prNumber} --web     # Open PR in browser`));
-    console.log(colors.dim(`    wtlink link                     # Link config files from main worktree`));
-    console.log();
+    printSummaryBox(`PR #${prNumber} worktree ready!`, [
+        { label: 'Branch', value: branchName },
+        { label: 'Worktree', value: worktreePath },
+        { label: 'PR URL', value: prUrl },
+    ]);
+    printNextSteps([
+        { command: `cd ${worktreePath}` },
+        { command: `gh pr view ${prNumber} --web`, description: 'Open PR in browser' },
+        { command: 'wtlink link', description: 'Link config files from main worktree' },
+    ]);
 }
 /**
  * Handle plan generation based on options and config
@@ -379,10 +352,10 @@ async function handlePlanGeneration(options, config, context) {
         shouldGenerate = await promptConfirm('Generate AI implementation plan document?', false);
     }
     if (!shouldGenerate) {
-        debug('Plan generation skipped', { reason: decision.reason });
+        logger.debug('Plan generation skipped', { reason: decision.reason });
         return undefined;
     }
-    progress(options, colors.info('Generating AI implementation plan...'));
+    printStatus('info', 'Generating AI implementation plan...');
     // Build path template variables
     const vars = buildPathTemplateVars({
         prNumber: context.prNumber,
@@ -400,10 +373,10 @@ async function handlePlanGeneration(options, config, context) {
         baseBranch: options.baseBranch,
     });
     if (result.generated) {
-        progress(options, colors.success(`Created plan: ${result.path}`));
+        printStatus('success', `Created plan: ${result.path}`);
     }
     else if (result.error) {
-        progress(options, colors.warning(`Plan generation failed: ${result.error}`));
+        printStatus('warning', `Plan generation failed: ${result.error}`);
     }
     return result;
 }
@@ -432,7 +405,7 @@ async function executePostWorktreeSequence(worktreePath, config, options, contex
  * Mode: Setup worktree for existing PR
  */
 async function modeExistingPr(prNumber, options) {
-    progress(options, colors.info(`Setting up worktree for existing PR #${prNumber}...`));
+    printStatus('info', `Setting up worktree for existing PR #${prNumber}...`);
     const repoRoot = git.getRepoRoot();
     const repoName = git.getRepoName(repoRoot);
     const config = loadConfig(repoRoot);
@@ -441,7 +414,7 @@ async function modeExistingPr(prNumber, options) {
         repoRoot,
         baseBranch: options.baseBranch,
     }, {
-        verbose: DEBUG_ENABLED,
+        verbose: options.verbose ?? false,
         showOutput: true,
         defaultTimeout: config.hookDefaults?.timeout,
         maxTimeout: config.hookDefaults?.maxTimeout,
@@ -452,9 +425,9 @@ async function modeExistingPr(prNumber, options) {
         exitWithError(`Could not find PR #${prNumber}`, ErrorCode.PR_NOT_FOUND, options.json);
     }
     if (pr.state !== 'OPEN') {
-        progress(options, colors.warning(`PR #${prNumber} is ${pr.state}`));
+        printStatus('warning', `PR #${prNumber} is ${pr.state}`);
     }
-    progress(options, colors.info(`PR branch: ${pr.headBranch}`));
+    printStatus('info', `PR branch: ${pr.headBranch}`);
     const worktreePath = generateWorktreePath(config, repoRoot, repoName, prNumber);
     if (fs.existsSync(worktreePath)) {
         exitWithError(`Worktree already exists: ${worktreePath}`, ErrorCode.WORKTREE_EXISTS, options.json);
@@ -500,7 +473,7 @@ async function modeExistingPr(prNumber, options) {
             }
         });
     }
-    progress(options, colors.success(`Created worktree: ${worktreePath}`));
+    printStatus('success', `Created worktree: ${worktreePath}`);
     await setupWorktree(worktreePath, config, options, repoRoot);
     // Generate description from branch name for plan context
     const descriptionFromBranch = pr.headBranch
@@ -513,13 +486,14 @@ async function modeExistingPr(prNumber, options) {
         branchName: pr.headBranch,
         description: descriptionFromBranch,
     }, hookRunner);
+    setAuditContext({ prNumber, worktreePath, gitBranch: pr.headBranch });
     printSummary(prNumber, pr.headBranch, worktreePath, pr.url, options, { draft: pr.isDraft });
 }
 /**
  * Mode: Create PR for existing branch
  */
 async function modeExistingBranch(branchName, options) {
-    progress(options, colors.info(`Creating PR for existing branch: ${branchName}...`));
+    printStatus('info', `Creating PR for existing branch: ${branchName}...`);
     const repoRoot = git.getRepoRoot();
     const repoName = git.getRepoName(repoRoot);
     const config = loadConfig(repoRoot);
@@ -528,7 +502,7 @@ async function modeExistingBranch(branchName, options) {
         repoRoot,
         baseBranch: options.baseBranch,
     }, {
-        verbose: DEBUG_ENABLED,
+        verbose: options.verbose ?? false,
         showOutput: true,
         defaultTimeout: config.hookDefaults?.timeout,
         maxTimeout: config.hookDefaults?.maxTimeout,
@@ -561,11 +535,11 @@ async function modeExistingBranch(branchName, options) {
     }
     const existingPr = github.getPrByBranch(branchName);
     if (existingPr) {
-        progress(options, colors.info(`PR #${existingPr.number} already exists for branch ${branchName}`));
+        printStatus('info', `PR #${existingPr.number} already exists for branch ${branchName}`);
         await modeExistingPr(existingPr.number, options);
         return;
     }
-    progress(options, colors.info('Creating pull request...'));
+    printStatus('info', 'Creating pull request...');
     // Generate description from branch name for AI context
     const descriptionFromBranch = branchName
         .replace(/^(feat|fix|chore)\//, '')
@@ -580,7 +554,7 @@ async function modeExistingBranch(branchName, options) {
         commitMessages: git.getCommitMessages(`origin/${options.baseBranch}`, branchName),
     });
     if (prContent.aiGenerated) {
-        progress(options, colors.info('✨ AI-generated PR content'));
+        printStatus('info', '✨ AI-generated PR content');
     }
     const defaultBody = `## Summary
 
@@ -603,7 +577,7 @@ PR created from existing branch: \`${branchName}\`
         head: branchName,
         draft: options.draft,
     });
-    progress(options, colors.success(`Created PR #${pr.number}: ${pr.url}`));
+    printStatus('success', `Created PR #${pr.number}: ${pr.url}`);
     // Update hook context
     hookRunner.updateContext({
         branchName,
@@ -636,7 +610,7 @@ PR created from existing branch: \`${branchName}\`
             }
         });
     }
-    progress(options, colors.success(`Created worktree: ${worktreePath}`));
+    printStatus('success', `Created worktree: ${worktreePath}`);
     await setupWorktree(worktreePath, config, options, repoRoot);
     // Execute unified post-worktree sequence (plan generation + hook)
     await executePostWorktreeSequence(worktreePath, config, options, {
@@ -644,6 +618,7 @@ PR created from existing branch: \`${branchName}\`
         branchName,
         description: descriptionFromBranch,
     }, hookRunner);
+    setAuditContext({ prNumber: pr.number, worktreePath, gitBranch: branchName });
     printSummary(pr.number, branchName, worktreePath, pr.url, options);
 }
 /**
@@ -660,7 +635,7 @@ async function modeNewFeature(description, options) {
         baseBranch: options.baseBranch,
         description,
     }, {
-        verbose: DEBUG_ENABLED,
+        verbose: options.verbose ?? false,
         showOutput: true,
         defaultTimeout: config.hookDefaults?.timeout,
         maxTimeout: config.hookDefaults?.maxTimeout,
@@ -682,7 +657,7 @@ async function modeNewFeature(description, options) {
         }
     }
     catch {
-        progress(options, colors.warning('Could not fetch from origin (network unavailable?)'));
+        printStatus('warning', 'Could not fetch from origin (network unavailable?)');
     }
     const state = analyzeGitState(options.baseBranch);
     const scenario = detectScenario(state);
@@ -696,7 +671,7 @@ async function modeNewFeature(description, options) {
     if (!(await hookRunner.runHook('post-analyze'))) {
         exitWithError('Aborted by post-analyze hook.', ErrorCode.HOOK_FAILED, options.json);
     }
-    debug('State analysis complete', {
+    logger.debug('State analysis complete', {
         scenario,
         branchType: state.branchType,
         currentBranch: state.currentBranch,
@@ -712,10 +687,10 @@ async function modeNewFeature(description, options) {
             console.log(formatJsonResult(createErrorResult('newpr', ErrorCode.USER_CANCELLED, 'User cancelled')));
             process.exit(1);
         }
-        console.log(colors.error('Aborted by user.'));
+        printStatus('error', 'Aborted by user.');
         process.exit(1);
     }
-    debug('User selected action', {
+    logger.debug('User selected action', {
         action: action.action,
         branchFrom: action.branchFrom,
         stashUnstaged: action.stashUnstaged,
@@ -734,36 +709,36 @@ async function modeNewFeature(description, options) {
         const deps = createActionDeps(repoRoot);
         executeStateAction(action, description, currentBranch, deps, repoRoot);
         if (!git.remoteBranchExists(currentBranch)) {
-            progress(options, colors.info('Pushing branch to origin...'));
+            printStatus('info', 'Pushing branch to origin...');
             git.push({ setUpstream: true, remote: 'origin', branch: currentBranch });
         }
         await modeExistingBranch(currentBranch, options);
         return;
     }
-    progress(options, colors.info(`Creating feature branch: ${branchName}`));
+    printStatus('info', `Creating feature branch: ${branchName}`);
     if (git.remoteBranchExists(branchName)) {
-        progress(options, colors.warning(`Branch ${branchName} already exists on remote`));
+        printStatus('warning', `Branch ${branchName} already exists on remote`);
         const existingPr = github.getPrByBranch(branchName);
         if (existingPr) {
-            progress(options, colors.info(`PR #${existingPr.number} already exists, setting up worktree...`));
+            printStatus('info', `PR #${existingPr.number} already exists, setting up worktree...`);
             await modeExistingPr(existingPr.number, options);
         }
         else {
-            progress(options, colors.info('No PR exists, creating one...'));
+            printStatus('info', 'No PR exists, creating one...');
             await modeExistingBranch(branchName, options);
         }
         return;
     }
     const originalBranch = git.getCurrentBranch() || 'main';
     const deps = createActionDeps(repoRoot);
-    debug('Before executeStateAction', {
+    logger.debug('Before executeStateAction', {
         originalBranch,
         branchName,
         stagedFilesBefore: git.getStagedFiles(),
         unstagedFilesBefore: git.getUnstagedFiles(),
     });
     const actionResult = executeStateAction(action, description, branchName, deps, repoRoot);
-    debug('After executeStateAction', {
+    logger.debug('After executeStateAction', {
         success: actionResult.success,
         stashRef: actionResult.stashRef,
         stagedFilesAfter: git.getStagedFiles(),
@@ -775,7 +750,7 @@ async function modeNewFeature(description, options) {
     // Stash unstaged changes if needed
     let unstagedStashRef = null;
     if (action.stashUnstaged) {
-        progress(options, colors.info('Stashing unstaged changes (will move to worktree)...'));
+        printStatus('info', 'Stashing unstaged changes (will move to worktree)...');
         unstagedStashRef = git.stash({
             keepIndex: true,
             message: 'newpr: unstaged changes for worktree',
@@ -787,8 +762,8 @@ async function modeNewFeature(description, options) {
         if (!(await hookRunner.runHook('pre-branch'))) {
             exitWithError('Aborted by pre-branch hook.', ErrorCode.HOOK_FAILED, options.json);
         }
-        progress(options, colors.info(`Creating branch from ${branchFrom}...`));
-        debug('Before checkout', {
+        printStatus('info', `Creating branch from ${branchFrom}...`);
+        logger.debug('Before checkout', {
             branchFrom,
             branchName,
             currentBranch: git.getCurrentBranch(),
@@ -802,16 +777,19 @@ async function modeNewFeature(description, options) {
             // the staged files in the index - no data is lost. Provide a helpful message.
             const errorMessage = checkoutError instanceof Error ? checkoutError.message : String(checkoutError);
             if (errorMessage.includes('overwritten') || errorMessage.includes('conflict')) {
-                progressError(options, colors.error('Checkout failed due to conflicting changes.'));
-                progressError(options, colors.info('Your staged changes are preserved. To resolve this, either:'));
-                progressError(options, colors.info('  1. Commit your changes first, then run newpr again'));
-                progressError(options, colors.info('  2. Stash your changes: git stash push'));
-                progressError(options, colors.info('  3. Use a different branch point (e.g., HEAD instead of origin/main)'));
+                printError({
+                    title: 'Checkout failed due to conflicting changes.',
+                    detail: 'Your staged changes are preserved in the index.',
+                    hint: 'To resolve this, either:\n' +
+                        '  1. Commit your changes first, then run newpr again\n' +
+                        '  2. Stash your changes: git stash push\n' +
+                        '  3. Use a different branch point (e.g., HEAD instead of origin/main)',
+                });
             }
             throw checkoutError;
         }
         const stagedFiles = git.getStagedFiles();
-        debug('After checkout', {
+        logger.debug('After checkout', {
             newBranch: git.getCurrentBranch(),
             stagedFilesAfterCheckout: stagedFiles,
             stagedFilesCount: stagedFiles.length,
@@ -825,9 +803,9 @@ async function modeNewFeature(description, options) {
             if (!(await hookRunner.runHook('pre-commit'))) {
                 exitWithError('Aborted by pre-commit hook.', ErrorCode.HOOK_FAILED, options.json);
             }
-            progress(options, colors.info('Committing staged changes...'));
+            printStatus('info', 'Committing staged changes...');
             git.commit({ message: `feat: ${description}\n\n🤖 Created with newpr` });
-            debug('Committed staged changes');
+            logger.debug('Committed staged changes');
             // Run post-commit hook
             await hookRunner.runHook('post-commit');
         }
@@ -836,12 +814,12 @@ async function modeNewFeature(description, options) {
             if (!(await hookRunner.runHook('pre-commit'))) {
                 exitWithError('Aborted by pre-commit hook.', ErrorCode.HOOK_FAILED, options.json);
             }
-            progress(options, colors.info('Creating initial commit (required for PR creation)...'));
+            printStatus('info', 'Creating initial commit (required for PR creation)...');
             git.commit({
                 message: `chore: initialize ${branchName}\n\nBranch created for: ${description}\n\n🤖 Created with newpr`,
                 allowEmpty: true,
             });
-            debug('Created empty commit (no staged files found)');
+            logger.debug('Created empty commit (no staged files found)');
             // Run post-commit hook
             await hookRunner.runHook('post-commit');
         }
@@ -865,7 +843,7 @@ async function modeNewFeature(description, options) {
         if (!(await hookRunner.runHook('pre-pr'))) {
             exitWithError('Aborted by pre-pr hook.', ErrorCode.HOOK_FAILED, options.json);
         }
-        progress(options, colors.info('Creating pull request...'));
+        printStatus('info', 'Creating pull request...');
         // Generate AI-enhanced PR content if enabled
         // Use origin/baseBranch to compare against remote, not potentially stale local branch
         const prContent = await generatePRContentAsync(config, {
@@ -876,7 +854,7 @@ async function modeNewFeature(description, options) {
             commitMessages: git.getCommitMessages(`origin/${options.baseBranch}`, branchName),
         });
         if (prContent.aiGenerated) {
-            progress(options, colors.info('✨ AI-generated PR content'));
+            printStatus('info', '✨ AI-generated PR content');
         }
         const defaultBody = `## Summary
 
@@ -899,7 +877,7 @@ ${description}
             head: branchName,
             draft: options.draft,
         });
-        progress(options, colors.success(`Created PR #${pr.number}: ${pr.url}`));
+        printStatus('success', `Created PR #${pr.number}: ${pr.url}`);
         // Update context with PR info
         hookRunner.updateContext({
             prNumber: pr.number,
@@ -923,17 +901,17 @@ ${description}
                 await git.addWorktreeAsync(worktreePath, branchName, { cwd: repoRoot });
             });
         }
-        progress(options, colors.success(`Created worktree: ${worktreePath}`));
+        printStatus('success', `Created worktree: ${worktreePath}`);
         if (unstagedStashRef) {
-            progress(options, colors.info('Moving unstaged changes to worktree...'));
+            printStatus('info', 'Moving unstaged changes to worktree...');
             try {
                 git.stashApply(unstagedStashRef, worktreePath);
-                progress(options, colors.success('Unstaged changes applied to worktree'));
+                printStatus('success', 'Unstaged changes applied to worktree');
                 git.stashDrop(unstagedStashRef);
             }
             catch {
-                progress(options, colors.warning('Failed to apply unstaged changes to worktree.'));
-                progress(options, colors.warning("Run 'git stash pop' in main worktree to recover them."));
+                printStatus('warning', 'Failed to apply unstaged changes to worktree.');
+                printStatus('warning', "Run 'git stash pop' in main worktree to recover them.");
             }
         }
         await setupWorktree(worktreePath, config, options, repoRoot);
@@ -943,6 +921,7 @@ ${description}
             branchName,
             description,
         }, hookRunner);
+        setAuditContext({ prNumber: pr.number, worktreePath, gitBranch: branchName });
         printSummary(pr.number, branchName, worktreePath, pr.url, options, {
             scenario,
             actionTaken: action.action,
@@ -952,12 +931,12 @@ ${description}
         // Run cleanup hook
         await hookRunner.runCleanup(error instanceof Error ? error : undefined);
         if (actionResult.stashRef) {
-            progress(options, colors.info('Restoring stashed changes...'));
+            printStatus('info', 'Restoring stashed changes...');
             try {
                 git.stashPop(actionResult.stashRef);
             }
             catch {
-                progress(options, colors.warning("Failed to restore stash. Run 'git stash pop' manually."));
+                printStatus('warning', "Failed to restore stash. Run 'git stash pop' manually.");
             }
         }
         throw error;
@@ -977,25 +956,23 @@ function exitWithError(message, code, useJson) {
         console.log(formatJsonResult(createErrorResult('newpr', code, message)));
     }
     else {
-        console.error(colors.error(message));
+        const hint = getErrorSuggestion(code);
+        printError({ title: message, hint });
     }
     process.exit(1);
 }
 /**
- * Main entry point
+ * Run the newpr handler with already-parsed options.
+ *
+ * This is the core newpr workflow, callable both from the standalone CLI
+ * entry point and from the `wt new` handler (in-process delegation).
+ *
+ * Callers are responsible for:
+ * - Initializing the logger (initializeLogger)
+ * - Setting JSON mode (setJsonMode)
+ * - Setting color enabled state (setColorEnabled)
  */
-async function main() {
-    const rawArgs = process.argv.slice(2);
-    const useJson = hasJsonFlag(rawArgs);
-    const result = parseArgs(rawArgs);
-    if (result.kind === 'help') {
-        console.log(getHelpText());
-        process.exit(0);
-    }
-    if (result.kind === 'error') {
-        exitWithError(result.message, ErrorCode.INVALID_ARGUMENT, useJson);
-    }
-    const { options } = result;
+export async function runNewprHandler(options) {
     // Apply config.draftPr if user didn't explicitly set --draft or --ready
     try {
         const repoRoot = git.getRepoRoot();
@@ -1032,26 +1009,55 @@ async function main() {
             break;
     }
 }
-main().catch((error) => {
-    // Determine if JSON output is expected
-    const useJson = hasJsonFlag(process.argv.slice(2));
-    if (error instanceof NonInteractiveError) {
-        exitWithError(error.message, error.code, useJson);
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    const code = getErrorCodeFromError(error);
-    const suggestion = getErrorSuggestion(code);
-    if (useJson) {
-        exitWithError(message, code, useJson);
+/**
+ * Main entry point (standalone CLI)
+ */
+async function main() {
+    printDeprecationNotice('newpr', 'wt new');
+    const rawArgs = process.argv.slice(2);
+    const useJson = hasJsonFlag(rawArgs);
+    const result = parseArgs(rawArgs);
+    if (result.kind === 'help') {
+        console.log(getHelpText());
+        process.exit(0);
     }
-    else {
-        // Show friendly error with suggestion for non-JSON mode
-        console.error(colors.error(`Error: ${message}`));
-        if (suggestion) {
-            console.error('');
-            console.error(colors.dim(suggestion));
-        }
-        process.exit(1);
+    if (result.kind === 'error') {
+        exitWithError(result.message, ErrorCode.INVALID_ARGUMENT, useJson);
     }
-});
+    const { options } = result;
+    // Initialize logger (only when run as standalone CLI)
+    initializeLogger({
+        verbose: options.verbose,
+        quiet: options.quiet,
+        noColor: options.noColor,
+        json: options.json,
+        commandName: 'newpr',
+    });
+    setJsonMode(options.json);
+    if (options.noColor) {
+        setColorEnabled(false);
+    }
+    await runNewprHandler(options);
+}
+// Only run main() when this file is executed directly (not when imported)
+const isMain = import.meta.url.endsWith(process.argv[1]?.replace(/\\/g, '/') || '');
+if (isMain || process.argv[1]?.endsWith('newpr.js')) {
+    main().catch((error) => {
+        // Determine if JSON output is expected
+        const useJson = hasJsonFlag(process.argv.slice(2));
+        if (error instanceof NonInteractiveError) {
+            exitWithError(error.message, error.code, useJson);
+        }
+        if (useJson) {
+            const message = error instanceof Error ? error.message : String(error);
+            const code = getErrorCodeFromError(error);
+            exitWithError(message, code, useJson);
+        }
+        else {
+            const display = errorToDisplay(error);
+            printError(display);
+            process.exit(1);
+        }
+    });
+}
 //# sourceMappingURL=newpr.js.map