ccmanager 0.2.0 → 1.0.0

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/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 {};

package/dist/services/configurationManager.test.js

@@ -0,0 +1,313 @@
+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 - Command Presets', () => {
+    let configManager;
+    let mockConfigData;
+    beforeEach(() => {
+        // Reset all mocks
+        vi.clearAllMocks();
+        // Default mock config data
+        mockConfigData = {
+            shortcuts: {
+                returnToMenu: { ctrl: true, key: 'e' },
+                cancel: { key: 'escape' },
+            },
+            command: {
+                command: 'claude',
+                args: ['--existing'],
+            },
+        };
+        // 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('getCommandPresets', () => {
+        it('should return default presets when no presets are configured', () => {
+            // Remove command config for this test
+            delete mockConfigData.command;
+            configManager = new ConfigurationManager();
+            const presets = configManager.getCommandPresets();
+            expect(presets).toBeDefined();
+            expect(presets.presets).toHaveLength(1);
+            expect(presets.presets[0]).toEqual({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+            });
+            expect(presets.defaultPresetId).toBe('1');
+        });
+        it('should return configured presets', () => {
+            mockConfigData.commandPresets = {
+                presets: [
+                    { id: '1', name: 'Main', command: 'claude' },
+                    { id: '2', name: 'Development', command: 'claude', args: ['--resume'] },
+                ],
+                defaultPresetId: '2',
+            };
+            configManager = new ConfigurationManager();
+            const presets = configManager.getCommandPresets();
+            expect(presets.presets).toHaveLength(2);
+            expect(presets.defaultPresetId).toBe('2');
+        });
+        it('should migrate legacy command config to presets on first access', () => {
+            // Config has legacy command but no presets
+            mockConfigData.command = {
+                command: 'claude',
+                args: ['--resume'],
+                fallbackArgs: ['--no-mcp'],
+            };
+            delete mockConfigData.commandPresets;
+            configManager = new ConfigurationManager();
+            const presets = configManager.getCommandPresets();
+            expect(presets.presets).toHaveLength(1);
+            expect(presets.presets[0]).toEqual({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+                args: ['--resume'],
+                fallbackArgs: ['--no-mcp'],
+            });
+            expect(presets.defaultPresetId).toBe('1');
+            // Verify that writeFileSync was called to save the migration
+            expect(writeFileSync).toHaveBeenCalled();
+        });
+    });
+    describe('setCommandPresets', () => {
+        it('should save new presets configuration', () => {
+            const newPresets = {
+                presets: [
+                    { id: '1', name: 'Main', command: 'claude' },
+                    { id: '2', name: 'Custom', command: 'claude', args: ['--custom'] },
+                ],
+                defaultPresetId: '2',
+            };
+            configManager.setCommandPresets(newPresets);
+            expect(writeFileSync).toHaveBeenCalledWith(expect.stringContaining('config.json'), expect.stringContaining('commandPresets'));
+        });
+    });
+    describe('getDefaultPreset', () => {
+        it('should return the default preset', () => {
+            mockConfigData.commandPresets = {
+                presets: [
+                    { id: '1', name: 'Main', command: 'claude' },
+                    { id: '2', name: 'Custom', command: 'claude', args: ['--custom'] },
+                ],
+                defaultPresetId: '2',
+            };
+            configManager = new ConfigurationManager();
+            const defaultPreset = configManager.getDefaultPreset();
+            expect(defaultPreset).toEqual({
+                id: '2',
+                name: 'Custom',
+                command: 'claude',
+                args: ['--custom'],
+            });
+        });
+        it('should return first preset if defaultPresetId is invalid', () => {
+            mockConfigData.commandPresets = {
+                presets: [
+                    { id: '1', name: 'Main', command: 'claude' },
+                    { id: '2', name: 'Custom', command: 'claude', args: ['--custom'] },
+                ],
+                defaultPresetId: 'invalid',
+            };
+            configManager = new ConfigurationManager();
+            const defaultPreset = configManager.getDefaultPreset();
+            expect(defaultPreset).toEqual({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+            });
+        });
+    });
+    describe('getPresetById', () => {
+        it('should return preset by id', () => {
+            mockConfigData.commandPresets = {
+                presets: [
+                    { id: '1', name: 'Main', command: 'claude' },
+                    { id: '2', name: 'Custom', command: 'claude', args: ['--custom'] },
+                ],
+                defaultPresetId: '1',
+            };
+            configManager = new ConfigurationManager();
+            const preset = configManager.getPresetById('2');
+            expect(preset).toEqual({
+                id: '2',
+                name: 'Custom',
+                command: 'claude',
+                args: ['--custom'],
+            });
+        });
+        it('should return undefined for non-existent id', () => {
+            mockConfigData.commandPresets = {
+                presets: [{ id: '1', name: 'Main', command: 'claude' }],
+                defaultPresetId: '1',
+            };
+            configManager = new ConfigurationManager();
+            const preset = configManager.getPresetById('999');
+            expect(preset).toBeUndefined();
+        });
+    });
+    describe('addPreset', () => {
+        it('should add a new preset', () => {
+            mockConfigData.commandPresets = {
+                presets: [{ id: '1', name: 'Main', command: 'claude' }],
+                defaultPresetId: '1',
+            };
+            configManager = new ConfigurationManager();
+            const newPreset = {
+                id: '2',
+                name: 'New Preset',
+                command: 'claude',
+                args: ['--new'],
+            };
+            configManager.addPreset(newPreset);
+            const presets = configManager.getCommandPresets();
+            expect(presets.presets).toHaveLength(2);
+            expect(presets.presets[1]).toEqual(newPreset);
+        });
+        it('should replace preset with same id', () => {
+            mockConfigData.commandPresets = {
+                presets: [{ id: '1', name: 'Main', command: 'claude' }],
+                defaultPresetId: '1',
+            };
+            configManager = new ConfigurationManager();
+            const updatedPreset = {
+                id: '1',
+                name: 'Updated Default',
+                command: 'claude',
+                args: ['--updated'],
+            };
+            configManager.addPreset(updatedPreset);
+            const presets = configManager.getCommandPresets();
+            expect(presets.presets).toHaveLength(1);
+            expect(presets.presets[0]).toEqual(updatedPreset);
+        });
+    });
+    describe('deletePreset', () => {
+        it('should delete preset by id', () => {
+            mockConfigData.commandPresets = {
+                presets: [
+                    { id: '1', name: 'Main', command: 'claude' },
+                    { id: '2', name: 'Custom', command: 'claude', args: ['--custom'] },
+                ],
+                defaultPresetId: '1',
+            };
+            configManager = new ConfigurationManager();
+            configManager.deletePreset('2');
+            const presets = configManager.getCommandPresets();
+            expect(presets.presets).toHaveLength(1);
+            expect(presets.presets[0].id).toBe('1');
+        });
+        it('should not delete the last preset', () => {
+            mockConfigData.commandPresets = {
+                presets: [{ id: '1', name: 'Main', command: 'claude' }],
+                defaultPresetId: '1',
+            };
+            configManager = new ConfigurationManager();
+            configManager.deletePreset('1');
+            const presets = configManager.getCommandPresets();
+            expect(presets.presets).toHaveLength(1);
+        });
+        it('should update defaultPresetId if default preset is deleted', () => {
+            mockConfigData.commandPresets = {
+                presets: [
+                    { id: '1', name: 'Main', command: 'claude' },
+                    { id: '2', name: 'Custom', command: 'claude', args: ['--custom'] },
+                ],
+                defaultPresetId: '2',
+            };
+            configManager = new ConfigurationManager();
+            configManager.deletePreset('2');
+            const presets = configManager.getCommandPresets();
+            expect(presets.defaultPresetId).toBe('1');
+        });
+    });
+    describe('setDefaultPreset', () => {
+        it('should update default preset id', () => {
+            mockConfigData.commandPresets = {
+                presets: [
+                    { id: '1', name: 'Main', command: 'claude' },
+                    { id: '2', name: 'Custom', command: 'claude', args: ['--custom'] },
+                ],
+                defaultPresetId: '1',
+            };
+            configManager = new ConfigurationManager();
+            configManager.setDefaultPreset('2');
+            const presets = configManager.getCommandPresets();
+            expect(presets.defaultPresetId).toBe('2');
+        });
+        it('should not update if preset id does not exist', () => {
+            mockConfigData.commandPresets = {
+                presets: [{ id: '1', name: 'Main', command: 'claude' }],
+                defaultPresetId: '1',
+            };
+            configManager = new ConfigurationManager();
+            configManager.setDefaultPreset('999');
+            const presets = configManager.getCommandPresets();
+            expect(presets.defaultPresetId).toBe('1');
+        });
+    });
+    describe('backward compatibility', () => {
+        it('should maintain getCommandConfig for backward compatibility', () => {
+            mockConfigData.commandPresets = {
+                presets: [
+                    { id: '1', name: 'Main', command: 'claude', args: ['--resume'] },
+                    { id: '2', name: 'Custom', command: 'claude', args: ['--custom'] },
+                ],
+                defaultPresetId: '1',
+            };
+            configManager = new ConfigurationManager();
+            const commandConfig = configManager.getCommandConfig();
+            // Should return the default preset as CommandConfig
+            expect(commandConfig).toEqual({
+                command: 'claude',
+                args: ['--resume'],
+            });
+        });
+        it('should update default preset when setCommandConfig is called', () => {
+            mockConfigData.commandPresets = {
+                presets: [{ id: '1', name: 'Main', command: 'claude' }],
+                defaultPresetId: '1',
+            };
+            configManager = new ConfigurationManager();
+            const newConfig = {
+                command: 'claude',
+                args: ['--new-args'],
+                fallbackArgs: ['--new-fallback'],
+            };
+            configManager.setCommandConfig(newConfig);
+            const presets = configManager.getCommandPresets();
+            expect(presets.presets[0]).toEqual({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+                args: ['--new-args'],
+                fallbackArgs: ['--new-fallback'],
+            });
+        });
+    });
+});

package/dist/services/sessionManager.d.ts

@@ -1,15 +1,14 @@
 import { Session, SessionManager as ISessionManager, SessionState } from '../types/index.js';
 import { EventEmitter } from 'events';
-import pkg from '@xterm/headless';
-declare const Terminal: typeof pkg.Terminal;
 export declare class SessionManager extends EventEmitter implements ISessionManager {
     sessions: Map<string, Session>;
     private waitingWithBottomBorder;
     private busyTimers;
     private spawn;
-    detectTerminalState(terminal: InstanceType<typeof Terminal>): SessionState;
+    detectTerminalState(session: Session): SessionState;
     constructor();
     createSession(worktreePath: string): Promise<Session>;
+    createSessionWithPreset(worktreePath: string, presetId?: string): Promise<Session>;
     private setupDataHandler;
     private setupExitHandler;
     private setupBackgroundHandler;
@@ -21,4 +20,3 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private executeStatusHook;
     destroy(): void;
 }
-export {};