ccmanager 0.1.15 → 0.2.1

package/dist/components/Menu.js

@@ -2,16 +2,21 @@ import React, { useState, useEffect } from 'react';
 import { Box, Text, useInput } from 'ink';
 import SelectInput from 'ink-select-input';
 import { WorktreeService } from '../services/worktreeService.js';
-import { STATUS_ICONS, STATUS_LABELS, MENU_ICONS, getStatusDisplay, } from '../constants/statusIcons.js';
+import { STATUS_ICONS, STATUS_LABELS, MENU_ICONS, } from '../constants/statusIcons.js';
+import { useGitStatus } from '../hooks/useGitStatus.js';
+import { prepareWorktreeItems, calculateColumnPositions, assembleWorktreeLabel, } from '../utils/worktreeUtils.js';
 const Menu = ({ sessionManager, onSelectWorktree }) => {
-    const [worktrees, setWorktrees] = useState([]);
+    const [baseWorktrees, setBaseWorktrees] = useState([]);
+    const [defaultBranch, setDefaultBranch] = useState(null);
+    const worktrees = useGitStatus(baseWorktrees, defaultBranch);
     const [sessions, setSessions] = useState([]);
     const [items, setItems] = useState([]);
     useEffect(() => {
         // Load worktrees
         const worktreeService = new WorktreeService();
         const loadedWorktrees = worktreeService.getWorktrees();
-        setWorktrees(loadedWorktrees);
+        setBaseWorktrees(loadedWorktrees);
+        setDefaultBranch(worktreeService.getDefaultBranch());
         // Update sessions
         const updateSessions = () => {
             const allSessions = sessionManager.getAllSessions();
@@ -34,23 +39,18 @@ const Menu = ({ sessionManager, onSelectWorktree }) => {
         };
     }, [sessionManager]);
     useEffect(() => {
-        // Build menu items
-        const menuItems = worktrees.map((wt, index) => {
-            const session = sessions.find(s => s.worktreePath === wt.path);
-            let status = '';
-            if (session) {
-                status = ` [${getStatusDisplay(session.state)}]`;
-            }
-            const branchName = wt.branch
-                ? wt.branch.replace('refs/heads/', '')
-                : 'detached';
-            const isMain = wt.isMainWorktree ? ' (main)' : '';
+        // Prepare worktree items and calculate layout
+        const items = prepareWorktreeItems(worktrees, sessions);
+        const columnPositions = calculateColumnPositions(items);
+        // Build menu items with proper alignment
+        const menuItems = items.map((item, index) => {
+            const label = assembleWorktreeLabel(item, columnPositions);
             // Only show numbers for first 10 worktrees (0-9)
             const numberPrefix = index < 10 ? `${index} ❯ ` : '❯ ';
             return {
-                label: `${numberPrefix}${branchName}${isMain}${status}`,
-                value: wt.path,
-                worktree: wt,
+                label: numberPrefix + label,
+                value: item.worktree.path,
+                worktree: item.worktree,
             };
         });
         // Add menu options
@@ -79,7 +79,7 @@ const Menu = ({ sessionManager, onSelectWorktree }) => {
             value: 'exit',
         });
         setItems(menuItems);
-    }, [worktrees, sessions]);
+    }, [worktrees, sessions, defaultBranch]);
     // Handle hotkeys
     useInput((input, _key) => {
         const keyPressed = input.toLowerCase();

package/dist/components/PresetSelector.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface PresetSelectorProps {
+    onSelect: (presetId: string) => void;
+    onCancel: () => void;
+}
+declare const PresetSelector: React.FC<PresetSelectorProps>;
+export default PresetSelector;

package/dist/components/PresetSelector.js

@@ -0,0 +1,52 @@
+import React, { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import SelectInput from 'ink-select-input';
+import { configurationManager } from '../services/configurationManager.js';
+const PresetSelector = ({ onSelect, onCancel, }) => {
+    const presetsConfig = configurationManager.getCommandPresets();
+    const [presets] = useState(presetsConfig.presets);
+    const defaultPresetId = presetsConfig.defaultPresetId;
+    const selectItems = presets.map(preset => {
+        const isDefault = preset.id === defaultPresetId;
+        const args = preset.args?.join(' ') || '';
+        const fallback = preset.fallbackArgs?.join(' ') || '';
+        let label = preset.name;
+        if (isDefault)
+            label += ' (default)';
+        label += `\n    Command: ${preset.command}`;
+        if (args)
+            label += `\n    Args: ${args}`;
+        if (fallback)
+            label += `\n    Fallback: ${fallback}`;
+        return {
+            label,
+            value: preset.id,
+        };
+    });
+    // Add cancel option
+    selectItems.push({ label: '← Cancel', value: 'cancel' });
+    const handleSelectItem = (item) => {
+        if (item.value === 'cancel') {
+            onCancel();
+        }
+        else {
+            onSelect(item.value);
+        }
+    };
+    // Find initial index based on default preset
+    const initialIndex = selectItems.findIndex(item => item.value === defaultPresetId);
+    useInput((input, key) => {
+        if (key.escape) {
+            onCancel();
+        }
+    });
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "green" }, "Select Command Preset")),
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { dimColor: true }, "Choose a preset to start the session with")),
+        React.createElement(SelectInput, { items: selectItems, onSelect: handleSelectItem, initialIndex: initialIndex >= 0 ? initialIndex : 0 }),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true }, "Press \u2191\u2193 to navigate, Enter to select, ESC to cancel"))));
+};
+export default PresetSelector;

package/dist/hooks/useGitStatus.d.ts

@@ -0,0 +1,2 @@
+import { Worktree } from '../types/index.js';
+export declare function useGitStatus(worktrees: Worktree[], defaultBranch: string | null, updateInterval?: number): Worktree[];

package/dist/hooks/useGitStatus.js

@@ -0,0 +1,52 @@
+import { useEffect, useState } from 'react';
+import { getGitStatusLimited } from '../utils/gitStatus.js';
+export function useGitStatus(worktrees, defaultBranch, updateInterval = 5000) {
+    const [worktreesWithStatus, setWorktreesWithStatus] = useState(worktrees);
+    useEffect(() => {
+        if (!defaultBranch) {
+            return;
+        }
+        const timeouts = new Map();
+        const activeRequests = new Map();
+        let isCleanedUp = false;
+        const fetchStatus = async (worktree, abortController) => {
+            try {
+                const result = await getGitStatusLimited(worktree.path, abortController.signal);
+                if (result.data || result.error) {
+                    setWorktreesWithStatus(prev => prev.map(wt => wt.path === worktree.path
+                        ? { ...wt, gitStatus: result.data, gitStatusError: result.error }
+                        : wt));
+                }
+            }
+            catch {
+                // Ignore errors - the fetch failed or was aborted
+            }
+        };
+        const scheduleUpdate = (worktree) => {
+            const abortController = new AbortController();
+            activeRequests.set(worktree.path, abortController);
+            fetchStatus(worktree, abortController).finally(() => {
+                const isActive = () => !isCleanedUp && !abortController.signal.aborted;
+                if (isActive()) {
+                    const timeout = setTimeout(() => {
+                        if (isActive()) {
+                            scheduleUpdate(worktree);
+                        }
+                    }, updateInterval);
+                    timeouts.set(worktree.path, timeout);
+                }
+            });
+        };
+        setWorktreesWithStatus(worktrees);
+        // Start fetching for each worktree
+        worktrees.forEach(worktree => {
+            scheduleUpdate(worktree);
+        });
+        return () => {
+            isCleanedUp = true;
+            timeouts.forEach(timeout => clearTimeout(timeout));
+            activeRequests.forEach(controller => controller.abort());
+        };
+    }, [worktrees, defaultBranch, updateInterval]);
+    return worktreesWithStatus;
+}

package/dist/hooks/useGitStatus.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/useGitStatus.test.js

@@ -0,0 +1,186 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import React from 'react';
+import { render, cleanup } from 'ink-testing-library';
+import { Text } from 'ink';
+import { useGitStatus } from './useGitStatus.js';
+import { getGitStatusLimited } from '../utils/gitStatus.js';
+// Mock the gitStatus module
+vi.mock('../utils/gitStatus.js', () => ({
+    getGitStatusLimited: vi.fn(),
+}));
+describe('useGitStatus', () => {
+    const mockGetGitStatus = getGitStatusLimited;
+    const createWorktree = (path) => ({
+        path,
+        branch: 'main',
+        isMainWorktree: false,
+        hasSession: false,
+    });
+    const createGitStatus = (added = 1, deleted = 0) => ({
+        filesAdded: added,
+        filesDeleted: deleted,
+        aheadCount: 0,
+        behindCount: 0,
+        parentBranch: 'main',
+    });
+    beforeEach(() => {
+        vi.useFakeTimers();
+        mockGetGitStatus.mockClear();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+        cleanup();
+    });
+    // Main behavioral test
+    it('should fetch and update git status for worktrees', async () => {
+        const worktrees = [createWorktree('/path1'), createWorktree('/path2')];
+        const gitStatus1 = createGitStatus(5, 3);
+        const gitStatus2 = createGitStatus(2, 1);
+        let hookResult = [];
+        mockGetGitStatus.mockImplementation(async (path) => {
+            if (path === '/path1') {
+                return { success: true, data: gitStatus1 };
+            }
+            return { success: true, data: gitStatus2 };
+        });
+        const TestComponent = () => {
+            hookResult = useGitStatus(worktrees, 'main', 100);
+            return React.createElement(Text, null, 'test');
+        };
+        render(React.createElement(TestComponent));
+        // Should return worktrees immediately
+        expect(hookResult).toEqual(worktrees);
+        // Wait for status updates
+        await vi.waitFor(() => {
+            expect(hookResult[0]?.gitStatus).toBeDefined();
+            expect(hookResult[1]?.gitStatus).toBeDefined();
+        });
+        // Should have correct status for each worktree
+        expect(hookResult[0]?.gitStatus).toEqual(gitStatus1);
+        expect(hookResult[1]?.gitStatus).toEqual(gitStatus2);
+    });
+    it('should handle empty worktree array', () => {
+        let hookResult = [];
+        const TestComponent = () => {
+            hookResult = useGitStatus([], 'main');
+            return React.createElement(Text, null, 'test');
+        };
+        render(React.createElement(TestComponent));
+        expect(hookResult).toEqual([]);
+        expect(mockGetGitStatus).not.toHaveBeenCalled();
+    });
+    it('should not fetch when defaultBranch is null', async () => {
+        const worktrees = [createWorktree('/path1'), createWorktree('/path2')];
+        let hookResult = [];
+        const TestComponent = () => {
+            hookResult = useGitStatus(worktrees, null);
+            return React.createElement(Text, null, 'test');
+        };
+        render(React.createElement(TestComponent));
+        // Should return worktrees immediately without modification
+        expect(hookResult).toEqual(worktrees);
+        // Wait to ensure no fetches occur
+        await vi.advanceTimersByTimeAsync(1000);
+        expect(mockGetGitStatus).not.toHaveBeenCalled();
+    });
+    it('should continue polling after errors', async () => {
+        const worktrees = [createWorktree('/path1')];
+        mockGetGitStatus.mockResolvedValue({
+            success: false,
+            error: 'Git error',
+        });
+        const TestComponent = () => {
+            useGitStatus(worktrees, 'main', 100);
+            return React.createElement(Text, null, 'test');
+        };
+        render(React.createElement(TestComponent));
+        // Wait for initial fetch
+        await vi.waitFor(() => {
+            expect(mockGetGitStatus).toHaveBeenCalledTimes(1);
+        });
+        // Clear to track subsequent calls
+        mockGetGitStatus.mockClear();
+        // Advance time and verify polling continues despite errors
+        await vi.advanceTimersByTimeAsync(100);
+        expect(mockGetGitStatus).toHaveBeenCalledTimes(1);
+        await vi.advanceTimersByTimeAsync(100);
+        expect(mockGetGitStatus).toHaveBeenCalledTimes(2);
+        // All calls should have been made despite continuous errors
+        expect(mockGetGitStatus).toHaveBeenCalledWith('/path1', expect.any(AbortSignal));
+    });
+    it('should handle slow git operations that exceed update interval', async () => {
+        const worktrees = [createWorktree('/path1')];
+        let fetchCount = 0;
+        let resolveFetch = null;
+        mockGetGitStatus.mockImplementation(async () => {
+            fetchCount++;
+            // Create a promise that we can resolve manually
+            return new Promise(resolve => {
+                resolveFetch = resolve;
+            });
+        });
+        const TestComponent = () => {
+            useGitStatus(worktrees, 'main', 100);
+            return React.createElement(Text, null, 'test');
+        };
+        render(React.createElement(TestComponent));
+        // Wait for initial fetch to start
+        await vi.waitFor(() => {
+            expect(mockGetGitStatus).toHaveBeenCalledTimes(1);
+        });
+        // Advance time past the update interval while fetch is still pending
+        await vi.advanceTimersByTimeAsync(250);
+        // Should not have started a second fetch yet
+        expect(mockGetGitStatus).toHaveBeenCalledTimes(1);
+        // Complete the first fetch
+        resolveFetch({ success: true, data: createGitStatus(1, 0) });
+        // Wait for the promise to resolve
+        await vi.waitFor(() => {
+            expect(fetchCount).toBe(1);
+        });
+        // Now advance time by the update interval
+        await vi.advanceTimersByTimeAsync(100);
+        // Should have started the second fetch
+        await vi.waitFor(() => {
+            expect(mockGetGitStatus).toHaveBeenCalledTimes(2);
+        });
+    });
+    it('should properly cleanup resources when worktrees change', async () => {
+        let activeRequests = 0;
+        const abortedSignals = [];
+        mockGetGitStatus.mockImplementation(async (path, signal) => {
+            activeRequests++;
+            signal.addEventListener('abort', () => {
+                activeRequests--;
+                abortedSignals.push(signal);
+            });
+            // Simulate ongoing request
+            return new Promise(() => { });
+        });
+        const TestComponent = ({ worktrees }) => {
+            useGitStatus(worktrees, 'main', 100);
+            return React.createElement(Text, null, 'test');
+        };
+        // Start with 3 worktrees
+        const initialWorktrees = [
+            createWorktree('/path1'),
+            createWorktree('/path2'),
+            createWorktree('/path3'),
+        ];
+        const { rerender } = render(React.createElement(TestComponent, { worktrees: initialWorktrees }));
+        // Should have 3 active requests
+        await vi.waitFor(() => {
+            expect(activeRequests).toBe(3);
+        });
+        // Change to 2 different worktrees
+        const newWorktrees = [createWorktree('/path4'), createWorktree('/path5')];
+        rerender(React.createElement(TestComponent, { worktrees: newWorktrees }));
+        // Wait for cleanup and new requests
+        await vi.waitFor(() => {
+            expect(abortedSignals).toHaveLength(3);
+            expect(activeRequests).toBe(2);
+        });
+        // Verify all old signals were aborted
+        expect(abortedSignals.every(signal => signal.aborted)).toBe(true);
+    });
+});

package/dist/services/configurationManager.d.ts

@@ -1,4 +1,4 @@
-import { ConfigurationData, StatusHookConfig, ShortcutConfig, WorktreeConfig, CommandConfig } from '../types/index.js';
+import { ConfigurationData, StatusHookConfig, ShortcutConfig, WorktreeConfig, CommandConfig, CommandPreset, CommandPresetsConfig } from '../types/index.js';
 export declare class ConfigurationManager {
     private configPath;
     private legacyShortcutsPath;
@@ -17,5 +17,15 @@ export declare class ConfigurationManager {
     setWorktreeConfig(worktreeConfig: WorktreeConfig): void;
     getCommandConfig(): CommandConfig;
     setCommandConfig(commandConfig: CommandConfig): void;
+    private migrateLegacyCommandToPresets;
+    getCommandPresets(): CommandPresetsConfig;
+    setCommandPresets(presets: CommandPresetsConfig): void;
+    getDefaultPreset(): CommandPreset;
+    getPresetById(id: string): CommandPreset | undefined;
+    addPreset(preset: CommandPreset): void;
+    deletePreset(id: string): void;
+    setDefaultPreset(id: string): void;
+    getSelectPresetOnStart(): boolean;
+    setSelectPresetOnStart(enabled: boolean): void;
 }
 export declare const configurationManager: ConfigurationManager;

package/dist/services/configurationManager.js

@@ -73,6 +73,8 @@ export class ConfigurationManager {
                 command: 'claude',
             };
         }
+        // Migrate legacy command config to presets if needed
+        this.migrateLegacyCommandToPresets();
     }
     migrateLegacyShortcuts() {
         if (existsSync(this.legacyShortcutsPath)) {
@@ -131,13 +133,119 @@ export class ConfigurationManager {
         this.saveConfig();
     }
     getCommandConfig() {
-        return (this.config.command || {
-            command: 'claude',
-        });
+        // For backward compatibility, return the default preset as CommandConfig
+        const defaultPreset = this.getDefaultPreset();
+        return {
+            command: defaultPreset.command,
+            args: defaultPreset.args,
+            fallbackArgs: defaultPreset.fallbackArgs,
+        };
     }
     setCommandConfig(commandConfig) {
         this.config.command = commandConfig;
+        // Also update the default preset for backward compatibility
+        if (this.config.commandPresets) {
+            const defaultPreset = this.config.commandPresets.presets.find(p => p.id === this.config.commandPresets.defaultPresetId);
+            if (defaultPreset) {
+                defaultPreset.command = commandConfig.command;
+                defaultPreset.args = commandConfig.args;
+                defaultPreset.fallbackArgs = commandConfig.fallbackArgs;
+            }
+        }
+        this.saveConfig();
+    }
+    migrateLegacyCommandToPresets() {
+        // Only migrate if we have legacy command config but no presets
+        if (this.config.command && !this.config.commandPresets) {
+            const defaultPreset = {
+                id: '1',
+                name: 'Main',
+                command: this.config.command.command,
+                args: this.config.command.args,
+                fallbackArgs: this.config.command.fallbackArgs,
+            };
+            this.config.commandPresets = {
+                presets: [defaultPreset],
+                defaultPresetId: '1',
+            };
+            this.saveConfig();
+        }
+        // Ensure default presets if none exist
+        if (!this.config.commandPresets) {
+            this.config.commandPresets = {
+                presets: [
+                    {
+                        id: '1',
+                        name: 'Main',
+                        command: 'claude',
+                    },
+                ],
+                defaultPresetId: '1',
+            };
+        }
+    }
+    getCommandPresets() {
+        if (!this.config.commandPresets) {
+            this.migrateLegacyCommandToPresets();
+        }
+        return this.config.commandPresets;
+    }
+    setCommandPresets(presets) {
+        this.config.commandPresets = presets;
         this.saveConfig();
     }
+    getDefaultPreset() {
+        const presets = this.getCommandPresets();
+        const defaultPreset = presets.presets.find(p => p.id === presets.defaultPresetId);
+        // If default preset not found, return the first one
+        return defaultPreset || presets.presets[0];
+    }
+    getPresetById(id) {
+        const presets = this.getCommandPresets();
+        return presets.presets.find(p => p.id === id);
+    }
+    addPreset(preset) {
+        const presets = this.getCommandPresets();
+        // Replace if exists, otherwise add
+        const existingIndex = presets.presets.findIndex(p => p.id === preset.id);
+        if (existingIndex >= 0) {
+            presets.presets[existingIndex] = preset;
+        }
+        else {
+            presets.presets.push(preset);
+        }
+        this.setCommandPresets(presets);
+    }
+    deletePreset(id) {
+        const presets = this.getCommandPresets();
+        // Don't delete if it's the last preset
+        if (presets.presets.length <= 1) {
+            return;
+        }
+        // Remove the preset
+        presets.presets = presets.presets.filter(p => p.id !== id);
+        // Update default if needed
+        if (presets.defaultPresetId === id && presets.presets.length > 0) {
+            presets.defaultPresetId = presets.presets[0].id;
+        }
+        this.setCommandPresets(presets);
+    }
+    setDefaultPreset(id) {
+        const presets = this.getCommandPresets();
+        // Only update if preset exists
+        if (presets.presets.some(p => p.id === id)) {
+            presets.defaultPresetId = id;
+            this.setCommandPresets(presets);
+        }
+    }
+    getSelectPresetOnStart() {
+        const presets = this.getCommandPresets();
+        return presets.selectPresetOnStart ?? false;
+    }
+    setSelectPresetOnStart(enabled) {
+        const presets = this.getCommandPresets();
+        presets.selectPresetOnStart = enabled;
+        this.setCommandPresets(presets);
+    }
 }
 export const configurationManager = new ConfigurationManager();

package/dist/services/configurationManager.selectPresetOnStart.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/configurationManager.selectPresetOnStart.test.js

@@ -0,0 +1,103 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { ConfigurationManager } from './configurationManager.js';
+// Mock fs module
+vi.mock('fs', () => ({
+    existsSync: vi.fn(),
+    mkdirSync: vi.fn(),
+    readFileSync: vi.fn(),
+    writeFileSync: vi.fn(),
+}));
+// Mock os module
+vi.mock('os', () => ({
+    homedir: vi.fn(() => '/home/test'),
+}));
+describe('ConfigurationManager - selectPresetOnStart', () => {
+    let configManager;
+    let mockConfigData;
+    beforeEach(() => {
+        // Reset all mocks
+        vi.clearAllMocks();
+        // Default mock config data
+        mockConfigData = {
+            shortcuts: {
+                returnToMenu: { ctrl: true, key: 'e' },
+                cancel: { key: 'escape' },
+            },
+            commandPresets: {
+                presets: [
+                    {
+                        id: '1',
+                        name: 'Main',
+                        command: 'claude',
+                    },
+                    {
+                        id: '2',
+                        name: 'Development',
+                        command: 'claude',
+                        args: ['--resume'],
+                    },
+                ],
+                defaultPresetId: '1',
+            },
+        };
+        // Mock file system operations
+        existsSync.mockImplementation((path) => {
+            return path.includes('config.json');
+        });
+        readFileSync.mockImplementation(() => {
+            return JSON.stringify(mockConfigData);
+        });
+        mkdirSync.mockImplementation(() => { });
+        writeFileSync.mockImplementation(() => { });
+        // Create new instance for each test
+        configManager = new ConfigurationManager();
+    });
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
+    describe('getSelectPresetOnStart', () => {
+        it('should return false by default', () => {
+            const result = configManager.getSelectPresetOnStart();
+            expect(result).toBe(false);
+        });
+        it('should return true when configured', () => {
+            mockConfigData.commandPresets.selectPresetOnStart = true;
+            configManager = new ConfigurationManager();
+            const result = configManager.getSelectPresetOnStart();
+            expect(result).toBe(true);
+        });
+        it('should return false when explicitly set to false', () => {
+            mockConfigData.commandPresets.selectPresetOnStart = false;
+            configManager = new ConfigurationManager();
+            const result = configManager.getSelectPresetOnStart();
+            expect(result).toBe(false);
+        });
+    });
+    describe('setSelectPresetOnStart', () => {
+        it('should set selectPresetOnStart to true', () => {
+            configManager.setSelectPresetOnStart(true);
+            const result = configManager.getSelectPresetOnStart();
+            expect(result).toBe(true);
+            // Verify that config was saved
+            expect(writeFileSync).toHaveBeenCalledWith(expect.stringContaining('config.json'), expect.stringContaining('"selectPresetOnStart": true'));
+        });
+        it('should set selectPresetOnStart to false', () => {
+            // First set to true
+            configManager.setSelectPresetOnStart(true);
+            // Then set to false
+            configManager.setSelectPresetOnStart(false);
+            const result = configManager.getSelectPresetOnStart();
+            expect(result).toBe(false);
+            // Verify that config was saved
+            expect(writeFileSync).toHaveBeenLastCalledWith(expect.stringContaining('config.json'), expect.stringContaining('"selectPresetOnStart": false'));
+        });
+        it('should preserve other preset configuration when setting selectPresetOnStart', () => {
+            configManager.setSelectPresetOnStart(true);
+            const presets = configManager.getCommandPresets();
+            expect(presets.presets).toHaveLength(2);
+            expect(presets.defaultPresetId).toBe('1');
+            expect(presets.selectPresetOnStart).toBe(true);
+        });
+    });
+});

package/dist/services/configurationManager.test.d.ts

@@ -0,0 +1 @@
+export {};