prompt-language-shell 0.8.4 → 0.8.6

package/dist/ui/Config.js

@@ -6,7 +6,7 @@ import { ComponentStatus } from '../types/components.js';
 import { FeedbackType } from '../types/types.js';
 import { Colors } from '../services/colors.js';
 import { createFeedback } from '../services/components.js';
-import { DebugLevel } from '../services/configuration.js';
+import { DebugLevel } from '../configuration/types.js';
 import { useInput } from '../services/keyboard.js';
 /**
  * Get postfix with debug brackets if debug is enabled
@@ -78,16 +78,52 @@ function SelectionStep({ options, selectedIndex, isCurrentStep, }) {
             return (_jsx(Box, { marginRight: 2, children: _jsx(Text, { dimColor: !isSelected || !isCurrentStep, bold: isSelected, children: option.label }) }, option.value));
         }) }));
 }
+export const ConfigView = ({ steps, state, status, debug = DebugLevel.None, onInputChange, onInputSubmit, }) => {
+    const isActive = status === ComponentStatus.Active;
+    const { values, completedStep, selectedIndex } = state;
+    const renderStepInput = (stepConfig, isCurrentStep) => {
+        const configKey = stepConfig.path || stepConfig.key;
+        const displayValue = values[configKey];
+        switch (stepConfig.type) {
+            case StepType.Text:
+                if (isCurrentStep && onInputChange && onInputSubmit) {
+                    return (_jsx(TextStep, { value: values[configKey] || '', placeholder: stepConfig.value || undefined, validate: stepConfig.validate, onChange: onInputChange, onSubmit: onInputSubmit }));
+                }
+                return (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: displayValue || '' }));
+            case StepType.Selection: {
+                if (!isCurrentStep) {
+                    const option = stepConfig.options.find((opt) => opt.value === displayValue);
+                    return _jsx(Text, { dimColor: true, children: option?.label || '' });
+                }
+                return (_jsx(SelectionStep, { options: stepConfig.options, selectedIndex: selectedIndex, isCurrentStep: true }));
+            }
+            default: {
+                const _exhaustiveCheck = stepConfig;
+                throw new Error('Unsupported step type');
+            }
+        }
+    };
+    return (_jsx(Box, { flexDirection: "column", marginLeft: 1, children: steps.map((stepConfig, index) => {
+            const isCurrentStep = index === completedStep && isActive;
+            const isCompleted = index < completedStep;
+            const wasAborted = index === completedStep && !isActive;
+            const shouldShow = isCompleted || isCurrentStep || wasAborted;
+            if (!shouldShow) {
+                return null;
+            }
+            const postfix = getPostfix(stepConfig.path, debug);
+            return (_jsxs(Box, { flexDirection: "column", marginTop: index === 0 ? 0 : 1, children: [_jsxs(Box, { children: [_jsx(Text, { children: stepConfig.description }), _jsx(Text, { children: ": " }), postfix && _jsx(Text, { color: Colors.Type.Config, children: postfix })] }), _jsxs(Box, { children: [_jsx(Text, { children: " " }), _jsx(Text, { color: Colors.Action.Select, dimColor: !isCurrentStep, children: ">" }), _jsx(Text, { children: " " }), renderStepInput(stepConfig, isCurrentStep)] })] }, stepConfig.path || stepConfig.key));
+        }) }));
+};
+/**
+ * Config controller: Multi-step wizard logic
+ */
 export function Config(props) {
-    const { steps, state, status, debug = DebugLevel.None, stateHandlers, lifecycleHandlers, onFinished, onAborted, } = props;
+    const { steps, status, debug = DebugLevel.None, requestHandlers, lifecycleHandlers, onFinished, onAborted, } = props;
     const isActive = status === ComponentStatus.Active;
-    const [step, setStep] = useState(!isActive ? (state?.completedStep ?? steps.length) : 0);
+    const [step, setStep] = useState(0);
     const [values, setValues] = useState(() => {
-        // If not active and we have saved state values, use those
-        if (!isActive && state?.values) {
-            return state.values;
-        }
-        // Otherwise initialize from step defaults
+        // Initialize from step defaults
         const initial = {};
         steps.forEach((stepConfig) => {
             // Use full path if available, otherwise use key
@@ -112,26 +148,14 @@ export function Config(props) {
     });
     const [inputValue, setInputValue] = useState(() => {
         // Initialize with the current step's value if available
-        if (isActive && step < steps.length) {
+        if (step < steps.length) {
             const stepConfig = steps[step];
             const configKey = stepConfig.path || stepConfig.key;
             return values[configKey] || '';
         }
         return '';
     });
-    const [selectedIndex, setSelectedIndex] = useState(() => {
-        // If not active, use saved state
-        if (!isActive && state?.selectedIndex !== undefined) {
-            return state.selectedIndex;
-        }
-        // Initialize selectedIndex based on current step's defaultIndex
-        if (isActive &&
-            step < steps.length &&
-            steps[step].type === StepType.Selection) {
-            return steps[step].defaultIndex;
-        }
-        return 0;
-    });
+    const [selectedIndex, setSelectedIndex] = useState(0);
     const normalizeValue = (value) => {
         if (value === null || value === undefined) {
             return '';
@@ -167,20 +191,21 @@ export function Config(props) {
                     throw new Error('Unsupported step type');
                 }
             }
-            if (currentValue) {
-                setValues({ ...values, [configKey]: currentValue });
-            }
-            // Save state before aborting
-            stateHandlers?.updateState({
-                values,
+            const finalValues = currentValue
+                ? { ...values, [configKey]: currentValue }
+                : values;
+            // Expose final state
+            const finalState = {
+                values: finalValues,
                 completedStep: step,
                 selectedIndex,
-            });
+            };
+            requestHandlers.onCompleted(finalState);
             if (onAborted) {
                 onAborted('configuration');
             }
             // Complete with abort feedback
-            lifecycleHandlers?.completeActive(createFeedback(FeedbackType.Aborted, 'Configuration cancelled.'));
+            lifecycleHandlers.completeActive(createFeedback(FeedbackType.Aborted, 'Configuration cancelled.'));
             return;
         }
         // Handle selection step navigation
@@ -192,7 +217,7 @@ export function Config(props) {
                 handleSubmit(currentStepConfig.options[selectedIndex].value);
             }
         }
-    });
+    }, { isActive });
     const handleSubmit = (value) => {
         const currentStepConfig = steps[step];
         let finalValue = '';
@@ -230,37 +255,29 @@ export function Config(props) {
         setInputValue('');
         if (step === steps.length - 1) {
             // Last step completed
-            // IMPORTANT: Update state BEFORE calling onFinished
-            // onFinished may call handlers.completeActive(), so state must be saved first
-            const stateUpdate = {
+            // Expose final state
+            const finalState = {
                 values: newValues,
                 completedStep: steps.length,
                 selectedIndex,
             };
-            stateHandlers?.updateState(stateUpdate);
+            requestHandlers.onCompleted(finalState);
             // Call onFinished callback and handle result
             try {
                 if (onFinished) {
                     onFinished(newValues);
                 }
                 // Success - complete with success feedback
-                lifecycleHandlers?.completeActive(createFeedback(FeedbackType.Succeeded, 'Configuration saved successfully.'));
+                lifecycleHandlers.completeActive(createFeedback(FeedbackType.Succeeded, 'Configuration saved successfully.'));
             }
             catch (error) {
                 // Failure - complete with error feedback
                 const errorMessage = error instanceof Error ? error.message : 'Configuration failed';
-                lifecycleHandlers?.completeActive(createFeedback(FeedbackType.Failed, errorMessage));
+                lifecycleHandlers.completeActive(createFeedback(FeedbackType.Failed, errorMessage));
             }
             setStep(steps.length);
         }
         else {
-            // Save state after each step
-            const stateUpdate = {
-                values: newValues,
-                completedStep: step + 1,
-                selectedIndex,
-            };
-            stateHandlers?.updateState(stateUpdate);
             const nextStep = step + 1;
             setStep(nextStep);
             // Reset selectedIndex for next step
@@ -270,39 +287,12 @@ export function Config(props) {
             }
         }
     };
-    const renderStepInput = (stepConfig, isCurrentStep) => {
-        const configKey = stepConfig.path || stepConfig.key;
-        // Use state values when inactive, local values when active
-        const displayValue = !isActive && state?.values ? state.values[configKey] : values[configKey];
-        switch (stepConfig.type) {
-            case StepType.Text:
-                if (isCurrentStep) {
-                    return (_jsx(TextStep, { value: inputValue, placeholder: stepConfig.value || undefined, validate: stepConfig.validate, onChange: setInputValue, onSubmit: handleSubmit }));
-                }
-                return (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: displayValue || '' }));
-            case StepType.Selection: {
-                if (!isCurrentStep) {
-                    // Find the option that matches the saved/current value
-                    const option = stepConfig.options.find((opt) => opt.value === displayValue);
-                    return _jsx(Text, { dimColor: true, children: option?.label || '' });
-                }
-                return (_jsx(SelectionStep, { options: stepConfig.options, selectedIndex: selectedIndex, isCurrentStep: true }));
-            }
-            default: {
-                const _exhaustiveCheck = stepConfig;
-                throw new Error('Unsupported step type');
-            }
-        }
+    // Build current state for View
+    // Controller always renders View, passing current state and callbacks
+    const state = {
+        values,
+        completedStep: step,
+        selectedIndex,
     };
-    return (_jsx(Box, { flexDirection: "column", marginLeft: 1, children: steps.map((stepConfig, index) => {
-            const isCurrentStep = index === step && isActive;
-            const isCompleted = index < step;
-            const wasAborted = index === step && !isActive;
-            const shouldShow = isCompleted || isCurrentStep || wasAborted;
-            if (!shouldShow) {
-                return null;
-            }
-            const postfix = getPostfix(stepConfig.path, debug);
-            return (_jsxs(Box, { flexDirection: "column", marginTop: index === 0 ? 0 : 1, children: [_jsxs(Box, { children: [_jsx(Text, { children: stepConfig.description }), _jsx(Text, { children: ": " }), postfix && _jsx(Text, { color: Colors.Type.Config, children: postfix })] }), _jsxs(Box, { children: [_jsx(Text, { children: " " }), _jsx(Text, { color: Colors.Action.Select, dimColor: !isCurrentStep, children: ">" }), _jsx(Text, { children: " " }), renderStepInput(stepConfig, isCurrentStep)] })] }, stepConfig.path || stepConfig.key));
-        }) }));
+    return (_jsx(ConfigView, { steps: steps, state: state, status: status, debug: debug, onInputChange: setInputValue, onInputSubmit: handleSubmit }));
 }

package/dist/ui/Confirm.js

@@ -1,31 +1,53 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState } from 'react';
 import { Box, Text } from 'ink';
-import { ComponentStatus } from '../types/components.js';
+import { ComponentStatus, } from '../types/components.js';
 import { Colors, getTextColor, Palette } from '../services/colors.js';
 import { useInput } from '../services/keyboard.js';
 import { UserQuery } from './UserQuery.js';
-export function Confirm({ message, state, status, stateHandlers, onConfirmed, onCancelled, }) {
+export const ConfirmView = ({ message, state, status }) => {
     const isActive = status === ComponentStatus.Active;
-    const [selectedIndex, setSelectedIndex] = useState(state?.selectedIndex ?? 0); // 0 = Yes, 1 = No
+    const { selectedIndex } = state;
+    const options = [
+        { label: 'yes', value: 'yes', color: Palette.BrightGreen },
+        { label: 'no', value: 'no', color: Colors.Status.Error },
+    ];
+    // Timeline rendering (Done status)
+    if (status === ComponentStatus.Done) {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, marginLeft: 1, children: _jsx(Text, { color: undefined, children: message }) }), _jsxs(UserQuery, { children: ["> ", options[selectedIndex].label] })] }));
+    }
+    // Active/Pending rendering
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, marginLeft: 1, children: _jsx(Text, { color: getTextColor(isActive), children: message }) }), _jsxs(Box, { marginLeft: 1, children: [_jsx(Text, { color: Colors.Action.Select, children: ">" }), _jsx(Text, { children: " " }), _jsx(Box, { children: options.map((option, index) => {
+                            const isSelected = index === selectedIndex;
+                            return (_jsx(Box, { marginRight: 2, children: _jsx(Text, { color: isSelected ? option.color : undefined, dimColor: !isSelected, children: option.label }) }, option.value));
+                        }) })] })] }));
+};
+/**
+ * Confirm controller: Manages yes/no selection
+ */
+export function Confirm({ message, status, requestHandlers, onConfirmed, onCancelled, }) {
+    const isActive = status === ComponentStatus.Active;
+    const [selectedIndex, setSelectedIndex] = useState(0); // 0 = Yes, 1 = No
     useInput((input, key) => {
         if (!isActive)
             return;
         if (key.escape) {
             // Escape: highlight "No" and cancel
-            setSelectedIndex(1);
-            stateHandlers?.updateState({ selectedIndex: 1 });
+            const finalState = { selectedIndex: 1, confirmed: false };
+            requestHandlers.onCompleted(finalState);
             onCancelled();
         }
         else if (key.tab) {
             // Toggle between Yes (0) and No (1)
-            const newIndex = selectedIndex === 0 ? 1 : 0;
-            setSelectedIndex(newIndex);
-            stateHandlers?.updateState({ selectedIndex: newIndex });
+            setSelectedIndex((prev) => (prev === 0 ? 1 : 0));
         }
         else if (key.return) {
             // Confirm selection
-            stateHandlers?.updateState({ selectedIndex, confirmed: true });
+            const finalState = {
+                selectedIndex,
+                confirmed: true,
+            };
+            requestHandlers.onCompleted(finalState);
             if (selectedIndex === 0) {
                 onConfirmed();
             }
@@ -34,16 +56,7 @@ export function Confirm({ message, state, status, stateHandlers, onConfirmed, on
             }
         }
     }, { isActive });
-    const options = [
-        { label: 'yes', value: 'yes', color: Palette.BrightGreen },
-        { label: 'no', value: 'no', color: Colors.Status.Error },
-    ];
-    if (!isActive) {
-        // When done, show both the message and user's choice in timeline
-        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, marginLeft: 1, children: _jsx(Text, { color: undefined, children: message }) }), _jsxs(UserQuery, { children: ["> ", options[selectedIndex].label] })] }));
-    }
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, marginLeft: 1, children: _jsx(Text, { color: getTextColor(isActive), children: message }) }), _jsxs(Box, { marginLeft: 1, children: [_jsx(Text, { color: Colors.Action.Select, children: ">" }), _jsx(Text, { children: " " }), _jsx(Box, { children: options.map((option, index) => {
-                            const isSelected = index === selectedIndex;
-                            return (_jsx(Box, { marginRight: 2, children: _jsx(Text, { color: isSelected ? option.color : undefined, dimColor: !isSelected, children: option.label }) }, option.value));
-                        }) })] })] }));
+    // Controller always renders View, passing current state
+    const state = { selectedIndex, confirmed: false };
+    return _jsx(ConfirmView, { message: message, state: state, status: status });
 }