@camaradesuk/git-worktree-tools 1.8.0 → 1.10.0

package/dist/cli/newpr.js

@@ -6,18 +6,20 @@
  */
 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 { promptChoiceIndex, withSpinner } from '../lib/prompts.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';
 import { loadConfig, generateBranchNameAsync, generateWorktreePath, generatePRContentAsync, } from '../lib/config.js';
 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';
-/**
- * Debug logging - enabled with DEBUG=newpr or DEBUG=*
- */
-const DEBUG_ENABLED = process.env.DEBUG === 'newpr' || process.env.DEBUG === '*' || process.env.DEBUG === '1';
+import { shouldGeneratePlan, resolvePlanPath, buildPathTemplateVars, generatePlanDocument, } from '../lib/newpr/plan-generator.js';
+import { printStatus, printDim, printSummaryBox, printNextSteps, printError, errorToDisplay, setJsonMode, } from '../lib/ui/index.js';
 /**
  * Error class for non-interactive mode failures
  */
@@ -29,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
@@ -133,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?', [
@@ -178,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();
@@ -230,13 +211,17 @@ async function handleScenario(state, baseBranch, options) {
 }
 /**
  * Setup worktree (symlinks, wtlink, deps)
+ *
+ * @param worktreePath - Path to the newly created worktree
+ * @param config - Resolved configuration
+ * @param options - CLI options
+ * @param repoRoot - Repository root (required to avoid CWD issues when running from subdirectories)
  */
-async function setupWorktree(worktreePath, config, options) {
-    const repoRoot = git.getRepoRoot();
+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);
@@ -244,18 +229,74 @@ async function setupWorktree(worktreePath, config, options) {
                 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}`);
+            }
+        }
+    }
+    // Auto-link config files from main worktree
+    let mainWorktreeRoot;
+    try {
+        mainWorktreeRoot = git.getMainWorktreeRoot(repoRoot);
+    }
+    catch {
+        // If we can't determine main worktree, skip linking
+        logger.debug('Could not determine main worktree root, skipping config file linking');
+        return;
+    }
+    const enabledFiles = getEnabledFiles(mainWorktreeRoot);
+    if (enabledFiles.length > 0) {
+        let shouldLink = false;
+        if (config.linkConfigFiles === false) {
+            // Explicitly disabled - skip
+            logger.debug('linkConfigFiles is false, skipping auto-link');
+        }
+        else if (config.linkConfigFiles === true) {
+            // Explicitly enabled - auto-link
+            shouldLink = true;
+            logger.debug('linkConfigFiles is true, auto-linking');
+        }
+        else if (!options.nonInteractive && !options.json) {
+            // Not configured - prompt user
+            printStatus('info', `Found ${enabledFiles.length} config file(s) to link:`);
+            for (const file of enabledFiles.slice(0, 5)) {
+                printDim(`  - ${file}`);
+            }
+            if (enabledFiles.length > 5) {
+                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;
+            logger.debug('Non-interactive mode, defaulting to auto-link');
+        }
+        if (shouldLink) {
+            try {
+                await runWtlink({
+                    source: mainWorktreeRoot,
+                    destination: worktreePath,
+                    dryRun: false,
+                    manifestFile: '.wtlinkrc',
+                    type: 'hard',
+                    yes: true,
+                });
+                printStatus('success', `Linked ${enabledFiles.length} config file(s)`);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                printStatus('warning', `Failed to link config files: ${errorMessage}`);
             }
         }
     }
@@ -277,41 +318,127 @@ 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
+ */
+async function handlePlanGeneration(options, config, context) {
+    const aiConfig = config.ai ?? {};
+    // Check if AI provider is configured (simple check without initialization)
+    const aiAvailable = aiConfig.provider !== undefined &&
+        aiConfig.provider !== 'none' &&
+        aiConfig.planDocument === true;
+    // Determine if we should generate a plan
+    const decision = shouldGeneratePlan({
+        cliFlag: options.generatePlan,
+        noFlag: options.noPlan,
+        configEnabled: aiConfig.planDocument,
+        aiAvailable,
+        nonInteractive: options.nonInteractive ?? false,
+    });
+    // If prompting is needed and we're interactive, ask the user
+    let shouldGenerate = decision.generate;
+    if (decision.prompt && !options.json) {
+        shouldGenerate = await promptConfirm('Generate AI implementation plan document?', false);
+    }
+    if (!shouldGenerate) {
+        logger.debug('Plan generation skipped', { reason: decision.reason });
+        return undefined;
+    }
+    printStatus('info', 'Generating AI implementation plan...');
+    // Build path template variables
+    const vars = buildPathTemplateVars({
+        prNumber: context.prNumber,
+        description: context.description,
+        branchName: context.branchName,
+    });
+    // Resolve plan path
+    const planPath = resolvePlanPath(context.worktreePath, aiConfig, vars);
+    // Generate the plan
+    const result = await generatePlanDocument({
+        description: context.description,
+        branchName: context.branchName,
+    }, planPath, aiConfig, {
+        prNumber: context.prNumber,
+        baseBranch: options.baseBranch,
+    });
+    if (result.generated) {
+        printStatus('success', `Created plan: ${result.path}`);
+    }
+    else if (result.error) {
+        printStatus('warning', `Plan generation failed: ${result.error}`);
+    }
+    return result;
+}
+/**
+ * Execute the unified post-worktree sequence:
+ * 1. Plan generation (if enabled)
+ * 2. Post-worktree hook
+ *
+ * This ensures consistent behavior across all three newpr modes.
+ */
+async function executePostWorktreeSequence(worktreePath, config, options, context, hookRunner) {
+    const result = {};
+    // Generate plan (if enabled) - happens BEFORE post-worktree hook
+    result.planResult = await handlePlanGeneration(options, config, {
+        ...context,
+        worktreePath,
+    });
+    // Run post-worktree hook
+    if (hookRunner) {
+        hookRunner.updateContext({ worktreePath });
+        await hookRunner.runHook('post-worktree');
+    }
+    return result;
 }
 /**
  * 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);
+    // Initialize hook runner for post-worktree hook
+    const hookRunner = createHookRunner(options.noHooks ? {} : (config.hooks ?? {}), {
+        repoRoot,
+        baseBranch: options.baseBranch,
+    }, {
+        verbose: options.verbose ?? false,
+        showOutput: true,
+        defaultTimeout: config.hookDefaults?.timeout,
+        maxTimeout: config.hookDefaults?.maxTimeout,
+        confirmHooks: options.confirmHooks,
+    });
     const pr = github.getPr(prNumber);
     if (!pr) {
         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);
     }
+    // Update hook context
+    hookRunner.updateContext({
+        branchName: pr.headBranch,
+        prNumber,
+        prUrl: pr.url,
+        worktreePath,
+    });
     // Use spinner for fetch (only in non-JSON mode)
     if (options.json) {
         git.fetch('origin');
@@ -346,18 +473,41 @@ async function modeExistingPr(prNumber, options) {
             }
         });
     }
-    progress(options, colors.success(`Created worktree: ${worktreePath}`));
-    await setupWorktree(worktreePath, config, options);
+    printStatus('success', `Created worktree: ${worktreePath}`);
+    await setupWorktree(worktreePath, config, options, repoRoot);
+    // Generate description from branch name for plan context
+    const descriptionFromBranch = pr.headBranch
+        .replace(/^(feat|fix|chore)\//, '')
+        .replace(/-/g, ' ')
+        .replace(/\b\w/g, (c) => c.toUpperCase());
+    // Execute unified post-worktree sequence (plan generation + hook)
+    await executePostWorktreeSequence(worktreePath, config, options, {
+        prNumber,
+        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);
+    // Initialize hook runner for post-worktree hook
+    const hookRunner = createHookRunner(options.noHooks ? {} : (config.hooks ?? {}), {
+        repoRoot,
+        baseBranch: options.baseBranch,
+    }, {
+        verbose: options.verbose ?? false,
+        showOutput: true,
+        defaultTimeout: config.hookDefaults?.timeout,
+        maxTimeout: config.hookDefaults?.maxTimeout,
+        confirmHooks: options.confirmHooks,
+    });
     // Use spinner for fetch
     if (options.json) {
         git.fetch('origin');
@@ -385,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)\//, '')
@@ -404,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
 
@@ -427,7 +577,13 @@ 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,
+        prNumber: pr.number,
+        prUrl: pr.url,
+    });
     const worktreePath = generateWorktreePath(config, repoRoot, repoName, pr.number);
     // Use spinner for worktree creation
     if (options.json) {
@@ -454,8 +610,15 @@ PR created from existing branch: \`${branchName}\`
             }
         });
     }
-    progress(options, colors.success(`Created worktree: ${worktreePath}`));
-    await setupWorktree(worktreePath, config, options);
+    printStatus('success', `Created worktree: ${worktreePath}`);
+    await setupWorktree(worktreePath, config, options, repoRoot);
+    // Execute unified post-worktree sequence (plan generation + hook)
+    await executePostWorktreeSequence(worktreePath, config, options, {
+        prNumber: pr.number,
+        branchName,
+        description: descriptionFromBranch,
+    }, hookRunner);
+    setAuditContext({ prNumber: pr.number, worktreePath, gitBranch: branchName });
     printSummary(pr.number, branchName, worktreePath, pr.url, options);
 }
 /**
@@ -472,10 +635,11 @@ 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,
+        confirmHooks: options.confirmHooks,
     });
     // Run pre-analyze hook
     if (!(await hookRunner.runHook('pre-analyze'))) {
@@ -493,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);
@@ -507,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,
@@ -523,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,
@@ -545,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(),
@@ -586,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',
@@ -598,31 +762,34 @@ 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(),
             stagedFilesBeforeCheckout: git.getStagedFiles(),
         });
         try {
-            git.exec(['checkout', '-b', branchName, branchFrom]);
+            git.exec(['checkout', '-b', branchName, branchFrom], { cwd: repoRoot });
         }
         catch (checkoutError) {
             // When checkout fails (e.g., due to conflicting changes), git preserves
             // 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,
@@ -636,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');
         }
@@ -647,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');
         }
@@ -662,21 +829,21 @@ async function modeNewFeature(description, options) {
         }
         // Use spinner for push
         if (options.json) {
-            git.push({ setUpstream: true, remote: 'origin', branch: branchName });
+            git.push({ setUpstream: true, remote: 'origin', branch: branchName }, repoRoot);
         }
         else {
             await withSpinner('Pushing branch to origin...', async () => {
-                await git.pushAsync({ setUpstream: true, remote: 'origin', branch: branchName });
+                await git.pushAsync({ setUpstream: true, remote: 'origin', branch: branchName }, repoRoot);
             });
         }
         // Run post-push hook
         await hookRunner.runHook('post-push');
-        git.checkout(originalBranch);
+        git.checkout(originalBranch, repoRoot);
         // Run pre-pr hook
         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, {
@@ -687,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
 
@@ -710,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,
@@ -727,29 +894,34 @@ ${description}
         }
         // Use spinner for worktree creation
         if (options.json) {
-            git.addWorktree(worktreePath, branchName);
+            git.addWorktree(worktreePath, branchName, { cwd: repoRoot });
         }
         else {
             await withSpinner(`Creating worktree at ${worktreePath}...`, async () => {
-                await git.addWorktreeAsync(worktreePath, branchName);
+                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);
-        // Run post-worktree hook
-        await hookRunner.runHook('post-worktree');
+        await setupWorktree(worktreePath, config, options, repoRoot);
+        // Execute unified post-worktree sequence (plan generation + hook)
+        await executePostWorktreeSequence(worktreePath, config, options, {
+            prNumber: pr.number,
+            branchName,
+            description,
+        }, hookRunner);
+        setAuditContext({ prNumber: pr.number, worktreePath, gitBranch: branchName });
         printSummary(pr.number, branchName, worktreePath, pr.url, options, {
             scenario,
             actionTaken: action.action,
@@ -759,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;
@@ -784,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();
@@ -839,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