@camaradesuk/git-worktree-tools 1.7.0 → 1.9.0

package/dist/cli/newpr.test.js

@@ -3,11 +3,14 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 vi.mock('../lib/git.js', () => ({
     getRepoRoot: vi.fn(),
     getRepoName: vi.fn(),
+    getMainWorktreeRoot: vi.fn(),
     fetch: vi.fn(),
+    fetchAsync: vi.fn().mockResolvedValue(undefined),
     getCurrentBranch: vi.fn(),
     checkout: vi.fn(),
     exec: vi.fn(),
     push: vi.fn(),
+    pushAsync: vi.fn().mockResolvedValue(undefined),
     commit: vi.fn(),
     add: vi.fn(),
     stash: vi.fn(),
@@ -15,6 +18,7 @@ vi.mock('../lib/git.js', () => ({
     stashDrop: vi.fn(),
     stashPop: vi.fn(),
     addWorktree: vi.fn(),
+    addWorktreeAsync: vi.fn().mockResolvedValue(undefined),
     getStagedFiles: vi.fn(),
     getUnstagedFiles: vi.fn(),
     getStatusOutput: vi.fn(),
@@ -33,6 +37,10 @@ vi.mock('../lib/github.js', () => ({
 }));
 vi.mock('../lib/prompts.js', () => ({
     promptChoiceIndex: vi.fn(),
+    promptConfirm: vi.fn(),
+    withSpinner: vi.fn(async (message, fn) => {
+        return await fn();
+    }),
 }));
 vi.mock('../lib/config.js', () => ({
     loadConfig: vi.fn(),
@@ -80,6 +88,12 @@ vi.mock('fs', () => ({
     existsSync: vi.fn(),
     symlinkSync: vi.fn(),
 }));
+vi.mock('../lib/wtlink/config-manifest.js', () => ({
+    getEnabledFiles: vi.fn(),
+}));
+vi.mock('../lib/wtlink/link-configs.js', () => ({
+    run: vi.fn(),
+}));
 // Import after mocking
 import * as git from '../lib/git.js';
 import * as github from '../lib/github.js';
@@ -88,18 +102,22 @@ import { loadConfig, generateBranchNameAsync, generateWorktreePath, generatePRCo
 import { analyzeGitState, detectScenario } from '../lib/state-detection.js';
 import * as newpr from '../lib/newpr/index.js';
 import fs from 'fs';
+import { getEnabledFiles } from '../lib/wtlink/config-manifest.js';
+import { run as runWtlink } from '../lib/wtlink/link-configs.js';
 describe('cli/newpr', () => {
     let mockConsoleLog;
     let mockConsoleError;
     let mockProcessExit;
     let originalArgv;
     const defaultConfig = {
+        configVersion: 1,
         baseBranch: 'main',
         worktreePattern: '{repo}.pr{number}',
         worktreeParent: '..',
         draftPr: false,
         sharedRepos: [],
         branchPrefix: 'feature',
+        previewLabel: 'preview',
         syncPatterns: [],
         preferredEditor: 'auto',
         ai: { provider: 'none' },
@@ -110,6 +128,8 @@ describe('cli/newpr', () => {
         integrations: {},
         logging: { level: 'info', timestamps: true },
         global: { warnNotGlobal: true },
+        wtlink: { enabled: [], disabled: [] },
+        linkConfigFiles: undefined,
     };
     const defaultOptions = {
         baseBranch: 'main',
@@ -146,6 +166,14 @@ describe('cli/newpr', () => {
     });
     beforeEach(() => {
         vi.resetAllMocks();
+        // Reset async git mocks (resetAllMocks clears implementations)
+        vi.mocked(git.fetchAsync).mockResolvedValue(undefined);
+        vi.mocked(git.pushAsync).mockResolvedValue(undefined);
+        vi.mocked(git.addWorktreeAsync).mockResolvedValue(undefined);
+        // Reset withSpinner mock (resetAllMocks clears the implementation)
+        vi.mocked(prompts.withSpinner).mockImplementation(async (message, fn) => {
+            return await fn();
+        });
         // Reset the hook runner mock to allow all hooks to pass
         mockHookRunner.runHook.mockResolvedValue(true);
         mockHookRunner.runCleanup.mockResolvedValue(undefined);
@@ -170,6 +198,12 @@ describe('cli/newpr', () => {
         });
         vi.mocked(git.getChangedFiles).mockReturnValue([]);
         vi.mocked(git.getCommitMessages).mockReturnValue([]);
+        // Default mocks for auto-link feature (throw by default to skip auto-link)
+        vi.mocked(git.getMainWorktreeRoot).mockImplementation(() => {
+            throw new Error('Mock: getMainWorktreeRoot not configured');
+        });
+        vi.mocked(getEnabledFiles).mockReturnValue([]);
+        vi.mocked(runWtlink).mockResolvedValue(undefined);
         mockConsoleLog = vi.spyOn(console, 'log').mockImplementation(() => { });
         mockConsoleError = vi.spyOn(console, 'error').mockImplementation(() => { });
         // @ts-expect-error - process.exit mock type is complex
@@ -186,7 +220,8 @@ describe('cli/newpr', () => {
     async function runCli(args = []) {
         process.argv = ['node', 'newpr', ...args];
         await import('./newpr.js');
-        await new Promise((resolve) => setTimeout(resolve, 10));
+        // Allow time for all async operations to complete
+        await new Promise((resolve) => setTimeout(resolve, 100));
     }
     describe('help option', () => {
         it('prints help and exits 0 on --help', async () => {
@@ -246,7 +281,8 @@ describe('cli/newpr', () => {
             vi.mocked(fs.existsSync).mockReturnValue(false);
             await runCli(['--pr', '123']);
             // Verify wiring: worktree path, branch, and options are correctly passed through
-            expect(git.addWorktree).toHaveBeenCalledWith('/repo.pr123', // path from generateWorktreePath
+            // Non-JSON mode uses addWorktreeAsync
+            expect(git.addWorktreeAsync).toHaveBeenCalledWith('/repo.pr123', // path from generateWorktreePath
             'feature-123', // branch from PR info
             expect.objectContaining({
                 createBranch: true,
@@ -292,8 +328,8 @@ describe('cli/newpr', () => {
                 head: 'my-feature',
                 base: 'main', // from config
             }));
-            // Verify wiring: addWorktree receives correct path, branch, and options
-            expect(git.addWorktree).toHaveBeenCalledWith('/repo.pr456', // path from generateWorktreePath
+            // Verify wiring: addWorktreeAsync receives correct path, branch, and options (non-JSON mode)
+            expect(git.addWorktreeAsync).toHaveBeenCalledWith('/repo.pr456', // path from generateWorktreePath
             'my-feature', // the branch name
             expect.objectContaining({
                 createBranch: true,
@@ -362,22 +398,24 @@ describe('cli/newpr', () => {
                 aiGenerated: false,
             });
             await runCli(['Add new feature']);
-            // Verify wiring: checkout uses generated branch name and branch point
+            // Verify wiring: checkout uses generated branch name and branch point with repoRoot
             expect(git.exec).toHaveBeenCalledWith([
                 'checkout',
                 '-b',
                 'feature/add-new-feature', // from generateBranchNameAsync
                 'origin/main', // from getBranchPoint
-            ]);
+            ], { cwd: '/repo' } // repoRoot from getRepoRoot()
+            );
             // Verify wiring: createPr receives correct branch and title (from generatePRContentAsync)
             expect(github.createPr).toHaveBeenCalledWith(expect.objectContaining({
                 head: 'feature/add-new-feature',
                 base: 'main',
                 title: 'Add new feature',
             }));
-            // Verify wiring: addWorktree receives correct path and branch
-            expect(git.addWorktree).toHaveBeenCalledWith('/repo.pr100', // path from generateWorktreePath
-            'feature/add-new-feature' // the branch name
+            // Verify wiring: addWorktreeAsync receives correct path, branch, and cwd option
+            expect(git.addWorktreeAsync).toHaveBeenCalledWith('/repo.pr100', // path from generateWorktreePath
+            'feature/add-new-feature', // the branch name
+            { cwd: '/repo' } // repoRoot from getRepoRoot()
             );
         });
         it('exits 1 when user cancels', async () => {
@@ -851,5 +889,294 @@ describe('cli/newpr', () => {
             );
         });
     });
+    describe('Bug fix: git operations must use repoRoot (empty commit worktree bug)', () => {
+        // These tests verify the fix for the bug where creating a PR worktree
+        // with an empty commit failed because git.checkout() didn't switch back
+        // to main (missing repoRoot parameter), causing git.addWorktree() to fail
+        // with "branch already checked out" error.
+        it('git.checkout after push must use repoRoot parameter', async () => {
+            const repoRoot = '/repo';
+            vi.mocked(newpr.parseArgs).mockReturnValue({
+                kind: 'success',
+                options: { mode: 'new', description: 'Test feature', ...defaultOptions },
+            });
+            vi.mocked(github.isGhInstalled).mockReturnValue(true);
+            vi.mocked(github.isAuthenticated).mockReturnValue(true);
+            vi.mocked(git.getRepoRoot).mockReturnValue(repoRoot);
+            vi.mocked(git.getRepoName).mockReturnValue('repo');
+            vi.mocked(loadConfig).mockReturnValue(defaultConfig);
+            vi.mocked(generateBranchNameAsync).mockResolvedValue('feat/test-feature');
+            vi.mocked(analyzeGitState).mockReturnValue(makeGitState());
+            vi.mocked(detectScenario).mockReturnValue('main_clean_same');
+            vi.mocked(newpr.isPrWorktreeScenario).mockReturnValue(false);
+            vi.mocked(newpr.getScenarioContext).mockReturnValue({
+                message: 'No changes detected',
+                choices: [
+                    {
+                        label: 'Continue with empty initial commit',
+                        action: { action: 'empty_commit', branchFrom: 'origin_main', stashUnstaged: false },
+                    },
+                    { label: 'Cancel', action: null },
+                ],
+            });
+            vi.mocked(newpr.getScenarioMessageLevel).mockReturnValue('warning');
+            vi.mocked(prompts.promptChoiceIndex).mockResolvedValue(1);
+            vi.mocked(newpr.isExistingBranchAction).mockReturnValue(false);
+            vi.mocked(newpr.executeStateAction).mockReturnValue({ success: true, stashRef: null });
+            vi.mocked(newpr.getBranchPoint).mockReturnValue('origin/main');
+            vi.mocked(git.remoteBranchExists).mockReturnValue(false);
+            vi.mocked(git.getCurrentBranch).mockReturnValue('main');
+            vi.mocked(git.getStagedFiles).mockReturnValue([]);
+            vi.mocked(github.createPr).mockReturnValue(makePrInfo({ number: 100 }));
+            vi.mocked(generateWorktreePath).mockReturnValue('/repo.pr100');
+            await runCli(['Test feature']);
+            // CRITICAL: git.checkout must be called with repoRoot to switch back to main
+            // Without this, the branch remains checked out and worktree creation fails
+            expect(git.checkout).toHaveBeenCalledWith('main', repoRoot);
+        });
+        it('git.addWorktreeAsync must use { cwd: repoRoot } option', async () => {
+            const repoRoot = '/repo';
+            vi.mocked(newpr.parseArgs).mockReturnValue({
+                kind: 'success',
+                options: { mode: 'new', description: 'Test feature', ...defaultOptions },
+            });
+            vi.mocked(github.isGhInstalled).mockReturnValue(true);
+            vi.mocked(github.isAuthenticated).mockReturnValue(true);
+            vi.mocked(git.getRepoRoot).mockReturnValue(repoRoot);
+            vi.mocked(git.getRepoName).mockReturnValue('repo');
+            vi.mocked(loadConfig).mockReturnValue(defaultConfig);
+            vi.mocked(generateBranchNameAsync).mockResolvedValue('feat/test-feature');
+            vi.mocked(analyzeGitState).mockReturnValue(makeGitState());
+            vi.mocked(detectScenario).mockReturnValue('main_clean_same');
+            vi.mocked(newpr.isPrWorktreeScenario).mockReturnValue(false);
+            vi.mocked(newpr.getScenarioContext).mockReturnValue({
+                message: 'No changes detected',
+                choices: [
+                    {
+                        label: 'Continue with empty initial commit',
+                        action: { action: 'empty_commit', branchFrom: 'origin_main', stashUnstaged: false },
+                    },
+                    { label: 'Cancel', action: null },
+                ],
+            });
+            vi.mocked(newpr.getScenarioMessageLevel).mockReturnValue('warning');
+            vi.mocked(prompts.promptChoiceIndex).mockResolvedValue(1);
+            vi.mocked(newpr.isExistingBranchAction).mockReturnValue(false);
+            vi.mocked(newpr.executeStateAction).mockReturnValue({ success: true, stashRef: null });
+            vi.mocked(newpr.getBranchPoint).mockReturnValue('origin/main');
+            vi.mocked(git.remoteBranchExists).mockReturnValue(false);
+            vi.mocked(git.getCurrentBranch).mockReturnValue('main');
+            vi.mocked(git.getStagedFiles).mockReturnValue([]);
+            vi.mocked(github.createPr).mockReturnValue(makePrInfo({ number: 100 }));
+            vi.mocked(generateWorktreePath).mockReturnValue('/repo.pr100');
+            await runCli(['Test feature']);
+            // CRITICAL: git.addWorktreeAsync must be called with { cwd: repoRoot }
+            // to ensure worktree is created from the correct directory
+            expect(git.addWorktreeAsync).toHaveBeenCalledWith('/repo.pr100', 'feat/test-feature', {
+                cwd: repoRoot,
+            });
+        });
+        it('git.pushAsync must use repoRoot parameter', async () => {
+            const repoRoot = '/repo';
+            vi.mocked(newpr.parseArgs).mockReturnValue({
+                kind: 'success',
+                options: { mode: 'new', description: 'Test feature', ...defaultOptions },
+            });
+            vi.mocked(github.isGhInstalled).mockReturnValue(true);
+            vi.mocked(github.isAuthenticated).mockReturnValue(true);
+            vi.mocked(git.getRepoRoot).mockReturnValue(repoRoot);
+            vi.mocked(git.getRepoName).mockReturnValue('repo');
+            vi.mocked(loadConfig).mockReturnValue(defaultConfig);
+            vi.mocked(generateBranchNameAsync).mockResolvedValue('feat/test-feature');
+            vi.mocked(analyzeGitState).mockReturnValue(makeGitState());
+            vi.mocked(detectScenario).mockReturnValue('main_clean_same');
+            vi.mocked(newpr.isPrWorktreeScenario).mockReturnValue(false);
+            vi.mocked(newpr.getScenarioContext).mockReturnValue({
+                message: 'No changes detected',
+                choices: [
+                    {
+                        label: 'Continue with empty initial commit',
+                        action: { action: 'empty_commit', branchFrom: 'origin_main', stashUnstaged: false },
+                    },
+                    { label: 'Cancel', action: null },
+                ],
+            });
+            vi.mocked(newpr.getScenarioMessageLevel).mockReturnValue('warning');
+            vi.mocked(prompts.promptChoiceIndex).mockResolvedValue(1);
+            vi.mocked(newpr.isExistingBranchAction).mockReturnValue(false);
+            vi.mocked(newpr.executeStateAction).mockReturnValue({ success: true, stashRef: null });
+            vi.mocked(newpr.getBranchPoint).mockReturnValue('origin/main');
+            vi.mocked(git.remoteBranchExists).mockReturnValue(false);
+            vi.mocked(git.getCurrentBranch).mockReturnValue('main');
+            vi.mocked(git.getStagedFiles).mockReturnValue([]);
+            vi.mocked(github.createPr).mockReturnValue(makePrInfo({ number: 100 }));
+            vi.mocked(generateWorktreePath).mockReturnValue('/repo.pr100');
+            await runCli(['Test feature']);
+            // git.pushAsync must be called with repoRoot to push from correct directory
+            expect(git.pushAsync).toHaveBeenCalledWith({ setUpstream: true, remote: 'origin', branch: 'feat/test-feature' }, repoRoot);
+        });
+        it('git.exec for branch checkout must use { cwd: repoRoot } option', async () => {
+            const repoRoot = '/repo';
+            vi.mocked(newpr.parseArgs).mockReturnValue({
+                kind: 'success',
+                options: { mode: 'new', description: 'Test feature', ...defaultOptions },
+            });
+            vi.mocked(github.isGhInstalled).mockReturnValue(true);
+            vi.mocked(github.isAuthenticated).mockReturnValue(true);
+            vi.mocked(git.getRepoRoot).mockReturnValue(repoRoot);
+            vi.mocked(git.getRepoName).mockReturnValue('repo');
+            vi.mocked(loadConfig).mockReturnValue(defaultConfig);
+            vi.mocked(generateBranchNameAsync).mockResolvedValue('feat/test-feature');
+            vi.mocked(analyzeGitState).mockReturnValue(makeGitState());
+            vi.mocked(detectScenario).mockReturnValue('main_clean_same');
+            vi.mocked(newpr.isPrWorktreeScenario).mockReturnValue(false);
+            vi.mocked(newpr.getScenarioContext).mockReturnValue({
+                message: 'No changes detected',
+                choices: [
+                    {
+                        label: 'Continue with empty initial commit',
+                        action: { action: 'empty_commit', branchFrom: 'origin_main', stashUnstaged: false },
+                    },
+                    { label: 'Cancel', action: null },
+                ],
+            });
+            vi.mocked(newpr.getScenarioMessageLevel).mockReturnValue('warning');
+            vi.mocked(prompts.promptChoiceIndex).mockResolvedValue(1);
+            vi.mocked(newpr.isExistingBranchAction).mockReturnValue(false);
+            vi.mocked(newpr.executeStateAction).mockReturnValue({ success: true, stashRef: null });
+            vi.mocked(newpr.getBranchPoint).mockReturnValue('origin/main');
+            vi.mocked(git.remoteBranchExists).mockReturnValue(false);
+            vi.mocked(git.getCurrentBranch).mockReturnValue('main');
+            vi.mocked(git.getStagedFiles).mockReturnValue([]);
+            vi.mocked(github.createPr).mockReturnValue(makePrInfo({ number: 100 }));
+            vi.mocked(generateWorktreePath).mockReturnValue('/repo.pr100');
+            await runCli(['Test feature']);
+            // git.exec for branch creation must use cwd option to ensure
+            // branch is created in the correct worktree
+            expect(git.exec).toHaveBeenCalledWith(['checkout', '-b', 'feat/test-feature', 'origin/main'], { cwd: repoRoot });
+        });
+    });
+    describe('auto-link config files (linkConfigFiles feature)', () => {
+        // Helper to set up all the mocks for a successful PR creation
+        const setupPrCreationMocks = (configOverrides = {}) => {
+            vi.mocked(newpr.parseArgs).mockReturnValue({
+                kind: 'success',
+                options: { mode: 'pr', prNumber: 123, ...defaultOptions },
+            });
+            vi.mocked(github.isGhInstalled).mockReturnValue(true);
+            vi.mocked(github.isAuthenticated).mockReturnValue(true);
+            vi.mocked(git.getRepoRoot).mockReturnValue('/repo');
+            vi.mocked(git.getRepoName).mockReturnValue('repo');
+            vi.mocked(git.getMainWorktreeRoot).mockReturnValue('/main-repo');
+            vi.mocked(loadConfig).mockReturnValue({ ...defaultConfig, ...configOverrides });
+            vi.mocked(github.getPr).mockReturnValue(makePrInfo());
+            vi.mocked(generateWorktreePath).mockReturnValue('/repo.pr123');
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+        };
+        it('auto-links config files when linkConfigFiles is true', async () => {
+            setupPrCreationMocks({ linkConfigFiles: true });
+            vi.mocked(getEnabledFiles).mockReturnValue(['.env.local', '.vscode/settings.json']);
+            vi.mocked(runWtlink).mockResolvedValue(undefined);
+            await runCli(['--pr', '123']);
+            expect(getEnabledFiles).toHaveBeenCalledWith('/main-repo');
+            expect(runWtlink).toHaveBeenCalledWith(expect.objectContaining({
+                source: '/main-repo',
+                destination: '/repo.pr123',
+                dryRun: false,
+                yes: true,
+            }));
+            expect(prompts.promptConfirm).not.toHaveBeenCalled();
+        });
+        it('skips linking when linkConfigFiles is false', async () => {
+            setupPrCreationMocks({ linkConfigFiles: false });
+            vi.mocked(getEnabledFiles).mockReturnValue(['.env.local', '.vscode/settings.json']);
+            await runCli(['--pr', '123']);
+            expect(getEnabledFiles).toHaveBeenCalledWith('/main-repo');
+            expect(runWtlink).not.toHaveBeenCalled();
+            expect(prompts.promptConfirm).not.toHaveBeenCalled();
+        });
+        it('prompts user when linkConfigFiles is undefined in interactive mode', async () => {
+            setupPrCreationMocks({ linkConfigFiles: undefined });
+            vi.mocked(getEnabledFiles).mockReturnValue(['.env.local']);
+            vi.mocked(prompts.promptConfirm).mockResolvedValue(true);
+            vi.mocked(runWtlink).mockResolvedValue(undefined);
+            await runCli(['--pr', '123']);
+            expect(getEnabledFiles).toHaveBeenCalledWith('/main-repo');
+            expect(prompts.promptConfirm).toHaveBeenCalledWith(expect.stringContaining('Link these config files'), true);
+            expect(runWtlink).toHaveBeenCalled();
+        });
+        it('skips linking when user declines the prompt', async () => {
+            setupPrCreationMocks({ linkConfigFiles: undefined });
+            vi.mocked(getEnabledFiles).mockReturnValue(['.env.local']);
+            vi.mocked(prompts.promptConfirm).mockResolvedValue(false);
+            await runCli(['--pr', '123']);
+            expect(prompts.promptConfirm).toHaveBeenCalled();
+            expect(runWtlink).not.toHaveBeenCalled();
+        });
+        it('defaults to linking in non-interactive mode when linkConfigFiles is undefined', async () => {
+            vi.mocked(newpr.parseArgs).mockReturnValue({
+                kind: 'success',
+                options: { mode: 'pr', prNumber: 123, ...defaultOptions, nonInteractive: true },
+            });
+            vi.mocked(github.isGhInstalled).mockReturnValue(true);
+            vi.mocked(github.isAuthenticated).mockReturnValue(true);
+            vi.mocked(git.getRepoRoot).mockReturnValue('/repo');
+            vi.mocked(git.getRepoName).mockReturnValue('repo');
+            vi.mocked(git.getMainWorktreeRoot).mockReturnValue('/main-repo');
+            vi.mocked(loadConfig).mockReturnValue({ ...defaultConfig, linkConfigFiles: undefined });
+            vi.mocked(github.getPr).mockReturnValue(makePrInfo());
+            vi.mocked(generateWorktreePath).mockReturnValue('/repo.pr123');
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            vi.mocked(getEnabledFiles).mockReturnValue(['.env.local']);
+            vi.mocked(runWtlink).mockResolvedValue(undefined);
+            await runCli(['--pr', '123', '--non-interactive']);
+            expect(prompts.promptConfirm).not.toHaveBeenCalled();
+            expect(runWtlink).toHaveBeenCalled();
+        });
+        it('defaults to linking in JSON mode when linkConfigFiles is undefined', async () => {
+            vi.mocked(newpr.parseArgs).mockReturnValue({
+                kind: 'success',
+                options: { mode: 'pr', prNumber: 123, ...defaultOptions, json: true },
+            });
+            vi.mocked(github.isGhInstalled).mockReturnValue(true);
+            vi.mocked(github.isAuthenticated).mockReturnValue(true);
+            vi.mocked(git.getRepoRoot).mockReturnValue('/repo');
+            vi.mocked(git.getRepoName).mockReturnValue('repo');
+            vi.mocked(git.getMainWorktreeRoot).mockReturnValue('/main-repo');
+            vi.mocked(loadConfig).mockReturnValue({ ...defaultConfig, linkConfigFiles: undefined });
+            vi.mocked(github.getPr).mockReturnValue(makePrInfo());
+            vi.mocked(generateWorktreePath).mockReturnValue('/repo.pr123');
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            vi.mocked(getEnabledFiles).mockReturnValue(['.env.local']);
+            vi.mocked(runWtlink).mockResolvedValue(undefined);
+            await runCli(['--pr', '123', '--json']);
+            expect(prompts.promptConfirm).not.toHaveBeenCalled();
+            expect(runWtlink).toHaveBeenCalled();
+        });
+        it('does not link when there are no enabled files', async () => {
+            setupPrCreationMocks({ linkConfigFiles: true });
+            vi.mocked(getEnabledFiles).mockReturnValue([]);
+            await runCli(['--pr', '123']);
+            expect(runWtlink).not.toHaveBeenCalled();
+            expect(prompts.promptConfirm).not.toHaveBeenCalled();
+        });
+        it('handles linking errors gracefully', async () => {
+            setupPrCreationMocks({ linkConfigFiles: true });
+            vi.mocked(getEnabledFiles).mockReturnValue(['.env.local']);
+            vi.mocked(runWtlink).mockRejectedValue(new Error('Permission denied'));
+            await runCli(['--pr', '123']);
+            // Should not crash, just warn about the failure
+            expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('Failed to link config files'));
+        });
+        it('skips config linking when main worktree cannot be determined', async () => {
+            setupPrCreationMocks({ linkConfigFiles: true });
+            vi.mocked(git.getMainWorktreeRoot).mockImplementation(() => {
+                throw new Error('Not in a git worktree');
+            });
+            await runCli(['--pr', '123']);
+            expect(getEnabledFiles).not.toHaveBeenCalled();
+            expect(runWtlink).not.toHaveBeenCalled();
+        });
+    });
 });
 //# sourceMappingURL=newpr.test.js.map