@camaradesuk/git-worktree-tools 1.10.0 → 1.11.0

package/dist/cli/wt/clean.test.js

@@ -1,624 +0,0 @@
-/**
- * Tests for wt clean command handler
- *
- * Exercises the handler through different code paths to cover internal
- * helper functions: outputJsonResult, outputJsonError, resultToCleanedInfo, printWorktree.
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-// Mock all dependencies before imports
-vi.mock('child_process', () => ({
-    execSync: vi.fn(),
-}));
-vi.mock('../../lib/git.js', () => ({
-    getRepoRoot: vi.fn().mockReturnValue('/fake/repo'),
-    getMainWorktreeRoot: vi.fn().mockReturnValue('/fake/repo'),
-    removeWorktree: vi.fn(),
-    pruneWorktrees: vi.fn(),
-}));
-vi.mock('../../lib/github.js', () => ({
-    isGhInstalled: vi.fn().mockReturnValue(true),
-}));
-vi.mock('../../lib/prompts.js', () => ({
-    withSpinner: vi.fn((_msg, fn) => fn()),
-    promptChoice: vi.fn(),
-    promptConfirm: vi.fn(),
-}));
-vi.mock('../../lib/config.js', () => ({
-    loadConfig: vi.fn().mockReturnValue({
-        worktreePattern: '{repo}.pr{number}',
-        baseBranch: 'main',
-    }),
-}));
-vi.mock('../../lib/logger.js', () => ({
-    logger: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
-}));
-vi.mock('../../lib/colors.js', () => ({
-    error: vi.fn((s) => s),
-    dim: vi.fn((s) => s),
-    success: vi.fn((s) => s),
-    info: vi.fn((s) => s),
-    cyan: vi.fn((s) => s),
-    yellow: vi.fn((s) => s),
-    red: vi.fn((s) => s),
-    green: vi.fn((s) => s),
-    bold: vi.fn((s) => s),
-    warning: vi.fn((s) => s),
-}));
-vi.mock('../../lib/cleanpr/index.js', () => ({
-    gatherPrWorktreeInfo: vi.fn().mockResolvedValue([]),
-    createDefaultDeps: vi.fn().mockReturnValue({}),
-    groupWorktreesByState: vi.fn().mockReturnValue({ merged: [], closed: [], open: [], unknown: [] }),
-    getCleanableWorktrees: vi.fn().mockReturnValue([]),
-    findWorktreeByPrNumber: vi.fn().mockReturnValue(null),
-    cleanWorktree: vi.fn().mockReturnValue({
-        success: true,
-        prNumber: 42,
-        message: 'Cleaned PR #42',
-        localBranchDeleted: true,
-        remoteBranchDeleted: false,
-    }),
-    summarizeResults: vi.fn().mockReturnValue({ cleaned: 0, total: 0, failed: 0 }),
-}));
-vi.mock('../../lib/ui/index.js', () => ({
-    setJsonMode: vi.fn(),
-    isJsonMode: vi.fn().mockReturnValue(false),
-    printStatus: vi.fn(),
-    printDim: vi.fn(),
-    printError: vi.fn(),
-    printHeader: vi.fn(),
-    printNextSteps: vi.fn(),
-    changeIndicator: vi.fn().mockReturnValue(''),
-    errorToDisplay: vi.fn().mockReturnValue({ title: 'error' }),
-}));
-vi.mock('../../lib/json-output.js', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        createSuccessResult: vi.fn().mockReturnValue({ success: true }),
-        createErrorResult: vi.fn().mockReturnValue({ success: false }),
-        formatJsonResult: vi.fn().mockReturnValue('{}'),
-    };
-});
-// Import the command under test
-import { cleanCommand } from './clean.js';
-// Import mocked modules for assertions and setup
-import * as git from '../../lib/git.js';
-import * as github from '../../lib/github.js';
-import { gatherPrWorktreeInfo, getCleanableWorktrees, findWorktreeByPrNumber, cleanWorktree, summarizeResults, groupWorktreesByState, } from '../../lib/cleanpr/index.js';
-import { setJsonMode, printError, printStatus, printDim, printNextSteps, changeIndicator, } from '../../lib/ui/index.js';
-import { createSuccessResult, createErrorResult, formatJsonResult, ErrorCode, } from '../../lib/json-output.js';
-// Mock process.exit - throws to halt execution (mimics real exit behavior)
-class ExitError extends Error {
-    code;
-    constructor(code) {
-        super(`process.exit(${code})`);
-        this.code = code;
-    }
-}
-const mockExit = vi.spyOn(process, 'exit').mockImplementation((code) => {
-    throw new ExitError(code);
-});
-// Capture console.log output for JSON assertions
-const mockConsoleLog = vi.spyOn(console, 'log').mockImplementation(() => { });
-function makeWorktree(overrides = {}) {
-    return {
-        path: '/fake/repo.pr42',
-        branch: 'feat/thing',
-        commit: 'abc1234',
-        prNumber: 42,
-        prState: 'MERGED',
-        hasChanges: false,
-        ...overrides,
-    };
-}
-function makeCleanupResult(overrides = {}) {
-    return {
-        success: true,
-        prNumber: 42,
-        message: 'Cleaned PR #42',
-        localBranchDeleted: true,
-        remoteBranchDeleted: false,
-        ...overrides,
-    };
-}
-describe('wt clean handler', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        // Restore default mock return values
-        vi.mocked(git.getRepoRoot).mockReturnValue('/fake/repo');
-        vi.mocked(github.isGhInstalled).mockReturnValue(true);
-        vi.mocked(gatherPrWorktreeInfo).mockResolvedValue([]);
-        vi.mocked(getCleanableWorktrees).mockReturnValue([]);
-        vi.mocked(findWorktreeByPrNumber).mockReturnValue(undefined);
-        vi.mocked(changeIndicator).mockReturnValue('');
-    });
-    afterEach(() => {
-        mockExit.mockClear();
-        mockConsoleLog.mockClear();
-    });
-    // =========================================================================
-    // Error paths with JSON output
-    // =========================================================================
-    describe('prerequisite errors with --json', () => {
-        it('outputs JSON error when gh is not installed', async () => {
-            vi.mocked(github.isGhInstalled).mockReturnValue(false);
-            await expect(cleanCommand.handler({
-                all: true,
-                'dry-run': false,
-                force: false,
-                json: true,
-            })).rejects.toThrow(ExitError);
-            expect(setJsonMode).toHaveBeenCalledWith(true);
-            expect(createErrorResult).toHaveBeenCalledWith('cleanpr', ErrorCode.GH_NOT_INSTALLED, expect.stringContaining('GitHub CLI'));
-            expect(formatJsonResult).toHaveBeenCalled();
-            expect(mockConsoleLog).toHaveBeenCalledWith('{}');
-            expect(mockExit).toHaveBeenCalledWith(1);
-        });
-        it('outputs JSON error when not in a git repo', async () => {
-            vi.mocked(git.getRepoRoot).mockReturnValue(null);
-            await expect(cleanCommand.handler({
-                all: true,
-                'dry-run': false,
-                force: false,
-                json: true,
-            })).rejects.toThrow(ExitError);
-            expect(createErrorResult).toHaveBeenCalledWith('cleanpr', ErrorCode.NOT_GIT_REPO, expect.stringContaining('git repository'));
-            expect(formatJsonResult).toHaveBeenCalled();
-            expect(mockExit).toHaveBeenCalledWith(1);
-        });
-    });
-    // =========================================================================
-    // --all --json: no worktrees found
-    // =========================================================================
-    describe('--all --json with no worktrees', () => {
-        it('outputs JSON success with zero cleaned message', async () => {
-            vi.mocked(gatherPrWorktreeInfo).mockResolvedValue([]);
-            vi.mocked(getCleanableWorktrees).mockReturnValue([]);
-            await cleanCommand.handler({
-                all: true,
-                'dry-run': false,
-                force: false,
-                json: true,
-            });
-            // cleanAll path: no cleanable worktrees, json mode -> outputs success JSON directly
-            expect(createSuccessResult).toHaveBeenCalledWith('cleanpr', expect.objectContaining({
-                totalCleaned: 0,
-                totalSkipped: 0,
-                message: expect.stringContaining('No merged or closed'),
-            }));
-            expect(formatJsonResult).toHaveBeenCalled();
-            expect(mockConsoleLog).toHaveBeenCalledWith('{}');
-        });
-    });
-    // =========================================================================
-    // --all --json: cleanable worktrees found (exercises outputJsonResult non-dry-run)
-    // =========================================================================
-    describe('--all --json with cleanable worktrees', () => {
-        it('outputs JSON result with cleaned worktrees', async () => {
-            const wt1 = makeWorktree({
-                prNumber: 10,
-                branch: 'feat/a',
-                path: '/fake/repo.pr10',
-                prState: 'MERGED',
-            });
-            const wt2 = makeWorktree({
-                prNumber: 20,
-                branch: 'feat/b',
-                path: '/fake/repo.pr20',
-                prState: 'CLOSED',
-            });
-            vi.mocked(gatherPrWorktreeInfo).mockResolvedValue([wt1, wt2]);
-            vi.mocked(getCleanableWorktrees).mockReturnValue([wt1, wt2]);
-            vi.mocked(cleanWorktree)
-                .mockReturnValueOnce(makeCleanupResult({ prNumber: 10, message: 'Cleaned PR #10' }))
-                .mockReturnValueOnce(makeCleanupResult({ prNumber: 20, message: 'Cleaned PR #20' }));
-            await cleanCommand.handler({
-                all: true,
-                'dry-run': false,
-                force: false,
-                json: true,
-            });
-            // outputJsonResult called for non-dry-run path
-            expect(cleanWorktree).toHaveBeenCalledTimes(2);
-            expect(createSuccessResult).toHaveBeenCalledWith('cleanpr', expect.objectContaining({
-                totalCleaned: 2,
-                totalSkipped: 0,
-            }));
-            // printStatus should NOT be called in json mode
-            expect(printStatus).not.toHaveBeenCalled();
-        });
-        it('includes skipped entries for failed cleanups', async () => {
-            const wt1 = makeWorktree({ prNumber: 10, path: '/fake/repo.pr10' });
-            const wt2 = makeWorktree({ prNumber: 20, path: '/fake/repo.pr20' });
-            vi.mocked(gatherPrWorktreeInfo).mockResolvedValue([wt1, wt2]);
-            vi.mocked(getCleanableWorktrees).mockReturnValue([wt1, wt2]);
-            vi.mocked(cleanWorktree)
-                .mockReturnValueOnce(makeCleanupResult({ prNumber: 10, success: true }))
-                .mockReturnValueOnce(makeCleanupResult({ prNumber: 20, success: false, message: 'Has uncommitted changes' }));
-            await cleanCommand.handler({
-                all: true,
-                'dry-run': false,
-                force: false,
-                json: true,
-            });
-            expect(createSuccessResult).toHaveBeenCalledWith('cleanpr', expect.objectContaining({
-                totalCleaned: 1,
-                totalSkipped: 1,
-            }));
-        });
-    });
-    // =========================================================================
-    // --all --json --dry-run: exercises outputJsonResult dry-run branch
-    // =========================================================================
-    describe('--all --json --dry-run with cleanable worktrees', () => {
-        it('outputs dry-run JSON with wouldClean entries', async () => {
-            const wt1 = makeWorktree({
-                prNumber: 10,
-                branch: 'feat/a',
-                path: '/fake/repo.pr10',
-                prState: 'MERGED',
-            });
-            vi.mocked(gatherPrWorktreeInfo).mockResolvedValue([wt1]);
-            vi.mocked(getCleanableWorktrees).mockReturnValue([wt1]);
-            vi.mocked(cleanWorktree).mockReturnValue(makeCleanupResult({ prNumber: 10, success: true, dryRun: true }));
-            await cleanCommand.handler({
-                all: true,
-                'dry-run': true,
-                force: false,
-                json: true,
-            });
-            expect(createSuccessResult).toHaveBeenCalledWith('cleanpr', expect.objectContaining({
-                wouldClean: expect.arrayContaining([
-                    expect.objectContaining({ prNumber: 10, branch: 'feat/a' }),
-                ]),
-                totalWouldClean: 1,
-                message: expect.stringContaining('Would clean 1 PR worktree'),
-            }));
-        });
-        it('outputs dry-run JSON with zero wouldClean when all fail', async () => {
-            const wt1 = makeWorktree({ prNumber: 10, path: '/fake/repo.pr10' });
-            vi.mocked(gatherPrWorktreeInfo).mockResolvedValue([wt1]);
-            vi.mocked(getCleanableWorktrees).mockReturnValue([wt1]);
-            vi.mocked(cleanWorktree).mockReturnValue(makeCleanupResult({ prNumber: 10, success: false, message: 'Failed' }));
-            await cleanCommand.handler({
-                all: true,
-                'dry-run': true,
-                force: false,
-                json: true,
-            });
-            expect(createSuccessResult).toHaveBeenCalledWith('cleanpr', expect.objectContaining({
-                wouldClean: [],
-                totalWouldClean: 0,
-                message: expect.stringContaining('No PR worktrees would be cleaned'),
-            }));
-        });
-    });
-    // =========================================================================
-    // Specific PR number path (cleanSpecific)
-    // =========================================================================
-    describe('specific PR number', () => {
-        it('cleans specific PR and outputs JSON result', async () => {
-            const wt = makeWorktree({ prNumber: 42, branch: 'feat/thing', path: '/fake/repo.pr42' });
-            vi.mocked(gatherPrWorktreeInfo).mockResolvedValue([wt]);
-            vi.mocked(findWorktreeByPrNumber).mockReturnValue(wt);
-            vi.mocked(cleanWorktree).mockReturnValue(makeCleanupResult({ prNumber: 42 }));
-            await cleanCommand.handler({
-                prNumber: 42,
-                all: false,
-                'dry-run': false,
-                force: false,
-                json: true,
-            });
-            expect(findWorktreeByPrNumber).toHaveBeenCalled();
-            expect(cleanWorktree).toHaveBeenCalledTimes(1);
-            // JSON output via outputJsonResult
-            expect(createSuccessResult).toHaveBeenCalledWith('cleanpr', expect.objectContaining({
-                totalCleaned: 1,
-            }));
-        });
-        it('outputs JSON error when specific PR not found', async () => {
-            vi.mocked(gatherPrWorktreeInfo).mockResolvedValue([]);
-            vi.mocked(findWorktreeByPrNumber).mockReturnValue(undefined);
-            await expect(cleanCommand.handler({
-                prNumber: 999,
-                all: false,
-                'dry-run': false,
-                force: false,
-                json: true,
-            })).rejects.toThrow(ExitError);
-            // outputJsonError path
-            expect(createErrorResult).toHaveBeenCalledWith('cleanpr', ErrorCode.PR_NOT_FOUND, expect.stringContaining('No worktree found for PR #999'));
-            expect(mockExit).toHaveBeenCalledWith(1);
-        });
-        it('prints error display when specific PR not found without --json', async () => {
-            vi.mocked(gatherPrWorktreeInfo).mockResolvedValue([]);
-            vi.mocked(findWorktreeByPrNumber).mockReturnValue(undefined);
-            await expect(cleanCommand.handler({
-                prNumber: 999,
-                all: false,
-                'dry-run': false,
-                force: false,
-                json: false,
-            })).rejects.toThrow(ExitError);
-            expect(printError).toHaveBeenCalledWith(expect.objectContaining({
-                title: expect.stringContaining('No worktree found for PR #999'),
-            }));
-            expect(mockExit).toHaveBeenCalledWith(1);
-        });
-        it('prints success status for non-json specific PR cleanup', async () => {
-            const wt = makeWorktree({ prNumber: 42 });
-            vi.mocked(gatherPrWorktreeInfo).mockResolvedValue([wt]);
-            vi.mocked(findWorktreeByPrNumber).mockReturnValue(wt);
-            vi.mocked(cleanWorktree).mockReturnValue(makeCleanupResult({ prNumber: 42, success: true }));
-            await cleanCommand.handler({
-                prNumber: 42,
-                all: false,
-                'dry-run': false,
-                force: false,
-                json: false,
-            });
-            expect(printStatus).toHaveBeenCalledWith('info', expect.stringContaining('Cleaning PR #42'));
-            expect(printDim).toHaveBeenCalled();
-            expect(printStatus).toHaveBeenCalledWith('success', expect.stringContaining('PR #42 worktree cleaned up successfully'));
-            expect(printNextSteps).toHaveBeenCalled();
-        });
-        it('prints dry-run info status for specific PR', async () => {
-            const wt = makeWorktree({ prNumber: 42 });
-            vi.mocked(gatherPrWorktreeInfo).mockResolvedValue([wt]);
-            vi.mocked(findWorktreeByPrNumber).mockReturnValue(wt);
-            vi.mocked(cleanWorktree).mockReturnValue(makeCleanupResult({ prNumber: 42, success: true, message: 'Would clean PR #42' }));
-            await cleanCommand.handler({
-                prNumber: 42,
-                all: false,
-                'dry-run': true,
-                force: false,
-                json: false,
-            });
-            expect(printStatus).toHaveBeenCalledWith('info', expect.stringContaining('Would clean'));
-        });
-        it('prints warning and exits 1 on failed specific PR cleanup', async () => {
-            const wt = makeWorktree({ prNumber: 42 });
-            vi.mocked(gatherPrWorktreeInfo).mockResolvedValue([wt]);
-            vi.mocked(findWorktreeByPrNumber).mockReturnValue(wt);
-            vi.mocked(cleanWorktree).mockReturnValue(makeCleanupResult({ prNumber: 42, success: false, message: 'Has uncommitted changes' }));
-            await expect(cleanCommand.handler({
-                prNumber: 42,
-                all: false,
-                'dry-run': false,
-                force: false,
-                json: false,
-            })).rejects.toThrow(ExitError);
-            expect(printStatus).toHaveBeenCalledWith('warning', 'Has uncommitted changes');
-            expect(mockExit).toHaveBeenCalledWith(1);
-        });
-    });
-    // =========================================================================
-    // --all without --json: text output paths
-    // =========================================================================
-    describe('--all without --json (text output)', () => {
-        it('prints info when no cleanable worktrees found', async () => {
-            vi.mocked(gatherPrWorktreeInfo).mockResolvedValue([]);
-            vi.mocked(getCleanableWorktrees).mockReturnValue([]);
-            await cleanCommand.handler({
-                all: true,
-                'dry-run': false,
-                force: false,
-                json: false,
-            });
-            expect(printStatus).toHaveBeenCalledWith('info', expect.stringContaining('No merged or closed'));
-        });
-        it('prints success/warning per worktree and summary', async () => {
-            const wt1 = makeWorktree({ prNumber: 10 });
-            const wt2 = makeWorktree({ prNumber: 20 });
-            vi.mocked(gatherPrWorktreeInfo).mockResolvedValue([wt1, wt2]);
-            vi.mocked(getCleanableWorktrees).mockReturnValue([wt1, wt2]);
-            vi.mocked(cleanWorktree)
-                .mockReturnValueOnce(makeCleanupResult({ prNumber: 10, success: true, message: 'Cleaned #10' }))
-                .mockReturnValueOnce(makeCleanupResult({ prNumber: 20, success: false, message: 'Failed #20' }));
-            vi.mocked(summarizeResults).mockReturnValue({ cleaned: 1, total: 2, failed: 1 });
-            await cleanCommand.handler({
-                all: true,
-                'dry-run': false,
-                force: false,
-                json: false,
-            });
-            expect(printStatus).toHaveBeenCalledWith('success', 'Cleaned #10');
-            expect(printStatus).toHaveBeenCalledWith('warning', 'Failed #20');
-            expect(printStatus).toHaveBeenCalledWith('success', expect.stringContaining('Cleaned 1 of 2'));
-        });
-        it('prints dry-run summary for text output', async () => {
-            const wt1 = makeWorktree({ prNumber: 10 });
-            vi.mocked(gatherPrWorktreeInfo).mockResolvedValue([wt1]);
-            vi.mocked(getCleanableWorktrees).mockReturnValue([wt1]);
-            vi.mocked(cleanWorktree).mockReturnValue(makeCleanupResult({ prNumber: 10, success: true, message: 'Would clean' }));
-            vi.mocked(summarizeResults).mockReturnValue({ cleaned: 1, total: 1, failed: 0 });
-            await cleanCommand.handler({
-                all: true,
-                'dry-run': true,
-                force: false,
-                json: false,
-            });
-            expect(printStatus).toHaveBeenCalledWith('info', expect.stringContaining('Would clean 1 of 1'));
-        });
-        it('shows next steps when worktrees were cleaned', async () => {
-            const wt1 = makeWorktree({ prNumber: 10 });
-            vi.mocked(gatherPrWorktreeInfo).mockResolvedValue([wt1]);
-            vi.mocked(getCleanableWorktrees).mockReturnValue([wt1]);
-            vi.mocked(cleanWorktree).mockReturnValue(makeCleanupResult({ prNumber: 10, success: true }));
-            vi.mocked(summarizeResults).mockReturnValue({ cleaned: 1, total: 1, failed: 0 });
-            await cleanCommand.handler({
-                all: true,
-                'dry-run': false,
-                force: false,
-                json: false,
-            });
-            expect(printNextSteps).toHaveBeenCalled();
-        });
-    });
-    // =========================================================================
-    // Interactive mode with --json (not supported)
-    // =========================================================================
-    describe('interactive mode with --json', () => {
-        it('outputs JSON error for interactive + json combination', async () => {
-            vi.mocked(gatherPrWorktreeInfo).mockResolvedValue([]);
-            await expect(cleanCommand.handler({
-                all: false,
-                'dry-run': false,
-                force: false,
-                json: true,
-                // prNumber is undefined -> interactive mode
-            })).rejects.toThrow(ExitError);
-            expect(createErrorResult).toHaveBeenCalledWith('cleanpr', ErrorCode.INVALID_ARGUMENT, expect.stringContaining('Interactive mode not supported'));
-            expect(mockExit).toHaveBeenCalledWith(1);
-        });
-    });
-    // =========================================================================
-    // printWorktree coverage (via interactiveClean path)
-    // =========================================================================
-    describe('interactive mode (non-json)', () => {
-        it('prints grouped worktrees and shows no-cleanable message', async () => {
-            const openWt = makeWorktree({ prNumber: 10, prState: 'OPEN', branch: 'feat/open' });
-            vi.mocked(gatherPrWorktreeInfo).mockResolvedValue([openWt]);
-            vi.mocked(groupWorktreesByState).mockReturnValue({
-                merged: [],
-                closed: [],
-                open: [openWt],
-                unknown: [],
-            });
-            vi.mocked(getCleanableWorktrees).mockReturnValue([]);
-            await cleanCommand.handler({
-                all: false,
-                'dry-run': false,
-                force: false,
-                json: false,
-            });
-            // printWorktree is called for open worktrees
-            expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('PR #10: feat/open'));
-            expect(printStatus).toHaveBeenCalledWith('info', expect.stringContaining('No merged or closed PRs to clean'));
-        });
-        it('prints all four groups when all states present', async () => {
-            const merged = makeWorktree({ prNumber: 1, prState: 'MERGED', branch: 'feat/merged' });
-            const closed = makeWorktree({ prNumber: 2, prState: 'CLOSED', branch: 'feat/closed' });
-            const open = makeWorktree({ prNumber: 3, prState: 'OPEN', branch: 'feat/open' });
-            const unknown = makeWorktree({ prNumber: 4, prState: 'UNKNOWN', branch: 'feat/unknown' });
-            vi.mocked(gatherPrWorktreeInfo).mockResolvedValue([merged, closed, open, unknown]);
-            vi.mocked(groupWorktreesByState).mockReturnValue({
-                merged: [merged],
-                closed: [closed],
-                open: [open],
-                unknown: [unknown],
-            });
-            vi.mocked(getCleanableWorktrees).mockReturnValue([]);
-            await cleanCommand.handler({
-                all: false,
-                'dry-run': false,
-                force: false,
-                json: false,
-            });
-            // Each group header is printed
-            expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('Merged (1)'));
-            expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('Closed (1)'));
-            expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('Open (1)'));
-            expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('Unknown (1)'));
-            // printWorktree called for each
-            expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('PR #1: feat/merged'));
-            expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('PR #2: feat/closed'));
-            expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('PR #3: feat/open'));
-            expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('PR #4: feat/unknown'));
-        });
-        it('prints "No PR worktrees found" when list is empty', async () => {
-            vi.mocked(gatherPrWorktreeInfo).mockResolvedValue([]);
-            await cleanCommand.handler({
-                all: false,
-                'dry-run': false,
-                force: false,
-                json: false,
-            });
-            expect(printStatus).toHaveBeenCalledWith('info', 'No PR worktrees found.');
-        });
-    });
-    // =========================================================================
-    // printWorktree with changes indicator
-    // =========================================================================
-    describe('printWorktree with changes', () => {
-        it('includes change indicator in output', async () => {
-            const wt = makeWorktree({ prNumber: 55, branch: 'feat/dirty', hasChanges: true });
-            vi.mocked(changeIndicator).mockReturnValue(' [modified]');
-            vi.mocked(gatherPrWorktreeInfo).mockResolvedValue([wt]);
-            vi.mocked(groupWorktreesByState).mockReturnValue({
-                merged: [wt],
-                closed: [],
-                open: [],
-                unknown: [],
-            });
-            vi.mocked(getCleanableWorktrees).mockReturnValue([]);
-            await cleanCommand.handler({
-                all: false,
-                'dry-run': false,
-                force: false,
-                json: false,
-            });
-            expect(changeIndicator).toHaveBeenCalledWith(true);
-            expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('PR #55: feat/dirty [modified]'));
-        });
-    });
-    // =========================================================================
-    // Options mapping
-    // =========================================================================
-    describe('options mapping', () => {
-        it('maps --delete-remote to options.deleteRemote', async () => {
-            const wt = makeWorktree({ prNumber: 42 });
-            vi.mocked(gatherPrWorktreeInfo).mockResolvedValue([wt]);
-            vi.mocked(getCleanableWorktrees).mockReturnValue([wt]);
-            vi.mocked(cleanWorktree).mockReturnValue(makeCleanupResult());
-            await cleanCommand.handler({
-                all: true,
-                'dry-run': false,
-                force: false,
-                'delete-remote': true,
-                json: false,
-            });
-            expect(cleanWorktree).toHaveBeenCalledWith(wt, expect.objectContaining({ deleteRemote: true }), expect.any(Object));
-        });
-        it('maps --force to options.force', async () => {
-            const wt = makeWorktree({ prNumber: 42 });
-            vi.mocked(gatherPrWorktreeInfo).mockResolvedValue([wt]);
-            vi.mocked(getCleanableWorktrees).mockReturnValue([wt]);
-            vi.mocked(cleanWorktree).mockReturnValue(makeCleanupResult());
-            await cleanCommand.handler({
-                all: true,
-                'dry-run': false,
-                force: true,
-                json: false,
-            });
-            expect(cleanWorktree).toHaveBeenCalledWith(wt, expect.objectContaining({ force: true }), expect.any(Object));
-        });
-    });
-    // =========================================================================
-    // JSON mode skips spinner
-    // =========================================================================
-    describe('spinner behavior', () => {
-        it('skips spinner in json mode and calls gatherPrWorktreeInfo directly', async () => {
-            const { withSpinner } = await import('../../lib/prompts.js');
-            await cleanCommand.handler({
-                all: true,
-                'dry-run': false,
-                force: false,
-                json: true,
-            });
-            expect(withSpinner).not.toHaveBeenCalled();
-            expect(gatherPrWorktreeInfo).toHaveBeenCalled();
-        });
-        it('uses spinner in non-json mode', async () => {
-            const { withSpinner } = await import('../../lib/prompts.js');
-            await cleanCommand.handler({
-                all: true,
-                'dry-run': false,
-                force: false,
-                json: false,
-            });
-            expect(withSpinner).toHaveBeenCalledWith('Scanning worktrees...', expect.any(Function));
-        });
-    });
-});
-//# sourceMappingURL=clean.test.js.map