ccmanager 0.2.0 → 1.0.0

package/dist/components/ConfigureCommand.js

@@ -1,150 +1,298 @@
 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 formatDetectionStrategy = (strategy) => {
+    const value = strategy || 'claude';
+    return value === 'gemini' ? 'Gemini' : 'Claude';
+};
 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) => {
-        if (key.upArrow) {
-            setSelectedIndex(prev => (prev > 0 ? prev - 1 : menuItems.length - 1));
+    const [isSelectingStrategy, setIsSelectingStrategy] = useState(false);
+    const [isSelectingStrategyInAdd, setIsSelectingStrategyInAdd] = useState(false);
+    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 handleEditMenuSelect = (item) => {
+        // Ignore separator selections
+        if (item.value.startsWith('separator')) {
+            return;
         }
-        else if (key.downArrow) {
-            setSelectedIndex(prev => (prev < menuItems.length - 1 ? prev + 1 : 0));
+        const preset = presets.find(p => p.id === selectedPresetId);
+        if (!preset)
+            return;
+        switch (item.value) {
+            case 'name':
+                setEditField('name');
+                setInputValue(preset.name);
+                break;
+            case 'command':
+                setEditField('command');
+                setInputValue(preset.command);
+                break;
+            case 'args':
+                setEditField('args');
+                setInputValue(preset.args?.join(' ') || '');
+                break;
+            case 'fallbackArgs':
+                setEditField('fallbackArgs');
+                setInputValue(preset.fallbackArgs?.join(' ') || '');
+                break;
+            case 'detectionStrategy':
+                setIsSelectingStrategy(true);
+                break;
+            case 'setDefault':
+                setDefaultPresetId(preset.id);
+                configurationManager.setDefaultPreset(preset.id);
+                break;
+            case 'delete':
+                if (presets.length > 1) {
+                    setViewMode('delete-confirm');
+                    setSelectedIndex(0);
+                }
+                break;
+            case 'back':
+                setViewMode('list');
+                setSelectedIndex(presets.findIndex(p => p.id === selectedPresetId));
+                break;
         }
     };
-    const getInitialInputValue = (key) => {
-        switch (key) {
+    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;
+                setNewPreset({ ...newPreset, fallbackArgs });
+                setAddStep('detectionStrategy');
+                setIsSelectingStrategyInAdd(true);
+                break;
+            }
+        }
+    };
+    const handleStrategySelect = (item) => {
+        const preset = presets.find(p => p.id === selectedPresetId);
+        if (!preset)
+            return;
+        const updatedPreset = { ...preset };
+        updatedPreset.detectionStrategy = item.value;
+        const updatedPresets = presets.map(p => p.id === preset.id ? updatedPreset : p);
+        setPresets(updatedPresets);
+        configurationManager.addPreset(updatedPreset);
+        setIsSelectingStrategy(false);
+    };
+    const handleAddStrategySelect = (item) => {
+        const id = Date.now().toString();
+        const completePreset = {
+            id,
+            name: newPreset.name || 'New Preset',
+            command: newPreset.command || 'claude',
+            args: newPreset.args,
+            fallbackArgs: newPreset.fallbackArgs,
+            detectionStrategy: item.value,
+        };
+        const updatedPresets = [...presets, completePreset];
+        setPresets(updatedPresets);
+        configurationManager.addPreset(completePreset);
+        setViewMode('list');
+        setSelectedIndex(updatedPresets.length - 1);
+        setNewPreset({});
+        setAddStep('name');
+        setInputValue('');
+        setIsSelectingStrategyInAdd(false);
+        setErrorMessage(null);
+    };
+    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(6); // Back to delete option (index updated for new field)
         }
     };
     useInput((input, key) => {
-        // Handle cancel shortcut in any mode
         if (shortcutManager.matchesShortcut('cancel', input, key)) {
-            if (editMode === 'menu') {
-                onComplete(); // Exit without saving
+            if (isSelectingStrategy) {
+                setIsSelectingStrategy(false);
             }
-            else {
-                setEditMode('menu');
+            else if (isSelectingStrategyInAdd) {
+                setIsSelectingStrategyInAdd(false);
+                setViewMode('list');
+                setAddStep('name');
+                setNewPreset({});
+            }
+            else 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(6); // Updated index for delete option
             }
+            else {
+                onComplete();
+            }
+            return;
+        }
+        if (editField ||
+            (viewMode === 'add' &&
+                inputValue !== undefined &&
+                !isSelectingStrategyInAdd) ||
+            isSelectingStrategy ||
+            isSelectingStrategyInAdd) {
+            // In input mode, let TextInput or SelectInput handle it
+            return;
+        }
+        if (viewMode === 'list' || viewMode === 'edit') {
+            // SelectInput handles navigation and selection
             return;
         }
-        // Handle menu mode inputs
-        if (editMode === 'menu') {
-            handleMenuNavigation(key);
-            if (key.return) {
-                handleMenuItemSelect();
+        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 strategy selection
+    if (isSelectingStrategy) {
+        const preset = presets.find(p => p.id === selectedPresetId);
+        if (!preset)
+            return null;
+        const strategyItems = [
+            { label: 'Claude', value: 'claude' },
+            { label: 'Gemini', value: 'gemini' },
+        ];
+        const currentStrategy = preset.detectionStrategy || 'claude';
+        const initialIndex = strategyItems.findIndex(item => item.value === currentStrategy);
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { bold: true, color: "green" }, "Select Detection Strategy")),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, null, "Choose the state detection strategy for this preset:")),
+            React.createElement(SelectInput, { items: strategyItems, onSelect: handleStrategySelect, initialIndex: initialIndex }),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true },
+                    "Press Enter to select,",
+                    ' ',
+                    shortcutManager.getShortcutDisplay('cancel'),
+                    " to cancel"))));
+    }
+    // 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 +302,212 @@ const ConfigureCommand = ({ onComplete }) => {
                     ' ',
                     "to cancel"))));
     }
+    // Render add preset form
+    if (viewMode === 'add') {
+        if (isSelectingStrategyInAdd) {
+            const strategyItems = [
+                { label: 'Claude', value: 'claude' },
+                { label: 'Gemini', value: 'gemini' },
+            ];
+            return (React.createElement(Box, { flexDirection: "column" },
+                React.createElement(Box, { marginBottom: 1 },
+                    React.createElement(Text, { bold: true, color: "green" }, "Add New Preset - Detection Strategy")),
+                React.createElement(Box, { marginBottom: 1 },
+                    React.createElement(Text, null, "Choose the state detection strategy for this preset:")),
+                React.createElement(SelectInput, { items: strategyItems, onSelect: handleAddStrategySelect, initialIndex: 0 }),
+                React.createElement(Box, { marginTop: 1 },
+                    React.createElement(Text, { dimColor: true },
+                        "Press Enter to select,",
+                        ' ',
+                        shortcutManager.getShortcutDisplay('cancel'),
+                        " to cancel"))));
+        }
+        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 editMenuItems = [
+            {
+                label: `Name: ${preset.name}`,
+                value: 'name',
+            },
+            {
+                label: `Command: ${preset.command}`,
+                value: 'command',
+            },
+            {
+                label: `Arguments: ${preset.args?.join(' ') || '(none)'}`,
+                value: 'args',
+            },
+            {
+                label: `Fallback Arguments: ${preset.fallbackArgs?.join(' ') || '(none)'}`,
+                value: 'fallbackArgs',
+            },
+            {
+                label: `Detection Strategy: ${formatDetectionStrategy(preset.detectionStrategy)}`,
+                value: 'detectionStrategy',
+            },
+            { label: '─────────────────────────', value: 'separator1' },
+            {
+                label: isDefault ? '⭐ Already Default' : 'Set as Default',
+                value: 'setDefault',
+            },
+            {
+                label: canDelete
+                    ? 'Delete Preset'
+                    : 'Delete Preset (cannot delete last preset)',
+                value: 'delete',
+            },
+            { label: '─────────────────────────', value: 'separator2' },
+            { label: '← Back to List', value: 'back' },
+        ];
+        // Filter out disabled items for SelectInput
+        const selectableItems = editMenuItems.filter(item => {
+            if (item.value === 'setDefault' && isDefault)
+                return false;
+            if (item.value === 'delete' && !canDelete)
+                return false;
+            return true;
+        });
+        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(SelectInput, { items: selectableItems, onSelect: handleEditMenuSelect }),
+            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}`;
+            label += `\n    Detection: ${formatDetectionStrategy(preset.detectionStrategy)}`;
+            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;