ccmanager 0.2.0 → 0.2.1

package/dist/components/App.js

@@ -6,9 +6,11 @@ import NewWorktree from './NewWorktree.js';
 import DeleteWorktree from './DeleteWorktree.js';
 import MergeWorktree from './MergeWorktree.js';
 import Configuration from './Configuration.js';
+import PresetSelector from './PresetSelector.js';
 import { SessionManager } from '../services/sessionManager.js';
 import { WorktreeService } from '../services/worktreeService.js';
 import { shortcutManager } from '../services/shortcutManager.js';
+import { configurationManager } from '../services/configurationManager.js';
 const App = () => {
     const { exit } = useApp();
     const [view, setView] = useState('menu');
@@ -17,6 +19,7 @@ const App = () => {
     const [activeSession, setActiveSession] = useState(null);
     const [error, setError] = useState(null);
     const [menuKey, setMenuKey] = useState(0); // Force menu refresh
+    const [selectedWorktree, setSelectedWorktree] = useState(null); // Store selected worktree for preset selection
     useEffect(() => {
         // Listen for session exits to return to menu automatically
         const handleSessionExit = (session) => {
@@ -76,8 +79,15 @@ const App = () => {
         // Get or create session for this worktree
         let session = sessionManager.getSession(worktree.path);
         if (!session) {
+            // Check if we should show preset selector
+            if (configurationManager.getSelectPresetOnStart()) {
+                setSelectedWorktree(worktree);
+                setView('preset-selector');
+                return;
+            }
             try {
-                session = await sessionManager.createSession(worktree.path);
+                // Use preset-based session creation with default preset
+                session = await sessionManager.createSessionWithPreset(worktree.path);
             }
             catch (error) {
                 setError(`Failed to create session: ${error}`);
@@ -87,6 +97,27 @@ const App = () => {
         setActiveSession(session);
         setView('session');
     };
+    const handlePresetSelected = async (presetId) => {
+        if (!selectedWorktree)
+            return;
+        try {
+            // Create session with selected preset
+            const session = await sessionManager.createSessionWithPreset(selectedWorktree.path, presetId);
+            setActiveSession(session);
+            setView('session');
+            setSelectedWorktree(null);
+        }
+        catch (error) {
+            setError(`Failed to create session: ${error}`);
+            setView('menu');
+            setSelectedWorktree(null);
+        }
+    };
+    const handlePresetSelectorCancel = () => {
+        setSelectedWorktree(null);
+        setView('menu');
+        setMenuKey(prev => prev + 1);
+    };
     const handleReturnToMenu = () => {
         setActiveSession(null);
         setError(null);
@@ -229,6 +260,9 @@ const App = () => {
     if (view === 'configuration') {
         return React.createElement(Configuration, { onComplete: handleReturnToMenu });
     }
+    if (view === 'preset-selector') {
+        return (React.createElement(PresetSelector, { onSelect: handlePresetSelected, onCancel: handlePresetSelectorCancel }));
+    }
     return null;
 };
 export default App;

package/dist/components/ConfigureCommand.js

@@ -1,150 +1,240 @@
 import React, { useState } from 'react';
 import { Box, Text, useInput } from 'ink';
 import TextInput from 'ink-text-input';
+import SelectInput from 'ink-select-input';
 import { configurationManager } from '../services/configurationManager.js';
 import { shortcutManager } from '../services/shortcutManager.js';
 const ConfigureCommand = ({ onComplete }) => {
-    // Load current configuration once
-    const currentConfig = configurationManager.getCommandConfig();
-    const [originalConfig] = useState(currentConfig);
-    const [config, setConfig] = useState(currentConfig);
-    const [editMode, setEditMode] = useState('menu');
+    const presetsConfig = configurationManager.getCommandPresets();
+    const [presets, setPresets] = useState(presetsConfig.presets);
+    const [defaultPresetId, setDefaultPresetId] = useState(presetsConfig.defaultPresetId);
+    const [selectPresetOnStart, setSelectPresetOnStart] = useState(configurationManager.getSelectPresetOnStart());
+    const [viewMode, setViewMode] = useState('list');
+    const [selectedPresetId, setSelectedPresetId] = useState(null);
     const [selectedIndex, setSelectedIndex] = useState(0);
+    const [editField, setEditField] = useState(null);
     const [inputValue, setInputValue] = useState('');
-    const [hasChanges, setHasChanges] = useState(false);
-    const menuItems = [
-        {
-            label: 'Command',
-            value: config.command,
-            key: 'command',
-            isButton: false,
-            disabled: false,
-        },
-        {
-            label: 'Arguments',
-            value: config.args?.join(' ') || '(none)',
-            key: 'args',
-            isButton: false,
-            disabled: false,
-        },
-        {
-            label: 'Fallback Arguments',
-            value: config.fallbackArgs?.join(' ') || '(none)',
-            key: 'fallbackArgs',
-            isButton: false,
-            disabled: false,
-        },
-        {
-            label: hasChanges ? '💾 Save Changes' : '💾 Save Changes (no changes)',
-            value: '',
-            key: 'save',
-            isButton: true,
-            disabled: !hasChanges,
-        },
-        {
-            label: '❌ Exit Without Saving',
-            value: '',
-            key: 'exit',
-            isButton: true,
-            disabled: false,
-        },
-    ];
-    const handleMenuNavigation = (key) => {
+    const [newPreset, setNewPreset] = useState({});
+    const [addStep, setAddStep] = useState('name');
+    const [errorMessage, setErrorMessage] = useState(null);
+    // Remove handleListNavigation as SelectInput handles navigation internally
+    // Remove handleListSelection as we now use handleSelectItem
+    const handleEditNavigation = (key) => {
+        const menuItems = 7; // name, command, args, fallbackArgs, set default, delete, back
         if (key.upArrow) {
-            setSelectedIndex(prev => (prev > 0 ? prev - 1 : menuItems.length - 1));
+            setSelectedIndex(prev => (prev > 0 ? prev - 1 : menuItems - 1));
         }
         else if (key.downArrow) {
-            setSelectedIndex(prev => (prev < menuItems.length - 1 ? prev + 1 : 0));
+            setSelectedIndex(prev => (prev < menuItems - 1 ? prev + 1 : 0));
         }
     };
-    const getInitialInputValue = (key) => {
-        switch (key) {
+    const handleEditSelection = () => {
+        const preset = presets.find(p => p.id === selectedPresetId);
+        if (!preset)
+            return;
+        switch (selectedIndex) {
+            case 0: // Name
+                setEditField('name');
+                setInputValue(preset.name);
+                break;
+            case 1: // Command
+                setEditField('command');
+                setInputValue(preset.command);
+                break;
+            case 2: // Args
+                setEditField('args');
+                setInputValue(preset.args?.join(' ') || '');
+                break;
+            case 3: // Fallback Args
+                setEditField('fallbackArgs');
+                setInputValue(preset.fallbackArgs?.join(' ') || '');
+                break;
+            case 4: // Set as Default
+                setDefaultPresetId(preset.id);
+                configurationManager.setDefaultPreset(preset.id);
+                break;
+            case 5: // Delete
+                if (presets.length > 1) {
+                    setViewMode('delete-confirm');
+                    setSelectedIndex(0);
+                }
+                break;
+            case 6: // Back
+                setViewMode('list');
+                setSelectedIndex(presets.findIndex(p => p.id === selectedPresetId));
+                break;
+        }
+    };
+    const handleFieldUpdate = (value) => {
+        const preset = presets.find(p => p.id === selectedPresetId);
+        if (!preset || !editField)
+            return;
+        const updatedPreset = { ...preset };
+        switch (editField) {
+            case 'name':
+                // Prevent using "Default" as a name to avoid confusion
+                if (value.trim().toLowerCase() === 'default') {
+                    setErrorMessage('Cannot use "Default" as a preset name. Please choose a different name.');
+                    return;
+                }
+                updatedPreset.name = value;
+                break;
             case 'command':
-                return config.command;
+                updatedPreset.command = value || 'claude';
+                break;
             case 'args':
-                return config.args?.join(' ') || '';
+                updatedPreset.args = value.trim()
+                    ? value.trim().split(/\s+/)
+                    : undefined;
+                break;
             case 'fallbackArgs':
-                return config.fallbackArgs?.join(' ') || '';
-            default:
-                return '';
+                updatedPreset.fallbackArgs = value.trim()
+                    ? value.trim().split(/\s+/)
+                    : undefined;
+                break;
         }
+        const updatedPresets = presets.map(p => p.id === preset.id ? updatedPreset : p);
+        setPresets(updatedPresets);
+        configurationManager.addPreset(updatedPreset);
+        setEditField(null);
+        setInputValue('');
+        setErrorMessage(null);
     };
-    const handleMenuItemSelect = () => {
-        const selectedItem = menuItems[selectedIndex];
-        if (!selectedItem || selectedItem.disabled)
-            return;
-        switch (selectedItem.key) {
-            case 'save':
-                configurationManager.setCommandConfig(config);
-                onComplete();
+    const handleAddPresetInput = (value) => {
+        switch (addStep) {
+            case 'name':
+                // Prevent using "Default" as a name to avoid confusion
+                if (value.trim().toLowerCase() === 'default') {
+                    setErrorMessage('Cannot use "Default" as a preset name. Please choose a different name.');
+                    return;
+                }
+                setNewPreset({ ...newPreset, name: value });
+                setAddStep('command');
+                setInputValue('');
+                setErrorMessage(null);
                 break;
-            case 'exit':
-                onComplete();
+            case 'command':
+                setNewPreset({ ...newPreset, command: value || 'claude' });
+                setAddStep('args');
+                setInputValue('');
+                break;
+            case 'args': {
+                const args = value.trim() ? value.trim().split(/\s+/) : undefined;
+                setNewPreset({ ...newPreset, args });
+                setAddStep('fallbackArgs');
+                setInputValue('');
                 break;
-            default:
-                if (!selectedItem.isButton) {
-                    setEditMode(selectedItem.key);
-                    setInputValue(getInitialInputValue(selectedItem.key));
+            }
+            case 'fallbackArgs': {
+                const fallbackArgs = value.trim()
+                    ? value.trim().split(/\s+/)
+                    : undefined;
+                const id = Date.now().toString();
+                const completePreset = {
+                    id,
+                    name: newPreset.name || 'New Preset',
+                    command: newPreset.command || 'claude',
+                    args: newPreset.args,
+                    fallbackArgs,
+                };
+                const updatedPresets = [...presets, completePreset];
+                setPresets(updatedPresets);
+                configurationManager.addPreset(completePreset);
+                setViewMode('list');
+                setSelectedIndex(updatedPresets.length - 1);
+                break;
+            }
+        }
+    };
+    const handleDeleteConfirm = () => {
+        if (selectedIndex === 0) {
+            // Yes, delete
+            const newPresets = presets.filter(p => p.id !== selectedPresetId);
+            setPresets(newPresets);
+            // Update default if needed
+            if (defaultPresetId === selectedPresetId && newPresets.length > 0) {
+                const firstPreset = newPresets[0];
+                if (firstPreset) {
+                    setDefaultPresetId(firstPreset.id);
+                    configurationManager.setDefaultPreset(firstPreset.id);
                 }
+            }
+            configurationManager.deletePreset(selectedPresetId);
+            setViewMode('list');
+            setSelectedIndex(0);
+        }
+        else {
+            // Cancel
+            setViewMode('edit');
+            setSelectedIndex(5); // Back to delete option
         }
     };
     useInput((input, key) => {
-        // Handle cancel shortcut in any mode
         if (shortcutManager.matchesShortcut('cancel', input, key)) {
-            if (editMode === 'menu') {
-                onComplete(); // Exit without saving
+            if (editField) {
+                setEditField(null);
+                setInputValue('');
+                setErrorMessage(null);
+            }
+            else if (viewMode === 'edit') {
+                setViewMode('list');
+                setSelectedIndex(presets.findIndex(p => p.id === selectedPresetId));
+                setErrorMessage(null);
+            }
+            else if (viewMode === 'add') {
+                setViewMode('list');
+                setSelectedIndex(presets.length);
+                setErrorMessage(null);
+            }
+            else if (viewMode === 'delete-confirm') {
+                setViewMode('edit');
+                setSelectedIndex(5);
             }
             else {
-                setEditMode('menu');
-                setInputValue('');
+                onComplete();
             }
             return;
         }
-        // Handle menu mode inputs
-        if (editMode === 'menu') {
-            handleMenuNavigation(key);
+        if (editField || (viewMode === 'add' && inputValue !== undefined)) {
+            // In input mode, let TextInput handle it
+            return;
+        }
+        if (viewMode === 'list') {
+            // SelectInput handles navigation and selection
+            return;
+        }
+        else if (viewMode === 'edit') {
+            handleEditNavigation(key);
             if (key.return) {
-                handleMenuItemSelect();
+                handleEditSelection();
+            }
+        }
+        else if (viewMode === 'delete-confirm') {
+            if (key.upArrow || key.downArrow) {
+                setSelectedIndex(prev => (prev === 0 ? 1 : 0));
+            }
+            else if (key.return) {
+                handleDeleteConfirm();
             }
         }
     });
-    const handleInputSubmit = (value) => {
-        let updatedConfig = { ...config };
-        if (editMode === 'command') {
-            updatedConfig.command = value || 'claude';
-        }
-        else if (editMode === 'args') {
-            // Parse arguments, handling empty string as no arguments
-            const args = value.trim() ? value.trim().split(/\s+/) : undefined;
-            updatedConfig.args = args;
-        }
-        else if (editMode === 'fallbackArgs') {
-            // Parse fallback arguments, handling empty string as no arguments
-            const fallbackArgs = value.trim() ? value.trim().split(/\s+/) : undefined;
-            updatedConfig.fallbackArgs = fallbackArgs;
-        }
-        // Update state only (don't save to file yet)
-        setConfig(updatedConfig);
-        // Check if there are changes
-        const hasChanges = JSON.stringify(updatedConfig) !== JSON.stringify(originalConfig);
-        setHasChanges(hasChanges);
-        // Return to menu
-        setEditMode('menu');
-        setInputValue('');
-    };
-    if (editMode !== 'menu') {
+    // Render input field
+    if (editField) {
         const titles = {
+            name: 'Enter preset name:',
             command: 'Enter command (e.g., claude):',
             args: 'Enter command arguments (space-separated):',
             fallbackArgs: 'Enter fallback arguments (space-separated):',
         };
         return (React.createElement(Box, { flexDirection: "column" },
             React.createElement(Box, { marginBottom: 1 },
-                React.createElement(Text, { bold: true, color: "green" }, "Configure Command")),
+                React.createElement(Text, { bold: true, color: "green" }, "Edit Preset")),
             React.createElement(Box, { marginBottom: 1 },
-                React.createElement(Text, null, titles[editMode])),
+                React.createElement(Text, null, titles[editField])),
+            errorMessage && (React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { color: "red" }, errorMessage))),
             React.createElement(Box, null,
-                React.createElement(TextInput, { value: inputValue, onChange: setInputValue, onSubmit: handleInputSubmit, placeholder: editMode === 'args' || editMode === 'fallbackArgs'
+                React.createElement(TextInput, { value: inputValue, onChange: setInputValue, onSubmit: handleFieldUpdate, placeholder: editField === 'args' || editField === 'fallbackArgs'
                         ? 'e.g., --resume or leave empty'
                         : '' })),
             React.createElement(Box, { marginTop: 1 },
@@ -154,29 +244,185 @@ const ConfigureCommand = ({ onComplete }) => {
                     ' ',
                     "to cancel"))));
     }
+    // Render add preset form
+    if (viewMode === 'add') {
+        const titles = {
+            name: 'Enter preset name:',
+            command: 'Enter command (e.g., claude):',
+            args: 'Enter command arguments (space-separated):',
+            fallbackArgs: 'Enter fallback arguments (space-separated):',
+        };
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { bold: true, color: "green" }, "Add New Preset")),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, null, titles[addStep])),
+            errorMessage && (React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { color: "red" }, errorMessage))),
+            React.createElement(Box, null,
+                React.createElement(TextInput, { value: inputValue, onChange: setInputValue, onSubmit: handleAddPresetInput, placeholder: addStep === 'args' || addStep === 'fallbackArgs'
+                        ? 'e.g., --resume or leave empty'
+                        : addStep === 'name'
+                            ? 'e.g., Development'
+                            : '' })),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true },
+                    "Press Enter to continue,",
+                    ' ',
+                    shortcutManager.getShortcutDisplay('cancel'),
+                    " to cancel"))));
+    }
+    // Render delete confirmation
+    if (viewMode === 'delete-confirm') {
+        const preset = presets.find(p => p.id === selectedPresetId);
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { bold: true, color: "red" }, "Confirm Delete")),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, null,
+                    "Delete preset \"",
+                    preset?.name,
+                    "\"?")),
+            React.createElement(Box, { flexDirection: "column" },
+                React.createElement(Box, null,
+                    React.createElement(Text, { color: selectedIndex === 0 ? 'red' : undefined },
+                        selectedIndex === 0 ? '> ' : '  ',
+                        "Yes, delete")),
+                React.createElement(Box, null,
+                    React.createElement(Text, { color: selectedIndex === 1 ? 'cyan' : undefined },
+                        selectedIndex === 1 ? '> ' : '  ',
+                        "Cancel"))),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "Press \u2191\u2193 to navigate, Enter to confirm"))));
+    }
+    // Render edit preset view
+    if (viewMode === 'edit') {
+        const preset = presets.find(p => p.id === selectedPresetId);
+        if (!preset)
+            return null;
+        const isDefault = preset.id === defaultPresetId;
+        const canDelete = presets.length > 1;
+        const menuItems = [
+            { label: 'Name', value: preset.name },
+            { label: 'Command', value: preset.command },
+            { label: 'Arguments', value: preset.args?.join(' ') || '(none)' },
+            {
+                label: 'Fallback Arguments',
+                value: preset.fallbackArgs?.join(' ') || '(none)',
+            },
+            {
+                label: isDefault ? 'Already Default' : 'Set as Default',
+                value: '',
+                isButton: true,
+                disabled: isDefault,
+            },
+            {
+                label: canDelete
+                    ? 'Delete Preset'
+                    : 'Delete Preset (cannot delete last preset)',
+                value: '',
+                isButton: true,
+                disabled: !canDelete,
+            },
+            { label: 'Back to List', value: '', isButton: true, disabled: false },
+        ];
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { bold: true, color: "green" },
+                    "Edit Preset: ",
+                    preset.name)),
+            isDefault && (React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { color: "yellow" }, "\u2B50 This is the default preset"))),
+            React.createElement(Box, { flexDirection: "column" }, menuItems.map((item, index) => {
+                const isSelected = selectedIndex === index;
+                const color = item.disabled
+                    ? 'gray'
+                    : isSelected
+                        ? 'cyan'
+                        : undefined;
+                return (React.createElement(Box, { key: index, marginTop: item.isButton && index > 0 ? 1 : 0 },
+                    React.createElement(Text, { color: color },
+                        isSelected ? '> ' : '  ',
+                        item.isButton ? (React.createElement(Text, { bold: isSelected && !item.disabled, dimColor: item.disabled }, item.label)) : (`${item.label}: ${item.value}`))));
+            })),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true },
+                    "Press \u2191\u2193 to navigate, Enter to edit/select,",
+                    ' ',
+                    shortcutManager.getShortcutDisplay('cancel'),
+                    " to go back"))));
+    }
+    // Render preset list (default view)
+    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,
+            };
+        }),
+        { label: '─────────────────────────', value: 'separator1' },
+        {
+            label: `Select preset before session start: ${selectPresetOnStart ? '✅ Enabled' : '❌ Disabled'}`,
+            value: 'toggle-select-on-start',
+        },
+        { label: '─────────────────────────', value: 'separator2' },
+        { label: 'Add New Preset', value: 'add' },
+        { label: '← Cancel', value: 'exit' },
+    ];
+    const handleSelectItem = (item) => {
+        if (item.value === 'add') {
+            // Add New Preset
+            setViewMode('add');
+            setNewPreset({});
+            setAddStep('name');
+            setInputValue('');
+        }
+        else if (item.value === 'exit') {
+            // Exit
+            onComplete();
+        }
+        else if (item.value === 'toggle-select-on-start') {
+            // Toggle select preset on start
+            const newValue = !selectPresetOnStart;
+            setSelectPresetOnStart(newValue);
+            configurationManager.setSelectPresetOnStart(newValue);
+        }
+        else if (item.value.startsWith('separator')) {
+            // Ignore separator selections
+            return;
+        }
+        else {
+            // Selected a preset
+            const preset = presets.find(p => p.id === item.value);
+            if (preset) {
+                setSelectedPresetId(preset.id);
+                setViewMode('edit');
+                setSelectedIndex(0);
+            }
+        }
+    };
     return (React.createElement(Box, { flexDirection: "column" },
         React.createElement(Box, { marginBottom: 1 },
-            React.createElement(Text, { bold: true, color: "green" }, "Configure Command")),
+            React.createElement(Text, { bold: true, color: "green" }, "Command Presets")),
         React.createElement(Box, { marginBottom: 1 },
-            React.createElement(Text, { dimColor: true }, "Configure the command and arguments for running code sessions")),
-        hasChanges && (React.createElement(Box, { marginBottom: 1 },
-            React.createElement(Text, { color: "yellow" }, "\u26A0\uFE0F You have unsaved changes"))),
-        React.createElement(Box, { flexDirection: "column" }, menuItems.map((item, index) => {
-            const isSelected = selectedIndex === index;
-            const isDisabled = item.disabled || false;
-            const color = isDisabled ? 'gray' : isSelected ? 'cyan' : undefined;
-            return (React.createElement(Box, { key: item.key, marginTop: item.isButton && index > 0 ? 1 : 0 },
-                React.createElement(Text, { color: color },
-                    isSelected ? '> ' : '  ',
-                    item.isButton ? (React.createElement(Text, { bold: isSelected && !isDisabled, dimColor: isDisabled }, item.label)) : (`${item.label}: ${item.value}`))));
-        })),
+            React.createElement(Text, { dimColor: true }, "Configure command presets for running code sessions")),
+        React.createElement(SelectInput, { items: selectItems, onSelect: handleSelectItem, initialIndex: selectedIndex }),
         React.createElement(Box, { marginTop: 1 },
             React.createElement(Text, { dimColor: true },
-                "Press \u2191\u2193 to navigate, Enter to edit,",
+                "Press \u2191\u2193 to navigate, Enter to select,",
                 ' ',
                 shortcutManager.getShortcutDisplay('cancel'),
-                " to go back")),
-        React.createElement(Box, { marginTop: 1 },
-            React.createElement(Text, { dimColor: true }, "Note: If command fails with main args, fallback args will be tried"))));
+                " to exit"))));
 };
 export default ConfigureCommand;

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;