@camaradesuk/git-worktree-tools 1.8.0 → 1.10.0

package/dist/cli/wt/interactive-menu.test.js

@@ -3,8 +3,10 @@
  *
  * These tests verify that each menu flow:
  * 1. Gathers the correct user inputs
- * 2. Passes the correct arguments to subcommands
- * 3. Handles cancellation and back navigation correctly
+ * 2. Calls the correct library functions with proper arguments
+ * 3. Returns to menu after operation execution (not exit)
+ * 4. Handles cancellation and back navigation correctly
+ * 5. Uses direct library calls (no subprocess spawning)
  */
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 // Mock modules before importing the module under test
@@ -23,14 +25,9 @@ vi.mock('../../lib/prompts.js', () => {
         UserNavigatedBack: MockUserNavigatedBack,
     };
 });
-vi.mock('./run-command.js', () => ({
-    runSubcommand: vi.fn(() => {
-        // Mock never returns - simulate process.exit
-        throw new Error('process.exit called');
-    }),
-}));
 vi.mock('../../lib/config.js', () => ({
     loadConfig: vi.fn(() => ({
+        configVersion: 1,
         sharedRepos: [],
         baseBranch: 'main',
         draftPr: true,
@@ -62,12 +59,90 @@ vi.mock('../../lib/config.js', () => ({
 vi.mock('../../lib/git.js', () => ({
     getRepoRoot: vi.fn(() => '/mock/repo'),
     listLocalBranches: vi.fn(() => ['feat/existing-branch', 'fix/bug-fix', 'main', 'develop']),
+    removeWorktree: vi.fn(),
+    pruneWorktrees: vi.fn(),
+}));
+vi.mock('../../lib/wtlink/config-manifest.js', () => ({
+    loadManifestData: vi.fn(() => ({
+        enabled: ['.env', '.env.local'],
+        disabled: ['config.json'],
+        source: 'config',
+    })),
+    saveManifestData: vi.fn(),
+}));
+// Mock direct library imports
+vi.mock('../../lib/lswt/index.js', () => ({
+    gatherWorktreeInfo: vi.fn(async () => []),
+    createDefaultDeps: vi.fn(() => ({})),
+    runInteractiveMode: vi.fn(async () => { }),
+}));
+vi.mock('../../lib/prs/command.js', () => ({
+    runPrsCommand: vi.fn(async () => { }),
+}));
+vi.mock('../newpr.js', () => ({
+    runNewprHandler: vi.fn(async () => { }),
+}));
+vi.mock('../../lib/cleanpr/index.js', () => ({
+    gatherPrWorktreeInfo: vi.fn(async () => []),
+    createDefaultDeps: vi.fn(() => ({})),
+    getCleanableWorktrees: vi.fn(() => []),
+    cleanWorktree: vi.fn(() => ({ success: true, message: 'Cleaned', prNumber: 42 })),
+    findWorktreeByPrNumber: vi.fn(() => null),
+    summarizeResults: vi.fn(() => ({ cleaned: 0, total: 0 })),
+}));
+vi.mock('../../lib/wtstate/index.js', () => ({
+    analyzeState: vi.fn(() => ({
+        scenario: 'main_clean_same',
+        scenarioDescription: 'On main, clean, same as origin',
+        currentBranch: 'main',
+        baseBranch: 'main',
+        worktreeType: 'main_worktree',
+        hasChanges: false,
+        hasStagedChanges: false,
+        hasUnstagedChanges: false,
+        localCommits: 0,
+        stagedFiles: [],
+        unstagedFiles: [],
+        availableActions: [],
+        recommendedAction: null,
+    })),
+    formatText: vi.fn(() => 'State: main_clean_same'),
+}));
+vi.mock('../../lib/wtlink/link-configs.js', () => ({
+    run: vi.fn(async () => { }),
+}));
+vi.mock('../../lib/wtlink/validate-manifest.js', () => ({
+    run: vi.fn(() => { }),
+}));
+vi.mock('../../lib/wtconfig/index.js', () => ({
+    formatConfigDisplay: vi.fn(() => '{ baseBranch: "main" }'),
+    setConfigValue: vi.fn((config, _key, _value) => config),
+    loadRepoConfig: vi.fn(() => ({})),
+    saveRepoConfig: vi.fn(),
+    validateConfig: vi.fn(() => ({ valid: true, errors: [], warnings: [] })),
+}));
+vi.mock('../../lib/constants.js', () => ({
+    DEFAULT_MANIFEST_FILE: '.wtlinkrc',
+}));
+vi.mock('../../lib/ui/index.js', () => ({
+    printStatus: vi.fn(),
+}));
+vi.mock('child_process', () => ({
+    execSync: vi.fn(),
 }));
 // Import mocked modules
 import { promptChoice, promptInput, promptConfirm } from '../../lib/prompts.js';
-import { runSubcommand } from './run-command.js';
 import { loadConfig } from '../../lib/config.js';
 import * as git from '../../lib/git.js';
+import { loadManifestData, saveManifestData } from '../../lib/wtlink/config-manifest.js';
+import { gatherWorktreeInfo, runInteractiveMode } from '../../lib/lswt/index.js';
+import { runPrsCommand } from '../../lib/prs/command.js';
+import { runNewprHandler } from '../newpr.js';
+import { gatherPrWorktreeInfo, getCleanableWorktrees, } from '../../lib/cleanpr/index.js';
+import { analyzeState, formatText } from '../../lib/wtstate/index.js';
+import { run as runWtlinkLink } from '../../lib/wtlink/link-configs.js';
+import { run as runWtlinkValidate } from '../../lib/wtlink/validate-manifest.js';
+import { formatConfigDisplay, setConfigValue, loadRepoConfig, saveRepoConfig, } from '../../lib/wtconfig/index.js';
 // Import flows after mocks are set up
 import { flows, showMainMenu } from './interactive-menu.js';
 // Mock console.log to keep test output clean
@@ -80,36 +155,41 @@ describe('Interactive Menu Flows', () => {
         consoleSpy.mockClear();
     });
     describe('handleListWorktrees', () => {
-        it('calls lswt subcommand with no args', async () => {
-            try {
-                await flows.handleListWorktrees();
-            }
-            catch {
-                // Expected - runSubcommand throws
-            }
-            expect(runSubcommand).toHaveBeenCalledWith('lswt', []);
+        it('calls gatherWorktreeInfo and runInteractiveMode and returns to menu', async () => {
+            const result = await flows.handleListWorktrees();
+            expect(gatherWorktreeInfo).toHaveBeenCalledWith('/mock/repo', { verbose: false, json: false, showStatus: false }, expect.anything());
+            expect(runInteractiveMode).toHaveBeenCalled();
+            expect(result).toEqual({ completed: true, returnToMenu: true });
+        });
+        it('returns to menu with error message when library call fails', async () => {
+            vi.mocked(gatherWorktreeInfo).mockRejectedValueOnce(new Error('git error'));
+            const result = await flows.handleListWorktrees();
+            expect(result).toEqual({ completed: true, returnToMenu: true });
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('git error'));
         });
     });
     describe('handleBrowsePRs', () => {
-        it('calls prs subcommand with no args', async () => {
-            try {
-                await flows.handleBrowsePRs();
-            }
-            catch {
-                // Expected - runSubcommand throws
-            }
-            expect(runSubcommand).toHaveBeenCalledWith('prs', []);
+        it('calls runPrsCommand and returns to menu', async () => {
+            const result = await flows.handleBrowsePRs();
+            expect(runPrsCommand).toHaveBeenCalledWith({
+                state: 'open',
+                limit: 50,
+                json: false,
+                noInteractive: false,
+            });
+            expect(result).toEqual({ completed: true, returnToMenu: true });
         });
     });
     describe('handleShowState', () => {
-        it('calls wtstate subcommand with no args', async () => {
-            try {
-                await flows.handleShowState();
-            }
-            catch {
-                // Expected - runSubcommand throws
-            }
-            expect(runSubcommand).toHaveBeenCalledWith('wtstate', []);
+        it('calls analyzeState and formatText and returns to menu', async () => {
+            const result = await flows.handleShowState();
+            expect(analyzeState).toHaveBeenCalledWith({
+                verbose: false,
+                json: false,
+                baseBranch: 'main',
+            });
+            expect(formatText).toHaveBeenCalled();
+            expect(result).toEqual({ completed: true, returnToMenu: true });
         });
     });
     describe('handleNewPR', () => {
@@ -117,7 +197,7 @@ describe('Interactive Menu Flows', () => {
             vi.mocked(promptChoice).mockResolvedValueOnce('back');
             const result = await flows.handleNewPR();
             expect(result).toEqual({ completed: false, returnToMenu: true });
-            expect(runSubcommand).not.toHaveBeenCalled();
+            expect(runNewprHandler).not.toHaveBeenCalled();
         });
         it('handles user cancellation (Ctrl+C)', async () => {
             vi.mocked(promptChoice).mockRejectedValueOnce(new Error('User cancelled'));
@@ -125,7 +205,7 @@ describe('Interactive Menu Flows', () => {
             expect(result).toEqual({ completed: false, returnToMenu: true });
         });
         describe('from-description flow', () => {
-            it('gathers all inputs and calls newpr with correct args', async () => {
+            it('gathers all inputs and calls runNewprHandler with correct Options', async () => {
                 vi.mocked(promptChoice)
                     .mockResolvedValueOnce('from-description') // New PR sub-menu
                     .mockResolvedValueOnce(true); // Draft PR selection
@@ -135,15 +215,18 @@ describe('Interactive Menu Flows', () => {
                 vi.mocked(promptConfirm)
                     .mockResolvedValueOnce(false) // Install deps
                     .mockResolvedValueOnce(false); // Open VS Code
-                try {
-                    await flows.handleNewPR();
-                }
-                catch {
-                    // Expected
-                }
-                expect(runSubcommand).toHaveBeenCalledWith('newpr', ['Add dark mode support']);
-            });
-            it('passes --ready flag when not draft', async () => {
+                const result = await flows.handleNewPR();
+                expect(runNewprHandler).toHaveBeenCalledWith(expect.objectContaining({
+                    mode: 'new',
+                    description: 'Add dark mode support',
+                    baseBranch: 'main',
+                    draft: true,
+                    installDeps: false,
+                    openEditor: false,
+                }));
+                expect(result).toEqual({ completed: true, returnToMenu: true });
+            });
+            it('passes ready flag when not draft', async () => {
                 vi.mocked(promptChoice)
                     .mockResolvedValueOnce('from-description')
                     .mockResolvedValueOnce(false); // Ready for review (not draft)
@@ -151,15 +234,15 @@ describe('Interactive Menu Flows', () => {
                     .mockResolvedValueOnce('Fix critical bug')
                     .mockResolvedValueOnce('main');
                 vi.mocked(promptConfirm).mockResolvedValueOnce(false).mockResolvedValueOnce(false);
-                try {
-                    await flows.handleNewPR();
-                }
-                catch {
-                    // Expected
-                }
-                expect(runSubcommand).toHaveBeenCalledWith('newpr', ['Fix critical bug', '--ready']);
-            });
-            it('passes --base flag when not main', async () => {
+                const result = await flows.handleNewPR();
+                expect(runNewprHandler).toHaveBeenCalledWith(expect.objectContaining({
+                    mode: 'new',
+                    description: 'Fix critical bug',
+                    draft: false,
+                }));
+                expect(result).toEqual({ completed: true, returnToMenu: true });
+            });
+            it('passes non-main base branch', async () => {
                 vi.mocked(promptChoice)
                     .mockResolvedValueOnce('from-description')
                     .mockResolvedValueOnce(true);
@@ -167,15 +250,13 @@ describe('Interactive Menu Flows', () => {
                     .mockResolvedValueOnce('Feature work')
                     .mockResolvedValueOnce('develop'); // Non-main base branch
                 vi.mocked(promptConfirm).mockResolvedValueOnce(false).mockResolvedValueOnce(false);
-                try {
-                    await flows.handleNewPR();
-                }
-                catch {
-                    // Expected
-                }
-                expect(runSubcommand).toHaveBeenCalledWith('newpr', ['Feature work', '--base', 'develop']);
-            });
-            it('passes --install flag when requested', async () => {
+                const result = await flows.handleNewPR();
+                expect(runNewprHandler).toHaveBeenCalledWith(expect.objectContaining({
+                    baseBranch: 'develop',
+                }));
+                expect(result).toEqual({ completed: true, returnToMenu: true });
+            });
+            it('passes install flag when requested', async () => {
                 vi.mocked(promptChoice)
                     .mockResolvedValueOnce('from-description')
                     .mockResolvedValueOnce(true);
@@ -183,27 +264,23 @@ describe('Interactive Menu Flows', () => {
                 vi.mocked(promptConfirm)
                     .mockResolvedValueOnce(true) // Install deps
                     .mockResolvedValueOnce(false);
-                try {
-                    await flows.handleNewPR();
-                }
-                catch {
-                    // Expected
-                }
-                expect(runSubcommand).toHaveBeenCalledWith('newpr', ['Add feature', '--install']);
-            });
-            it('passes --code flag when requested', async () => {
+                const result = await flows.handleNewPR();
+                expect(runNewprHandler).toHaveBeenCalledWith(expect.objectContaining({
+                    installDeps: true,
+                }));
+                expect(result).toEqual({ completed: true, returnToMenu: true });
+            });
+            it('passes code flag when requested', async () => {
                 vi.mocked(promptChoice)
                     .mockResolvedValueOnce('from-description')
                     .mockResolvedValueOnce(true);
                 vi.mocked(promptInput).mockResolvedValueOnce('Add feature').mockResolvedValueOnce('main');
                 vi.mocked(promptConfirm).mockResolvedValueOnce(false).mockResolvedValueOnce(true); // Open VS Code
-                try {
-                    await flows.handleNewPR();
-                }
-                catch {
-                    // Expected
-                }
-                expect(runSubcommand).toHaveBeenCalledWith('newpr', ['Add feature', '--code']);
+                const result = await flows.handleNewPR();
+                expect(runNewprHandler).toHaveBeenCalledWith(expect.objectContaining({
+                    openEditor: true,
+                }));
+                expect(result).toEqual({ completed: true, returnToMenu: true });
             });
             it('passes all optional flags together', async () => {
                 vi.mocked(promptChoice)
@@ -215,27 +292,23 @@ describe('Interactive Menu Flows', () => {
                 vi.mocked(promptConfirm)
                     .mockResolvedValueOnce(true) // Install
                     .mockResolvedValueOnce(true); // VS Code
-                try {
-                    await flows.handleNewPR();
-                }
-                catch {
-                    // Expected
-                }
-                expect(runSubcommand).toHaveBeenCalledWith('newpr', [
-                    'Full feature',
-                    '--base',
-                    'develop',
-                    '--ready',
-                    '--install',
-                    '--code',
-                ]);
+                const result = await flows.handleNewPR();
+                expect(runNewprHandler).toHaveBeenCalledWith(expect.objectContaining({
+                    mode: 'new',
+                    description: 'Full feature',
+                    baseBranch: 'develop',
+                    draft: false,
+                    installDeps: true,
+                    openEditor: true,
+                }));
+                expect(result).toEqual({ completed: true, returnToMenu: true });
             });
             it('returns CANCELLED when description is empty', async () => {
                 vi.mocked(promptChoice).mockResolvedValueOnce('from-description');
                 vi.mocked(promptInput).mockResolvedValueOnce(''); // Empty description
                 const result = await flows.handleNewPR();
                 expect(result).toEqual({ completed: false, returnToMenu: true });
-                expect(runSubcommand).not.toHaveBeenCalled();
+                expect(runNewprHandler).not.toHaveBeenCalled();
             });
             it('handles user cancellation during input', async () => {
                 vi.mocked(promptChoice).mockResolvedValueOnce('from-description');
@@ -245,59 +318,59 @@ describe('Interactive Menu Flows', () => {
             });
         });
         describe('from-pr flow', () => {
-            it('gathers PR number and calls newpr with --pr flag', async () => {
+            it('gathers PR number and calls runNewprHandler with mode pr', async () => {
                 vi.mocked(promptChoice).mockResolvedValueOnce('from-pr');
                 vi.mocked(promptInput).mockResolvedValueOnce('42');
                 vi.mocked(promptConfirm).mockResolvedValueOnce(false).mockResolvedValueOnce(false);
-                try {
-                    await flows.handleNewPR();
-                }
-                catch {
-                    // Expected
-                }
-                expect(runSubcommand).toHaveBeenCalledWith('newpr', ['--pr', '42']);
-            });
-            it('passes --install and --code flags', async () => {
+                const result = await flows.handleNewPR();
+                expect(runNewprHandler).toHaveBeenCalledWith(expect.objectContaining({
+                    mode: 'pr',
+                    prNumber: 42,
+                }));
+                expect(result).toEqual({ completed: true, returnToMenu: true });
+            });
+            it('passes install and code flags', async () => {
                 vi.mocked(promptChoice).mockResolvedValueOnce('from-pr');
                 vi.mocked(promptInput).mockResolvedValueOnce('123');
                 vi.mocked(promptConfirm)
                     .mockResolvedValueOnce(true) // Install
                     .mockResolvedValueOnce(true); // VS Code
-                try {
-                    await flows.handleNewPR();
-                }
-                catch {
-                    // Expected
-                }
-                expect(runSubcommand).toHaveBeenCalledWith('newpr', ['--pr', '123', '--install', '--code']);
+                const result = await flows.handleNewPR();
+                expect(runNewprHandler).toHaveBeenCalledWith(expect.objectContaining({
+                    mode: 'pr',
+                    prNumber: 123,
+                    installDeps: true,
+                    openEditor: true,
+                }));
+                expect(result).toEqual({ completed: true, returnToMenu: true });
             });
             it('returns CANCELLED when PR number is empty', async () => {
                 vi.mocked(promptChoice).mockResolvedValueOnce('from-pr');
                 vi.mocked(promptInput).mockResolvedValueOnce('');
                 const result = await flows.handleNewPR();
                 expect(result).toEqual({ completed: false, returnToMenu: true });
-                expect(runSubcommand).not.toHaveBeenCalled();
+                expect(runNewprHandler).not.toHaveBeenCalled();
             });
             it('returns CANCELLED when PR number is invalid', async () => {
                 vi.mocked(promptChoice).mockResolvedValueOnce('from-pr');
                 vi.mocked(promptInput).mockResolvedValueOnce('not-a-number');
                 const result = await flows.handleNewPR();
                 expect(result).toEqual({ completed: false, returnToMenu: true });
-                expect(runSubcommand).not.toHaveBeenCalled();
+                expect(runNewprHandler).not.toHaveBeenCalled();
             });
             it('returns CANCELLED when PR number is zero', async () => {
                 vi.mocked(promptChoice).mockResolvedValueOnce('from-pr');
                 vi.mocked(promptInput).mockResolvedValueOnce('0');
                 const result = await flows.handleNewPR();
                 expect(result).toEqual({ completed: false, returnToMenu: true });
-                expect(runSubcommand).not.toHaveBeenCalled();
+                expect(runNewprHandler).not.toHaveBeenCalled();
             });
             it('returns CANCELLED when PR number is negative', async () => {
                 vi.mocked(promptChoice).mockResolvedValueOnce('from-pr');
                 vi.mocked(promptInput).mockResolvedValueOnce('-5');
                 const result = await flows.handleNewPR();
                 expect(result).toEqual({ completed: false, returnToMenu: true });
-                expect(runSubcommand).not.toHaveBeenCalled();
+                expect(runNewprHandler).not.toHaveBeenCalled();
             });
         });
         describe('from-branch flow', () => {
@@ -307,13 +380,12 @@ describe('Interactive Menu Flows', () => {
                     .mockResolvedValueOnce('feat/existing-branch') // Select branch
                     .mockResolvedValueOnce(true); // Draft PR
                 vi.mocked(promptInput).mockResolvedValueOnce('main');
-                try {
-                    await flows.handleNewPR();
-                }
-                catch {
-                    // Expected
-                }
-                expect(runSubcommand).toHaveBeenCalledWith('newpr', ['--branch', 'feat/existing-branch']);
+                const result = await flows.handleNewPR();
+                expect(runNewprHandler).toHaveBeenCalledWith(expect.objectContaining({
+                    mode: 'branch',
+                    branchName: 'feat/existing-branch',
+                }));
+                expect(result).toEqual({ completed: true, returnToMenu: true });
             });
             it('allows typing custom branch name', async () => {
                 vi.mocked(promptChoice)
@@ -323,33 +395,27 @@ describe('Interactive Menu Flows', () => {
                 vi.mocked(promptInput)
                     .mockResolvedValueOnce('feat/my-new-branch') // Custom branch name
                     .mockResolvedValueOnce('main');
-                try {
-                    await flows.handleNewPR();
-                }
-                catch {
-                    // Expected
-                }
-                expect(runSubcommand).toHaveBeenCalledWith('newpr', ['--branch', 'feat/my-new-branch']);
-            });
-            it('passes --base and --ready flags', async () => {
+                const result = await flows.handleNewPR();
+                expect(runNewprHandler).toHaveBeenCalledWith(expect.objectContaining({
+                    mode: 'branch',
+                    branchName: 'feat/my-new-branch',
+                }));
+                expect(result).toEqual({ completed: true, returnToMenu: true });
+            });
+            it('passes non-main base branch and ready flag', async () => {
                 vi.mocked(promptChoice)
                     .mockResolvedValueOnce('from-branch')
                     .mockResolvedValueOnce('fix/bug-fix')
                     .mockResolvedValueOnce(false); // Ready for review
                 vi.mocked(promptInput).mockResolvedValueOnce('develop');
-                try {
-                    await flows.handleNewPR();
-                }
-                catch {
-                    // Expected
-                }
-                expect(runSubcommand).toHaveBeenCalledWith('newpr', [
-                    '--branch',
-                    'fix/bug-fix',
-                    '--base',
-                    'develop',
-                    '--ready',
-                ]);
+                const result = await flows.handleNewPR();
+                expect(runNewprHandler).toHaveBeenCalledWith(expect.objectContaining({
+                    mode: 'branch',
+                    branchName: 'fix/bug-fix',
+                    baseBranch: 'develop',
+                    draft: false,
+                }));
+                expect(result).toEqual({ completed: true, returnToMenu: true });
             });
             it('returns CANCELLED when branch name is empty', async () => {
                 vi.mocked(promptChoice)
@@ -358,7 +424,7 @@ describe('Interactive Menu Flows', () => {
                 vi.mocked(promptInput).mockResolvedValueOnce(''); // Empty branch name
                 const result = await flows.handleNewPR();
                 expect(result).toEqual({ completed: false, returnToMenu: true });
-                expect(runSubcommand).not.toHaveBeenCalled();
+                expect(runNewprHandler).not.toHaveBeenCalled();
             });
             it('handles empty branch list gracefully', async () => {
                 // Mock empty branch list
@@ -368,14 +434,10 @@ describe('Interactive Menu Flows', () => {
                     .mockResolvedValueOnce('feat/new-branch') // Manual branch input
                     .mockResolvedValueOnce('main');
                 vi.mocked(promptChoice).mockResolvedValueOnce(true); // Draft
-                try {
-                    await flows.handleNewPR();
-                }
-                catch {
-                    // Expected
-                }
+                const result = await flows.handleNewPR();
                 // Should have prompted for branch name directly
                 expect(promptInput).toHaveBeenCalledWith('Branch name');
+                expect(result).toEqual({ completed: true, returnToMenu: true });
             });
         });
     });
@@ -384,39 +446,31 @@ describe('Interactive Menu Flows', () => {
             vi.mocked(promptChoice).mockResolvedValueOnce('back');
             const result = await flows.handleCleanPRs();
             expect(result).toEqual({ completed: false, returnToMenu: true });
-            expect(runSubcommand).not.toHaveBeenCalled();
+            expect(gatherPrWorktreeInfo).not.toHaveBeenCalled();
         });
         describe('clean-all', () => {
-            it('calls cleanpr with --all after confirmation', async () => {
+            it('calls cleanpr library after confirmation and returns to menu', async () => {
                 vi.mocked(promptChoice).mockResolvedValueOnce('clean-all');
                 vi.mocked(promptConfirm).mockResolvedValueOnce(true);
-                try {
-                    await flows.handleCleanPRs();
-                }
-                catch {
-                    // Expected
-                }
-                expect(runSubcommand).toHaveBeenCalledWith('cleanpr', ['--all']);
+                const result = await flows.handleCleanPRs();
+                expect(gatherPrWorktreeInfo).toHaveBeenCalled();
+                expect(result).toEqual({ completed: true, returnToMenu: true });
             });
             it('returns CANCELLED when not confirmed', async () => {
                 vi.mocked(promptChoice).mockResolvedValueOnce('clean-all');
                 vi.mocked(promptConfirm).mockResolvedValueOnce(false);
                 const result = await flows.handleCleanPRs();
                 expect(result).toEqual({ completed: false, returnToMenu: true });
-                expect(runSubcommand).not.toHaveBeenCalled();
+                expect(gatherPrWorktreeInfo).not.toHaveBeenCalled();
             });
         });
         describe('clean-specific', () => {
-            it('calls cleanpr with PR number', async () => {
+            it('calls cleanpr with PR number and returns to menu', async () => {
                 vi.mocked(promptChoice).mockResolvedValueOnce('clean-specific');
                 vi.mocked(promptInput).mockResolvedValueOnce('42');
-                try {
-                    await flows.handleCleanPRs();
-                }
-                catch {
-                    // Expected
-                }
-                expect(runSubcommand).toHaveBeenCalledWith('cleanpr', ['42']);
+                const result = await flows.handleCleanPRs();
+                expect(gatherPrWorktreeInfo).toHaveBeenCalled();
+                expect(result).toEqual({ completed: true, returnToMenu: true });
             });
             it('returns CANCELLED when PR number is empty', async () => {
                 vi.mocked(promptChoice).mockResolvedValueOnce('clean-specific');
@@ -432,15 +486,12 @@ describe('Interactive Menu Flows', () => {
             });
         });
         describe('dry-run', () => {
-            it('calls cleanpr with --dry-run', async () => {
+            it('calls cleanpr with dry-run and returns to menu', async () => {
                 vi.mocked(promptChoice).mockResolvedValueOnce('dry-run');
-                try {
-                    await flows.handleCleanPRs();
-                }
-                catch {
-                    // Expected
-                }
-                expect(runSubcommand).toHaveBeenCalledWith('cleanpr', ['--dry-run']);
+                const result = await flows.handleCleanPRs();
+                expect(gatherPrWorktreeInfo).toHaveBeenCalled();
+                expect(getCleanableWorktrees).toHaveBeenCalled();
+                expect(result).toEqual({ completed: true, returnToMenu: true });
             });
         });
         it('handles user cancellation', async () => {
@@ -454,72 +505,110 @@ describe('Interactive Menu Flows', () => {
             vi.mocked(promptChoice).mockResolvedValueOnce('back');
             const result = await flows.handleLinkConfig();
             expect(result).toEqual({ completed: false, returnToMenu: true });
-            expect(runSubcommand).not.toHaveBeenCalled();
         });
-        it('view calls wtlink list', async () => {
-            vi.mocked(promptChoice).mockResolvedValueOnce('view');
-            try {
-                await flows.handleLinkConfig();
-            }
-            catch {
-                // Expected
-            }
-            expect(runSubcommand).toHaveBeenCalledWith('wtlink', ['list']);
-        });
-        it('sync calls wtlink sync', async () => {
-            vi.mocked(promptChoice).mockResolvedValueOnce('sync');
-            try {
-                await flows.handleLinkConfig();
-            }
-            catch {
-                // Expected
-            }
-            expect(runSubcommand).toHaveBeenCalledWith('wtlink', ['sync']);
-        });
-        it('add calls wtlink add with file path', async () => {
-            vi.mocked(promptChoice).mockResolvedValueOnce('add');
-            vi.mocked(promptInput).mockResolvedValueOnce('.env');
-            try {
-                await flows.handleLinkConfig();
-            }
-            catch {
-                // Expected
-            }
-            expect(runSubcommand).toHaveBeenCalledWith('wtlink', ['add', '.env']);
-        });
-        it('add returns CANCELLED when file path is empty', async () => {
-            vi.mocked(promptChoice).mockResolvedValueOnce('add');
-            vi.mocked(promptInput).mockResolvedValueOnce('');
-            const result = await flows.handleLinkConfig();
-            expect(result).toEqual({ completed: false, returnToMenu: true });
-            expect(runSubcommand).not.toHaveBeenCalled();
-        });
-        it('remove calls wtlink remove with file path', async () => {
-            vi.mocked(promptChoice).mockResolvedValueOnce('remove');
-            vi.mocked(promptInput).mockResolvedValueOnce('.env.local');
-            try {
-                await flows.handleLinkConfig();
-            }
-            catch {
-                // Expected
-            }
-            expect(runSubcommand).toHaveBeenCalledWith('wtlink', ['remove', '.env.local']);
-        });
-        it('remove returns CANCELLED when file path is empty', async () => {
-            vi.mocked(promptChoice).mockResolvedValueOnce('remove');
-            vi.mocked(promptInput).mockResolvedValueOnce('');
-            const result = await flows.handleLinkConfig();
-            expect(result).toEqual({ completed: false, returnToMenu: true });
+        describe('view via library', () => {
+            it('displays manifest contents from loadManifestData', async () => {
+                vi.mocked(promptChoice).mockResolvedValueOnce('view');
+                const result = await flows.handleLinkConfig();
+                expect(loadManifestData).toHaveBeenCalledWith('/mock/repo');
+                expect(result).toEqual({ completed: true, returnToMenu: true });
+            });
+            it('shows empty message when manifest has no files', async () => {
+                vi.mocked(loadManifestData).mockReturnValueOnce({
+                    enabled: [],
+                    disabled: [],
+                    source: 'empty',
+                });
+                vi.mocked(promptChoice).mockResolvedValueOnce('view');
+                const result = await flows.handleLinkConfig();
+                expect(result).toEqual({ completed: true, returnToMenu: true });
+                expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('No files'));
+            });
+            it('displays enabled and disabled files', async () => {
+                vi.mocked(promptChoice).mockResolvedValueOnce('view');
+                const result = await flows.handleLinkConfig();
+                expect(result).toEqual({ completed: true, returnToMenu: true });
+                // Check enabled files are shown
+                expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Enabled'));
+                expect(consoleSpy).toHaveBeenCalledWith('  .env');
+                expect(consoleSpy).toHaveBeenCalledWith('  .env.local');
+                // Check disabled files are shown
+                expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Disabled'));
+            });
         });
-        it('validate calls wtlink validate', async () => {
-            vi.mocked(promptChoice).mockResolvedValueOnce('validate');
-            try {
-                await flows.handleLinkConfig();
-            }
-            catch {
-                // Expected
-            }
-            expect(runSubcommand).toHaveBeenCalledWith('wtlink', ['validate']);
+        describe('sync via wtlink link', () => {
+            it('calls wtlink link library function', async () => {
+                vi.mocked(promptChoice).mockResolvedValueOnce('sync');
+                const result = await flows.handleLinkConfig();
+                expect(runWtlinkLink).toHaveBeenCalledWith(expect.objectContaining({
+                    manifestFile: '.wtlinkrc',
+                    dryRun: false,
+                    type: 'hard',
+                }));
+                expect(result).toEqual({ completed: true, returnToMenu: true });
+            });
+            it('shows error when sync fails', async () => {
+                vi.mocked(runWtlinkLink).mockRejectedValueOnce(new Error('Link failed'));
+                vi.mocked(promptChoice).mockResolvedValueOnce('sync');
+                const result = await flows.handleLinkConfig();
+                expect(result).toEqual({ completed: true, returnToMenu: true });
+                expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Link failed'));
+            });
+        });
+        describe('add via library', () => {
+            it('adds file to manifest via saveManifestData', async () => {
+                vi.mocked(promptChoice).mockResolvedValueOnce('add');
+                vi.mocked(promptInput).mockResolvedValueOnce('.npmrc');
+                const result = await flows.handleLinkConfig();
+                expect(saveManifestData).toHaveBeenCalledWith('/mock/repo', ['.env', '.env.local', '.npmrc'], ['config.json']);
+                expect(result).toEqual({ completed: true, returnToMenu: true });
+            });
+            it('skips duplicate files', async () => {
+                vi.mocked(promptChoice).mockResolvedValueOnce('add');
+                vi.mocked(promptInput).mockResolvedValueOnce('.env');
+                const result = await flows.handleLinkConfig();
+                expect(saveManifestData).not.toHaveBeenCalled();
+                expect(result).toEqual({ completed: true, returnToMenu: true });
+            });
+            it('returns CANCELLED when file path is empty', async () => {
+                vi.mocked(promptChoice).mockResolvedValueOnce('add');
+                vi.mocked(promptInput).mockResolvedValueOnce('');
+                const result = await flows.handleLinkConfig();
+                expect(result).toEqual({ completed: false, returnToMenu: true });
+                expect(saveManifestData).not.toHaveBeenCalled();
+            });
+        });
+        describe('remove via library', () => {
+            it('removes file from manifest via saveManifestData', async () => {
+                vi.mocked(promptChoice).mockResolvedValueOnce('remove');
+                vi.mocked(promptInput).mockResolvedValueOnce('.env');
+                const result = await flows.handleLinkConfig();
+                expect(saveManifestData).toHaveBeenCalledWith('/mock/repo', ['.env.local'], ['config.json']);
+                expect(result).toEqual({ completed: true, returnToMenu: true });
+            });
+            it('handles file not in manifest', async () => {
+                vi.mocked(promptChoice).mockResolvedValueOnce('remove');
+                vi.mocked(promptInput).mockResolvedValueOnce('nonexistent.txt');
+                const result = await flows.handleLinkConfig();
+                expect(saveManifestData).not.toHaveBeenCalled();
+                expect(result).toEqual({ completed: true, returnToMenu: true });
+            });
+            it('returns CANCELLED when file path is empty', async () => {
+                vi.mocked(promptChoice).mockResolvedValueOnce('remove');
+                vi.mocked(promptInput).mockResolvedValueOnce('');
+                const result = await flows.handleLinkConfig();
+                expect(result).toEqual({ completed: false, returnToMenu: true });
+            });
+        });
+        describe('validate', () => {
+            it('calls wtlink validate and returns to menu', async () => {
+                vi.mocked(promptChoice).mockResolvedValueOnce('validate');
+                const result = await flows.handleLinkConfig();
+                expect(runWtlinkValidate).toHaveBeenCalledWith(expect.objectContaining({
+                    manifestFile: '.wtlinkrc',
+                }));
+                expect(result).toEqual({ completed: true, returnToMenu: true });
+            });
         });
         it('handles user cancellation', async () => {
             vi.mocked(promptChoice).mockRejectedValueOnce(new Error('User cancelled'));
@@ -532,53 +621,41 @@ describe('Interactive Menu Flows', () => {
             vi.mocked(promptChoice).mockResolvedValueOnce('back');
             const result = await flows.handleConfigure();
             expect(result).toEqual({ completed: false, returnToMenu: true });
-            expect(runSubcommand).not.toHaveBeenCalled();
         });
-        it('view calls wtconfig show', async () => {
+        it('view calls formatConfigDisplay and returns to menu', async () => {
             vi.mocked(promptChoice).mockResolvedValueOnce('view');
-            try {
-                await flows.handleConfigure();
-            }
-            catch {
-                // Expected
-            }
-            expect(runSubcommand).toHaveBeenCalledWith('wtconfig', ['show']);
-        });
-        it('init calls wtconfig init after confirmation', async () => {
+            const result = await flows.handleConfigure();
+            expect(loadRepoConfig).toHaveBeenCalledWith('/mock/repo');
+            expect(formatConfigDisplay).toHaveBeenCalled();
+            expect(result).toEqual({ completed: true, returnToMenu: true });
+        });
+        it('init shows redirect message after confirmation and returns to menu', async () => {
             vi.mocked(promptChoice).mockResolvedValueOnce('init');
             vi.mocked(promptConfirm).mockResolvedValueOnce(true);
-            try {
-                await flows.handleConfigure();
-            }
-            catch {
-                // Expected
-            }
-            expect(runSubcommand).toHaveBeenCalledWith('wtconfig', ['init']);
+            const result = await flows.handleConfigure();
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('wt init'));
+            expect(result).toEqual({ completed: true, returnToMenu: true });
         });
         it('init returns CANCELLED when not confirmed', async () => {
             vi.mocked(promptChoice).mockResolvedValueOnce('init');
             vi.mocked(promptConfirm).mockResolvedValueOnce(false);
             const result = await flows.handleConfigure();
             expect(result).toEqual({ completed: false, returnToMenu: true });
-            expect(runSubcommand).not.toHaveBeenCalled();
         });
-        it('edit calls wtconfig set with setting and value', async () => {
+        it('edit calls setConfigValue and saveRepoConfig with setting and value', async () => {
             vi.mocked(promptChoice).mockResolvedValueOnce('edit').mockResolvedValueOnce('baseBranch');
             vi.mocked(promptInput).mockResolvedValueOnce('develop');
-            try {
-                await flows.handleConfigure();
-            }
-            catch {
-                // Expected
-            }
-            expect(runSubcommand).toHaveBeenCalledWith('wtconfig', ['set', 'baseBranch', 'develop']);
+            const result = await flows.handleConfigure();
+            expect(setConfigValue).toHaveBeenCalledWith({}, 'baseBranch', 'develop');
+            expect(saveRepoConfig).toHaveBeenCalled();
+            expect(result).toEqual({ completed: true, returnToMenu: true });
         });
         it('edit returns CANCELLED when value is empty', async () => {
             vi.mocked(promptChoice).mockResolvedValueOnce('edit').mockResolvedValueOnce('branchPrefix');
             vi.mocked(promptInput).mockResolvedValueOnce('');
             const result = await flows.handleConfigure();
             expect(result).toEqual({ completed: false, returnToMenu: true });
-            expect(runSubcommand).not.toHaveBeenCalled();
+            expect(saveRepoConfig).not.toHaveBeenCalled();
         });
         it('handles user cancellation', async () => {
             vi.mocked(promptChoice).mockRejectedValueOnce(new Error('User cancelled'));
@@ -590,12 +667,12 @@ describe('Interactive Menu Flows', () => {
         it('exits on exit selection', async () => {
             vi.mocked(promptChoice).mockResolvedValueOnce('exit');
             await showMainMenu();
-            expect(runSubcommand).not.toHaveBeenCalled();
+            expect(runNewprHandler).not.toHaveBeenCalled();
         });
         it('exits on user cancellation', async () => {
             vi.mocked(promptChoice).mockRejectedValueOnce(new Error('User cancelled'));
             await showMainMenu();
-            expect(runSubcommand).not.toHaveBeenCalled();
+            expect(runNewprHandler).not.toHaveBeenCalled();
         });
         it('re-throws non-cancellation errors', async () => {
             vi.mocked(promptChoice).mockRejectedValueOnce(new Error('Some other error'));
@@ -610,35 +687,29 @@ describe('Interactive Menu Flows', () => {
             // Should have called promptChoice 3 times (menu -> sub-menu -> back to menu -> exit)
             expect(promptChoice).toHaveBeenCalledTimes(3);
         });
-        it('handles list worktrees selection', async () => {
-            vi.mocked(promptChoice).mockResolvedValueOnce('list');
-            try {
-                await showMainMenu();
-            }
-            catch {
-                // Expected - runSubcommand throws
-            }
-            expect(runSubcommand).toHaveBeenCalledWith('lswt', []);
-        });
-        it('handles browse PRs selection', async () => {
-            vi.mocked(promptChoice).mockResolvedValueOnce('browse-prs');
-            try {
-                await showMainMenu();
-            }
-            catch {
-                // Expected - runSubcommand throws
-            }
-            expect(runSubcommand).toHaveBeenCalledWith('prs', []);
-        });
-        it('handles show state selection', async () => {
-            vi.mocked(promptChoice).mockResolvedValueOnce('state');
-            try {
-                await showMainMenu();
-            }
-            catch {
-                // Expected
-            }
-            expect(runSubcommand).toHaveBeenCalledWith('wtstate', []);
+        it('handles list worktrees and returns to menu', async () => {
+            vi.mocked(promptChoice)
+                .mockResolvedValueOnce('list') // Select list
+                .mockResolvedValueOnce('exit'); // Then exit
+            await showMainMenu();
+            expect(gatherWorktreeInfo).toHaveBeenCalled();
+            expect(promptChoice).toHaveBeenCalledTimes(2);
+        });
+        it('handles browse PRs and returns to menu', async () => {
+            vi.mocked(promptChoice)
+                .mockResolvedValueOnce('browse-prs') // Select browse-prs
+                .mockResolvedValueOnce('exit'); // Then exit
+            await showMainMenu();
+            expect(runPrsCommand).toHaveBeenCalled();
+            expect(promptChoice).toHaveBeenCalledTimes(2);
+        });
+        it('handles show state and returns to menu', async () => {
+            vi.mocked(promptChoice)
+                .mockResolvedValueOnce('state') // Select state
+                .mockResolvedValueOnce('exit'); // Then exit
+            await showMainMenu();
+            expect(analyzeState).toHaveBeenCalled();
+            expect(promptChoice).toHaveBeenCalledTimes(2);
         });
     });
     describe('FlowResult types', () => {
@@ -648,17 +719,10 @@ describe('Interactive Menu Flows', () => {
             expect(result.completed).toBe(false);
             expect(result.returnToMenu).toBe(true);
         });
-        it('flows that run subcommands return COMPLETED_EXIT', async () => {
+        it('flows that run operations return completed with returnToMenu=true', async () => {
             vi.mocked(promptChoice).mockResolvedValueOnce('dry-run');
-            // We can't test the actual return value since runSubcommand throws,
-            // but we can verify the flow attempted to call the subcommand
-            try {
-                await flows.handleCleanPRs();
-            }
-            catch {
-                // Expected
-            }
-            expect(runSubcommand).toHaveBeenCalled();
+            const result = await flows.handleCleanPRs();
+            expect(result).toEqual({ completed: true, returnToMenu: true });
         });
     });
 });
@@ -669,6 +733,7 @@ describe('Config loading in flows', () => {
     it('uses config default for base branch', async () => {
         // Set up config mock to return custom baseBranch
         vi.mocked(loadConfig).mockReturnValueOnce({
+            configVersion: 1,
             sharedRepos: [],
             baseBranch: 'develop',
             draftPr: true,
@@ -695,20 +760,19 @@ describe('Config loading in flows', () => {
             logging: { level: 'info', timestamps: true },
             global: { warnNotGlobal: true },
             wtlink: { enabled: [], disabled: [] },
+            linkConfigFiles: undefined,
         });
         vi.mocked(promptChoice).mockResolvedValueOnce('from-description').mockResolvedValueOnce(true);
         vi.mocked(promptInput).mockResolvedValueOnce('Test feature').mockResolvedValueOnce('develop'); // User accepts default
         vi.mocked(promptConfirm).mockResolvedValueOnce(false).mockResolvedValueOnce(false);
-        try {
-            await flows.handleNewPR();
-        }
-        catch {
-            // Expected
-        }
+        const result = await flows.handleNewPR();
         // Verify loadConfig was called
         expect(loadConfig).toHaveBeenCalled();
-        // Since user entered 'develop' (matching config default), no --base flag
-        expect(runSubcommand).toHaveBeenCalledWith('newpr', ['Test feature', '--base', 'develop']);
+        // Verify runNewprHandler was called with develop base branch
+        expect(runNewprHandler).toHaveBeenCalledWith(expect.objectContaining({
+            baseBranch: 'develop',
+        }));
+        expect(result).toEqual({ completed: true, returnToMenu: true });
     });
 });
 describe('Git branch listing in flows', () => {
@@ -723,14 +787,10 @@ describe('Git branch listing in flows', () => {
             .mockResolvedValueOnce('feat/existing-branch')
             .mockResolvedValueOnce(true);
         vi.mocked(promptInput).mockResolvedValueOnce('main');
-        try {
-            await flows.handleNewPR();
-        }
-        catch {
-            // Expected
-        }
+        const result = await flows.handleNewPR();
         // Check that listLocalBranches was called
         expect(git.listLocalBranches).toHaveBeenCalled();
+        expect(result).toEqual({ completed: true, returnToMenu: true });
     });
 });
 //# sourceMappingURL=interactive-menu.test.js.map