prompt-language-shell 0.9.2 → 0.9.4

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

@@ -1,59 +1,20 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useCallback, useEffect, useReducer, useRef, useState } from 'react';
-import { Box, Text } from 'ink';
-import { ComponentStatus, } from '../types/components.js';
-import { getTextColor } from '../services/colors.js';
-import { useInput } from '../services/keyboard.js';
-import { formatErrorMessage, getExecutionErrorMessage, } from '../services/messages.js';
-import { ExecutionStatus } from '../services/shell.js';
-import { ensureMinimumTime } from '../services/timing.js';
-import { handleTaskCompletion, handleTaskFailure, } from '../execution/handlers.js';
-import { processTasks } from '../execution/processing.js';
-import { executeReducer, initialState } from '../execution/reducer.js';
-import { executeTask } from '../execution/runner.js';
-import { ExecuteActionType } from '../execution/types.js';
-import { getCurrentTaskIndex } from '../execution/utils.js';
-import { createFeedback, createMessage } from '../services/components.js';
-import { FeedbackType } from '../types/types.js';
-import { Spinner } from './Spinner.js';
-import { TaskView } from './Task.js';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useEffect, useReducer, useRef } from 'react';
+import { ComponentStatus, } from '../../types/components.js';
+import { useInput } from '../../services/keyboard.js';
+import { formatErrorMessage, getExecutionErrorMessage, } from '../../services/messages.js';
+import { ExecutionStatus } from '../../services/shell.js';
+import { ELAPSED_UPDATE_INTERVAL, ensureMinimumTime, } from '../../services/timing.js';
+import { handleTaskCompletion, handleTaskFailure, } from '../../execution/handlers.js';
+import { processTasks } from '../../execution/processing.js';
+import { executeReducer, initialState } from '../../execution/reducer.js';
+import { executeTask } from '../../execution/runner.js';
+import { ExecuteActionType } from '../../execution/types.js';
+import { getCurrentTaskIndex } from '../../execution/utils.js';
+import { createMessage } from '../../services/components.js';
+import { ExecuteView } from '../views/Execute.js';
+export { ExecuteView, mapStateToViewProps, } from '../views/Execute.js';
 const MINIMUM_PROCESSING_TIME = 400;
-const ELAPSED_UPDATE_INTERVAL = 1000;
-/**
- * Check if a task is finished (success, failed, or aborted)
- */
-function isTaskFinished(task) {
-    return (task.status === ExecutionStatus.Success ||
-        task.status === ExecutionStatus.Failed ||
-        task.status === ExecutionStatus.Aborted);
-}
-/**
- * Map ExecuteState to view props for rendering in timeline
- */
-export function mapStateToViewProps(state, isActive) {
-    const taskViewData = state.tasks.map((task) => {
-        return {
-            label: task.label,
-            command: task.command,
-            status: task.status,
-            elapsed: task.elapsed,
-            stdout: task.stdout ?? '',
-            stderr: task.stderr ?? '',
-            isActive: false, // In timeline, no task is active
-            isFinished: isTaskFinished(task),
-        };
-    });
-    return {
-        isLoading: false,
-        isExecuting: false,
-        isActive,
-        error: state.error,
-        message: state.message,
-        tasks: taskViewData,
-        completionMessage: state.completionMessage,
-        showTasks: state.tasks.length > 0,
-    };
-}
 /**
  * Create an ExecuteState with defaults
  */
@@ -67,32 +28,16 @@ function createExecuteState(overrides = {}) {
         ...overrides,
     };
 }
-/**
- * Execute view: Pure display component for task execution progress
- */
-export const ExecuteView = ({ isLoading, isExecuting, isActive, error, message, tasks, completionMessage, showTasks, }) => {
-    // Return null only when loading completes with no commands
-    if (!isActive && tasks.length === 0 && !error) {
-        return null;
-    }
-    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isLoading && (_jsxs(Box, { marginLeft: 1, children: [_jsx(Text, { color: getTextColor(isActive), children: "Preparing commands. " }), _jsx(Spinner, {})] })), (isExecuting || showTasks) && (_jsxs(Box, { flexDirection: "column", marginLeft: 1, children: [message && (_jsxs(Box, { marginBottom: 1, gap: 1, children: [_jsx(Text, { color: getTextColor(isActive), children: message }), isExecuting && _jsx(Spinner, {})] })), tasks.map((task, index) => (_jsx(Box, { marginBottom: index < tasks.length - 1 ? 1 : 0, children: _jsx(TaskView, { label: task.label, command: task.command, status: task.status, elapsed: task.elapsed, stdout: task.stdout, stderr: task.stderr, isFinished: task.isFinished }) }, index)))] })), completionMessage && !isActive && (_jsx(Box, { marginTop: 1, marginLeft: 1, children: _jsx(Text, { color: getTextColor(false), children: completionMessage }) })), error && (_jsx(Box, { marginLeft: 1, children: _jsx(Text, { children: error }) }))] }));
-};
 /**
  * Execute controller: Runs tasks sequentially and manages all execution state
  */
-export function Execute({ tasks: inputTasks, status, service, requestHandlers, lifecycleHandlers, workflowHandlers, }) {
+export function Execute({ tasks: inputTasks, status, service, upcoming, label, requestHandlers, lifecycleHandlers, workflowHandlers, }) {
     const isActive = status === ComponentStatus.Active;
     const [localState, dispatch] = useReducer(executeReducer, initialState);
-    // Live output state for currently executing task
-    const [liveOutput, setLiveOutput] = useState({
-        stdout: '',
-        stderr: '',
-        error: '',
-    });
-    const [liveElapsed, setLiveElapsed] = useState(0);
-    const [taskStartTime, setTaskStartTime] = useState(null);
     // Track working directory across commands (persists cd changes)
     const workdirRef = useRef(undefined);
+    // Ref to collect live output during execution (dispatched every second)
+    const outputRef = useRef({ stdout: '', stderr: '' });
     // Ref to track if current task execution is cancelled
     const cancelledRef = useRef(false);
     const { error, tasks, message, hasProcessed, completionMessage, summary } = localState;
@@ -102,30 +47,45 @@ export function Execute({ tasks: inputTasks, status, service, requestHandlers, l
     const isLoading = isActive && tasks.length === 0 && !error && !hasProcessed;
     const isExecuting = isActive && currentTaskIndex < tasks.length;
     const showTasks = !isActive && tasks.length > 0;
-    // Update elapsed time while task is running
+    // Get current running task for progress updates
+    const runningTask = tasks.find((t) => t.status === ExecutionStatus.Running);
+    // Update reducer with progress every second while task is running
     useEffect(() => {
-        if (!taskStartTime || !isExecuting)
+        if (!runningTask?.startTime || !isExecuting)
             return;
+        const taskStartTime = runningTask.startTime;
         const interval = setInterval(() => {
-            setLiveElapsed(Date.now() - taskStartTime);
+            const elapsed = Date.now() - taskStartTime;
+            dispatch({
+                type: ExecuteActionType.TaskProgress,
+                payload: {
+                    index: currentTaskIndex,
+                    elapsed,
+                    output: {
+                        stdout: outputRef.current.stdout,
+                        stderr: outputRef.current.stderr,
+                    },
+                },
+            });
         }, ELAPSED_UPDATE_INTERVAL);
         return () => {
             clearInterval(interval);
         };
-    }, [taskStartTime, isExecuting]);
-    // Handle cancel
+    }, [runningTask?.startTime, isExecuting, currentTaskIndex]);
+    // Handle cancel - state already in reducer, just need to update final output
     const handleCancel = useCallback(() => {
         cancelledRef.current = true;
         dispatch({ type: ExecuteActionType.CancelExecution });
-        // Build updated task infos with current output for the running task
-        const updatedTaskInfos = tasks.map((task) => {
+        // Build final state with current output for the running task
+        const updatedTasks = tasks.map((task) => {
             if (task.status === ExecutionStatus.Running) {
                 return {
                     ...task,
                     status: ExecutionStatus.Aborted,
-                    stdout: liveOutput.stdout,
-                    stderr: liveOutput.stderr,
-                    error: liveOutput.error,
+                    output: {
+                        stdout: outputRef.current.stdout,
+                        stderr: outputRef.current.stderr,
+                    },
                 };
             }
             else if (task.status === ExecutionStatus.Pending) {
@@ -136,11 +96,11 @@ export function Execute({ tasks: inputTasks, status, service, requestHandlers, l
         const finalState = createExecuteState({
             message,
             summary,
-            tasks: updatedTaskInfos,
+            tasks: updatedTasks,
         });
         requestHandlers.onCompleted(finalState);
         requestHandlers.onAborted('execution');
-    }, [message, summary, tasks, liveOutput, requestHandlers]);
+    }, [message, summary, tasks, requestHandlers]);
     useInput((_, key) => {
         if (key.escape && (isLoading || isExecuting)) {
             handleCancel();
@@ -179,25 +139,26 @@ export function Execute({ tasks: inputTasks, status, service, requestHandlers, l
                     lifecycleHandlers.completeActive();
                     return;
                 }
-                // Create task infos from commands
-                const taskInfos = result.commands.map((cmd, index) => ({
+                // Create task data from commands
+                const tasks = result.commands.map((cmd, index) => ({
                     label: inputTasks[index]?.action ?? cmd.description,
                     command: cmd,
                     status: ExecutionStatus.Pending,
                     elapsed: 0,
+                    output: null,
                 }));
                 dispatch({
                     type: ExecuteActionType.CommandsReady,
                     payload: {
                         message: result.message,
                         summary: result.summary,
-                        tasks: taskInfos,
+                        tasks,
                     },
                 });
                 requestHandlers.onCompleted(createExecuteState({
                     message: result.message,
                     summary: result.summary,
-                    tasks: taskInfos,
+                    tasks,
                 }));
             }
             catch (err) {
@@ -243,36 +204,34 @@ export function Execute({ tasks: inputTasks, status, service, requestHandlers, l
         // Mark task as started (running)
         dispatch({
             type: ExecuteActionType.TaskStarted,
-            payload: { index: currentTaskIndex },
+            payload: { index: currentTaskIndex, startTime: Date.now() },
         });
-        // Reset live state for new task
-        setLiveOutput({ stdout: '', stderr: '', error: '' });
-        setLiveElapsed(0);
-        setTaskStartTime(Date.now());
+        // Reset output ref for new task
+        outputRef.current = { stdout: '', stderr: '' };
         // Merge workdir into command
         const command = workdirRef.current
             ? { ...currentTask.command, workdir: workdirRef.current }
             : currentTask.command;
         void executeTask(command, currentTaskIndex, {
-            onOutputChange: (output) => {
+            onUpdate: (output) => {
                 if (!cancelledRef.current) {
-                    setLiveOutput(output);
+                    outputRef.current = { stdout: output.stdout, stderr: output.stderr };
                 }
             },
-            onComplete: (elapsed, output) => {
+            onComplete: (elapsed, execOutput) => {
                 if (cancelledRef.current)
                     return;
-                setTaskStartTime(null);
                 // Track working directory
-                if (output.workdir) {
-                    workdirRef.current = output.workdir;
+                if (execOutput.workdir) {
+                    workdirRef.current = execOutput.workdir;
                 }
                 const tasksWithOutput = tasks.map((task, i) => i === currentTaskIndex
                     ? {
                         ...task,
-                        stdout: output.stdout,
-                        stderr: output.stderr,
-                        error: output.error,
+                        output: {
+                            stdout: execOutput.stdout,
+                            stderr: execOutput.stderr,
+                        },
                     }
                     : task);
                 const result = handleTaskCompletion(currentTaskIndex, elapsed, {
@@ -286,36 +245,32 @@ export function Execute({ tasks: inputTasks, status, service, requestHandlers, l
                     lifecycleHandlers.completeActive();
                 }
             },
-            onError: (errorMsg, elapsed, output) => {
+            onError: (errorMsg, execOutput) => {
                 if (cancelledRef.current)
                     return;
-                setTaskStartTime(null);
                 // Track working directory
-                if (output.workdir) {
-                    workdirRef.current = output.workdir;
+                if (execOutput.workdir) {
+                    workdirRef.current = execOutput.workdir;
                 }
                 const tasksWithOutput = tasks.map((task, i) => i === currentTaskIndex
                     ? {
                         ...task,
-                        stdout: output.stdout,
-                        stderr: output.stderr,
-                        error: output.error,
+                        output: {
+                            stdout: execOutput.stdout,
+                            stderr: execOutput.stderr,
+                        },
+                        error: execOutput.error || undefined,
                     }
                     : task);
-                const result = handleTaskFailure(currentTaskIndex, errorMsg, elapsed, {
+                const result = handleTaskFailure(currentTaskIndex, errorMsg, {
                     tasks: tasksWithOutput,
                     message,
                     summary,
                 });
                 dispatch(result.action);
                 requestHandlers.onCompleted(result.finalState);
-                if (result.action.type === ExecuteActionType.TaskErrorCritical) {
-                    const errorMessage = getExecutionErrorMessage(errorMsg);
-                    workflowHandlers.addToQueue(createFeedback({ type: FeedbackType.Failed, message: errorMessage }));
-                }
-                if (result.shouldComplete) {
-                    lifecycleHandlers.completeActive();
-                }
+                const errorMessage = getExecutionErrorMessage(errorMsg);
+                requestHandlers.onError(errorMessage);
             },
         });
     }, [
@@ -329,29 +284,5 @@ export function Execute({ tasks: inputTasks, status, service, requestHandlers, l
         lifecycleHandlers,
         workflowHandlers,
     ]);
-    // Build view data for each task
-    const taskViewData = tasks.map((task) => {
-        const isTaskActive = isActive && task.status === ExecutionStatus.Running;
-        const finished = isTaskFinished(task);
-        // Use live output for active task, stored output for finished tasks
-        const stdout = isTaskActive ? liveOutput.stdout : (task.stdout ?? '');
-        const stderr = isTaskActive ? liveOutput.stderr : (task.stderr ?? '');
-        // Use live elapsed for active running task
-        const elapsed = isTaskActive ? liveElapsed : task.elapsed;
-        // Merge workdir for active task
-        const command = isTaskActive && workdirRef.current
-            ? { ...task.command, workdir: workdirRef.current }
-            : task.command;
-        return {
-            label: task.label,
-            command,
-            status: task.status,
-            elapsed,
-            stdout,
-            stderr,
-            isActive: isTaskActive,
-            isFinished: finished,
-        };
-    });
-    return (_jsx(ExecuteView, { isLoading: isLoading, isExecuting: isExecuting, isActive: isActive, error: error, message: message, tasks: taskViewData, completionMessage: completionMessage, showTasks: showTasks }));
+    return (_jsx(ExecuteView, { isLoading: isLoading, isExecuting: isExecuting, isActive: isActive, error: error, message: message, tasks: tasks, completionMessage: completionMessage, showTasks: showTasks, upcoming: upcoming, label: label }));
 }

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

@@ -1,25 +1,15 @@
-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 } from 'ink';
-import { ComponentStatus, } from '../types/components.js';
-import { Origin } from '../types/types.js';
-import { Colors, getTextColor } from '../services/colors.js';
-import { createReport } from '../services/components.js';
-import { DebugLevel } from '../configuration/types.js';
-import { useInput } from '../services/keyboard.js';
-import { formatErrorMessage } from '../services/messages.js';
-import { ensureMinimumTime } from '../services/timing.js';
-import { Spinner } from './Spinner.js';
+import { ComponentStatus, } from '../../types/components.js';
+import { Origin } from '../../types/types.js';
+import { createReport } from '../../services/components.js';
+import { DebugLevel } from '../../configuration/types.js';
+import { useInput } from '../../services/keyboard.js';
+import { formatErrorMessage } from '../../services/messages.js';
+import { ensureMinimumTime } from '../../services/timing.js';
+import { IntrospectView } from '../views/Introspect.js';
+export { IntrospectView } from '../views/Introspect.js';
 const MIN_PROCESSING_TIME = 1000;
-export const IntrospectView = ({ state, status, children, }) => {
-    const isActive = status === ComponentStatus.Active;
-    const { error } = state;
-    // Don't render wrapper when done and nothing to show
-    if (!isActive && !error && !children) {
-        return null;
-    }
-    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isActive && (_jsxs(Box, { marginLeft: 1, children: [_jsx(Text, { color: getTextColor(isActive), children: "Listing capabilities. " }), _jsx(Spinner, {})] })), error && (_jsx(Box, { marginTop: 1, marginLeft: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) })), children] }));
-};
 /**
  * Introspect controller: Lists capabilities via LLM
  */
@@ -27,7 +17,6 @@ export function Introspect({ tasks, status, service, children, debug = DebugLeve
     const isActive = status === ComponentStatus.Active;
     const [error, setError] = useState(null);
     const [capabilities, setCapabilities] = useState(null);
-    const [message, setMessage] = useState(null);
     useInput((input, key) => {
         if (key.escape && isActive) {
             requestHandlers.onAborted('introspection');
@@ -59,7 +48,6 @@ export function Introspect({ tasks, status, service, children, debug = DebugLeve
                         ? result.capabilities.filter((cap) => cap.origin !== Origin.Indirect)
                         : result.capabilities;
                     setCapabilities(capabilities);
-                    setMessage(message);
                     const finalState = {
                         error: null,
                         capabilities,
@@ -100,10 +88,6 @@ export function Introspect({ tasks, status, service, children, debug = DebugLeve
         lifecycleHandlers,
         workflowHandlers,
     ]);
-    const state = {
-        error,
-        capabilities: capabilities || [],
-        message,
-    };
-    return (_jsx(IntrospectView, { state: state, status: status, children: children }));
+    const hasCapabilities = capabilities !== null && capabilities.length > 0;
+    return (_jsx(IntrospectView, { status: status, hasCapabilities: hasCapabilities, error: error, children: children }));
 }

package/dist/components/controllers/Refinement.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ComponentStatus } from '../../types/components.js';
+import { useInput } from '../../services/keyboard.js';
+import { RefinementView } from '../views/Refinement.js';
+export { RefinementView } from '../views/Refinement.js';
+/**
+ * Refinement controller: Handles abort input
+ */
+export const Refinement = ({ text, status, onAborted }) => {
+    const isActive = status === ComponentStatus.Active;
+    useInput((_, key) => {
+        if (key.escape && isActive) {
+            onAborted('plan refinement');
+            return;
+        }
+    }, { isActive });
+    return _jsx(RefinementView, { text: text, status: status });
+};

package/dist/components/controllers/Schedule.js

@@ -0,0 +1,139 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { ComponentStatus, } from '../../types/components.js';
+import { TaskType } from '../../types/types.js';
+import { DebugLevel } from '../../configuration/types.js';
+import { useInput } from '../../services/keyboard.js';
+import { ScheduleView } from '../views/Schedule.js';
+export { ScheduleView, taskToListItem, } from '../views/Schedule.js';
+/**
+ * Schedule controller: Manages task selection and navigation
+ */
+export function Schedule({ message, tasks, status, debug = DebugLevel.None, requestHandlers, lifecycleHandlers, onSelectionConfirmed, }) {
+    const isActive = status === ComponentStatus.Active;
+    const [highlightedIndex, setHighlightedIndex] = useState(null);
+    const [currentDefineGroupIndex, setCurrentDefineGroupIndex] = useState(0);
+    const [completedSelections, setCompletedSelections] = useState([]);
+    // Find all Define tasks
+    const defineTaskIndices = tasks
+        .map((t, idx) => (t.type === TaskType.Define ? idx : -1))
+        .filter((idx) => idx !== -1);
+    // Get the current active define task
+    const currentDefineTaskIndex = defineTaskIndices[currentDefineGroupIndex] ?? -1;
+    const defineTask = currentDefineTaskIndex >= 0 ? tasks[currentDefineTaskIndex] : null;
+    const optionsCount = Array.isArray(defineTask?.params?.options)
+        ? defineTask.params.options.length
+        : 0;
+    const hasMoreGroups = currentDefineGroupIndex < defineTaskIndices.length - 1;
+    // If no DEFINE tasks, immediately confirm with all tasks
+    useEffect(() => {
+        if (isActive && defineTaskIndices.length === 0 && onSelectionConfirmed) {
+            // No selection needed - all tasks are concrete
+            const concreteTasks = tasks.filter((task) => task.type !== TaskType.Ignore && task.type !== TaskType.Discard);
+            // Expose final state
+            const finalState = {
+                highlightedIndex,
+                currentDefineGroupIndex,
+                completedSelections,
+            };
+            requestHandlers.onCompleted(finalState);
+            // Complete the selection phase - it goes to timeline
+            // Callback will create a new Plan showing refined tasks (pending) + Confirm (active)
+            lifecycleHandlers.completeActive();
+            void onSelectionConfirmed(concreteTasks);
+        }
+    }, [
+        isActive,
+        defineTaskIndices.length,
+        tasks,
+        onSelectionConfirmed,
+        lifecycleHandlers,
+        highlightedIndex,
+        currentDefineGroupIndex,
+        completedSelections,
+        requestHandlers,
+    ]);
+    useInput((input, key) => {
+        // Don't handle input if not active or no define task
+        if (!isActive || !defineTask) {
+            return;
+        }
+        if (key.escape) {
+            requestHandlers.onAborted('task selection');
+            return;
+        }
+        if (key.downArrow) {
+            setHighlightedIndex((prev) => {
+                if (prev === null) {
+                    return 0; // Select first
+                }
+                return (prev + 1) % optionsCount; // Wrap around
+            });
+        }
+        else if (key.upArrow) {
+            setHighlightedIndex((prev) => {
+                if (prev === null) {
+                    return optionsCount - 1; // Select last
+                }
+                return (prev - 1 + optionsCount) % optionsCount; // Wrap around
+            });
+        }
+        else if (key.return && highlightedIndex !== null) {
+            // Record the selection for this group
+            const newCompletedSelections = [...completedSelections];
+            newCompletedSelections[currentDefineGroupIndex] = highlightedIndex;
+            setCompletedSelections(newCompletedSelections);
+            if (hasMoreGroups) {
+                // Advance to next group
+                const newGroupIndex = currentDefineGroupIndex + 1;
+                setCurrentDefineGroupIndex(newGroupIndex);
+                setHighlightedIndex(null);
+            }
+            else {
+                // Clear highlight to show Execute color
+                setHighlightedIndex(null);
+                // Build refined task list with only selected options (no discarded or ignored ones)
+                const refinedTasks = [];
+                tasks.forEach((task, idx) => {
+                    const defineGroupIndex = defineTaskIndices.indexOf(idx);
+                    if (defineGroupIndex !== -1 &&
+                        Array.isArray(task.params?.options)) {
+                        // This is a Define task - only include the selected option
+                        const options = task.params.options;
+                        const selectedIndex = newCompletedSelections[defineGroupIndex];
+                        const selectedOption = options[selectedIndex];
+                        // Use Execute as default - LLM will properly classify during refinement
+                        refinedTasks.push({
+                            action: selectedOption,
+                            type: TaskType.Execute,
+                            config: [],
+                        });
+                    }
+                    else if (task.type !== TaskType.Ignore &&
+                        task.type !== TaskType.Discard) {
+                        // Regular task - keep as is, but skip Ignore and Discard tasks
+                        refinedTasks.push(task);
+                    }
+                });
+                // Expose final state
+                const finalState = {
+                    highlightedIndex: null,
+                    currentDefineGroupIndex,
+                    completedSelections: newCompletedSelections,
+                };
+                requestHandlers.onCompleted(finalState);
+                if (onSelectionConfirmed) {
+                    // Complete the selection phase - it goes to timeline
+                    // Callback will create a new Plan showing refined tasks (pending) + Confirm (active)
+                    lifecycleHandlers.completeActive();
+                    void onSelectionConfirmed(refinedTasks);
+                }
+                else {
+                    // No selection callback, just complete normally
+                    lifecycleHandlers.completeActive();
+                }
+            }
+        }
+    }, { isActive: isActive && defineTask !== null });
+    return (_jsx(ScheduleView, { status: status, message: message, tasks: tasks, highlightedIndex: highlightedIndex, currentDefineGroupIndex: currentDefineGroupIndex, completedSelections: completedSelections, debug: debug }));
+}

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

@@ -1,28 +1,18 @@
-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 { saveConfig } from '../configuration/io.js';
-import { createConfigStepsFromSchema } from '../configuration/steps.js';
-import { unflattenConfig } from '../configuration/transformation.js';
-import { Colors, getTextColor } from '../services/colors.js';
-import { createConfig, createMessage } from '../services/components.js';
-import { saveConfigLabels } from '../configuration/labels.js';
-import { useInput } from '../services/keyboard.js';
-import { formatErrorMessage, getUnresolvedPlaceholdersMessage, } from '../services/messages.js';
-import { ensureMinimumTime } from '../services/timing.js';
-import { Spinner } from './Spinner.js';
+import { ComponentStatus, } from '../../types/components.js';
+import { TaskType } from '../../types/types.js';
+import { saveConfig } from '../../configuration/io.js';
+import { createConfigStepsFromSchema } from '../../configuration/steps.js';
+import { unflattenConfig } from '../../configuration/transformation.js';
+import { createConfig, createMessage } from '../../services/components.js';
+import { saveConfigLabels } from '../../configuration/labels.js';
+import { useInput } from '../../services/keyboard.js';
+import { formatErrorMessage, getUnresolvedPlaceholdersMessage, } from '../../services/messages.js';
+import { ensureMinimumTime } from '../../services/timing.js';
+import { ValidateView } from '../views/Validate.js';
+export { ValidateView } from '../views/Validate.js';
 const MIN_PROCESSING_TIME = 1000;
-export const ValidateView = ({ state, status }) => {
-    const isActive = status === ComponentStatus.Active;
-    const { error, completionMessage } = state;
-    // Don't render when not active and nothing to show
-    if (!isActive && !completionMessage && !error) {
-        return null;
-    }
-    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isActive && !completionMessage && !error && (_jsxs(Box, { marginLeft: 1, children: [_jsxs(Text, { color: getTextColor(isActive), children: ["Validating configuration requirements.", ' '] }), _jsx(Spinner, {})] })), completionMessage && (_jsx(Box, { marginLeft: 1, children: _jsx(Text, { color: getTextColor(isActive), children: completionMessage }) })), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) }))] }));
-};
 /**
  * Validate controller: Validates missing config
  */
@@ -30,7 +20,6 @@ export function Validate({ missingConfig, userRequest, status, service, onError,
     const isActive = status === ComponentStatus.Active;
     const [error, setError] = useState(null);
     const [completionMessage, setCompletionMessage] = useState(null);
-    const [configRequirements, setConfigRequirements] = useState([]);
     useInput((_, key) => {
         if (key.escape && isActive) {
             onAborted('validation');
@@ -72,7 +61,6 @@ export function Validate({ missingConfig, userRequest, status, service, onError,
                     // Build completion message showing which config properties are needed
                     const message = getUnresolvedPlaceholdersMessage(withDescriptions.length);
                     setCompletionMessage(message);
-                    setConfigRequirements(withDescriptions);
                     // Add validation message to timeline before Config component
                     workflowHandlers.addToTimeline(createMessage({ text: message }));
                     // Create Config component and add to queue
@@ -152,13 +140,7 @@ export function Validate({ missingConfig, userRequest, status, service, onError,
         lifecycleHandlers,
         workflowHandlers,
     ]);
-    const state = {
-        error,
-        completionMessage,
-        configRequirements,
-        validated: error === null && completionMessage !== null,
-    };
-    return _jsx(ValidateView, { state: state, status: status });
+    return (_jsx(ValidateView, { status: status, completionMessage: completionMessage, error: error }));
 }
 /**
  * Build prompt for VALIDATE tool