prompt-language-shell 0.8.8 → 0.9.2

package/dist/execution/hooks.js

@@ -0,0 +1,291 @@
+import { useCallback, useEffect, useRef, useState, } from 'react';
+import { ComponentStatus, } from '../types/components.js';
+import { FeedbackType } from '../types/types.js';
+import { createFeedback, createMessage } from '../services/components.js';
+import { formatErrorMessage, getExecutionErrorMessage, } from '../services/messages.js';
+import { ExecutionStatus } from '../services/shell.js';
+import { ensureMinimumTime } from '../services/timing.js';
+import { handleTaskCompletion, handleTaskFailure } from './handlers.js';
+import { processTasks } from './processing.js';
+import { executeTask } from './runner.js';
+import { ExecuteActionType } from './types.js';
+import { getCurrentTaskIndex } from './utils.js';
+const ELAPSED_UPDATE_INTERVAL = 1000;
+/**
+ * Track elapsed time from a start timestamp.
+ * Returns 0 when not active or no start time.
+ */
+export function useElapsedTimer(startTime, isActive) {
+    const [elapsed, setElapsed] = useState(0);
+    useEffect(() => {
+        if (!startTime || !isActive)
+            return;
+        const interval = setInterval(() => {
+            setElapsed(Date.now() - startTime);
+        }, ELAPSED_UPDATE_INTERVAL);
+        return () => {
+            clearInterval(interval);
+        };
+    }, [startTime, isActive]);
+    return elapsed;
+}
+/**
+ * Manage live output and timing for the currently executing task.
+ * Groups related state for tracking a running task's output.
+ */
+export function useLiveTaskOutput() {
+    const [output, setOutput] = useState({
+        stdout: '',
+        stderr: '',
+        error: '',
+    });
+    const [startTime, setStartTime] = useState(null);
+    const start = useCallback(() => {
+        setOutput({ stdout: '', stderr: '', error: '' });
+        setStartTime(Date.now());
+    }, []);
+    const stop = useCallback(() => {
+        setStartTime(null);
+    }, []);
+    return {
+        output,
+        startTime,
+        setOutput,
+        start,
+        stop,
+    };
+}
+/**
+ * Handle execution cancellation with a ref-based flag.
+ * The ref is needed because callbacks check the current cancellation state.
+ */
+export function useCancellation() {
+    const cancelledRef = useRef(false);
+    const cancel = useCallback(() => {
+        cancelledRef.current = true;
+    }, []);
+    const reset = useCallback(() => {
+        cancelledRef.current = false;
+    }, []);
+    return {
+        cancelledRef,
+        cancel,
+        reset,
+    };
+}
+const MINIMUM_PROCESSING_TIME = 400;
+/**
+ * Helper to create ExecuteState with defaults
+ */
+function createExecuteState(overrides = {}) {
+    return {
+        message: '',
+        summary: '',
+        tasks: [],
+        completionMessage: null,
+        error: null,
+        ...overrides,
+    };
+}
+/**
+ * Process input tasks through AI to generate executable commands.
+ * Handles the initial phase of task execution.
+ */
+export function useTaskProcessor(config) {
+    const { inputTasks, service, isActive, hasProcessed, tasksCount, dispatch, requestHandlers, lifecycleHandlers, workflowHandlers, } = config;
+    useEffect(() => {
+        if (!isActive || tasksCount > 0 || hasProcessed) {
+            return;
+        }
+        let mounted = true;
+        async function process(svc) {
+            const startTime = Date.now();
+            try {
+                const result = await processTasks(inputTasks, 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);
+                }
+                if (result.commands.length === 0) {
+                    if (result.error) {
+                        const errorMessage = getExecutionErrorMessage(result.error);
+                        workflowHandlers.addToTimeline(createMessage({ text: errorMessage }, ComponentStatus.Done));
+                        requestHandlers.onCompleted(createExecuteState({ message: result.message }));
+                        lifecycleHandlers.completeActive();
+                        return;
+                    }
+                    dispatch({
+                        type: ExecuteActionType.ProcessingComplete,
+                        payload: { message: result.message },
+                    });
+                    requestHandlers.onCompleted(createExecuteState({ message: result.message }));
+                    lifecycleHandlers.completeActive();
+                    return;
+                }
+                // Create task infos from commands
+                const taskInfos = result.commands.map((cmd, index) => ({
+                    label: inputTasks[index]?.action ?? cmd.description,
+                    command: cmd,
+                    status: ExecutionStatus.Pending,
+                    elapsed: 0,
+                }));
+                dispatch({
+                    type: ExecuteActionType.CommandsReady,
+                    payload: {
+                        message: result.message,
+                        summary: result.summary,
+                        tasks: taskInfos,
+                    },
+                });
+                requestHandlers.onCompleted(createExecuteState({
+                    message: result.message,
+                    summary: result.summary,
+                    tasks: taskInfos,
+                }));
+            }
+            catch (err) {
+                await ensureMinimumTime(startTime, MINIMUM_PROCESSING_TIME);
+                if (mounted) {
+                    const errorMessage = formatErrorMessage(err);
+                    dispatch({
+                        type: ExecuteActionType.ProcessingError,
+                        payload: { error: errorMessage },
+                    });
+                    requestHandlers.onCompleted(createExecuteState({ error: errorMessage }));
+                    requestHandlers.onError(errorMessage);
+                }
+            }
+        }
+        void process(service);
+        return () => {
+            mounted = false;
+        };
+    }, [
+        inputTasks,
+        isActive,
+        service,
+        requestHandlers,
+        lifecycleHandlers,
+        workflowHandlers,
+        tasksCount,
+        hasProcessed,
+        dispatch,
+    ]);
+}
+/**
+ * Execute tasks sequentially, managing state and handling completion/errors.
+ */
+export function useTaskExecutor(config) {
+    const { isActive, tasks, message, summary, error, workdir, setWorkdir, cancelledRef, liveOutput, dispatch, requestHandlers, lifecycleHandlers, workflowHandlers, } = config;
+    const currentTaskIndex = getCurrentTaskIndex(tasks);
+    useEffect(() => {
+        if (!isActive ||
+            tasks.length === 0 ||
+            currentTaskIndex >= tasks.length ||
+            error) {
+            return;
+        }
+        const currentTask = tasks[currentTaskIndex];
+        if (currentTask.status !== ExecutionStatus.Pending) {
+            return;
+        }
+        cancelledRef.current = false;
+        // Mark task as started (running)
+        dispatch({
+            type: ExecuteActionType.TaskStarted,
+            payload: { index: currentTaskIndex },
+        });
+        // Reset live state for new task
+        liveOutput.start();
+        // Merge workdir into command
+        const command = workdir
+            ? { ...currentTask.command, workdir }
+            : currentTask.command;
+        void executeTask(command, currentTaskIndex, {
+            onOutputChange: (output) => {
+                if (!cancelledRef.current) {
+                    liveOutput.setOutput(output);
+                }
+            },
+            onComplete: (elapsed, output) => {
+                if (cancelledRef.current)
+                    return;
+                liveOutput.stop();
+                // Track working directory
+                if (output.workdir) {
+                    setWorkdir(output.workdir);
+                }
+                const tasksWithOutput = tasks.map((task, i) => i === currentTaskIndex
+                    ? {
+                        ...task,
+                        stdout: output.stdout,
+                        stderr: output.stderr,
+                        error: output.error,
+                    }
+                    : task);
+                const result = handleTaskCompletion(currentTaskIndex, elapsed, {
+                    tasks: tasksWithOutput,
+                    message,
+                    summary,
+                });
+                dispatch(result.action);
+                requestHandlers.onCompleted(result.finalState);
+                if (result.shouldComplete) {
+                    lifecycleHandlers.completeActive();
+                }
+            },
+            onError: (errorMsg, elapsed, output) => {
+                if (cancelledRef.current)
+                    return;
+                liveOutput.stop();
+                // Track working directory
+                if (output.workdir) {
+                    setWorkdir(output.workdir);
+                }
+                const tasksWithOutput = tasks.map((task, i) => i === currentTaskIndex
+                    ? {
+                        ...task,
+                        stdout: output.stdout,
+                        stderr: output.stderr,
+                        error: output.error,
+                    }
+                    : task);
+                const result = handleTaskFailure(currentTaskIndex, errorMsg, elapsed, {
+                    tasks: tasksWithOutput,
+                    message,
+                    summary,
+                });
+                dispatch(result.action);
+                requestHandlers.onCompleted(result.finalState);
+                if (result.action.type === ExecuteActionType.TaskErrorCritical) {
+                    const criticalErrorMessage = getExecutionErrorMessage(errorMsg);
+                    workflowHandlers.addToQueue(createFeedback({
+                        type: FeedbackType.Failed,
+                        message: criticalErrorMessage,
+                    }));
+                }
+                if (result.shouldComplete) {
+                    lifecycleHandlers.completeActive();
+                }
+            },
+        });
+    }, [
+        isActive,
+        tasks,
+        currentTaskIndex,
+        message,
+        summary,
+        error,
+        workdir,
+        setWorkdir,
+        cancelledRef,
+        liveOutput,
+        dispatch,
+        requestHandlers,
+        lifecycleHandlers,
+        workflowHandlers,
+    ]);
+}

package/dist/execution/processing.js

@@ -1,6 +1,15 @@
 import { loadUserConfig } from '../services/loader.js';
 import { replacePlaceholders } from '../services/resolver.js';
 import { validatePlaceholderResolution } from './validation.js';
+/**
+ * Fix escaped quotes in commands
+ * JSON parsing removes backslashes before quotes in patterns like key="value"
+ * This restores them: key="value" -> key=\"value\"
+ */
+export function fixEscapedQuotes(command) {
+    // Replace ="value" with =\"value\"
+    return command.replace(/="([^"]*)"/g, '=\\"$1\\"');
+}
 /**
  * Processes tasks through the AI service to generate executable commands.
  * Resolves placeholders in task descriptions and validates the results.
@@ -9,7 +18,7 @@ export async function processTasks(tasks, service) {
     // Load user config for placeholder resolution
     const userConfig = loadUserConfig();
     // Format tasks for the execute tool and resolve placeholders
-    const taskDescriptions = tasks
+    const taskList = tasks
         .map((task) => {
         const resolvedAction = replacePlaceholders(task.action, userConfig);
         const params = task.params
@@ -18,11 +27,15 @@ export async function processTasks(tasks, service) {
         return `- ${resolvedAction}${params}`;
     })
         .join('\n');
+    // Build message with confirmed schedule header
+    const taskDescriptions = `Confirmed schedule (${tasks.length} tasks):\n${taskList}`;
     // Call execute tool to get commands
     const result = await service.processWithTool(taskDescriptions, 'execute');
     // Resolve placeholders in command strings
     const resolvedCommands = (result.commands || []).map((cmd) => {
-        const resolved = replacePlaceholders(cmd.command, userConfig);
+        // Fix escaped quotes lost in JSON parsing
+        const fixed = fixEscapedQuotes(cmd.command);
+        const resolved = replacePlaceholders(fixed, userConfig);
         validatePlaceholderResolution(resolved);
         return { ...cmd, command: resolved };
     });

package/dist/execution/reducer.js

@@ -1,13 +1,12 @@
 import { ExecutionStatus } from '../services/shell.js';
 import { formatDuration } from '../services/utils.js';
 import { ExecuteActionType, } from './types.js';
+import { getTotalElapsed } from './utils.js';
 export const initialState = {
     error: null,
-    taskInfos: [],
+    tasks: [],
     message: '',
-    completed: 0,
     hasProcessed: false,
-    taskExecutionTimes: [],
     completionMessage: null,
     summary: '',
 };
@@ -24,8 +23,7 @@ export function executeReducer(state, action) {
                 ...state,
                 message: action.payload.message,
                 summary: action.payload.summary,
-                taskInfos: action.payload.taskInfos,
-                completed: 0,
+                tasks: action.payload.tasks,
             };
         case ExecuteActionType.ProcessingError:
             return {
@@ -33,12 +31,17 @@ export function executeReducer(state, action) {
                 error: action.payload.error,
                 hasProcessed: true,
             };
+        case ExecuteActionType.TaskStarted: {
+            const updatedTasks = state.tasks.map((task, i) => i === action.payload.index
+                ? { ...task, status: ExecutionStatus.Running }
+                : task);
+            return {
+                ...state,
+                tasks: updatedTasks,
+            };
+        }
         case ExecuteActionType.TaskComplete: {
-            const updatedTimes = [
-                ...state.taskExecutionTimes,
-                action.payload.elapsed,
-            ];
-            const updatedTaskInfos = state.taskInfos.map((task, i) => i === action.payload.index
+            const updatedTaskInfos = state.tasks.map((task, i) => i === action.payload.index
                 ? {
                     ...task,
                     status: ExecutionStatus.Success,
@@ -47,49 +50,37 @@ export function executeReducer(state, action) {
                 : task);
             return {
                 ...state,
-                taskInfos: updatedTaskInfos,
-                taskExecutionTimes: updatedTimes,
-                completed: action.payload.index + 1,
+                tasks: updatedTaskInfos,
             };
         }
         case ExecuteActionType.AllTasksComplete: {
-            const updatedTimes = [
-                ...state.taskExecutionTimes,
-                action.payload.elapsed,
-            ];
-            const updatedTaskInfos = state.taskInfos.map((task, i) => i === action.payload.index
+            const updatedTaskInfos = state.tasks.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 totalElapsed = getTotalElapsed(updatedTaskInfos);
             const completion = `${action.payload.summaryText} in ${formatDuration(totalElapsed)}.`;
             return {
                 ...state,
-                taskInfos: updatedTaskInfos,
-                taskExecutionTimes: updatedTimes,
-                completed: action.payload.index + 1,
+                tasks: updatedTaskInfos,
                 completionMessage: completion,
             };
         }
         case ExecuteActionType.TaskErrorCritical: {
-            const updatedTaskInfos = state.taskInfos.map((task, i) => i === action.payload.index
+            const updatedTaskInfos = state.tasks.map((task, i) => i === action.payload.index
                 ? { ...task, status: ExecutionStatus.Failed, elapsed: 0 }
                 : task);
             return {
                 ...state,
-                taskInfos: updatedTaskInfos,
+                tasks: updatedTaskInfos,
                 error: action.payload.error,
             };
         }
         case ExecuteActionType.TaskErrorContinue: {
-            const updatedTimes = [
-                ...state.taskExecutionTimes,
-                action.payload.elapsed,
-            ];
-            const updatedTaskInfos = state.taskInfos.map((task, i) => i === action.payload.index
+            const updatedTaskInfos = state.tasks.map((task, i) => i === action.payload.index
                 ? {
                     ...task,
                     status: ExecutionStatus.Failed,
@@ -98,48 +89,39 @@ export function executeReducer(state, action) {
                 : task);
             return {
                 ...state,
-                taskInfos: updatedTaskInfos,
-                taskExecutionTimes: updatedTimes,
-                completed: action.payload.index + 1,
+                tasks: updatedTaskInfos,
             };
         }
         case ExecuteActionType.LastTaskError: {
-            const updatedTimes = [
-                ...state.taskExecutionTimes,
-                action.payload.elapsed,
-            ];
-            const updatedTaskInfos = state.taskInfos.map((task, i) => i === action.payload.index
+            const updatedTaskInfos = state.tasks.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 totalElapsed = getTotalElapsed(updatedTaskInfos);
             const completion = `${action.payload.summaryText} in ${formatDuration(totalElapsed)}.`;
             return {
                 ...state,
-                taskInfos: updatedTaskInfos,
-                taskExecutionTimes: updatedTimes,
-                completed: action.payload.index + 1,
+                tasks: updatedTaskInfos,
                 completionMessage: completion,
             };
         }
         case ExecuteActionType.CancelExecution: {
-            const updatedTaskInfos = state.taskInfos.map((task, taskIndex) => {
-                if (taskIndex < action.payload.completed) {
-                    return { ...task, status: ExecutionStatus.Success };
-                }
-                else if (taskIndex === action.payload.completed) {
+            // Mark running task as aborted, pending tasks as cancelled
+            const updatedTaskInfos = state.tasks.map((task) => {
+                if (task.status === ExecutionStatus.Running) {
                     return { ...task, status: ExecutionStatus.Aborted };
                 }
-                else {
+                else if (task.status === ExecutionStatus.Pending) {
                     return { ...task, status: ExecutionStatus.Cancelled };
                 }
+                return task;
             });
             return {
                 ...state,
-                taskInfos: updatedTaskInfos,
+                tasks: updatedTaskInfos,
             };
         }
         default:

package/dist/execution/runner.js

@@ -0,0 +1,81 @@
+import { ExecutionResult, ExecutionStatus, executeCommand, setOutputCallback, } from '../services/shell.js';
+import { calculateElapsed } from '../services/utils.js';
+/**
+ * Execute a single task and track its progress.
+ * All execution logic is contained here, outside of React components.
+ */
+export async function executeTask(command, index, callbacks) {
+    const startTime = Date.now();
+    let stdout = '';
+    let stderr = '';
+    let error = '';
+    let workdir;
+    // Helper to create current output snapshot
+    const createOutput = () => ({
+        stdout,
+        stderr,
+        error,
+        workdir,
+    });
+    // Set up output streaming callback
+    setOutputCallback((data, stream) => {
+        if (stream === 'stdout') {
+            stdout += data;
+        }
+        else {
+            stderr += data;
+        }
+        callbacks.onOutputChange?.(createOutput());
+    });
+    callbacks.onStart?.();
+    try {
+        const result = await executeCommand(command, undefined, index);
+        // Clear callback
+        setOutputCallback(undefined);
+        const elapsed = calculateElapsed(startTime);
+        // Update final output from result
+        stdout = result.output;
+        stderr = result.errors;
+        workdir = result.workdir;
+        if (result.result === ExecutionResult.Success) {
+            const output = createOutput();
+            callbacks.onComplete?.(elapsed, output);
+            return {
+                status: ExecutionStatus.Success,
+                elapsed,
+                output,
+            };
+        }
+        else {
+            const errorMsg = result.errors || result.error || 'Command failed';
+            error = errorMsg;
+            const output = createOutput();
+            callbacks.onError?.(errorMsg, elapsed, output);
+            return {
+                status: ExecutionStatus.Failed,
+                elapsed,
+                output,
+            };
+        }
+    }
+    catch (err) {
+        // Clear callback
+        setOutputCallback(undefined);
+        const elapsed = calculateElapsed(startTime);
+        const errorMsg = err instanceof Error ? err.message : 'Unknown error';
+        error = errorMsg;
+        const output = createOutput();
+        callbacks.onError?.(errorMsg, elapsed, output);
+        return {
+            status: ExecutionStatus.Failed,
+            elapsed,
+            output,
+        };
+    }
+}
+/**
+ * Create an empty task output
+ */
+export function createEmptyOutput() {
+    return { stdout: '', stderr: '', error: '' };
+}

package/dist/execution/types.js

@@ -3,6 +3,7 @@ export var ExecuteActionType;
     ExecuteActionType["ProcessingComplete"] = "PROCESSING_COMPLETE";
     ExecuteActionType["CommandsReady"] = "COMMANDS_READY";
     ExecuteActionType["ProcessingError"] = "PROCESSING_ERROR";
+    ExecuteActionType["TaskStarted"] = "TASK_STARTED";
     ExecuteActionType["TaskComplete"] = "TASK_COMPLETE";
     ExecuteActionType["AllTasksComplete"] = "ALL_TASKS_COMPLETE";
     ExecuteActionType["TaskErrorCritical"] = "TASK_ERROR_CRITICAL";

package/dist/execution/utils.js

@@ -0,0 +1,28 @@
+import { ExecutionStatus } from '../services/shell.js';
+/**
+ * Calculate total elapsed time from task infos
+ */
+export function getTotalElapsed(tasks) {
+    return tasks.reduce((sum, task) => sum + task.elapsed, 0);
+}
+/**
+ * Calculate the number of finished tasks (success, failed, or aborted)
+ */
+export function getCompletedCount(tasks) {
+    return tasks.filter((task) => task.status === ExecutionStatus.Success ||
+        task.status === ExecutionStatus.Failed ||
+        task.status === ExecutionStatus.Aborted).length;
+}
+/**
+ * Get the index of the current task to execute.
+ * Returns the index of the first Running or Pending task, or tasks.length if all done.
+ */
+export function getCurrentTaskIndex(tasks) {
+    const runningIndex = tasks.findIndex((t) => t.status === ExecutionStatus.Running);
+    if (runningIndex !== -1)
+        return runningIndex;
+    const pendingIndex = tasks.findIndex((t) => t.status === ExecutionStatus.Pending);
+    if (pendingIndex !== -1)
+        return pendingIndex;
+    return tasks.length;
+}