prompt-language-shell 0.8.8 → 0.9.0

package/dist/types/errors.js

@@ -0,0 +1,47 @@
+/**
+ * Error codes for categorization and programmatic handling
+ */
+export var ErrorCode;
+(function (ErrorCode) {
+    // User errors - display to user, usually recoverable
+    ErrorCode["InvalidInput"] = "INVALID_INPUT";
+    ErrorCode["MissingConfig"] = "MISSING_CONFIG";
+    ErrorCode["SkillNotFound"] = "SKILL_NOT_FOUND";
+    // System errors - log + display, may be recoverable
+    ErrorCode["FileReadError"] = "FILE_READ_ERROR";
+    ErrorCode["FileWriteError"] = "FILE_WRITE_ERROR";
+    ErrorCode["NetworkError"] = "NETWORK_ERROR";
+    ErrorCode["ApiError"] = "API_ERROR";
+    ErrorCode["ParseError"] = "PARSE_ERROR";
+    // Fatal errors - must abort
+    ErrorCode["CircularReference"] = "CIRCULAR_REFERENCE";
+    ErrorCode["InvalidState"] = "INVALID_STATE";
+    ErrorCode["ConfigCorruption"] = "CONFIG_CORRUPTION";
+})(ErrorCode || (ErrorCode = {}));
+/**
+ * Base error class with cause chain support
+ * Provides consistent error structure throughout the application
+ */
+export class AppError extends Error {
+    code;
+    cause;
+    constructor(message, code, cause) {
+        super(message);
+        this.code = code;
+        this.cause = cause;
+        this.name = 'AppError';
+    }
+}
+/**
+ * Type guard for AppError
+ */
+export function isAppError(error) {
+    return error instanceof AppError;
+}
+/**
+ * Helper to wrap unknown errors with context
+ */
+export function wrapError(error, code, message) {
+    const cause = error instanceof Error ? error : undefined;
+    return new AppError(message, code, cause);
+}

package/dist/types/result.js

@@ -0,0 +1,40 @@
+/**
+ * Create a successful result
+ */
+export function ok(value) {
+    return { ok: true, value };
+}
+/**
+ * Create a failed result
+ */
+export function err(error) {
+    return { ok: false, error };
+}
+/**
+ * Unwrap a result, throwing if it's an error
+ */
+export function unwrap(result) {
+    if (result.ok)
+        return result.value;
+    throw result.error;
+}
+/**
+ * Map the value of a successful result
+ */
+export function mapResult(result, fn) {
+    if (result.ok)
+        return ok(fn(result.value));
+    return result;
+}
+/**
+ * Check if a result is successful
+ */
+export function isOk(result) {
+    return result.ok;
+}
+/**
+ * Check if a result is an error
+ */
+export function isErr(result) {
+    return !result.ok;
+}

package/dist/ui/Component.js

@@ -107,8 +107,8 @@ export const ViewComponent = memo(function ViewComponent({ def, }) {
             return (_jsx(ScheduleView, { message: message, tasks: tasks, state: state, status: status }));
         }
         case ComponentName.Execute: {
-            const { props: { tasks }, state, status, } = def;
-            return _jsx(ExecuteView, { tasks: tasks, state: state, status: status });
+            const { state, status } = def;
+            return _jsx(ExecuteView, { state: state, status: status });
         }
         case ComponentName.Answer: {
             const { props: { question }, state, status, } = def;

package/dist/ui/Execute.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useCallback, useEffect, useReducer } from 'react';
+import { useCallback, useEffect, useReducer, useRef } from 'react';
 import { Box, Text } from 'ink';
 import { ComponentStatus, } from '../types/components.js';
 import { getTextColor } from '../services/colors.js';
@@ -11,74 +11,108 @@ import { buildAbortedState, handleTaskCompletion, handleTaskFailure, } from '../
 import { processTasks } from '../execution/processing.js';
 import { executeReducer, initialState } from '../execution/reducer.js';
 import { ExecuteActionType } from '../execution/types.js';
-import { createMessage, markAsDone } from '../services/components.js';
+import { createFeedback, createMessage, markAsDone, } from '../services/components.js';
+import { FeedbackType } from '../types/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, }) => {
+/**
+ * Create an ExecuteState with defaults
+ */
+function createExecuteState(overrides = {}) {
+    return {
+        message: '',
+        summary: '',
+        tasks: [],
+        completed: 0,
+        completionMessage: null,
+        error: null,
+        ...overrides,
+    };
+}
+export const ExecuteView = ({ state, status, workdir, onOutputChange, onTaskComplete, onTaskAbort, onTaskError, }) => {
     const isActive = status === ComponentStatus.Active;
-    const { error, taskInfos, message, completed, completionMessage } = state;
-    const hasProcessed = taskInfos.length > 0;
+    const { error, tasks, message, completed, completionMessage } = state;
+    const hasProcessed = tasks.length > 0;
     // Derive loading state from current conditions
-    const isLoading = isActive && taskInfos.length === 0 && !error && !hasProcessed;
-    const isExecuting = completed < taskInfos.length;
+    const isLoading = isActive && tasks.length === 0 && !error && !hasProcessed;
+    const isExecuting = completed < tasks.length;
     // Return null only when loading completes with no commands
-    if (!isActive && taskInfos.length === 0 && !error) {
+    if (!isActive && tasks.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 })] }));
+    const showTasks = !isActive && tasks.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, {})] })), tasks.map((taskInfo, index) => {
+                        // Merge workdir into active task's command
+                        const taskCommand = isActive && index === completed && workdir
+                            ? { ...taskInfo.command, workdir }
+                            : taskInfo.command;
+                        return (_jsx(Box, { marginBottom: index < tasks.length - 1 ? 1 : 0, children: _jsx(Task, { label: taskInfo.label, command: taskCommand, isActive: isActive && index === completed, isFinished: index < completed, index: index, initialStatus: taskInfo.status, initialElapsed: taskInfo.elapsed, initialOutput: taskInfo.stdout || taskInfo.stderr || taskInfo.error
+                                    ? {
+                                        stdout: taskInfo.stdout ?? '',
+                                        stderr: taskInfo.stderr ?? '',
+                                        error: taskInfo.error ?? '',
+                                    }
+                                    : undefined, onOutputChange: onOutputChange, 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 })] }));
 };
 /**
  * Execute controller: Runs tasks sequentially
  */
-export function Execute({ tasks, status, service, requestHandlers, lifecycleHandlers, workflowHandlers, }) {
+export function Execute({ tasks: inputTasks, status, service, requestHandlers, lifecycleHandlers, workflowHandlers, }) {
     const isActive = status === ComponentStatus.Active;
     const [localState, dispatch] = useReducer(executeReducer, initialState);
-    const { error, taskInfos, message, completed, hasProcessed, taskExecutionTimes, completionMessage, summary, } = localState;
+    // Ref to store current output for each task (avoids re-renders)
+    const taskOutputRef = useRef(new Map());
+    // Track working directory across commands (persists cd changes)
+    const workdirRef = useRef(undefined);
+    const { error, tasks, message, completed, hasProcessed, completionMessage, summary, } = localState;
     // Derive loading state from current conditions
-    const isLoading = isActive && taskInfos.length === 0 && !error && !hasProcessed;
-    const isExecuting = completed < taskInfos.length;
+    const isLoading = isActive && tasks.length === 0 && !error && !hasProcessed;
+    const isExecuting = completed < tasks.length;
+    // Handle output changes from Task - store in ref (no re-render)
+    const handleOutputChange = useCallback((index, taskOutput) => {
+        taskOutputRef.current.set(index, taskOutput);
+    }, []);
     // Handle cancel with useCallback to ensure we capture latest state
     const handleCancel = useCallback(() => {
         dispatch({
             type: ExecuteActionType.CancelExecution,
             payload: { completed },
         });
-        // Get updated task infos after cancel
-        const updatedTaskInfos = taskInfos.map((task, taskIndex) => {
+        // Get updated task infos after cancel, merging output from ref
+        const updatedTaskInfos = tasks.map((task, taskIndex) => {
+            const output = taskOutputRef.current.get(taskIndex);
+            const baseTask = output
+                ? {
+                    ...task,
+                    stdout: output.stdout,
+                    stderr: output.stderr,
+                    error: output.error,
+                }
+                : task;
             if (taskIndex < completed) {
-                return { ...task, status: ExecutionStatus.Success };
+                return { ...baseTask, status: ExecutionStatus.Success };
             }
             else if (taskIndex === completed) {
-                return { ...task, status: ExecutionStatus.Aborted };
+                return { ...baseTask, status: ExecutionStatus.Aborted };
             }
             else {
-                return { ...task, status: ExecutionStatus.Cancelled };
+                return { ...baseTask, status: ExecutionStatus.Cancelled };
             }
         });
         // Expose final state
-        const finalState = {
+        const finalState = createExecuteState({
             message,
             summary,
-            taskInfos: updatedTaskInfos,
+            tasks: updatedTaskInfos,
             completed,
-            taskExecutionTimes,
-            completionMessage: null,
-            error: null,
-        };
+        });
         requestHandlers.onCompleted(finalState);
         requestHandlers.onAborted('execution');
-    }, [
-        message,
-        summary,
-        taskInfos,
-        completed,
-        taskExecutionTimes,
-        requestHandlers,
-    ]);
+    }, [message, summary, tasks, completed, requestHandlers]);
     useInput((_, key) => {
         if (key.escape && (isLoading || isExecuting) && isActive) {
             handleCancel();
@@ -86,14 +120,14 @@ export function Execute({ tasks, status, service, requestHandlers, lifecycleHand
     }, { isActive: (isLoading || isExecuting) && isActive });
     // Process tasks to get commands from AI
     useEffect(() => {
-        if (!isActive || taskInfos.length > 0 || hasProcessed) {
+        if (!isActive || tasks.length > 0 || hasProcessed) {
             return;
         }
         let mounted = true;
         async function process(svc) {
             const startTime = Date.now();
             try {
-                const result = await processTasks(tasks, svc);
+                const result = await processTasks(inputTasks, svc);
                 await ensureMinimumTime(startTime, MINIMUM_PROCESSING_TIME);
                 if (!mounted)
                     return;
@@ -108,16 +142,7 @@ export function Execute({ tasks, status, service, requestHandlers, lifecycleHand
                         const errorMessage = getExecutionErrorMessage(result.error);
                         workflowHandlers.addToTimeline(markAsDone(createMessage(errorMessage)));
                         // Complete without error in state (message already in timeline)
-                        const finalState = {
-                            message: result.message,
-                            summary: '',
-                            taskInfos: [],
-                            completed: 0,
-                            taskExecutionTimes: [],
-                            completionMessage: null,
-                            error: null,
-                        };
-                        requestHandlers.onCompleted(finalState);
+                        requestHandlers.onCompleted(createExecuteState({ message: result.message }));
                         lifecycleHandlers.completeActive();
                         return;
                     }
@@ -126,43 +151,31 @@ export function Execute({ tasks, status, service, requestHandlers, lifecycleHand
                         type: ExecuteActionType.ProcessingComplete,
                         payload: { message: result.message },
                     });
-                    const finalState = {
-                        message: result.message,
-                        summary: '',
-                        taskInfos: [],
-                        completed: 0,
-                        taskExecutionTimes: [],
-                        completionMessage: null,
-                        error: null,
-                    };
-                    requestHandlers.onCompleted(finalState);
+                    requestHandlers.onCompleted(createExecuteState({ message: result.message }));
                     lifecycleHandlers.completeActive();
                     return;
                 }
                 // Create task infos from commands
-                const infos = result.commands.map((cmd, index) => ({
-                    label: tasks[index]?.action,
+                const tasks = 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,
-                        taskInfos: infos,
+                        tasks,
                     },
                 });
                 // Update state after AI processing
-                const finalState = {
+                requestHandlers.onCompleted(createExecuteState({
                     message: result.message,
                     summary: result.summary,
-                    taskInfos: infos,
-                    completed: 0,
-                    taskExecutionTimes: [],
-                    completionMessage: null,
-                    error: null,
-                };
-                requestHandlers.onCompleted(finalState);
+                    tasks,
+                }));
             }
             catch (err) {
                 await ensureMinimumTime(startTime, MINIMUM_PROCESSING_TIME);
@@ -172,16 +185,7 @@ export function Execute({ tasks, status, service, requestHandlers, lifecycleHand
                         type: ExecuteActionType.ProcessingError,
                         payload: { error: errorMessage },
                     });
-                    const finalState = {
-                        message: '',
-                        summary: '',
-                        taskInfos: [],
-                        completed: 0,
-                        taskExecutionTimes: [],
-                        completionMessage: null,
-                        error: errorMessage,
-                    };
-                    requestHandlers.onCompleted(finalState);
+                    requestHandlers.onCompleted(createExecuteState({ error: errorMessage }));
                     requestHandlers.onError(errorMessage);
                 }
             }
@@ -191,81 +195,100 @@ export function Execute({ tasks, status, service, requestHandlers, lifecycleHand
             mounted = false;
         };
     }, [
-        tasks,
+        inputTasks,
         isActive,
         service,
         requestHandlers,
         lifecycleHandlers,
         workflowHandlers,
-        taskInfos.length,
+        tasks.length,
         hasProcessed,
     ]);
     // Handle task completion - move to next task
-    const handleTaskComplete = useCallback((index, _output, elapsed) => {
+    const handleTaskComplete = useCallback((index, elapsed, taskOutput) => {
+        // Track working directory for subsequent commands
+        if (taskOutput.workdir) {
+            workdirRef.current = taskOutput.workdir;
+        }
+        // Update tasks with output before calling handler
+        const tasksWithOutput = tasks.map((task, i) => i === index
+            ? {
+                ...task,
+                stdout: taskOutput.stdout,
+                stderr: taskOutput.stderr,
+                error: taskOutput.error,
+            }
+            : task);
         const result = handleTaskCompletion(index, elapsed, {
-            taskInfos,
+            tasks: tasksWithOutput,
             message,
             summary,
-            taskExecutionTimes,
         });
         dispatch(result.action);
         requestHandlers.onCompleted(result.finalState);
         if (result.shouldComplete) {
             lifecycleHandlers.completeActive();
         }
-    }, [
-        taskInfos,
-        message,
-        summary,
-        taskExecutionTimes,
-        requestHandlers,
-        lifecycleHandlers,
-    ]);
-    const handleTaskError = useCallback((index, error, elapsed) => {
+    }, [tasks, message, summary, requestHandlers, lifecycleHandlers]);
+    const handleTaskError = useCallback((index, error, elapsed, taskOutput) => {
+        // Track working directory for subsequent commands (even on error)
+        if (taskOutput.workdir) {
+            workdirRef.current = taskOutput.workdir;
+        }
+        // Update tasks with output before calling handler
+        const tasksWithOutput = tasks.map((task, i) => i === index
+            ? {
+                ...task,
+                stdout: taskOutput.stdout,
+                stderr: taskOutput.stderr,
+                error: taskOutput.error,
+            }
+            : task);
         const result = handleTaskFailure(index, error, elapsed, {
-            taskInfos,
+            tasks: tasksWithOutput,
             message,
             summary,
-            taskExecutionTimes,
         });
         dispatch(result.action);
         requestHandlers.onCompleted(result.finalState);
-        if (result.shouldReportError) {
-            requestHandlers.onError(error);
+        // Add error feedback to queue for critical failures
+        if (result.action.type === ExecuteActionType.TaskErrorCritical) {
+            const errorMessage = getExecutionErrorMessage(error);
+            workflowHandlers.addToQueue(createFeedback(FeedbackType.Failed, errorMessage));
         }
         if (result.shouldComplete) {
             lifecycleHandlers.completeActive();
         }
     }, [
-        taskInfos,
+        tasks,
         message,
         summary,
-        taskExecutionTimes,
         requestHandlers,
         lifecycleHandlers,
+        workflowHandlers,
     ]);
-    const handleTaskAbort = useCallback((_index) => {
+    const handleTaskAbort = useCallback((index, taskOutput) => {
         // Task was aborted - execution already stopped by Escape handler
-        // Just update state, don't call onAborted (already called at Execute level)
-        const finalState = buildAbortedState(taskInfos, message, summary, completed, taskExecutionTimes);
+        // Update tasks with output before building state
+        const tasksWithOutput = tasks.map((task, i) => i === index
+            ? {
+                ...task,
+                stdout: taskOutput.stdout,
+                stderr: taskOutput.stderr,
+                error: taskOutput.error,
+            }
+            : task);
+        const finalState = buildAbortedState(tasksWithOutput, message, summary, completed);
         requestHandlers.onCompleted(finalState);
-    }, [
-        taskInfos,
-        message,
-        summary,
-        completed,
-        taskExecutionTimes,
-        requestHandlers,
-    ]);
+    }, [tasks, message, summary, completed, requestHandlers]);
     // Controller always renders View with current state
-    const viewState = {
+    const viewState = createExecuteState({
         error,
-        taskInfos,
+        tasks,
         message,
         summary,
         completed,
-        taskExecutionTimes,
         completionMessage,
-    };
-    return (_jsx(ExecuteView, { tasks: tasks, state: viewState, status: status, onTaskComplete: handleTaskComplete, onTaskAbort: handleTaskAbort, onTaskError: handleTaskError }));
+    });
+    return (_jsx(ExecuteView, { state: viewState, status: status, workdir: workdirRef.current, onOutputChange: handleOutputChange, onTaskComplete: handleTaskComplete, onTaskAbort: handleTaskAbort, onTaskError: handleTaskError }));
 }

package/dist/ui/Output.js

@@ -0,0 +1,54 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { Palette } from '../services/colors.js';
+import { ExecutionStatus } from '../services/shell.js';
+const MAX_LINES = 8;
+const MAX_WIDTH = 75;
+const SHORT_OUTPUT_THRESHOLD = 4;
+const MINIMAL_INFO_THRESHOLD = 2;
+/**
+ * Get the last N lines from text, filtering out empty/whitespace-only lines
+ */
+export function getLastLines(text, maxLines = MAX_LINES) {
+    const lines = text
+        .trim()
+        .split(/\r?\n/)
+        .filter((line) => line.trim().length > 0);
+    return lines.length <= maxLines ? lines : lines.slice(-maxLines);
+}
+/**
+ * Compute display configuration for output rendering.
+ * Encapsulates the logic for what to show and how to style it.
+ */
+export function computeDisplayConfig(stdout, stderr, status, isFinished) {
+    const hasStdout = stdout.trim().length > 0;
+    const hasStderr = stderr.trim().length > 0;
+    if (!hasStdout && !hasStderr)
+        return null;
+    const stdoutLines = hasStdout ? getLastLines(stdout) : [];
+    const stderrLines = hasStderr ? getLastLines(stderr) : [];
+    // Show stdout if no stderr, or if stderr is minimal (provides context)
+    const showStdout = hasStdout && (!hasStderr || stderrLines.length <= MINIMAL_INFO_THRESHOLD);
+    // Use word wrapping for short outputs to show more detail
+    const totalLines = stdoutLines.length + stderrLines.length;
+    const wrapMode = totalLines <= SHORT_OUTPUT_THRESHOLD ? 'wrap' : 'truncate-end';
+    // Darker colors for finished tasks
+    const baseColor = isFinished ? Palette.DarkGray : Palette.Gray;
+    const stderrColor = status === ExecutionStatus.Failed ? Palette.Yellow : baseColor;
+    return {
+        stdoutLines,
+        stderrLines,
+        showStdout,
+        wrapMode,
+        stdoutColor: baseColor,
+        stderrColor,
+    };
+}
+export function Output({ stdout, stderr, status, isFinished }) {
+    const config = computeDisplayConfig(stdout, stderr, status, isFinished ?? false);
+    if (!config)
+        return null;
+    const { stdoutLines, stderrLines, showStdout, wrapMode, stdoutColor, stderrColor, } = config;
+    return (_jsxs(Box, { marginTop: 1, marginLeft: 5, flexDirection: "column", width: MAX_WIDTH, children: [showStdout &&
+                stdoutLines.map((line, index) => (_jsx(Text, { color: stdoutColor, wrap: wrapMode, children: line }, `out-${index}`))), stderrLines.map((line, index) => (_jsx(Text, { color: stderrColor, wrap: wrapMode, children: line }, `err-${index}`)))] }));
+}