prompt-language-shell 0.8.0 → 0.8.4

package/dist/ui/Execute.js

@@ -1,9 +1,8 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useCallback, useEffect, useState } from 'react';
+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 { addDebugToTimeline } from '../services/components.js';
 import { useInput } from '../services/keyboard.js';
 import { loadUserConfig } from '../services/loader.js';
 import { formatErrorMessage } from '../services/messages.js';
@@ -14,41 +13,184 @@ import { formatDuration } from '../services/utils.js';
 import { Spinner } from './Spinner.js';
 import { Task } from './Task.js';
 const MINIMUM_PROCESSING_TIME = 400;
-export function Execute({ tasks, state, status, service, handlers, }) {
+/**
+ * Validates that all placeholders in a command have been resolved.
+ * Throws an error if unresolved placeholders are found.
+ */
+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, }) {
     const isActive = status === ComponentStatus.Active;
-    const [error, setError] = useState(state?.error ?? null);
-    const [taskInfos, setTaskInfos] = useState(state?.taskInfos ?? []);
-    const [message, setMessage] = useState(state?.message ?? '');
-    const [completed, setCompleted] = useState(state?.completed ?? 0);
-    const [hasProcessed, setHasProcessed] = useState(false);
-    const [taskExecutionTimes, setTaskExecutionTimes] = useState(state?.taskExecutionTimes ?? []);
-    const [completionMessage, setCompletionMessage] = useState(state?.completionMessage ?? null);
-    const [summary, setSummary] = useState(state?.summary ?? '');
+    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 { 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(() => {
-        // Mark tasks based on their status relative to completed:
-        // - Before completed: finished (Success)
-        // - At completed: interrupted (Aborted)
-        // - After completed: never started (Cancelled)
+        dispatch({ type: 'CANCEL_EXECUTION', payload: { completed } });
+        // Get updated task infos after cancel
         const updatedTaskInfos = taskInfos.map((task, taskIndex) => {
             if (taskIndex < completed) {
-                // Tasks that completed before interruption
                 return { ...task, status: ExecutionStatus.Success };
             }
             else if (taskIndex === completed) {
-                // Task that was running when interrupted
                 return { ...task, status: ExecutionStatus.Aborted };
             }
             else {
-                // Tasks that haven't started yet
                 return { ...task, status: ExecutionStatus.Cancelled };
             }
         });
-        setTaskInfos(updatedTaskInfos);
-        handlers?.updateState({
+        stateHandlers?.updateState({
             message,
             summary,
             taskInfos: updatedTaskInfos,
@@ -57,8 +199,16 @@ export function Execute({ tasks, state, status, service, handlers, }) {
             completionMessage: null,
             error: null,
         });
-        handlers?.onAborted('execution');
-    }, [message, summary, taskInfos, completed, taskExecutionTimes, handlers]);
+        errorHandlers?.onAborted('execution');
+    }, [
+        message,
+        summary,
+        taskInfos,
+        completed,
+        taskExecutionTimes,
+        stateHandlers,
+        errorHandlers,
+    ]);
     useInput((_, key) => {
         if (key.escape && (isLoading || isExecuting) && isActive) {
             handleCancel();
@@ -69,10 +219,6 @@ export function Execute({ tasks, state, status, service, handlers, }) {
         if (!isActive || taskInfos.length > 0 || hasProcessed) {
             return;
         }
-        if (!service) {
-            setError('No service available');
-            return;
-        }
         let mounted = true;
         async function process(svc) {
             const startTime = Date.now();
@@ -95,10 +241,15 @@ export function Execute({ tasks, state, status, service, handlers, }) {
                 if (!mounted)
                     return;
                 // Add debug components to timeline if present
-                addDebugToTimeline(result.debug, handlers);
+                if (result.debug?.length) {
+                    workflowHandlers?.addToTimeline(...result.debug);
+                }
                 if (!result.commands || result.commands.length === 0) {
-                    setHasProcessed(true);
-                    handlers?.updateState({
+                    dispatch({
+                        type: 'PROCESSING_COMPLETE',
+                        payload: { message: result.message },
+                    });
+                    stateHandlers?.updateState({
                         message: result.message,
                         summary: '',
                         taskInfos: [],
@@ -107,14 +258,15 @@ export function Execute({ tasks, state, status, service, handlers, }) {
                         completionMessage: null,
                         error: null,
                     });
-                    handlers?.completeActive();
+                    lifecycleHandlers?.completeActive();
                     return;
                 }
                 // Resolve placeholders in command strings
-                const resolvedCommands = result.commands.map((cmd) => ({
-                    ...cmd,
-                    command: replacePlaceholders(cmd.command, userConfig),
-                }));
+                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 || '';
@@ -122,12 +274,16 @@ export function Execute({ tasks, state, status, service, handlers, }) {
                     label: tasks[index]?.action,
                     command: cmd,
                 }));
-                setMessage(newMessage);
-                setSummary(newSummary);
-                setTaskInfos(infos);
-                setCompleted(0); // Start with first task
+                dispatch({
+                    type: 'COMMANDS_READY',
+                    payload: {
+                        message: newMessage,
+                        summary: newSummary,
+                        taskInfos: infos,
+                    },
+                });
                 // Update state after AI processing
-                handlers?.updateState({
+                stateHandlers?.updateState({
                     message: newMessage,
                     summary: newSummary,
                     taskInfos: infos,
@@ -141,9 +297,11 @@ export function Execute({ tasks, state, status, service, handlers, }) {
                 await ensureMinimumTime(startTime, MINIMUM_PROCESSING_TIME);
                 if (mounted) {
                     const errorMessage = formatErrorMessage(err);
-                    setError(errorMessage);
-                    setHasProcessed(true);
-                    handlers?.updateState({
+                    dispatch({
+                        type: 'PROCESSING_ERROR',
+                        payload: { error: errorMessage },
+                    });
+                    stateHandlers?.updateState({
                         message: '',
                         summary: '',
                         taskInfos: [],
@@ -152,28 +310,35 @@ export function Execute({ tasks, state, status, service, handlers, }) {
                         completionMessage: null,
                         error: errorMessage,
                     });
-                    handlers?.onError(errorMessage);
+                    errorHandlers?.onError(errorMessage);
                 }
             }
         }
-        process(service);
+        void process(service);
         return () => {
             mounted = false;
         };
-    }, [tasks, isActive, service, handlers, taskInfos.length, hasProcessed]);
+    }, [
+        tasks,
+        isActive,
+        service,
+        stateHandlers,
+        lifecycleHandlers,
+        workflowHandlers,
+        errorHandlers,
+        taskInfos.length,
+        hasProcessed,
+    ]);
     // Handle task completion - move to next task
     const handleTaskComplete = useCallback((index, _output, elapsed) => {
-        const updatedTimes = [...taskExecutionTimes, elapsed];
-        setTaskExecutionTimes(updatedTimes);
-        // Update task with elapsed time and success status
-        const updatedTaskInfos = taskInfos.map((task, i) => i === index
-            ? { ...task, status: ExecutionStatus.Success, elapsed }
-            : task);
-        setTaskInfos(updatedTaskInfos);
         if (index < taskInfos.length - 1) {
             // More tasks to execute
-            setCompleted(index + 1);
-            handlers?.updateState({
+            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,
@@ -185,11 +350,18 @@ export function Execute({ tasks, state, status, service, handlers, }) {
         }
         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 summaryText = summary?.trim() || 'Execution completed';
             const completion = `${summaryText} in ${formatDuration(totalElapsed)}.`;
-            setCompletionMessage(completion);
-            handlers?.updateState({
+            stateHandlers?.updateState({
                 message,
                 summary,
                 taskInfos: updatedTaskInfos,
@@ -198,21 +370,26 @@ export function Execute({ tasks, state, status, service, handlers, }) {
                 completionMessage: completion,
                 error: null,
             });
-            handlers?.completeActive();
+            lifecycleHandlers?.completeActive();
         }
-    }, [taskInfos, message, handlers, taskExecutionTimes, summary]);
+    }, [
+        taskInfos,
+        message,
+        lifecycleHandlers,
+        taskExecutionTimes,
+        summary,
+        stateHandlers,
+    ]);
     const handleTaskError = useCallback((index, error, elapsed) => {
         const task = taskInfos[index];
-        const isCritical = task?.command.critical !== false; // Default to true
-        // Update task with elapsed time and failed status
+        const isCritical = task.command.critical !== false; // Default to true
         const updatedTaskInfos = taskInfos.map((task, i) => i === index
             ? { ...task, status: ExecutionStatus.Failed, elapsed }
             : task);
-        setTaskInfos(updatedTaskInfos);
         if (isCritical) {
             // Critical failure - stop execution
-            setError(error);
-            handlers?.updateState({
+            dispatch({ type: 'TASK_ERROR_CRITICAL', payload: { index, error } });
+            stateHandlers?.updateState({
                 message,
                 summary,
                 taskInfos: updatedTaskInfos,
@@ -221,15 +398,17 @@ export function Execute({ tasks, state, status, service, handlers, }) {
                 completionMessage: null,
                 error,
             });
-            handlers?.onError(error);
+            errorHandlers?.onError(error);
         }
         else {
             // Non-critical failure - continue to next task
             const updatedTimes = [...taskExecutionTimes, elapsed];
-            setTaskExecutionTimes(updatedTimes);
             if (index < taskInfos.length - 1) {
-                setCompleted(index + 1);
-                handlers?.updateState({
+                dispatch({
+                    type: 'TASK_ERROR_CONTINUE',
+                    payload: { index, elapsed },
+                });
+                stateHandlers?.updateState({
                     message,
                     summary,
                     taskInfos: updatedTaskInfos,
@@ -241,11 +420,14 @@ export function Execute({ tasks, state, status, service, handlers, }) {
             }
             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 summaryText = summary?.trim() || 'Execution completed';
                 const completion = `${summaryText} in ${formatDuration(totalElapsed)}.`;
-                setCompletionMessage(completion);
-                handlers?.updateState({
+                stateHandlers?.updateState({
                     message,
                     summary,
                     taskInfos: updatedTaskInfos,
@@ -254,14 +436,22 @@ export function Execute({ tasks, state, status, service, handlers, }) {
                     completionMessage: completion,
                     error: null,
                 });
-                handlers?.completeActive();
+                lifecycleHandlers?.completeActive();
             }
         }
-    }, [taskInfos, message, handlers, taskExecutionTimes, summary]);
+    }, [
+        taskInfos,
+        message,
+        stateHandlers,
+        lifecycleHandlers,
+        errorHandlers,
+        taskExecutionTimes,
+        summary,
+    ]);
     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)
-        handlers?.updateState({
+        stateHandlers?.updateState({
             message,
             summary,
             taskInfos,
@@ -270,7 +460,7 @@ export function Execute({ tasks, state, status, service, handlers, }) {
             completionMessage: null,
             error: null,
         });
-    }, [taskInfos, message, summary, completed, taskExecutionTimes, handlers]);
+    }, [taskInfos, message, summary, completed, taskExecutionTimes, stateHandlers]);
     // Return null only when loading completes with no commands
     if (!isActive && taskInfos.length === 0 && !error) {
         return null;

package/dist/ui/Feedback.js

@@ -5,6 +5,7 @@ import { getFeedbackColor } from '../services/colors.js';
 function getSymbol(type) {
     return {
         [FeedbackType.Info]: 'ℹ',
+        [FeedbackType.Warning]: '⚠',
         [FeedbackType.Succeeded]: '✓',
         [FeedbackType.Aborted]: '⊘',
         [FeedbackType.Failed]: '✗',

package/dist/ui/Introspect.js

@@ -1,64 +1,22 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
 import { Box, Text } from 'ink';
-import { ComponentStatus, } from '../types/components.js';
+import { ComponentStatus } from '../types/components.js';
 import { Colors, getTextColor } from '../services/colors.js';
-import { addDebugToTimeline, createReportDefinition, } from '../services/components.js';
+import { createReportDefinition } from '../services/components.js';
 import { DebugLevel } from '../services/configuration.js';
 import { useInput } from '../services/keyboard.js';
 import { formatErrorMessage } from '../services/messages.js';
 import { ensureMinimumTime } from '../services/timing.js';
 import { Spinner } from './Spinner.js';
 const MIN_PROCESSING_TIME = 1000;
-const BUILT_IN_CAPABILITIES = new Set([
-    'CONFIGURE',
-    'SCHEDULE',
-    'INTROSPECT',
-    'ANSWER',
-    'EXECUTE',
-    'VALIDATE',
-    'REPORT',
-]);
-const INDIRECT_CAPABILITIES = new Set(['SCHEDULE', 'VALIDATE', 'REPORT']);
-function parseCapabilityFromTask(task) {
-    // Parse "NAME: Description" format from task.action
-    const colonIndex = task.action.indexOf(':');
-    if (colonIndex === -1) {
-        const upperName = task.action.toUpperCase();
-        // Check for status markers
-        const isIncomplete = task.action.includes('(INCOMPLETE)');
-        const cleanName = task.action.replace(/\s*\(INCOMPLETE\)\s*/gi, '').trim();
-        return {
-            name: cleanName,
-            description: '',
-            isBuiltIn: BUILT_IN_CAPABILITIES.has(upperName),
-            isIndirect: INDIRECT_CAPABILITIES.has(upperName),
-            isIncomplete,
-        };
-    }
-    const name = task.action.substring(0, colonIndex).trim();
-    const description = task.action.substring(colonIndex + 1).trim();
-    // Check for status markers
-    const isIncomplete = name.includes('(INCOMPLETE)');
-    const cleanName = name.replace(/\s*\(INCOMPLETE\)\s*/gi, '').trim();
-    const upperName = cleanName.toUpperCase();
-    const isBuiltIn = BUILT_IN_CAPABILITIES.has(upperName);
-    const isIndirect = INDIRECT_CAPABILITIES.has(upperName);
-    return {
-        name: cleanName,
-        description,
-        isBuiltIn,
-        isIndirect,
-        isIncomplete,
-    };
-}
-export function Introspect({ tasks, state, status, service, children, debug = DebugLevel.None, handlers, }) {
+export function Introspect({ tasks, state: _state, status, service, children, debug = DebugLevel.None, stateHandlers, lifecycleHandlers, queueHandlers, errorHandlers, workflowHandlers, }) {
     const isActive = status === ComponentStatus.Active;
     // isActive passed as prop
     const [error, setError] = useState(null);
     useInput((input, key) => {
         if (key.escape && isActive) {
-            handlers?.onAborted('introspection');
+            errorHandlers?.onAborted('introspection');
         }
     }, { isActive });
     useEffect(() => {
@@ -66,11 +24,6 @@ export function Introspect({ tasks, state, status, service, children, debug = De
         if (!isActive) {
             return;
         }
-        // Skip processing if no service available
-        if (!service) {
-            setError('No service available');
-            return;
-        }
         let mounted = true;
         async function process(svc) {
             const startTime = Date.now();
@@ -82,9 +35,11 @@ export function Introspect({ tasks, state, status, service, children, debug = De
                 await ensureMinimumTime(startTime, MIN_PROCESSING_TIME);
                 if (mounted) {
                     // Add debug components to timeline if present
-                    addDebugToTimeline(result.debug, handlers);
-                    // Parse capabilities from returned tasks
-                    let capabilities = result.tasks.map(parseCapabilityFromTask);
+                    if (result.debug?.length) {
+                        workflowHandlers?.addToTimeline(...result.debug);
+                    }
+                    // Capabilities come directly from result - no parsing needed
+                    let capabilities = result.capabilities;
                     // Filter out internal capabilities when not in debug mode
                     if (debug === DebugLevel.None) {
                         capabilities = capabilities.filter((cap) => cap.name.toUpperCase() !== 'SCHEDULE' &&
@@ -92,14 +47,14 @@ export function Introspect({ tasks, state, status, service, children, debug = De
                             cap.name.toUpperCase() !== 'REPORT');
                     }
                     // Save state before completing
-                    handlers?.updateState({
+                    stateHandlers?.updateState({
                         capabilities,
                         message: result.message,
                     });
                     // Add Report component to queue
-                    handlers?.addToQueue(createReportDefinition(result.message, capabilities));
+                    queueHandlers?.addToQueue(createReportDefinition(result.message, capabilities));
                     // Signal completion
-                    handlers?.completeActive();
+                    lifecycleHandlers?.completeActive();
                 }
             }
             catch (err) {
@@ -108,18 +63,18 @@ export function Introspect({ tasks, state, status, service, children, debug = De
                     const errorMessage = formatErrorMessage(err);
                     setError(errorMessage);
                     // Save error state
-                    handlers?.updateState({
+                    stateHandlers?.updateState({
                         error: errorMessage,
                     });
-                    handlers?.onError(errorMessage);
+                    errorHandlers?.onError(errorMessage);
                 }
             }
         }
-        process(service);
+        void process(service);
         return () => {
             mounted = false;
         };
-    }, [tasks, isActive, service, debug, handlers]);
+    }, [tasks, isActive, service, debug]);
     // Don't render wrapper when done and nothing to show
     if (!isActive && !error && !children) {
         return null;