prompt-language-shell 0.9.0 → 0.9.4

package/dist/{ui/Main.js → Main.js}

@@ -1,16 +1,17 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
-import { DebugLevel } from '../configuration/types.js';
-import { FeedbackType } from '../types/types.js';
-import { loadConfig, loadDebugSetting, saveConfig, saveDebugSetting, } from '../configuration/io.js';
-import { getConfigurationRequiredMessage } from '../configuration/messages.js';
-import { getMissingConfigKeys } from '../configuration/schema.js';
-import { unflattenConfig } from '../configuration/transformation.js';
-import { createAnthropicService } from '../services/anthropic.js';
-import { createCommandDefinition, createConfigDefinitionWithKeys, createFeedback, createMessage, createWelcomeDefinition, } from '../services/components.js';
-import { registerGlobalShortcut } from '../services/keyboard.js';
-import { initializeLogger, setDebugLevel } from '../services/logger.js';
-import { Workflow } from './Workflow.js';
+import { DebugLevel } from './configuration/types.js';
+import { FeedbackType } from './types/types.js';
+import { loadConfig, loadDebugSetting, saveConfig, saveDebugSetting, } from './configuration/io.js';
+import { getConfigurationRequiredMessage } from './configuration/messages.js';
+import { getMissingConfigKeys } from './configuration/schema.js';
+import { createConfigStepsFromSchema } from './configuration/steps.js';
+import { unflattenConfig } from './configuration/transformation.js';
+import { createAnthropicService } from './services/anthropic.js';
+import { createCommand, createConfig, createFeedback, createMessage, createWelcome, } from './services/components.js';
+import { registerGlobalShortcut } from './services/keyboard.js';
+import { initializeLogger, setDebugLevel } from './services/logger.js';
+import { Workflow } from './components/Workflow.js';
 export const Main = ({ app, command, serviceFactory = createAnthropicService, }) => {
     const [service, setService] = useState(null);
     const [initialQueue, setInitialQueue] = useState(null);
@@ -56,7 +57,9 @@ export const Main = ({ app, command, serviceFactory = createAnthropicService, })
                 const errorMessage = error instanceof Error
                     ? error.message
                     : 'Failed to initialize service';
-                setInitialQueue([createFeedback(FeedbackType.Failed, errorMessage)]);
+                setInitialQueue([
+                    createFeedback({ type: FeedbackType.Failed, message: errorMessage }),
+                ]);
             }
         }
         // If config is missing, service will be created after config completes
@@ -94,18 +97,22 @@ export const Main = ({ app, command, serviceFactory = createAnthropicService, })
                 // Config was cancelled
             };
             setInitialQueue([
-                createWelcomeDefinition(app),
-                createMessage(getConfigurationRequiredMessage()),
-                createConfigDefinitionWithKeys(missingKeys, handleConfigFinished, handleConfigAborted),
+                createWelcome({ app }),
+                createMessage({ text: getConfigurationRequiredMessage() }),
+                createConfig({
+                    steps: createConfigStepsFromSchema(missingKeys),
+                    onFinished: handleConfigFinished,
+                    onAborted: handleConfigAborted,
+                }),
             ]);
         }
         else if (service && command) {
             // Valid service exists and command provided - execute command
-            setInitialQueue([createCommandDefinition(command, service)]);
+            setInitialQueue([createCommand({ command, service })]);
         }
         else if (service && !command) {
             // Valid service exists, no command - show welcome
-            setInitialQueue([createWelcomeDefinition(app)]);
+            setInitialQueue([createWelcome({ app })]);
         }
         // Wait for service to be initialized before setting queue
     }, [app, command, service, initialQueue]);

package/dist/{ui → components}/Component.js

@@ -1,20 +1,21 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { memo } from 'react';
+import { ComponentStatus, } from '../types/components.js';
 import { ComponentName } from '../types/types.js';
-import { Answer, AnswerView } from './Answer.js';
-import { Command, CommandView } from './Command.js';
-import { Config, ConfigView } from './Config.js';
-import { Confirm, ConfirmView } from './Confirm.js';
-import { Debug } from './Debug.js';
-import { Execute, ExecuteView } from './Execute.js';
-import { Feedback } from './Feedback.js';
-import { Introspect, IntrospectView } from './Introspect.js';
-import { Message } from './Message.js';
-import { Refinement, RefinementView } from './Refinement.js';
-import { Report } from './Report.js';
-import { Schedule, ScheduleView } from './Schedule.js';
-import { Validate, ValidateView } from './Validate.js';
-import { Welcome } from './Welcome.js';
+import { Answer, AnswerView } from './controllers/Answer.js';
+import { Command, CommandView } from './controllers/Command.js';
+import { Config, ConfigView } from './controllers/Config.js';
+import { Confirm, ConfirmView } from './controllers/Confirm.js';
+import { Debug } from './views/Debug.js';
+import { Execute, ExecuteView, mapStateToViewProps, } from './controllers/Execute.js';
+import { Feedback } from './views/Feedback.js';
+import { Introspect, IntrospectView } from './controllers/Introspect.js';
+import { Message } from './views/Message.js';
+import { Refinement, RefinementView } from './controllers/Refinement.js';
+import { Report } from './views/Report.js';
+import { Schedule, ScheduleView } from './controllers/Schedule.js';
+import { Validate, ValidateView } from './controllers/Validate.js';
+import { Welcome } from './views/Welcome.js';
 /**
  * Render a simple component (no lifecycle management)
  */
@@ -74,16 +75,16 @@ export const ControllerComponent = memo(function ControllerComponent({ def, debu
             return (_jsx(Introspect, { tasks: tasks, service: service, children: children, requestHandlers: requestHandlers, lifecycleHandlers: lifecycleHandlers, workflowHandlers: workflowHandlers, status: status, debug: debug }));
         }
         case ComponentName.Answer: {
-            const { props: { question, service }, status, } = def;
-            return (_jsx(Answer, { question: question, service: service, requestHandlers: requestHandlers, lifecycleHandlers: lifecycleHandlers, workflowHandlers: workflowHandlers, status: status }));
+            const { props: { question, service, upcoming }, status, } = def;
+            return (_jsx(Answer, { question: question, service: service, upcoming: upcoming, requestHandlers: requestHandlers, lifecycleHandlers: lifecycleHandlers, workflowHandlers: workflowHandlers, status: status }));
         }
         case ComponentName.Validate: {
             const { props: { missingConfig, userRequest, service, onError, onValidationComplete, onAborted, }, status, } = def;
             return (_jsx(Validate, { missingConfig: missingConfig, userRequest: userRequest, service: service, onError: onError, onValidationComplete: onValidationComplete, onAborted: onAborted, requestHandlers: requestHandlers, lifecycleHandlers: lifecycleHandlers, workflowHandlers: workflowHandlers, status: status }));
         }
         case ComponentName.Execute: {
-            const { props: { tasks, service }, status, } = def;
-            return (_jsx(Execute, { tasks: tasks, service: service, requestHandlers: requestHandlers, lifecycleHandlers: lifecycleHandlers, workflowHandlers: workflowHandlers, status: status }));
+            const { props: { tasks, service, upcoming, label }, status, } = def;
+            return (_jsx(Execute, { tasks: tasks, service: service, upcoming: upcoming, label: label, requestHandlers: requestHandlers, lifecycleHandlers: lifecycleHandlers, workflowHandlers: workflowHandlers, status: status }));
         }
         default:
             throw new Error(`Unknown managed component: ${def.name}`);
@@ -96,7 +97,7 @@ export const ViewComponent = memo(function ViewComponent({ def, }) {
     switch (def.name) {
         case ComponentName.Confirm: {
             const { props: { message }, state, status, } = def;
-            return _jsx(ConfirmView, { message: message, state: state, status: status });
+            return (_jsx(ConfirmView, { status: status, message: message, selectedIndex: state.selectedIndex }));
         }
         case ComponentName.Config: {
             const { props: { steps }, state, status, } = def;
@@ -104,15 +105,18 @@ export const ViewComponent = memo(function ViewComponent({ def, }) {
         }
         case ComponentName.Schedule: {
             const { props: { message, tasks }, state, status, } = def;
-            return (_jsx(ScheduleView, { message: message, tasks: tasks, state: state, status: status }));
+            return (_jsx(ScheduleView, { status: status, message: message, tasks: tasks, highlightedIndex: state.highlightedIndex, currentDefineGroupIndex: state.currentDefineGroupIndex, completedSelections: state.completedSelections }));
         }
         case ComponentName.Execute: {
-            const { state, status } = def;
-            return _jsx(ExecuteView, { state: state, status: status });
+            const { props: { upcoming, label }, state, status, } = def;
+            const isActive = status === ComponentStatus.Active;
+            const viewProps = mapStateToViewProps(state, isActive, upcoming, label);
+            return _jsx(ExecuteView, { ...viewProps });
         }
         case ComponentName.Answer: {
-            const { props: { question }, state, status, } = def;
-            return _jsx(AnswerView, { question: question, state: state, status: status });
+            const { props: { question, upcoming }, state, status, } = def;
+            const lines = state.answer ? state.answer.split('\n') : null;
+            return (_jsx(AnswerView, { status: status, question: question, lines: lines, error: state.error, upcoming: upcoming, cancelled: state.cancelled }));
         }
         case ComponentName.Command: {
             const { props: { command }, state, status, } = def;
@@ -120,11 +124,12 @@ export const ViewComponent = memo(function ViewComponent({ def, }) {
         }
         case ComponentName.Introspect: {
             const { props: { children }, state, status, } = def;
-            return (_jsx(IntrospectView, { state: state, status: status, children: children }));
+            const hasCapabilities = state.capabilities.length > 0;
+            return (_jsx(IntrospectView, { status: status, hasCapabilities: hasCapabilities, error: state.error, children: children }));
         }
         case ComponentName.Validate: {
             const { state, status } = def;
-            return _jsx(ValidateView, { state: state, status: status });
+            return (_jsx(ValidateView, { status: status, completionMessage: state.completionMessage, error: state.error }));
         }
         case ComponentName.Refinement: {
             const { props: { text }, status, } = def;

package/dist/{ui → components}/Workflow.js

@@ -3,11 +3,19 @@ import { useCallback, useEffect, useMemo, useState } from 'react';
 import { Box, Static } from 'ink';
 import { ComponentStatus, } from '../types/components.js';
 import { ComponentName, FeedbackType } from '../types/types.js';
-import { createFeedback, isSimple, markAsDone, } from '../services/components.js';
+import { createFeedback } from '../services/components.js';
 import { getWarnings } from '../services/logger.js';
 import { getCancellationMessage } from '../services/messages.js';
 import { exitApp } from '../services/process.js';
 import { SimpleComponent, ControllerComponent, TimelineComponent, } from './Component.js';
+/**
+ * Mark a component as done. Returns the component to be added to timeline.
+ * Components use handlers.updateState to save their state before completion,
+ * so this function sets the status to Done and returns the updated component.
+ */
+function markAsDone(component) {
+    return { ...component, status: ComponentStatus.Done };
+}
 export const Workflow = ({ initialQueue, debug }) => {
     const [timeline, setTimeline] = useState([]);
     const [current, setCurrent] = useState({ active: null, pending: null });
@@ -39,17 +47,16 @@ export const Workflow = ({ initialQueue, debug }) => {
     const requestHandlers = useMemo(() => ({
         onError: (error) => {
             moveActiveToTimeline();
-            // Add feedback to queue
-            setQueue((queue) => [
-                ...queue,
-                createFeedback(FeedbackType.Failed, error),
+            // Clear queue and add only feedback to prevent subsequent components from executing
+            setQueue([
+                createFeedback({ type: FeedbackType.Failed, message: error }),
             ]);
         },
         onAborted: (operation) => {
             moveActiveToTimeline();
             // Clear queue and add only feedback to prevent subsequent components from executing
             const message = getCancellationMessage(operation);
-            setQueue([createFeedback(FeedbackType.Aborted, message)]);
+            setQueue([createFeedback({ type: FeedbackType.Aborted, message })]);
         },
         // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
         onCompleted: (finalState) => {
@@ -144,7 +151,7 @@ export const Workflow = ({ initialQueue, debug }) => {
     useEffect(() => {
         const warningMessages = getWarnings();
         if (warningMessages.length > 0) {
-            const warningComponents = warningMessages.map((msg) => markAsDone(createFeedback(FeedbackType.Warning, msg)));
+            const warningComponents = warningMessages.map((msg) => createFeedback({ type: FeedbackType.Warning, message: msg }, ComponentStatus.Done));
             setTimeline((prev) => [...prev, ...warningComponents]);
         }
     }, [timeline, current]);
@@ -187,3 +194,12 @@ export const Workflow = ({ initialQueue, debug }) => {
     const pendingComponent = useMemo(() => renderComponent(current.pending, ComponentStatus.Pending), [current.pending, renderComponent]);
     return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: timeline, children: (item) => (_jsx(Box, { marginTop: 1, children: _jsx(TimelineComponent, { def: item }) }, item.id)) }, "timeline"), pendingComponent && _jsx(Box, { marginTop: 1, children: pendingComponent }), activeComponent && _jsx(Box, { marginTop: 1, children: activeComponent })] }));
 };
+/**
+ * Check if a component is stateless (simple).
+ * Stateless components are display-only and complete immediately without
+ * tracking internal state. Stateful components manage user interaction
+ * and maintain state across their lifecycle.
+ */
+export function isSimple(component) {
+    return !('state' in component);
+}

package/dist/{ui → components/controllers}/Answer.js

@@ -1,28 +1,29 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
-import { Box, Text } from 'ink';
-import { ComponentStatus, } from '../types/components.js';
-import { Colors, getTextColor } from '../services/colors.js';
-import { useInput } from '../services/keyboard.js';
-import { formatErrorMessage } from '../services/messages.js';
-import { withMinimumTime } from '../services/timing.js';
-import { Spinner } from './Spinner.js';
+import { ComponentStatus, } from '../../types/components.js';
+import { useInput } from '../../services/keyboard.js';
+import { formatErrorMessage } from '../../services/messages.js';
+import { withMinimumTime } from '../../services/timing.js';
+import { AnswerView } from '../views/Answer.js';
+export { AnswerView } from '../views/Answer.js';
 const MINIMUM_PROCESSING_TIME = 400;
-export const AnswerView = ({ question, state, status }) => {
-    const isActive = status === ComponentStatus.Active;
-    const { error, answer } = state;
-    const lines = answer ? answer.split('\n') : [];
-    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isActive && !answer && !error && (_jsxs(Box, { marginLeft: 1, children: [_jsx(Text, { color: getTextColor(isActive), children: "Finding answer. " }), _jsx(Spinner, {})] })), answer && (_jsxs(_Fragment, { children: [_jsx(Box, { marginLeft: 1, marginBottom: 1, children: _jsx(Text, { color: getTextColor(isActive), children: question }) }), _jsx(Box, { flexDirection: "column", paddingLeft: 3, children: lines.map((line, index) => (_jsx(Text, { color: getTextColor(isActive), children: line }, index))) })] })), error && (_jsx(Box, { marginTop: 1, marginLeft: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) }))] }));
-};
 /**
  * Answer controller: Fetches answer from LLM
  */
-export function Answer({ question, status, service, requestHandlers, lifecycleHandlers, workflowHandlers, }) {
+export function Answer({ question, status, service, upcoming, requestHandlers, lifecycleHandlers, workflowHandlers, }) {
     const isActive = status === ComponentStatus.Active;
     const [error, setError] = useState(null);
     const [answer, setAnswer] = useState(null);
+    const [cancelled, setCancelled] = useState(false);
     useInput((input, key) => {
         if (key.escape && isActive) {
+            setCancelled(true);
+            const finalState = {
+                answer: null,
+                error: null,
+                cancelled: true,
+            };
+            requestHandlers.onCompleted(finalState);
             requestHandlers.onAborted('answer');
         }
     }, { isActive });
@@ -80,6 +81,6 @@ export function Answer({ question, status, service, requestHandlers, lifecycleHa
         lifecycleHandlers,
         workflowHandlers,
     ]);
-    const state = { error, answer };
-    return _jsx(AnswerView, { question: question, state: state, status: status });
+    const lines = answer ? answer.split('\n') : null;
+    return (_jsx(AnswerView, { status: status, question: question, lines: lines, error: error, upcoming: upcoming, cancelled: cancelled }));
 }

package/dist/{ui → components/controllers}/Command.js

@@ -1,23 +1,16 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
-import { Box, Text } from 'ink';
-import { ComponentStatus, } from '../types/components.js';
-import { TaskType } from '../types/types.js';
-import { Colors } from '../services/colors.js';
-import { createScheduleDefinition } from '../services/components.js';
-import { useInput } from '../services/keyboard.js';
-import { formatErrorMessage } from '../services/messages.js';
-import { handleRefinement } from '../services/refinement.js';
-import { routeTasksWithConfirm } from '../services/router.js';
-import { ensureMinimumTime } from '../services/timing.js';
-import { Spinner } from './Spinner.js';
-import { UserQuery } from './UserQuery.js';
+import { ComponentStatus, } from '../../types/components.js';
+import { TaskType } from '../../types/types.js';
+import { createSchedule } from '../../services/components.js';
+import { useInput } from '../../services/keyboard.js';
+import { formatErrorMessage } from '../../services/messages.js';
+import { handleRefinement } from '../../services/refinement.js';
+import { routeTasksWithConfirm } from '../../services/router.js';
+import { ensureMinimumTime } from '../../services/timing.js';
+import { CommandView } from '../views/Command.js';
+export { CommandView } from '../views/Command.js';
 const MIN_PROCESSING_TIME = 400; // purely for visual effect
-export const CommandView = ({ command, state, status }) => {
-    const isActive = status === ComponentStatus.Active;
-    const { error } = state;
-    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [!isActive ? (_jsxs(UserQuery, { children: ["> pls ", command] })) : (_jsxs(Box, { marginLeft: 1, children: [_jsxs(Text, { color: Colors.Text.Active, children: ["> pls ", command] }), _jsx(Text, { children: " " }), _jsx(Spinner, {})] })), error && (_jsx(Box, { marginTop: 1, marginLeft: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) }))] }));
-};
 /**
  * Command controller: Processes and routes command
  */
@@ -77,12 +70,16 @@ export function Command({ command, status, service, requestHandlers, lifecycleHa
                     // Check if tasks contain DEFINE type (variant selection needed)
                     const hasDefineTask = result.tasks.some((task) => task.type === TaskType.Define);
                     // Create Schedule definition
-                    const scheduleDefinition = createScheduleDefinition(result.message, result.tasks, hasDefineTask
-                        ? async (selectedTasks) => {
-                            // Refinement flow for DEFINE tasks
-                            await handleRefinement(selectedTasks, svc, command, lifecycleHandlers, workflowHandlers, requestHandlers);
-                        }
-                        : undefined);
+                    const scheduleDefinition = createSchedule({
+                        message: result.message,
+                        tasks: result.tasks,
+                        onSelectionConfirmed: hasDefineTask
+                            ? async (selectedTasks) => {
+                                // Refinement flow for DEFINE tasks
+                                await handleRefinement(selectedTasks, svc, command, lifecycleHandlers, workflowHandlers, requestHandlers);
+                            }
+                            : undefined,
+                    });
                     if (hasDefineTask) {
                         // DEFINE tasks: Move Command to timeline, add Schedule to queue
                         lifecycleHandlers.completeActive();

package/dist/{ui → components/controllers}/Config.js

@@ -1,120 +1,12 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
-import { Box, Text, useFocus } from 'ink';
-import TextInput from 'ink-text-input';
-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 '../configuration/types.js';
-import { useInput } from '../services/keyboard.js';
-/**
- * Get postfix with debug brackets if debug is enabled
- * Info: {key} | Verbose: {key} entry
- */
-function getPostfix(text, debugLevel) {
-    if (debugLevel === DebugLevel.None || !text) {
-        return '';
-    }
-    if (debugLevel === DebugLevel.Info) {
-        return `{${text}}`;
-    }
-    return `{${text}} entry`;
-}
-export var StepType;
-(function (StepType) {
-    StepType["Text"] = "text";
-    StepType["Selection"] = "selection";
-})(StepType || (StepType = {}));
-function TextStep({ value, placeholder, validate, onChange, onSubmit, }) {
-    const [inputValue, setInputValue] = useState(value);
-    const [validationFailed, setValidationFailed] = useState(false);
-    const { isFocused } = useFocus({ autoFocus: true });
-    // Sync internal state with prop changes
-    useEffect(() => {
-        setInputValue(value);
-    }, [value]);
-    const handleChange = (newValue) => {
-        setInputValue(newValue);
-        onChange(newValue);
-        if (validationFailed) {
-            setValidationFailed(false);
-        }
-    };
-    const handleSubmit = (value) => {
-        // Use placeholder if input is empty
-        const finalValue = value || placeholder || '';
-        if (!validate(finalValue)) {
-            setValidationFailed(true);
-            return;
-        }
-        onSubmit(finalValue);
-    };
-    // Handle input manually when validation fails
-    useInput((input, key) => {
-        if (!validationFailed)
-            return;
-        if (key.return) {
-            handleSubmit(inputValue);
-        }
-        else if (key.backspace || key.delete) {
-            const newValue = inputValue.slice(0, -1);
-            handleChange(newValue);
-        }
-        else if (!key.ctrl && !key.meta && input) {
-            const newValue = inputValue + input;
-            handleChange(newValue);
-        }
-    }, { isActive: validationFailed });
-    // When validation fails, show colored text
-    if (validationFailed) {
-        return (_jsxs(Text, { color: Colors.Status.Error, children: [inputValue || placeholder, isFocused && _jsx(Text, { inverse: true, children: " " })] }));
-    }
-    return (_jsx(TextInput, { value: inputValue, onChange: handleChange, onSubmit: handleSubmit, placeholder: placeholder }));
-}
-function SelectionStep({ options, selectedIndex, isCurrentStep, }) {
-    return (_jsx(Box, { children: options.map((option, optIndex) => {
-            const isSelected = optIndex === selectedIndex;
-            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));
-        }) }));
-};
+import { ComponentStatus } from '../../types/components.js';
+import { FeedbackType } from '../../types/types.js';
+import { createFeedback } from '../../services/components.js';
+import { DebugLevel } from '../../configuration/types.js';
+import { useInput } from '../../services/keyboard.js';
+import { ConfigView, StepType } from '../views/Config.js';
+export { ConfigView, StepType, } from '../views/Config.js';
 /**
  * Config controller: Multi-step wizard logic
  */
@@ -208,7 +100,10 @@ export function Config(props) {
             }
             else {
                 // Fallback: complete with abort feedback directly
-                lifecycleHandlers.completeActive(createFeedback(FeedbackType.Aborted, 'Configuration cancelled.'));
+                lifecycleHandlers.completeActive(createFeedback({
+                    type: FeedbackType.Aborted,
+                    message: 'Configuration cancelled.',
+                }));
             }
             return;
         }
@@ -272,12 +167,15 @@ export function Config(props) {
                     onFinished(newValues);
                 }
                 // Success - complete with success feedback
-                lifecycleHandlers.completeActive(createFeedback(FeedbackType.Succeeded, 'Configuration saved successfully.'));
+                lifecycleHandlers.completeActive(createFeedback({
+                    type: FeedbackType.Succeeded,
+                    message: '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({ type: FeedbackType.Failed, message: errorMessage }));
             }
             setStep(steps.length);
         }

package/dist/components/controllers/Confirm.js

@@ -0,0 +1,42 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useState } from 'react';
+import { ComponentStatus, } from '../../types/components.js';
+import { useInput } from '../../services/keyboard.js';
+import { ConfirmView } from '../views/Confirm.js';
+export { ConfirmView } from '../views/Confirm.js';
+/**
+ * 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
+            const finalState = { selectedIndex: 1, confirmed: false };
+            requestHandlers.onCompleted(finalState);
+            onCancelled();
+        }
+        else if (key.tab) {
+            // Toggle between Yes (0) and No (1)
+            setSelectedIndex((prev) => (prev === 0 ? 1 : 0));
+        }
+        else if (key.return) {
+            // Confirm selection
+            const finalState = {
+                selectedIndex,
+                confirmed: true,
+            };
+            requestHandlers.onCompleted(finalState);
+            if (selectedIndex === 0) {
+                onConfirmed();
+            }
+            else {
+                onCancelled();
+            }
+        }
+    }, { isActive });
+    return (_jsx(ConfirmView, { status: status, message: message, selectedIndex: selectedIndex }));
+}