prompt-language-shell 0.9.2 → 0.9.4

package/dist/execution/handlers.js

@@ -7,7 +7,7 @@ import { getTotalElapsed } from './utils.js';
  */
 export function handleTaskCompletion(index, elapsed, context) {
     const { tasks, message, summary } = context;
-    const updatedTaskInfos = tasks.map((task, i) => i === index ? { ...task, status: ExecutionStatus.Success, elapsed } : task);
+    const updatedTasks = tasks.map((task, i) => i === index ? { ...task, status: ExecutionStatus.Success, elapsed } : task);
     if (index < tasks.length - 1) {
         // More tasks to execute
         return {
@@ -18,7 +18,7 @@ export function handleTaskCompletion(index, elapsed, context) {
             finalState: {
                 message,
                 summary,
-                tasks: updatedTaskInfos,
+                tasks: updatedTasks,
                 completionMessage: null,
                 error: null,
             },
@@ -27,17 +27,17 @@ export function handleTaskCompletion(index, elapsed, context) {
     }
     // All tasks complete
     const summaryText = summary.trim() || 'Execution completed';
-    const totalElapsed = getTotalElapsed(updatedTaskInfos);
+    const totalElapsed = getTotalElapsed(updatedTasks);
     const completion = `${summaryText} in ${formatDuration(totalElapsed)}.`;
     return {
         action: {
-            type: ExecuteActionType.AllTasksComplete,
+            type: ExecuteActionType.ExecutionComplete,
             payload: { index, elapsed, summaryText },
         },
         finalState: {
             message,
             summary,
-            tasks: updatedTaskInfos,
+            tasks: updatedTasks,
             completionMessage: completion,
             error: null,
         },
@@ -47,63 +47,29 @@ export function handleTaskCompletion(index, elapsed, context) {
 /**
  * Handles task error logic and returns the appropriate action and state.
  */
-export function handleTaskFailure(index, error, elapsed, context) {
+export function handleTaskFailure(index, error, context) {
     const { tasks, message, summary } = context;
-    const task = tasks[index];
-    const isCritical = task.command.critical !== false; // Default to true
-    const updatedTaskInfos = tasks.map((task, i) => i === index ? { ...task, status: ExecutionStatus.Failed, elapsed } : task);
-    if (isCritical) {
-        // Critical failure - stop execution
-        return {
-            action: {
-                type: ExecuteActionType.TaskErrorCritical,
-                payload: { index, error },
-            },
-            finalState: {
-                message,
-                summary,
-                tasks: updatedTaskInfos,
-                completionMessage: null,
-                error: null,
-            },
-            shouldComplete: true,
-        };
-    }
-    // Non-critical failure - continue to next task
-    if (index < tasks.length - 1) {
-        return {
-            action: {
-                type: ExecuteActionType.TaskErrorContinue,
-                payload: { index, elapsed },
-            },
-            finalState: {
-                message,
-                summary,
-                tasks: updatedTaskInfos,
-                completionMessage: null,
-                error: null,
-            },
-            shouldComplete: false,
-        };
-    }
-    // Last task failed (non-critical), complete execution
-    // Non-critical failures still show completion message with summary
-    const summaryText = summary.trim() || 'Execution completed';
-    const totalElapsed = getTotalElapsed(updatedTaskInfos);
-    const completion = `${summaryText} in ${formatDuration(totalElapsed)}.`;
+    const updatedTasks = tasks.map((task, i) => {
+        if (i === index) {
+            return { ...task, status: ExecutionStatus.Failed, elapsed: 0 };
+        }
+        else if (i > index && task.status === ExecutionStatus.Pending) {
+            return { ...task, status: ExecutionStatus.Cancelled };
+        }
+        return task;
+    });
     return {
         action: {
-            type: ExecuteActionType.LastTaskError,
-            payload: { index, elapsed, summaryText },
+            type: ExecuteActionType.TaskError,
+            payload: { index, error },
         },
         finalState: {
             message,
             summary,
-            tasks: updatedTaskInfos,
-            completionMessage: completion,
+            tasks: updatedTasks,
+            completionMessage: null,
             error: null,
         },
-        shouldComplete: true,
     };
 }
 /**

package/dist/execution/reducer.js

@@ -33,84 +33,72 @@ export function executeReducer(state, action) {
             };
         case ExecuteActionType.TaskStarted: {
             const updatedTasks = state.tasks.map((task, i) => i === action.payload.index
-                ? { ...task, status: ExecutionStatus.Running }
+                ? {
+                    ...task,
+                    status: ExecutionStatus.Running,
+                    startTime: action.payload.startTime,
+                }
                 : task);
             return {
                 ...state,
                 tasks: updatedTasks,
             };
         }
-        case ExecuteActionType.TaskComplete: {
-            const updatedTaskInfos = state.tasks.map((task, i) => i === action.payload.index
+        case ExecuteActionType.TaskProgress: {
+            const updatedTasks = state.tasks.map((task, i) => i === action.payload.index
                 ? {
                     ...task,
-                    status: ExecutionStatus.Success,
                     elapsed: action.payload.elapsed,
+                    output: action.payload.output,
                 }
                 : task);
             return {
                 ...state,
-                tasks: updatedTaskInfos,
+                tasks: updatedTasks,
             };
         }
-        case ExecuteActionType.AllTasksComplete: {
-            const updatedTaskInfos = state.tasks.map((task, i) => i === action.payload.index
+        case ExecuteActionType.TaskComplete: {
+            const updatedTasks = state.tasks.map((task, i) => i === action.payload.index
                 ? {
                     ...task,
                     status: ExecutionStatus.Success,
                     elapsed: action.payload.elapsed,
                 }
                 : task);
-            const totalElapsed = getTotalElapsed(updatedTaskInfos);
-            const completion = `${action.payload.summaryText} in ${formatDuration(totalElapsed)}.`;
             return {
                 ...state,
-                tasks: updatedTaskInfos,
-                completionMessage: completion,
-            };
-        }
-        case ExecuteActionType.TaskErrorCritical: {
-            const updatedTaskInfos = state.tasks.map((task, i) => i === action.payload.index
-                ? { ...task, status: ExecutionStatus.Failed, elapsed: 0 }
-                : task);
-            return {
-                ...state,
-                tasks: updatedTaskInfos,
-                error: action.payload.error,
+                tasks: updatedTasks,
             };
         }
-        case ExecuteActionType.TaskErrorContinue: {
-            const updatedTaskInfos = state.tasks.map((task, i) => i === action.payload.index
+        case ExecuteActionType.ExecutionComplete: {
+            const updatedTasks = state.tasks.map((task, i) => i === action.payload.index
                 ? {
                     ...task,
-                    status: ExecutionStatus.Failed,
+                    status: ExecutionStatus.Success,
                     elapsed: action.payload.elapsed,
                 }
                 : task);
+            const totalElapsed = getTotalElapsed(updatedTasks);
+            const completion = `${action.payload.summaryText} in ${formatDuration(totalElapsed)}.`;
             return {
                 ...state,
-                tasks: updatedTaskInfos,
+                tasks: updatedTasks,
+                completionMessage: completion,
             };
         }
-        case ExecuteActionType.LastTaskError: {
-            const updatedTaskInfos = state.tasks.map((task, i) => i === action.payload.index
-                ? {
-                    ...task,
-                    status: ExecutionStatus.Failed,
-                    elapsed: action.payload.elapsed,
-                }
+        case ExecuteActionType.TaskError: {
+            const updatedTasks = state.tasks.map((task, i) => i === action.payload.index
+                ? { ...task, status: ExecutionStatus.Failed, elapsed: 0 }
                 : task);
-            const totalElapsed = getTotalElapsed(updatedTaskInfos);
-            const completion = `${action.payload.summaryText} in ${formatDuration(totalElapsed)}.`;
             return {
                 ...state,
-                tasks: updatedTaskInfos,
-                completionMessage: completion,
+                tasks: updatedTasks,
+                error: action.payload.error,
             };
         }
         case ExecuteActionType.CancelExecution: {
             // Mark running task as aborted, pending tasks as cancelled
-            const updatedTaskInfos = state.tasks.map((task) => {
+            const updatedTasks = state.tasks.map((task) => {
                 if (task.status === ExecutionStatus.Running) {
                     return { ...task, status: ExecutionStatus.Aborted };
                 }
@@ -121,7 +109,7 @@ export function executeReducer(state, action) {
             });
             return {
                 ...state,
-                tasks: updatedTaskInfos,
+                tasks: updatedTasks,
             };
         }
         default:

package/dist/execution/runner.js

@@ -1,5 +1,14 @@
 import { ExecutionResult, ExecutionStatus, executeCommand, setOutputCallback, } from '../services/shell.js';
 import { calculateElapsed } from '../services/utils.js';
+// Maximum number of output lines to keep in memory
+const MAX_OUTPUT_LINES = 128;
+/**
+ * Limit output to last MAX_OUTPUT_LINES lines to prevent memory exhaustion
+ */
+function limitLines(output) {
+    const lines = output.split('\n');
+    return lines.slice(-MAX_OUTPUT_LINES).join('\n');
+}
 /**
  * Execute a single task and track its progress.
  * All execution logic is contained here, outside of React components.
@@ -17,21 +26,38 @@ export async function executeTask(command, index, callbacks) {
         error,
         workdir,
     });
+    // Throttle updates to avoid excessive re-renders (100ms minimum interval)
+    let lastUpdateTime = 0;
+    let pendingTimeout;
+    const throttledUpdate = () => {
+        const now = Date.now();
+        if (now - lastUpdateTime >= 100) {
+            lastUpdateTime = now;
+            callbacks.onUpdate(createOutput());
+        }
+        else if (!pendingTimeout) {
+            pendingTimeout = setTimeout(() => {
+                pendingTimeout = undefined;
+                lastUpdateTime = Date.now();
+                callbacks.onUpdate(createOutput());
+            }, 100 - (now - lastUpdateTime));
+        }
+    };
     // Set up output streaming callback
     setOutputCallback((data, stream) => {
         if (stream === 'stdout') {
-            stdout += data;
+            stdout = limitLines(stdout + data);
         }
         else {
-            stderr += data;
+            stderr = limitLines(stderr + data);
         }
-        callbacks.onOutputChange?.(createOutput());
+        throttledUpdate();
     });
-    callbacks.onStart?.();
     try {
         const result = await executeCommand(command, undefined, index);
-        // Clear callback
+        // Clear callback and pending timeout
         setOutputCallback(undefined);
+        clearTimeout(pendingTimeout);
         const elapsed = calculateElapsed(startTime);
         // Update final output from result
         stdout = result.output;
@@ -39,42 +65,34 @@ export async function executeTask(command, index, callbacks) {
         workdir = result.workdir;
         if (result.result === ExecutionResult.Success) {
             const output = createOutput();
-            callbacks.onComplete?.(elapsed, output);
-            return {
-                status: ExecutionStatus.Success,
-                elapsed,
-                output,
-            };
+            callbacks.onUpdate(output);
+            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,
-            };
+            callbacks.onUpdate(output);
+            callbacks.onError(errorMsg, output);
+            return { status: ExecutionStatus.Failed, elapsed, output };
         }
     }
     catch (err) {
-        // Clear callback
+        // Clear callback and pending timeout
         setOutputCallback(undefined);
+        clearTimeout(pendingTimeout);
         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,
-        };
+        callbacks.onUpdate(output);
+        callbacks.onError(errorMsg, output);
+        return { status: ExecutionStatus.Failed, elapsed, output };
     }
 }
 /**
- * Create an empty task output
+ * Create an empty execution output
  */
 export function createEmptyOutput() {
     return { stdout: '', stderr: '', error: '' };

package/dist/execution/types.js

@@ -4,10 +4,9 @@ export var ExecuteActionType;
     ExecuteActionType["CommandsReady"] = "COMMANDS_READY";
     ExecuteActionType["ProcessingError"] = "PROCESSING_ERROR";
     ExecuteActionType["TaskStarted"] = "TASK_STARTED";
+    ExecuteActionType["TaskProgress"] = "TASK_PROGRESS";
     ExecuteActionType["TaskComplete"] = "TASK_COMPLETE";
-    ExecuteActionType["AllTasksComplete"] = "ALL_TASKS_COMPLETE";
-    ExecuteActionType["TaskErrorCritical"] = "TASK_ERROR_CRITICAL";
-    ExecuteActionType["TaskErrorContinue"] = "TASK_ERROR_CONTINUE";
-    ExecuteActionType["LastTaskError"] = "LAST_TASK_ERROR";
+    ExecuteActionType["ExecutionComplete"] = "EXECUTION_COMPLETE";
+    ExecuteActionType["TaskError"] = "TASK_ERROR";
     ExecuteActionType["CancelExecution"] = "CANCEL_EXECUTION";
 })(ExecuteActionType || (ExecuteActionType = {}));

package/dist/execution/utils.js

@@ -1,6 +1,6 @@
 import { ExecutionStatus } from '../services/shell.js';
 /**
- * Calculate total elapsed time from task infos
+ * Calculate total elapsed time from task data
  */
 export function getTotalElapsed(tasks) {
     return tasks.reduce((sum, task) => sum + task.elapsed, 0);

package/dist/index.js

@@ -5,7 +5,7 @@ import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 import { render } from 'ink';
 import { DebugLevel } from './configuration/types.js';
-import { Main } from './ui/Main.js';
+import { Main } from './Main.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // Get package info

package/dist/services/messages.js

@@ -162,3 +162,22 @@ export function getExecutionErrorMessage(_error) {
     ];
     return messages[Math.floor(Math.random() * messages.length)];
 }
+/**
+ * Returns a loading message while fetching an answer.
+ * Randomly selects from variations to sound natural.
+ */
+export function getAnswerLoadingMessage() {
+    const messages = [
+        'Finding that out for you.',
+        'Looking into this.',
+        'Let me find out.',
+        'One moment please.',
+        'Checking on that.',
+        'Let me look that up.',
+        'Give me a moment.',
+        'Looking that up now.',
+        'Let me check.',
+        'Just a moment.',
+    ];
+    return messages[Math.floor(Math.random() * messages.length)];
+}

package/dist/services/router.js

@@ -177,11 +177,37 @@ function executeTasksAfterConfirm(tasks, context) {
     // No missing config - proceed with normal routing
     routeTasksAfterConfig(scheduledTasks, context);
 }
+/**
+ * Task types that should appear in the upcoming display
+ */
+const UPCOMING_TASK_TYPES = [TaskType.Execute, TaskType.Answer];
+/**
+ * Collect names of all upcoming execution units (groups and standalone tasks)
+ * for display during task execution
+ */
+function collectUpcomingNames(scheduledTasks) {
+    const names = [];
+    for (const task of scheduledTasks) {
+        if (task.type === TaskType.Group && task.subtasks?.length) {
+            const subtasks = task.subtasks;
+            if (UPCOMING_TASK_TYPES.includes(subtasks[0].type)) {
+                names.push(task.action);
+            }
+        }
+        else if (UPCOMING_TASK_TYPES.includes(task.type)) {
+            names.push(task.action);
+        }
+    }
+    return names;
+}
 /**
  * Route tasks after config is complete (or when no config is needed)
  * Processes tasks in order, grouping by type
  */
 function routeTasksAfterConfig(scheduledTasks, context) {
+    // Collect all unit names for upcoming display
+    const allUnitNames = collectUpcomingNames(scheduledTasks);
+    let currentUnitIndex = 0;
     // Process tasks in order, preserving Group boundaries
     // Track consecutive standalone tasks to group them by type
     let consecutiveStandaloneTasks = [];
@@ -201,7 +227,18 @@ function routeTasksAfterConfig(scheduledTasks, context) {
             const taskType = type;
             if (typeTasks.length === 0)
                 continue;
-            routeTasksByType(taskType, typeTasks, context);
+            // For tasks that appear in upcoming, calculate from remaining units
+            if (UPCOMING_TASK_TYPES.includes(taskType)) {
+                // Each task advances the unit index
+                for (const task of typeTasks) {
+                    const upcoming = allUnitNames.slice(currentUnitIndex + 1);
+                    currentUnitIndex++;
+                    routeTasksByType(taskType, [task], context, upcoming);
+                }
+            }
+            else {
+                routeTasksByType(taskType, typeTasks, context, []);
+            }
         }
         consecutiveStandaloneTasks = [];
     };
@@ -214,7 +251,20 @@ function routeTasksAfterConfig(scheduledTasks, context) {
             if (task.subtasks.length > 0) {
                 const subtasks = task.subtasks;
                 const taskType = subtasks[0].type;
-                routeTasksByType(taskType, subtasks, context);
+                // Calculate upcoming (all units after this one)
+                const upcoming = UPCOMING_TASK_TYPES.includes(taskType)
+                    ? allUnitNames.slice(currentUnitIndex + 1)
+                    : [];
+                if (UPCOMING_TASK_TYPES.includes(taskType)) {
+                    currentUnitIndex++;
+                }
+                // Pass group name as label for Execute groups
+                if (taskType === TaskType.Execute) {
+                    routeExecuteTasks(subtasks, context, upcoming, task.action);
+                }
+                else {
+                    routeTasksByType(taskType, subtasks, context, upcoming);
+                }
             }
         }
         else {
@@ -228,21 +278,29 @@ function routeTasksAfterConfig(scheduledTasks, context) {
 /**
  * Route Answer tasks - creates separate Answer component for each question
  */
-function routeAnswerTasks(tasks, context) {
-    for (const task of tasks) {
-        context.workflowHandlers.addToQueue(createAnswer({ question: task.action, service: context.service }));
+function routeAnswerTasks(tasks, context, upcoming) {
+    for (let i = 0; i < tasks.length; i++) {
+        const task = tasks[i];
+        // Calculate upcoming: remaining answer tasks + original upcoming
+        const remainingAnswers = tasks.slice(i + 1).map((t) => t.action);
+        const taskUpcoming = [...remainingAnswers, ...upcoming];
+        context.workflowHandlers.addToQueue(createAnswer({
+            question: task.action,
+            service: context.service,
+            upcoming: taskUpcoming,
+        }));
     }
 }
 /**
  * Route Introspect tasks - creates single Introspect component for all tasks
  */
-function routeIntrospectTasks(tasks, context) {
+function routeIntrospectTasks(tasks, context, _upcoming) {
     context.workflowHandlers.addToQueue(createIntrospect({ tasks, service: context.service }));
 }
 /**
  * Route Config tasks - extracts keys, caches labels, creates Config component
  */
-function routeConfigTasks(tasks, context) {
+function routeConfigTasks(tasks, context, _upcoming) {
     const configKeys = tasks
         .map((task) => task.params?.key)
         .filter((key) => key !== undefined);
@@ -286,8 +344,8 @@ function routeConfigTasks(tasks, context) {
 /**
  * Route Execute tasks - creates Execute component (validation already done)
  */
-function routeExecuteTasks(tasks, context) {
-    context.workflowHandlers.addToQueue(createExecute({ tasks, service: context.service }));
+function routeExecuteTasks(tasks, context, upcoming, label) {
+    context.workflowHandlers.addToQueue(createExecute({ tasks, service: context.service, upcoming, label }));
 }
 /**
  * Registry mapping task types to their route handlers
@@ -302,9 +360,9 @@ const taskRouteHandlers = {
  * Route tasks by type to appropriate components
  * Uses registry pattern for extensibility
  */
-function routeTasksByType(taskType, tasks, context) {
+function routeTasksByType(taskType, tasks, context, upcoming) {
     const handler = taskRouteHandlers[taskType];
     if (handler) {
-        handler(tasks, context);
+        handler(tasks, context, upcoming);
     }
 }

package/dist/services/shell.js

@@ -61,6 +61,14 @@ export class DummyExecutor {
 }
 // Marker for extracting pwd from command output
 const PWD_MARKER = '__PWD_MARKER_7x9k2m__';
+const MAX_OUTPUT_LINES = 128;
+/**
+ * Limit output to last MAX_OUTPUT_LINES lines.
+ */
+function limitLines(output) {
+    const lines = output.split('\n');
+    return lines.slice(-MAX_OUTPUT_LINES).join('\n');
+}
 /**
  * Parse stdout to extract workdir and clean output.
  * Returns the cleaned output and the extracted workdir.
@@ -93,6 +101,12 @@ class OutputStreamer {
      */
     pushStdout(data) {
         this.chunks.push(data);
+        // Collapse when we have too many chunks to prevent memory growth
+        if (this.chunks.length > 16) {
+            const accumulated = this.chunks.join('');
+            this.chunks = [limitLines(accumulated)];
+            this.emittedLength = 0;
+        }
         if (!this.callback)
             return;
         const accumulated = this.chunks.join('');
@@ -123,7 +137,7 @@ class OutputStreamer {
      * Get the accumulated raw output.
      */
     getAccumulated() {
-        return this.chunks.join('');
+        return limitLines(this.chunks.join(''));
     }
 }
 /**
@@ -189,6 +203,13 @@ export class RealExecutor {
             child.stderr.on('data', (data) => {
                 const text = data.toString();
                 stderr.push(text);
+                // Collapse when we have too many chunks to prevent memory growth
+                if (stderr.length > 16) {
+                    const accumulated = stderr.join('');
+                    const limited = limitLines(accumulated);
+                    stderr.length = 0;
+                    stderr.push(limited);
+                }
                 this.outputCallback?.(text, 'stderr');
             });
             child.on('error', (error) => {
@@ -200,7 +221,7 @@ export class RealExecutor {
                     description: cmd.description,
                     command: cmd.command,
                     output: stdoutStreamer.getAccumulated(),
-                    errors: error.message,
+                    errors: limitLines(stderr.join('')) || error.message,
                     result: ExecutionResult.Error,
                     error: error.message,
                 };
@@ -218,7 +239,7 @@ export class RealExecutor {
                     description: cmd.description,
                     command: cmd.command,
                     output,
-                    errors: stderr.join(''),
+                    errors: limitLines(stderr.join('')),
                     result: success ? ExecutionResult.Success : ExecutionResult.Error,
                     error: success ? undefined : `Exit code: ${code}`,
                     workdir,
@@ -278,9 +299,8 @@ export async function executeCommands(commands, onProgress) {
                 : ExecutionStatus.Failed,
             output,
         });
-        // Stop if critical command failed
-        const isCritical = cmd.critical !== false;
-        if (output.result !== ExecutionResult.Success && isCritical) {
+        // Stop on failure
+        if (output.result !== ExecutionResult.Success) {
             break;
         }
     }

package/dist/services/timing.js

@@ -1,6 +1,7 @@
 /**
  * Timing utilities for UI components
  */
+export const ELAPSED_UPDATE_INTERVAL = 250;
 /**
  * Waits for at least the minimum processing time.
  * Ensures async operations don't complete too quickly for good UX.