prompt-language-shell 0.8.4 → 0.8.6

package/dist/ui/Execute.js

@@ -2,182 +2,50 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useCallback, useEffect, useReducer } from 'react';
 import { Box, Text } from 'ink';
 import { ComponentStatus, } from '../types/components.js';
-import { Colors, getTextColor } from '../services/colors.js';
+import { getTextColor } from '../services/colors.js';
 import { useInput } from '../services/keyboard.js';
-import { loadUserConfig } from '../services/loader.js';
 import { formatErrorMessage } from '../services/messages.js';
-import { replacePlaceholders } from '../services/resolver.js';
 import { ExecutionStatus } from '../services/shell.js';
 import { ensureMinimumTime } from '../services/timing.js';
-import { formatDuration } from '../services/utils.js';
+import { buildAbortedState, handleTaskCompletion, handleTaskFailure, } from '../execution/handlers.js';
+import { processTasks } from '../execution/processing.js';
+import { executeReducer, initialState } from '../execution/reducer.js';
+import { ExecuteActionType } from '../execution/types.js';
+import { Message } from './Message.js';
 import { Spinner } from './Spinner.js';
 import { Task } from './Task.js';
 const MINIMUM_PROCESSING_TIME = 400;
+export const ExecuteView = ({ state, status, onTaskComplete, onTaskAbort, onTaskError, }) => {
+    const isActive = status === ComponentStatus.Active;
+    const { error, taskInfos, message, completed, completionMessage } = state;
+    const hasProcessed = taskInfos.length > 0;
+    // Derive loading state from current conditions
+    const isLoading = isActive && taskInfos.length === 0 && !error && !hasProcessed;
+    const isExecuting = completed < taskInfos.length;
+    // Return null only when loading completes with no commands
+    if (!isActive && taskInfos.length === 0 && !error) {
+        return null;
+    }
+    // Show completed steps when not active
+    const showTasks = !isActive && taskInfos.length > 0;
+    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, {})] })), taskInfos.map((taskInfo, index) => (_jsx(Box, { marginBottom: index < taskInfos.length - 1 ? 1 : 0, children: _jsx(Task, { label: taskInfo.label, command: taskInfo.command, isActive: isActive && index === completed, index: index, initialStatus: taskInfo.status, initialElapsed: taskInfo.elapsed, onComplete: onTaskComplete, onAbort: onTaskAbort, onError: onTaskError }) }, index)))] })), completionMessage && !isActive && (_jsx(Box, { marginTop: 1, marginLeft: 1, children: _jsx(Text, { color: getTextColor(false), children: completionMessage }) })), error && _jsx(Message, { text: error, status: status })] }));
+};
 /**
- * Validates that all placeholders in a command have been resolved.
- * Throws an error if unresolved placeholders are found.
+ * Execute controller: Runs tasks sequentially
  */
-function validatePlaceholderResolution(command, original) {
-    const unresolvedPattern = /\{[^}]+\}/g;
-    const matches = command.match(unresolvedPattern);
-    if (matches && matches.length > 0) {
-        throw new Error(`Unresolved placeholders in command: ${matches.join(', ')}\nCommand: ${original}`);
-    }
-}
-function executeReducer(state, action) {
-    switch (action.type) {
-        case 'PROCESSING_COMPLETE':
-            return {
-                ...state,
-                message: action.payload.message,
-                hasProcessed: true,
-            };
-        case 'COMMANDS_READY':
-            return {
-                ...state,
-                message: action.payload.message,
-                summary: action.payload.summary,
-                taskInfos: action.payload.taskInfos,
-                completed: 0,
-            };
-        case 'PROCESSING_ERROR':
-            return {
-                ...state,
-                error: action.payload.error,
-                hasProcessed: true,
-            };
-        case 'TASK_COMPLETE': {
-            const updatedTimes = [
-                ...state.taskExecutionTimes,
-                action.payload.elapsed,
-            ];
-            const updatedTaskInfos = state.taskInfos.map((task, i) => i === action.payload.index
-                ? {
-                    ...task,
-                    status: ExecutionStatus.Success,
-                    elapsed: action.payload.elapsed,
-                }
-                : task);
-            return {
-                ...state,
-                taskInfos: updatedTaskInfos,
-                taskExecutionTimes: updatedTimes,
-                completed: action.payload.index + 1,
-            };
-        }
-        case 'ALL_TASKS_COMPLETE': {
-            const updatedTimes = [
-                ...state.taskExecutionTimes,
-                action.payload.elapsed,
-            ];
-            const updatedTaskInfos = state.taskInfos.map((task, i) => i === action.payload.index
-                ? {
-                    ...task,
-                    status: ExecutionStatus.Success,
-                    elapsed: action.payload.elapsed,
-                }
-                : task);
-            const totalElapsed = updatedTimes.reduce((sum, time) => sum + time, 0);
-            const completion = `${action.payload.summaryText} in ${formatDuration(totalElapsed)}.`;
-            return {
-                ...state,
-                taskInfos: updatedTaskInfos,
-                taskExecutionTimes: updatedTimes,
-                completed: action.payload.index + 1,
-                completionMessage: completion,
-            };
-        }
-        case 'TASK_ERROR_CRITICAL': {
-            const updatedTaskInfos = state.taskInfos.map((task, i) => i === action.payload.index
-                ? { ...task, status: ExecutionStatus.Failed, elapsed: 0 }
-                : task);
-            return {
-                ...state,
-                taskInfos: updatedTaskInfos,
-                error: action.payload.error,
-            };
-        }
-        case 'TASK_ERROR_CONTINUE': {
-            const updatedTimes = [
-                ...state.taskExecutionTimes,
-                action.payload.elapsed,
-            ];
-            const updatedTaskInfos = state.taskInfos.map((task, i) => i === action.payload.index
-                ? {
-                    ...task,
-                    status: ExecutionStatus.Failed,
-                    elapsed: action.payload.elapsed,
-                }
-                : task);
-            return {
-                ...state,
-                taskInfos: updatedTaskInfos,
-                taskExecutionTimes: updatedTimes,
-                completed: action.payload.index + 1,
-            };
-        }
-        case 'LAST_TASK_ERROR': {
-            const updatedTimes = [
-                ...state.taskExecutionTimes,
-                action.payload.elapsed,
-            ];
-            const updatedTaskInfos = state.taskInfos.map((task, i) => i === action.payload.index
-                ? {
-                    ...task,
-                    status: ExecutionStatus.Failed,
-                    elapsed: action.payload.elapsed,
-                }
-                : task);
-            const totalElapsed = updatedTimes.reduce((sum, time) => sum + time, 0);
-            const completion = `${action.payload.summaryText} in ${formatDuration(totalElapsed)}.`;
-            return {
-                ...state,
-                taskInfos: updatedTaskInfos,
-                taskExecutionTimes: updatedTimes,
-                completed: action.payload.index + 1,
-                completionMessage: completion,
-            };
-        }
-        case 'CANCEL_EXECUTION': {
-            const updatedTaskInfos = state.taskInfos.map((task, taskIndex) => {
-                if (taskIndex < action.payload.completed) {
-                    return { ...task, status: ExecutionStatus.Success };
-                }
-                else if (taskIndex === action.payload.completed) {
-                    return { ...task, status: ExecutionStatus.Aborted };
-                }
-                else {
-                    return { ...task, status: ExecutionStatus.Cancelled };
-                }
-            });
-            return {
-                ...state,
-                taskInfos: updatedTaskInfos,
-            };
-        }
-        default:
-            return state;
-    }
-}
-export function Execute({ tasks, state, status, service, stateHandlers, lifecycleHandlers, errorHandlers, workflowHandlers, }) {
+export function Execute({ tasks, status, service, requestHandlers, lifecycleHandlers, workflowHandlers, }) {
     const isActive = status === ComponentStatus.Active;
-    const [localState, dispatch] = useReducer(executeReducer, {
-        error: state?.error ?? null,
-        taskInfos: state?.taskInfos ?? [],
-        message: state?.message ?? '',
-        completed: state?.completed ?? 0,
-        hasProcessed: false,
-        taskExecutionTimes: state?.taskExecutionTimes ?? [],
-        completionMessage: state?.completionMessage ?? null,
-        summary: state?.summary ?? '',
-    });
+    const [localState, dispatch] = useReducer(executeReducer, initialState);
     const { error, taskInfos, message, completed, hasProcessed, taskExecutionTimes, completionMessage, summary, } = localState;
     // Derive loading state from current conditions
     const isLoading = isActive && taskInfos.length === 0 && !error && !hasProcessed;
     const isExecuting = completed < taskInfos.length;
     // Handle cancel with useCallback to ensure we capture latest state
     const handleCancel = useCallback(() => {
-        dispatch({ type: 'CANCEL_EXECUTION', payload: { completed } });
+        dispatch({
+            type: ExecuteActionType.CancelExecution,
+            payload: { completed },
+        });
         // Get updated task infos after cancel
         const updatedTaskInfos = taskInfos.map((task, taskIndex) => {
             if (taskIndex < completed) {
@@ -190,7 +58,8 @@ export function Execute({ tasks, state, status, service, stateHandlers, lifecycl
                 return { ...task, status: ExecutionStatus.Cancelled };
             }
         });
-        stateHandlers?.updateState({
+        // Expose final state
+        const finalState = {
             message,
             summary,
             taskInfos: updatedTaskInfos,
@@ -198,16 +67,16 @@ export function Execute({ tasks, state, status, service, stateHandlers, lifecycl
             taskExecutionTimes,
             completionMessage: null,
             error: null,
-        });
-        errorHandlers?.onAborted('execution');
+        };
+        requestHandlers.onCompleted(finalState);
+        requestHandlers.onAborted('execution');
     }, [
         message,
         summary,
         taskInfos,
         completed,
         taskExecutionTimes,
-        stateHandlers,
-        errorHandlers,
+        requestHandlers,
     ]);
     useInput((_, key) => {
         if (key.escape && (isLoading || isExecuting) && isActive) {
@@ -223,33 +92,20 @@ export function Execute({ tasks, state, status, service, stateHandlers, lifecycl
         async function process(svc) {
             const startTime = Date.now();
             try {
-                // Load user config for placeholder resolution
-                const userConfig = loadUserConfig();
-                // Format tasks for the execute tool and resolve placeholders
-                const taskDescriptions = tasks
-                    .map((task) => {
-                    const resolvedAction = replacePlaceholders(task.action, userConfig);
-                    const params = task.params
-                        ? ` (params: ${JSON.stringify(task.params)})`
-                        : '';
-                    return `- ${resolvedAction}${params}`;
-                })
-                    .join('\n');
-                // Call execute tool to get commands
-                const result = await svc.processWithTool(taskDescriptions, 'execute');
+                const result = await processTasks(tasks, svc);
                 await ensureMinimumTime(startTime, MINIMUM_PROCESSING_TIME);
                 if (!mounted)
                     return;
                 // Add debug components to timeline if present
                 if (result.debug?.length) {
-                    workflowHandlers?.addToTimeline(...result.debug);
+                    workflowHandlers.addToTimeline(...result.debug);
                 }
-                if (!result.commands || result.commands.length === 0) {
+                if (result.commands.length === 0) {
                     dispatch({
-                        type: 'PROCESSING_COMPLETE',
+                        type: ExecuteActionType.ProcessingComplete,
                         payload: { message: result.message },
                     });
-                    stateHandlers?.updateState({
+                    const finalState = {
                         message: result.message,
                         summary: '',
                         taskInfos: [],
@@ -257,51 +113,45 @@ export function Execute({ tasks, state, status, service, stateHandlers, lifecycl
                         taskExecutionTimes: [],
                         completionMessage: null,
                         error: null,
-                    });
-                    lifecycleHandlers?.completeActive();
+                    };
+                    requestHandlers.onCompleted(finalState);
+                    lifecycleHandlers.completeActive();
                     return;
                 }
-                // Resolve placeholders in command strings
-                const resolvedCommands = result.commands.map((cmd) => {
-                    const resolved = replacePlaceholders(cmd.command, userConfig);
-                    validatePlaceholderResolution(resolved, cmd.command);
-                    return { ...cmd, command: resolved };
-                });
-                // Set message, summary, and create task infos
-                const newMessage = result.message;
-                const newSummary = result.summary || '';
-                const infos = resolvedCommands.map((cmd, index) => ({
+                // Create task infos from commands
+                const infos = result.commands.map((cmd, index) => ({
                     label: tasks[index]?.action,
                     command: cmd,
                 }));
                 dispatch({
-                    type: 'COMMANDS_READY',
+                    type: ExecuteActionType.CommandsReady,
                     payload: {
-                        message: newMessage,
-                        summary: newSummary,
+                        message: result.message,
+                        summary: result.summary,
                         taskInfos: infos,
                     },
                 });
                 // Update state after AI processing
-                stateHandlers?.updateState({
-                    message: newMessage,
-                    summary: newSummary,
+                const finalState = {
+                    message: result.message,
+                    summary: result.summary,
                     taskInfos: infos,
                     completed: 0,
                     taskExecutionTimes: [],
                     completionMessage: null,
                     error: null,
-                });
+                };
+                requestHandlers.onCompleted(finalState);
             }
             catch (err) {
                 await ensureMinimumTime(startTime, MINIMUM_PROCESSING_TIME);
                 if (mounted) {
                     const errorMessage = formatErrorMessage(err);
                     dispatch({
-                        type: 'PROCESSING_ERROR',
+                        type: ExecuteActionType.ProcessingError,
                         payload: { error: errorMessage },
                     });
-                    stateHandlers?.updateState({
+                    const finalState = {
                         message: '',
                         summary: '',
                         taskInfos: [],
@@ -309,8 +159,9 @@ export function Execute({ tasks, state, status, service, stateHandlers, lifecycl
                         taskExecutionTimes: [],
                         completionMessage: null,
                         error: errorMessage,
-                    });
-                    errorHandlers?.onError(errorMessage);
+                    };
+                    requestHandlers.onCompleted(finalState);
+                    requestHandlers.onError(errorMessage);
                 }
             }
         }
@@ -322,150 +173,78 @@ export function Execute({ tasks, state, status, service, stateHandlers, lifecycl
         tasks,
         isActive,
         service,
-        stateHandlers,
+        requestHandlers,
         lifecycleHandlers,
         workflowHandlers,
-        errorHandlers,
         taskInfos.length,
         hasProcessed,
     ]);
     // Handle task completion - move to next task
     const handleTaskComplete = useCallback((index, _output, elapsed) => {
-        if (index < taskInfos.length - 1) {
-            // More tasks to execute
-            dispatch({ type: 'TASK_COMPLETE', payload: { index, elapsed } });
-            const updatedTimes = [...taskExecutionTimes, elapsed];
-            const updatedTaskInfos = taskInfos.map((task, i) => i === index
-                ? { ...task, status: ExecutionStatus.Success, elapsed }
-                : task);
-            stateHandlers?.updateState({
-                message,
-                summary,
-                taskInfos: updatedTaskInfos,
-                completed: index + 1,
-                taskExecutionTimes: updatedTimes,
-                completionMessage: null,
-                error: null,
-            });
-        }
-        else {
-            // All tasks complete
-            const summaryText = summary.trim() || 'Execution completed';
-            dispatch({
-                type: 'ALL_TASKS_COMPLETE',
-                payload: { index, elapsed, summaryText },
-            });
-            const updatedTimes = [...taskExecutionTimes, elapsed];
-            const updatedTaskInfos = taskInfos.map((task, i) => i === index
-                ? { ...task, status: ExecutionStatus.Success, elapsed }
-                : task);
-            const totalElapsed = updatedTimes.reduce((sum, time) => sum + time, 0);
-            const completion = `${summaryText} in ${formatDuration(totalElapsed)}.`;
-            stateHandlers?.updateState({
-                message,
-                summary,
-                taskInfos: updatedTaskInfos,
-                completed: index + 1,
-                taskExecutionTimes: updatedTimes,
-                completionMessage: completion,
-                error: null,
-            });
-            lifecycleHandlers?.completeActive();
+        const result = handleTaskCompletion(index, elapsed, {
+            taskInfos,
+            message,
+            summary,
+            taskExecutionTimes,
+        });
+        dispatch(result.action);
+        requestHandlers.onCompleted(result.finalState);
+        if (result.shouldComplete) {
+            lifecycleHandlers.completeActive();
         }
     }, [
         taskInfos,
         message,
-        lifecycleHandlers,
-        taskExecutionTimes,
         summary,
-        stateHandlers,
+        taskExecutionTimes,
+        requestHandlers,
+        lifecycleHandlers,
     ]);
     const handleTaskError = useCallback((index, error, elapsed) => {
-        const task = taskInfos[index];
-        const isCritical = task.command.critical !== false; // Default to true
-        const updatedTaskInfos = taskInfos.map((task, i) => i === index
-            ? { ...task, status: ExecutionStatus.Failed, elapsed }
-            : task);
-        if (isCritical) {
-            // Critical failure - stop execution
-            dispatch({ type: 'TASK_ERROR_CRITICAL', payload: { index, error } });
-            stateHandlers?.updateState({
-                message,
-                summary,
-                taskInfos: updatedTaskInfos,
-                completed: index + 1,
-                taskExecutionTimes,
-                completionMessage: null,
-                error,
-            });
-            errorHandlers?.onError(error);
+        const result = handleTaskFailure(index, error, elapsed, {
+            taskInfos,
+            message,
+            summary,
+            taskExecutionTimes,
+        });
+        dispatch(result.action);
+        requestHandlers.onCompleted(result.finalState);
+        if (result.shouldReportError) {
+            requestHandlers.onError(error);
         }
-        else {
-            // Non-critical failure - continue to next task
-            const updatedTimes = [...taskExecutionTimes, elapsed];
-            if (index < taskInfos.length - 1) {
-                dispatch({
-                    type: 'TASK_ERROR_CONTINUE',
-                    payload: { index, elapsed },
-                });
-                stateHandlers?.updateState({
-                    message,
-                    summary,
-                    taskInfos: updatedTaskInfos,
-                    completed: index + 1,
-                    taskExecutionTimes: updatedTimes,
-                    completionMessage: null,
-                    error: null,
-                });
-            }
-            else {
-                // Last task, complete execution
-                const summaryText = summary.trim() || 'Execution completed';
-                dispatch({
-                    type: 'LAST_TASK_ERROR',
-                    payload: { index, elapsed, summaryText },
-                });
-                const totalElapsed = updatedTimes.reduce((sum, time) => sum + time, 0);
-                const completion = `${summaryText} in ${formatDuration(totalElapsed)}.`;
-                stateHandlers?.updateState({
-                    message,
-                    summary,
-                    taskInfos: updatedTaskInfos,
-                    completed: index + 1,
-                    taskExecutionTimes: updatedTimes,
-                    completionMessage: completion,
-                    error: null,
-                });
-                lifecycleHandlers?.completeActive();
-            }
+        if (result.shouldComplete) {
+            lifecycleHandlers.completeActive();
         }
     }, [
         taskInfos,
         message,
-        stateHandlers,
-        lifecycleHandlers,
-        errorHandlers,
-        taskExecutionTimes,
         summary,
+        taskExecutionTimes,
+        requestHandlers,
+        lifecycleHandlers,
     ]);
     const handleTaskAbort = useCallback((_index) => {
         // Task was aborted - execution already stopped by Escape handler
         // Just update state, don't call onAborted (already called at Execute level)
-        stateHandlers?.updateState({
-            message,
-            summary,
-            taskInfos,
-            completed,
-            taskExecutionTimes,
-            completionMessage: null,
-            error: null,
-        });
-    }, [taskInfos, message, summary, completed, taskExecutionTimes, stateHandlers]);
-    // Return null only when loading completes with no commands
-    if (!isActive && taskInfos.length === 0 && !error) {
-        return null;
-    }
-    // Show completed steps when not active
-    const showTasks = !isActive && taskInfos.length > 0;
-    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, {})] })), taskInfos.map((taskInfo, index) => (_jsx(Box, { marginBottom: index < taskInfos.length - 1 ? 1 : 0, children: _jsx(Task, { label: taskInfo.label, command: taskInfo.command, isActive: isActive && index === completed, index: index, initialStatus: taskInfo.status, initialElapsed: taskInfo.elapsed, onComplete: handleTaskComplete, onAbort: handleTaskAbort, onError: handleTaskError }) }, index)))] })), completionMessage && !isActive && (_jsx(Box, { marginTop: 1, marginLeft: 1, children: _jsx(Text, { color: getTextColor(false), children: completionMessage }) })), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) }))] }));
+        const finalState = buildAbortedState(taskInfos, message, summary, completed, taskExecutionTimes);
+        requestHandlers.onCompleted(finalState);
+    }, [
+        taskInfos,
+        message,
+        summary,
+        completed,
+        taskExecutionTimes,
+        requestHandlers,
+    ]);
+    // Controller always renders View with current state
+    const viewState = {
+        error,
+        taskInfos,
+        message,
+        summary,
+        completed,
+        taskExecutionTimes,
+        completionMessage,
+    };
+    return (_jsx(ExecuteView, { tasks: tasks, state: viewState, status: status, onTaskComplete: handleTaskComplete, onTaskAbort: handleTaskAbort, onTaskError: handleTaskError }));
 }