@camaradesuk/git-worktree-tools 1.8.0 → 1.10.0

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

@@ -1,12 +1,180 @@
 /**
  * Tests for wt unified command handlers
  *
- * These are thin wrappers around spawnSync that delegate to the underlying CLI tools.
- * We test that each handler correctly builds the argument array and spawns the right tool.
+ * All commands are migrated to direct library calls (list, state, clean, new, link)
+ * and tested by mocking the library modules they call.
  */
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { spawnSync } from 'child_process';
 import yargs from 'yargs';
+vi.mock('child_process', () => ({
+    spawnSync: vi.fn(() => ({ status: 0 })),
+    execSync: vi.fn(),
+}));
+// Mock newpr.ts for new command (direct library call)
+vi.mock('../newpr.js', () => ({
+    runNewprHandler: vi.fn().mockResolvedValue(undefined),
+}));
+// Mock library dependencies for list command (direct library calls)
+vi.mock('../../lib/lswt/index.js', () => ({
+    gatherWorktreeInfo: vi.fn().mockResolvedValue([]),
+    createDefaultDeps: vi.fn().mockReturnValue({}),
+    formatJsonOutput: vi.fn().mockReturnValue('[]'),
+    runInteractiveMode: vi.fn().mockResolvedValue(undefined),
+    printWorktreeTable: vi.fn(),
+    parseArgs: vi.fn(),
+    getHelpText: vi.fn(),
+    formatTypeLabel: vi.fn(),
+    getDisplayPath: vi.fn(),
+    sortWorktrees: vi.fn(),
+    extractPrNumber: vi.fn(),
+    isMainWorktree: vi.fn(),
+}));
+// Mock library dependencies for state command (direct library calls)
+vi.mock('../../lib/wtstate/index.js', () => ({
+    analyzeState: vi.fn().mockReturnValue({
+        scenario: 'main_clean_same',
+        scenarioDescription: 'On main branch, same as origin/main, no changes',
+        currentBranch: 'main',
+        baseBranch: 'main',
+        worktreeType: 'main_worktree',
+        hasChanges: false,
+        hasStagedChanges: false,
+        hasUnstagedChanges: false,
+        localCommits: [],
+        stagedFiles: [],
+        unstagedFiles: [],
+        availableActions: [],
+        recommendedAction: null,
+    }),
+    formatText: vi.fn().mockReturnValue('State: main_clean_same'),
+    parseArgs: vi.fn(),
+    getHelpText: vi.fn(),
+    getDefaultOptions: vi.fn(),
+}));
+// Mock library dependencies for clean command (direct library calls)
+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',
+        localBranchDeleted: true,
+        remoteBranchDeleted: false,
+    }),
+    summarizeResults: vi.fn().mockReturnValue({ cleaned: 0, total: 0, failed: 0 }),
+}));
+// Mock config module for clean command
+vi.mock('../../lib/config.js', () => ({
+    loadConfig: vi.fn().mockReturnValue({ worktreePattern: '{repo}.pr{number}', baseBranch: 'main' }),
+    loadConfigWithValidation: vi.fn().mockReturnValue({ config: {}, validation: null }),
+    getDefaultConfig: vi.fn().mockReturnValue({}),
+    getConfigPath: vi.fn().mockReturnValue(null),
+}));
+// Mock logger for clean command
+vi.mock('../../lib/logger.js', () => ({
+    logger: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+// Mock prompts module for clean command
+vi.mock('../../lib/prompts.js', () => ({
+    withSpinner: vi.fn((_msg, fn) => fn()),
+    promptChoice: vi.fn(),
+    promptConfirm: vi.fn(),
+}));
+// Mock colors module for clean command
+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),
+}));
+// Mock config-editor for config command
+vi.mock('../../lib/config-editor.js', () => ({
+    runConfigEditor: vi.fn().mockResolvedValue({ saved: false }),
+    quickEditConfig: vi.fn().mockResolvedValue({ saved: false }),
+}));
+// Mock config-validation for config command
+vi.mock('../../lib/config-validation.js', () => ({
+    formatValidationErrors: vi.fn().mockReturnValue('formatted errors'),
+}));
+// Mock global-config for config command
+vi.mock('../../lib/global-config.js', () => ({
+    getSchemaUrl: vi.fn().mockReturnValue('https://example.com/schema.json'),
+}));
+// Mock library dependencies for link command (direct library calls)
+vi.mock('../../lib/wtlink/manage-manifest.js', () => ({
+    run: vi.fn().mockResolvedValue(undefined),
+}));
+vi.mock('../../lib/wtlink/link-configs.js', () => ({
+    run: vi.fn().mockResolvedValue(undefined),
+}));
+vi.mock('../../lib/wtlink/validate-manifest.js', () => ({
+    run: vi.fn(),
+}));
+vi.mock('../../lib/wtlink/main-menu.js', () => ({
+    showMainMenu: vi.fn().mockResolvedValue(undefined),
+}));
+vi.mock('../../lib/wtlink/config-manifest.js', () => ({
+    hasLegacyManifest: vi.fn().mockReturnValue(false),
+}));
+vi.mock('../../lib/config-migration/index.js', () => ({
+    detectMigrationIssues: vi.fn().mockReturnValue({ issues: [] }),
+    runMigration: vi.fn().mockResolvedValue({ success: true, errors: [] }),
+    formatMigrationReport: vi.fn().mockReturnValue(''),
+}));
+vi.mock('../../lib/errors.js', () => ({
+    ManifestError: class ManifestError extends Error {
+        issues;
+        constructor(message, issues) {
+            super(message);
+            this.name = 'ManifestError';
+            this.issues = issues;
+        }
+    },
+}));
+// Mock git module for list/state/clean/link handlers
+vi.mock('../../lib/git.js', () => ({
+    getRepoRoot: vi.fn().mockReturnValue('/fake/repo'),
+    getMainWorktreeRoot: vi.fn().mockReturnValue('/fake/repo'),
+    removeWorktree: vi.fn(),
+    pruneWorktrees: vi.fn(),
+}));
+// Mock github module for list/clean handlers
+vi.mock('../../lib/github.js', () => ({
+    isGhInstalled: vi.fn().mockReturnValue(true),
+}));
+// Mock UI module for all handlers
+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' }),
+}));
+// Mock json-output module (partial mock to preserve exports for all command handlers)
+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 all commands statically so coverage is tracked
 import { newCommand } from './new.js';
 import { listCommand } from './list.js';
@@ -14,15 +182,24 @@ import { cleanCommand } from './clean.js';
 import { stateCommand } from './state.js';
 import { configCommand } from './config.js';
 import { linkCommand } from './link.js';
-vi.mock('child_process', () => ({
-    spawnSync: vi.fn(() => ({ status: 0 })),
-}));
+// Import mocked modules for assertions
+import { gatherWorktreeInfo, printWorktreeTable, formatJsonOutput } from '../../lib/lswt/index.js';
+import { analyzeState, formatText } from '../../lib/wtstate/index.js';
+import { gatherPrWorktreeInfo, getCleanableWorktrees } from '../../lib/cleanpr/index.js';
+import { setJsonMode, printError } from '../../lib/ui/index.js';
+import { createSuccessResult, formatJsonResult } from '../../lib/json-output.js';
+import { runNewprHandler } from '../newpr.js';
+import { run as manageRun } from '../../lib/wtlink/manage-manifest.js';
+import { run as linkRun } from '../../lib/wtlink/link-configs.js';
+import { run as validateRun } from '../../lib/wtlink/validate-manifest.js';
+import { showMainMenu } from '../../lib/wtlink/main-menu.js';
+import * as git from '../../lib/git.js';
+import * as github from '../../lib/github.js';
 // Mock process.exit to prevent test from exiting
 const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => undefined);
 // Helper to invoke builder for coverage
-function invokeBuilder(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-command, args) {
+function invokeBuilder(command, args) {
     const parser = yargs(args);
     if (typeof command.builder === 'function') {
         command.builder(parser);
@@ -42,154 +219,195 @@ describe('wt subcommand handlers', () => {
         });
         it('builder registers all expected options', () => {
             invokeBuilder(newCommand, []);
-            expect(true).toBe(true); // Builder executed for coverage
-            // Verify builder returns a yargs instance with registered options
-            // The builder function is invoked for coverage
+            expect(true).toBe(true);
         });
-        it('passes description to newpr', () => {
-            newCommand.handler({
+        it('calls runNewprHandler with description', async () => {
+            await newCommand.handler({
                 description: 'Add dark mode',
                 json: false,
                 'non-interactive': false,
-                'stash-untracked': false,
+                draft: false,
             });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['Add dark mode']), expect.any(Object));
-            expect(mockExit).toHaveBeenCalledWith(0);
+            expect(runNewprHandler).toHaveBeenCalledWith(expect.objectContaining({
+                mode: 'new',
+                description: 'Add dark mode',
+            }));
         });
-        it('passes --pr flag to newpr', () => {
-            newCommand.handler({
+        it('calls runNewprHandler with pr mode for --pr flag', async () => {
+            await newCommand.handler({
                 pr: 42,
                 json: false,
                 'non-interactive': false,
-                'stash-untracked': false,
+                draft: false,
             });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--pr', '42']), expect.any(Object));
+            expect(runNewprHandler).toHaveBeenCalledWith(expect.objectContaining({
+                mode: 'pr',
+                prNumber: 42,
+            }));
         });
-        it('passes --ready flag to newpr', () => {
-            newCommand.handler({
+        it('maps --ready flag to draft=false and draftExplicitlySet=true', async () => {
+            await newCommand.handler({
                 ready: true,
                 json: false,
                 'non-interactive': false,
-                'stash-untracked': false,
+                draft: false,
                 install: false,
                 code: false,
                 'no-wtlink': false,
                 'no-hooks': false,
             });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--ready']), expect.any(Object));
+            expect(runNewprHandler).toHaveBeenCalledWith(expect.objectContaining({
+                draft: false,
+                draftExplicitlySet: true,
+            }));
         });
-        it('passes --base flag to newpr', () => {
-            newCommand.handler({
+        it('maps --base flag to baseBranch option', async () => {
+            await newCommand.handler({
                 base: 'develop',
                 json: false,
                 'non-interactive': false,
-                'stash-untracked': false,
+                draft: false,
                 install: false,
                 code: false,
                 ready: false,
                 'no-wtlink': false,
                 'no-hooks': false,
             });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--base', 'develop']), expect.any(Object));
+            expect(runNewprHandler).toHaveBeenCalledWith(expect.objectContaining({ baseBranch: 'develop' }));
         });
-        it('passes --branch flag to newpr', () => {
-            newCommand.handler({
+        it('maps --branch flag to branch mode', async () => {
+            await newCommand.handler({
                 branch: 'feat/my-feature',
                 json: false,
                 'non-interactive': false,
-                'stash-untracked': false,
+                draft: false,
                 install: false,
                 code: false,
                 ready: false,
                 'no-wtlink': false,
                 'no-hooks': false,
             });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--branch', 'feat/my-feature']), expect.any(Object));
+            expect(runNewprHandler).toHaveBeenCalledWith(expect.objectContaining({
+                mode: 'branch',
+                branchName: 'feat/my-feature',
+            }));
         });
-        it('passes --install flag to newpr', () => {
-            newCommand.handler({
+        it('maps --install flag to installDeps option', async () => {
+            await newCommand.handler({
                 install: true,
                 json: false,
                 'non-interactive': false,
-                'stash-untracked': false,
+                draft: false,
                 code: false,
                 ready: false,
                 'no-wtlink': false,
                 'no-hooks': false,
             });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--install']), expect.any(Object));
+            expect(runNewprHandler).toHaveBeenCalledWith(expect.objectContaining({ installDeps: true }));
         });
-        it('passes --code flag to newpr', () => {
-            newCommand.handler({
+        it('maps --code flag to openEditor option', async () => {
+            await newCommand.handler({
                 code: true,
                 json: false,
                 'non-interactive': false,
-                'stash-untracked': false,
+                draft: false,
                 install: false,
                 ready: false,
                 'no-wtlink': false,
                 'no-hooks': false,
             });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--code']), expect.any(Object));
+            expect(runNewprHandler).toHaveBeenCalledWith(expect.objectContaining({ openEditor: true }));
         });
-        it('passes --no-wtlink flag to newpr', () => {
-            newCommand.handler({
+        it('maps --no-wtlink flag to runWtlink=false option', async () => {
+            await newCommand.handler({
                 'no-wtlink': true,
                 json: false,
                 'non-interactive': false,
-                'stash-untracked': false,
+                draft: false,
                 install: false,
                 code: false,
                 ready: false,
                 'no-hooks': false,
             });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--no-wtlink']), expect.any(Object));
+            expect(runNewprHandler).toHaveBeenCalledWith(expect.objectContaining({ runWtlink: false }));
         });
-        it('passes --no-hooks flag to newpr', () => {
-            newCommand.handler({
+        it('maps --no-hooks flag to noHooks option', async () => {
+            await newCommand.handler({
                 'no-hooks': true,
                 json: false,
                 'non-interactive': false,
-                'stash-untracked': false,
+                draft: false,
                 install: false,
                 code: false,
                 ready: false,
                 'no-wtlink': false,
             });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--no-hooks']), expect.any(Object));
+            expect(runNewprHandler).toHaveBeenCalledWith(expect.objectContaining({ noHooks: true }));
         });
-        it('passes --json flag to newpr', () => {
-            newCommand.handler({
+        it('maps --json flag to json option', async () => {
+            await newCommand.handler({
                 json: true,
                 'non-interactive': false,
-                'stash-untracked': false,
+                draft: false,
             });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--json']), expect.any(Object));
+            expect(runNewprHandler).toHaveBeenCalledWith(expect.objectContaining({ json: true }));
+            expect(setJsonMode).toHaveBeenCalledWith(true);
         });
-        it('passes --non-interactive flag to newpr', () => {
-            newCommand.handler({
+        it('maps --non-interactive flag to nonInteractive option', async () => {
+            await newCommand.handler({
                 json: false,
                 'non-interactive': true,
-                'stash-untracked': false,
+                draft: false,
             });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--non-interactive']), expect.any(Object));
+            expect(runNewprHandler).toHaveBeenCalledWith(expect.objectContaining({ nonInteractive: true }));
         });
-        it('passes --action flag to newpr', () => {
-            newCommand.handler({
+        it('maps --action flag to action option', async () => {
+            await newCommand.handler({
                 action: 'commit_all',
                 json: false,
                 'non-interactive': false,
-                'stash-untracked': false,
+                draft: false,
+            });
+            expect(runNewprHandler).toHaveBeenCalledWith(expect.objectContaining({ action: 'commit_all' }));
+        });
+        it('maps --draft flag to draft=true and draftExplicitlySet=true', async () => {
+            await newCommand.handler({
+                json: false,
+                'non-interactive': false,
+                draft: true,
+            });
+            expect(runNewprHandler).toHaveBeenCalledWith(expect.objectContaining({
+                draft: true,
+                draftExplicitlySet: true,
+            }));
+        });
+        it('maps --plan flag to generatePlan option', async () => {
+            await newCommand.handler({
+                json: false,
+                'non-interactive': false,
+                draft: false,
+                plan: true,
+            });
+            expect(runNewprHandler).toHaveBeenCalledWith(expect.objectContaining({ generatePlan: true }));
+        });
+        it('maps --confirm-hooks flag to confirmHooks option', async () => {
+            await newCommand.handler({
+                json: false,
+                'non-interactive': false,
+                draft: false,
+                'confirm-hooks': true,
             });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--action', 'commit_all']), expect.any(Object));
+            expect(runNewprHandler).toHaveBeenCalledWith(expect.objectContaining({ confirmHooks: true }));
         });
-        it('passes --stash-untracked flag to newpr', () => {
-            newCommand.handler({
+        it('does not spawn a child process', async () => {
+            vi.mocked(spawnSync).mockClear();
+            await newCommand.handler({
+                description: 'Test',
                 json: false,
                 'non-interactive': false,
-                'stash-untracked': true,
+                draft: false,
             });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--stash-untracked']), expect.any(Object));
+            expect(spawnSync).not.toHaveBeenCalled();
         });
     });
     describe('listCommand', () => {
@@ -199,53 +417,39 @@ describe('wt subcommand handlers', () => {
         });
         it('builder registers all expected options', () => {
             invokeBuilder(listCommand, []);
-            expect(true).toBe(true); // Builder executed for coverage
+            expect(true).toBe(true);
         });
-        it('passes --verbose flag to lswt', () => {
-            listCommand.handler({
-                verbose: true,
-                json: false,
-                'no-interactive': false,
-                status: false,
-            });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--verbose']), expect.any(Object));
+        it('calls gatherWorktreeInfo with verbose option', async () => {
+            await listCommand.handler({ verbose: true, json: false, status: false });
+            expect(gatherWorktreeInfo).toHaveBeenCalledWith('/fake/repo', expect.objectContaining({ verbose: true }), expect.any(Object));
         });
-        it('passes --json flag to lswt', () => {
-            listCommand.handler({
-                json: true,
-                verbose: false,
-                'no-interactive': false,
-                status: false,
-            });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--json']), expect.any(Object));
+        it('calls setJsonMode and formatJsonOutput for --json', async () => {
+            await listCommand.handler({ json: true, verbose: false, status: false });
+            expect(setJsonMode).toHaveBeenCalledWith(true);
+            expect(formatJsonOutput).toHaveBeenCalled();
         });
-        it('passes --no-interactive flag to lswt', () => {
-            listCommand.handler({
-                'no-interactive': true,
+        it('calls printWorktreeTable for non-interactive non-json output', async () => {
+            await listCommand.handler({
                 json: false,
                 verbose: false,
                 status: false,
+                interactive: false,
             });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--no-interactive']), expect.any(Object));
+            expect(printWorktreeTable).toHaveBeenCalled();
         });
-        it('passes --interactive flag to lswt', () => {
-            listCommand.handler({
-                interactive: true,
-                json: false,
-                verbose: false,
-                status: false,
-                'no-interactive': false,
-            });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--interactive']), expect.any(Object));
+        it('passes status option to gatherWorktreeInfo', async () => {
+            await listCommand.handler({ status: true, json: false, verbose: false });
+            expect(gatherWorktreeInfo).toHaveBeenCalledWith('/fake/repo', expect.objectContaining({ showStatus: true }), expect.any(Object));
         });
-        it('passes --status flag to lswt', () => {
-            listCommand.handler({
-                status: true,
+        it('does not spawn a child process', async () => {
+            vi.mocked(spawnSync).mockClear();
+            await listCommand.handler({
                 json: false,
                 verbose: false,
-                'no-interactive': false,
+                status: false,
+                interactive: false,
             });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--status']), expect.any(Object));
+            expect(spawnSync).not.toHaveBeenCalled();
         });
     });
     describe('cleanCommand', () => {
@@ -255,64 +459,58 @@ describe('wt subcommand handlers', () => {
         });
         it('builder registers all expected options', () => {
             invokeBuilder(cleanCommand, []);
-            expect(true).toBe(true); // Builder executed for coverage
+            expect(true).toBe(true);
         });
-        it('passes pr-number to cleanpr', () => {
-            cleanCommand.handler({
-                prNumber: 42,
-                all: false,
+        it('calls gatherPrWorktreeInfo for --all mode', async () => {
+            await cleanCommand.handler({
+                all: true,
                 'dry-run': false,
                 force: false,
                 json: false,
             });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['42']), expect.any(Object));
+            expect(gatherPrWorktreeInfo).toHaveBeenCalledWith('/fake/repo', '{repo}.pr{number}', expect.any(Object));
+            expect(getCleanableWorktrees).toHaveBeenCalled();
         });
-        it('passes --all flag to cleanpr', () => {
-            cleanCommand.handler({
+        it('calls setJsonMode when --json is passed', async () => {
+            await cleanCommand.handler({
                 all: true,
                 'dry-run': false,
                 force: false,
-                json: false,
+                json: true,
             });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--all']), expect.any(Object));
+            expect(setJsonMode).toHaveBeenCalledWith(true);
         });
-        it('passes --dry-run flag to cleanpr', () => {
-            cleanCommand.handler({
-                'dry-run': true,
+        it('handles gh not installed error', async () => {
+            vi.mocked(github.isGhInstalled).mockReturnValueOnce(false);
+            await cleanCommand.handler({
                 all: false,
+                'dry-run': false,
                 force: false,
                 json: false,
             });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--dry-run']), expect.any(Object));
+            expect(printError).toHaveBeenCalledWith(expect.objectContaining({ title: expect.stringContaining('GitHub CLI') }));
+            expect(mockExit).toHaveBeenCalledWith(1);
         });
-        it('passes --force flag to cleanpr', () => {
-            cleanCommand.handler({
-                force: true,
+        it('handles not in git repo error', async () => {
+            vi.mocked(git.getRepoRoot).mockReturnValueOnce(null);
+            await cleanCommand.handler({
                 all: false,
                 'dry-run': false,
+                force: false,
                 json: false,
             });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--force']), expect.any(Object));
+            expect(printError).toHaveBeenCalledWith(expect.objectContaining({ title: expect.stringContaining('git repository') }));
+            expect(mockExit).toHaveBeenCalledWith(1);
         });
-        it('passes --json flag to cleanpr', () => {
-            cleanCommand.handler({
-                json: true,
-                all: false,
+        it('does not spawn a child process', async () => {
+            vi.mocked(spawnSync).mockClear();
+            await cleanCommand.handler({
+                all: true,
                 'dry-run': false,
                 force: false,
-                remote: false,
-            });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--json']), expect.any(Object));
-        });
-        it('passes --remote flag to cleanpr', () => {
-            cleanCommand.handler({
-                remote: true,
                 json: false,
-                all: false,
-                'dry-run': false,
-                force: false,
             });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--remote']), expect.any(Object));
+            expect(spawnSync).not.toHaveBeenCalled();
         });
     });
     describe('stateCommand', () => {
@@ -322,21 +520,31 @@ describe('wt subcommand handlers', () => {
         });
         it('builder registers all expected options', () => {
             invokeBuilder(stateCommand, []);
-            expect(true).toBe(true); // Builder executed for coverage
+            expect(true).toBe(true);
         });
-        it('passes --json flag to wtstate', () => {
-            stateCommand.handler({
-                json: true,
-                verbose: false,
-            });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--json']), expect.any(Object));
+        it('calls analyzeState and formatJsonResult for --json', async () => {
+            await stateCommand.handler({ json: true, verbose: false });
+            expect(analyzeState).toHaveBeenCalledWith(expect.objectContaining({ json: true, verbose: false }));
+            expect(createSuccessResult).toHaveBeenCalledWith('wtstate', expect.any(Object));
+            expect(formatJsonResult).toHaveBeenCalled();
         });
-        it('passes --verbose flag to wtstate', () => {
-            stateCommand.handler({
-                verbose: true,
+        it('calls analyzeState and formatText for text output', async () => {
+            await stateCommand.handler({ verbose: true, json: false });
+            expect(analyzeState).toHaveBeenCalledWith(expect.objectContaining({ verbose: true, json: false }));
+            expect(formatText).toHaveBeenCalled();
+        });
+        it('passes base-branch option to analyzeState', async () => {
+            await stateCommand.handler({
+                verbose: false,
                 json: false,
+                'base-branch': 'develop',
             });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--verbose']), expect.any(Object));
+            expect(analyzeState).toHaveBeenCalledWith(expect.objectContaining({ baseBranch: 'develop' }));
+        });
+        it('does not spawn a child process', async () => {
+            vi.mocked(spawnSync).mockClear();
+            await stateCommand.handler({ json: false, verbose: false });
+            expect(spawnSync).not.toHaveBeenCalled();
         });
     });
     describe('configCommand', () => {
@@ -346,32 +554,10 @@ describe('wt subcommand handlers', () => {
         });
         it('builder registers positional args', () => {
             invokeBuilder(configCommand, []);
-            expect(true).toBe(true); // Builder executed for coverage
-        });
-        it('passes subcommand to wtconfig', () => {
-            configCommand.handler({
-                subcommand: 'show',
-                args: [],
-            });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['show']), expect.any(Object));
-        });
-        it('passes subcommand and args to wtconfig', () => {
-            configCommand.handler({
-                subcommand: 'set',
-                args: ['baseBranch', 'develop'],
-            });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['set', 'baseBranch', 'develop']), expect.any(Object));
+            expect(true).toBe(true);
         });
         it('handles no subcommand (defaults to interactive)', async () => {
-            // The interactive mode calls git.getRepoRoot() first
-            // Since we're not in a git repo in tests, it will error out
-            // We just verify the handler runs without throwing
-            const handler = configCommand.handler({
-                subcommand: undefined,
-                args: [],
-            });
-            // Handler is now async; it will call process.exit
-            // We just check it returns a promise
+            const handler = configCommand.handler({ subcommand: undefined, args: [] });
             expect(handler).toBeInstanceOf(Promise);
         });
     });
@@ -382,10 +568,10 @@ describe('wt subcommand handlers', () => {
         });
         it('builder registers all expected options', () => {
             invokeBuilder(linkCommand, []);
-            expect(true).toBe(true); // Builder executed for coverage
+            expect(true).toBe(true);
         });
-        it('passes subcommand and args to wtlink', () => {
-            linkCommand.handler({
+        it('calls link.run with source and destination for link subcommand', async () => {
+            await linkCommand.handler({
                 subcommand: 'link',
                 args: ['source', 'dest'],
                 'dry-run': false,
@@ -394,65 +580,66 @@ describe('wt subcommand handlers', () => {
                 json: false,
                 verbose: false,
             });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['link', 'source', 'dest']), expect.any(Object));
+            expect(linkRun).toHaveBeenCalledWith(expect.objectContaining({
+                source: 'source',
+                destination: 'dest',
+                dryRun: false,
+                yes: false,
+            }));
         });
-        it('passes --dry-run flag to wtlink', () => {
-            linkCommand.handler({
-                'dry-run': true,
+        it('passes --dry-run to link.run', async () => {
+            await linkCommand.handler({
+                subcommand: 'link',
                 args: [],
+                'dry-run': true,
                 yes: false,
                 'non-interactive': false,
                 json: false,
                 verbose: false,
             });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--dry-run']), expect.any(Object));
+            expect(linkRun).toHaveBeenCalledWith(expect.objectContaining({ dryRun: true }));
         });
-        it('passes --yes flag to wtlink', () => {
-            linkCommand.handler({
-                yes: true,
+        it('passes --yes to link.run', async () => {
+            await linkCommand.handler({
+                subcommand: 'link',
                 args: [],
                 'dry-run': false,
+                yes: true,
                 'non-interactive': false,
                 json: false,
                 verbose: false,
             });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--yes']), expect.any(Object));
-        });
-        it('passes --non-interactive flag to wtlink', () => {
-            linkCommand.handler({
-                'non-interactive': true,
-                args: [],
-                'dry-run': false,
-                yes: false,
-                json: false,
-                verbose: false,
-            });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--non-interactive']), expect.any(Object));
+            expect(linkRun).toHaveBeenCalledWith(expect.objectContaining({ yes: true }));
         });
-        it('passes --json flag to wtlink', () => {
-            linkCommand.handler({
-                json: true,
+        it('calls setJsonMode when --json is passed', async () => {
+            await linkCommand.handler({
+                subcommand: 'link',
                 args: [],
                 'dry-run': false,
                 yes: false,
                 'non-interactive': false,
+                json: true,
                 verbose: false,
             });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--json']), expect.any(Object));
+            expect(setJsonMode).toHaveBeenCalledWith(true);
         });
-        it('passes --verbose flag to wtlink', () => {
-            linkCommand.handler({
-                verbose: true,
+        it('calls manage.run with verbose option for manage subcommand', async () => {
+            await linkCommand.handler({
+                subcommand: 'manage',
                 args: [],
                 'dry-run': false,
                 yes: false,
                 'non-interactive': false,
                 json: false,
+                verbose: true,
+                clean: false,
+                backup: false,
             });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--verbose']), expect.any(Object));
+            expect(manageRun).toHaveBeenCalledWith(expect.objectContaining({ verbose: true }));
         });
-        it('passes --manifest-file flag to wtlink', () => {
-            linkCommand.handler({
+        it('passes --manifest-file to manage.run', async () => {
+            await linkCommand.handler({
+                subcommand: 'manage',
                 'manifest-file': '.custom-manifest',
                 args: [],
                 'dry-run': false,
@@ -460,11 +647,13 @@ describe('wt subcommand handlers', () => {
                 'non-interactive': false,
                 json: false,
                 verbose: false,
+                clean: false,
+                backup: false,
             });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--manifest-file', '.custom-manifest']), expect.any(Object));
+            expect(manageRun).toHaveBeenCalledWith(expect.objectContaining({ manifestFile: '.custom-manifest' }));
         });
-        it('handles no subcommand (defaults to interactive)', () => {
-            linkCommand.handler({
+        it('shows interactive menu when no subcommand provided', async () => {
+            await linkCommand.handler({
                 args: [],
                 'dry-run': false,
                 yes: false,
@@ -474,10 +663,11 @@ describe('wt subcommand handlers', () => {
                 clean: false,
                 backup: false,
             });
-            expect(spawnSync).toHaveBeenCalled();
+            expect(showMainMenu).toHaveBeenCalled();
         });
-        it('passes --clean flag to wtlink', () => {
-            linkCommand.handler({
+        it('passes --clean to manage.run', async () => {
+            await linkCommand.handler({
+                subcommand: 'manage',
                 clean: true,
                 args: [],
                 'dry-run': false,
@@ -487,10 +677,11 @@ describe('wt subcommand handlers', () => {
                 verbose: false,
                 backup: false,
             });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--clean']), expect.any(Object));
+            expect(manageRun).toHaveBeenCalledWith(expect.objectContaining({ clean: true }));
         });
-        it('passes --backup flag to wtlink', () => {
-            linkCommand.handler({
+        it('passes --backup to manage.run', async () => {
+            await linkCommand.handler({
+                subcommand: 'manage',
                 backup: true,
                 args: [],
                 'dry-run': false,
@@ -500,10 +691,11 @@ describe('wt subcommand handlers', () => {
                 verbose: false,
                 clean: false,
             });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--backup']), expect.any(Object));
+            expect(manageRun).toHaveBeenCalledWith(expect.objectContaining({ backup: true }));
         });
-        it('passes --type flag to wtlink', () => {
-            linkCommand.handler({
+        it('passes --type to link.run', async () => {
+            await linkCommand.handler({
+                subcommand: 'link',
                 type: 'symbolic',
                 args: [],
                 'dry-run': false,
@@ -514,7 +706,33 @@ describe('wt subcommand handlers', () => {
                 clean: false,
                 backup: false,
             });
-            expect(spawnSync).toHaveBeenCalledWith(process.execPath, expect.arrayContaining(['--type', 'symbolic']), expect.any(Object));
+            expect(linkRun).toHaveBeenCalledWith(expect.objectContaining({ type: 'symbolic' }));
+        });
+        it('calls validate.run for validate subcommand', async () => {
+            await linkCommand.handler({
+                subcommand: 'validate',
+                args: [],
+                'dry-run': false,
+                yes: false,
+                'non-interactive': false,
+                json: false,
+                verbose: false,
+            });
+            expect(validateRun).toHaveBeenCalled();
+        });
+        it('does not spawn a child process', async () => {
+            vi.mocked(spawnSync).mockClear();
+            await linkCommand.handler({
+                args: [],
+                'dry-run': false,
+                yes: false,
+                'non-interactive': false,
+                json: false,
+                verbose: false,
+                clean: false,
+                backup: false,
+            });
+            expect(spawnSync).not.toHaveBeenCalled();
         });
     });
 });