prompt-language-shell 0.9.0 → 0.9.4

package/dist/ui/Execute.js

@@ -1,294 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useCallback, useEffect, useReducer, useRef } from 'react';
-import { Box, Text } from 'ink';
-import { ComponentStatus, } from '../types/components.js';
-import { getTextColor } from '../services/colors.js';
-import { useInput } from '../services/keyboard.js';
-import { formatErrorMessage, getExecutionErrorMessage, } from '../services/messages.js';
-import { ExecutionStatus } from '../services/shell.js';
-import { ensureMinimumTime } from '../services/timing.js';
-import { buildAbortedState, handleTaskCompletion, handleTaskFailure, } from '../execution/handlers.js';
-import { processTasks } from '../execution/processing.js';
-import { executeReducer, initialState } from '../execution/reducer.js';
-import { ExecuteActionType } from '../execution/types.js';
-import { 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;
-/**
- * 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, tasks, message, completed, completionMessage } = state;
-    const hasProcessed = tasks.length > 0;
-    // Derive loading state from current conditions
-    const isLoading = isActive && tasks.length === 0 && !error && !hasProcessed;
-    const isExecuting = completed < tasks.length;
-    // Return null only when loading completes with no commands
-    if (!isActive && tasks.length === 0 && !error) {
-        return null;
-    }
-    // Show completed steps when not active
-    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: inputTasks, status, service, requestHandlers, lifecycleHandlers, workflowHandlers, }) {
-    const isActive = status === ComponentStatus.Active;
-    const [localState, dispatch] = useReducer(executeReducer, initialState);
-    // 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 && 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, 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 { ...baseTask, status: ExecutionStatus.Success };
-            }
-            else if (taskIndex === completed) {
-                return { ...baseTask, status: ExecutionStatus.Aborted };
-            }
-            else {
-                return { ...baseTask, status: ExecutionStatus.Cancelled };
-            }
-        });
-        // Expose final state
-        const finalState = createExecuteState({
-            message,
-            summary,
-            tasks: updatedTaskInfos,
-            completed,
-        });
-        requestHandlers.onCompleted(finalState);
-        requestHandlers.onAborted('execution');
-    }, [message, summary, tasks, completed, requestHandlers]);
-    useInput((_, key) => {
-        if (key.escape && (isLoading || isExecuting) && isActive) {
-            handleCancel();
-        }
-    }, { isActive: (isLoading || isExecuting) && isActive });
-    // Process tasks to get commands from AI
-    useEffect(() => {
-        if (!isActive || tasks.length > 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) {
-                    // Check if this is an error response (has error field)
-                    if (result.error) {
-                        // Add error message to timeline
-                        const errorMessage = getExecutionErrorMessage(result.error);
-                        workflowHandlers.addToTimeline(markAsDone(createMessage(errorMessage)));
-                        // Complete without error in state (message already in timeline)
-                        requestHandlers.onCompleted(createExecuteState({ message: result.message }));
-                        lifecycleHandlers.completeActive();
-                        return;
-                    }
-                    // No commands and no error - just complete
-                    dispatch({
-                        type: ExecuteActionType.ProcessingComplete,
-                        payload: { message: result.message },
-                    });
-                    requestHandlers.onCompleted(createExecuteState({ message: result.message }));
-                    lifecycleHandlers.completeActive();
-                    return;
-                }
-                // Create task infos from commands
-                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,
-                        tasks,
-                    },
-                });
-                // Update state after AI processing
-                requestHandlers.onCompleted(createExecuteState({
-                    message: result.message,
-                    summary: result.summary,
-                    tasks,
-                }));
-            }
-            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,
-        tasks.length,
-        hasProcessed,
-    ]);
-    // Handle task completion - move to next task
-    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, {
-            tasks: tasksWithOutput,
-            message,
-            summary,
-        });
-        dispatch(result.action);
-        requestHandlers.onCompleted(result.finalState);
-        if (result.shouldComplete) {
-            lifecycleHandlers.completeActive();
-        }
-    }, [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, {
-            tasks: tasksWithOutput,
-            message,
-            summary,
-        });
-        dispatch(result.action);
-        requestHandlers.onCompleted(result.finalState);
-        // 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();
-        }
-    }, [
-        tasks,
-        message,
-        summary,
-        requestHandlers,
-        lifecycleHandlers,
-        workflowHandlers,
-    ]);
-    const handleTaskAbort = useCallback((index, taskOutput) => {
-        // Task was aborted - execution already stopped by Escape handler
-        // 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);
-    }, [tasks, message, summary, completed, requestHandlers]);
-    // Controller always renders View with current state
-    const viewState = createExecuteState({
-        error,
-        tasks,
-        message,
-        summary,
-        completed,
-        completionMessage,
-    });
-    return (_jsx(ExecuteView, { state: viewState, status: status, workdir: workdirRef.current, onOutputChange: handleOutputChange, onTaskComplete: handleTaskComplete, onTaskAbort: handleTaskAbort, onTaskError: handleTaskError }));
-}

package/dist/ui/Refinement.js

@@ -1,23 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box } from 'ink';
-import { ComponentStatus } from '../types/components.js';
-import { useInput } from '../services/keyboard.js';
-import { Message } from './Message.js';
-import { Spinner } from './Spinner.js';
-export const RefinementView = ({ text, status }) => {
-    const isActive = status === ComponentStatus.Active;
-    return (_jsxs(Box, { gap: 1, children: [_jsx(Message, { text: text, status: status }), isActive && _jsx(Spinner, {})] }));
-};
-/**
- * Refinement controller: Handles abort input
- */
-export const Refinement = ({ text, status, onAborted }) => {
-    const isActive = status === ComponentStatus.Active;
-    useInput((_, key) => {
-        if (key.escape && isActive) {
-            onAborted('plan refinement');
-            return;
-        }
-    }, { isActive });
-    return _jsx(RefinementView, { text: text, status: status });
-};

package/dist/ui/Task.js

@@ -1,175 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useEffect, useRef, useState } from 'react';
-import { Box } from 'ink';
-import { ExecutionResult, ExecutionStatus, executeCommand, setOutputCallback, } from '../services/shell.js';
-import { calculateElapsed } from '../services/utils.js';
-import { Output } from './Output.js';
-import { Subtask } from './Subtask.js';
-export function Task({ label, command, isActive, isFinished, index, initialStatus, initialElapsed, initialOutput, onOutputChange, onComplete, onAbort, onError, }) {
-    const [status, setStatus] = useState(initialStatus ?? ExecutionStatus.Pending);
-    const [startTime, setStartTime] = useState();
-    const [endTime, setEndTime] = useState();
-    const [elapsed, setElapsed] = useState(initialElapsed);
-    const [currentElapsed, setCurrentElapsed] = useState(0);
-    const [stdout, setStdout] = useState(initialOutput?.stdout ?? '');
-    const [stderr, setStderr] = useState(initialOutput?.stderr ?? '');
-    const [error, setError] = useState(initialOutput?.error ?? '');
-    // Refs to track current output for callbacks (avoid stale closure)
-    const stdoutRef = useRef(stdout);
-    const stderrRef = useRef(stderr);
-    const errorRef = useRef(error);
-    stdoutRef.current = stdout;
-    stderrRef.current = stderr;
-    errorRef.current = error;
-    // Refs for callbacks to avoid stale closures in async effects
-    const onOutputChangeRef = useRef(onOutputChange);
-    const onCompleteRef = useRef(onComplete);
-    const onErrorRef = useRef(onError);
-    const onAbortRef = useRef(onAbort);
-    onOutputChangeRef.current = onOutputChange;
-    onCompleteRef.current = onComplete;
-    onErrorRef.current = onError;
-    onAbortRef.current = onAbort;
-    // Update elapsed time while running
-    useEffect(() => {
-        if (status !== ExecutionStatus.Running || !startTime)
-            return;
-        const interval = setInterval(() => {
-            setCurrentElapsed((prev) => {
-                const next = Date.now() - startTime;
-                return next !== prev ? next : prev;
-            });
-        }, 1000);
-        return () => {
-            clearInterval(interval);
-        };
-    }, [status, startTime]);
-    // Execute command when becoming active
-    useEffect(() => {
-        // Don't execute if task is cancelled or if not active
-        if (!isActive ||
-            status === ExecutionStatus.Cancelled ||
-            status !== ExecutionStatus.Pending) {
-            return;
-        }
-        let mounted = true;
-        async function execute() {
-            const start = Date.now();
-            setStatus(ExecutionStatus.Running);
-            setStartTime(start);
-            setCurrentElapsed(0);
-            setStdout('');
-            setStderr('');
-            setError('');
-            // Set up output callback to capture real-time output
-            setOutputCallback((data, stream) => {
-                if (!mounted)
-                    return;
-                if (stream === 'stdout') {
-                    setStdout((prev) => {
-                        const newStdout = prev + data;
-                        stdoutRef.current = newStdout;
-                        // Report output change to parent using refs for current values
-                        onOutputChangeRef.current?.(index, {
-                            stdout: newStdout,
-                            stderr: stderrRef.current,
-                            error: errorRef.current,
-                        });
-                        return newStdout;
-                    });
-                }
-                else {
-                    setStderr((prev) => {
-                        const newStderr = prev + data;
-                        stderrRef.current = newStderr;
-                        // Report output change to parent using refs for current values
-                        onOutputChangeRef.current?.(index, {
-                            stdout: stdoutRef.current,
-                            stderr: newStderr,
-                            error: errorRef.current,
-                        });
-                        return newStderr;
-                    });
-                }
-            });
-            try {
-                const output = await executeCommand(command, undefined, index);
-                setOutputCallback(undefined); // Clear callback
-                if (!mounted)
-                    return;
-                const end = Date.now();
-                setEndTime(end);
-                const taskDuration = calculateElapsed(start);
-                setElapsed(taskDuration);
-                setStatus(output.result === ExecutionResult.Success
-                    ? ExecutionStatus.Success
-                    : ExecutionStatus.Failed);
-                if (output.result === ExecutionResult.Success) {
-                    const taskOutput = {
-                        stdout: output.output,
-                        stderr: output.errors,
-                        error: '',
-                        workdir: output.workdir,
-                    };
-                    onCompleteRef.current?.(index, taskDuration, taskOutput);
-                }
-                else {
-                    const errorMsg = output.errors || output.error || 'Command failed';
-                    setError(errorMsg);
-                    const taskOutput = {
-                        stdout: output.output,
-                        stderr: output.errors,
-                        error: errorMsg,
-                        workdir: output.workdir,
-                    };
-                    onErrorRef.current?.(index, errorMsg, taskDuration, taskOutput);
-                }
-            }
-            catch (err) {
-                setOutputCallback(undefined); // Clear callback
-                if (!mounted)
-                    return;
-                const end = Date.now();
-                setEndTime(end);
-                const errorDuration = calculateElapsed(start);
-                setElapsed(errorDuration);
-                setStatus(ExecutionStatus.Failed);
-                const errorMsg = err instanceof Error ? err.message : 'Unknown error';
-                setError(errorMsg);
-                const taskOutput = {
-                    stdout: stdoutRef.current,
-                    stderr: stderrRef.current,
-                    error: errorMsg,
-                };
-                // Use try/catch to prevent callback errors from propagating
-                try {
-                    onErrorRef.current?.(index, errorMsg, errorDuration, taskOutput);
-                }
-                catch {
-                    // Callback error - already set error state above
-                }
-            }
-        }
-        void execute();
-        return () => {
-            mounted = false;
-        };
-    }, [isActive]);
-    // Handle abort when task becomes inactive while running
-    useEffect(() => {
-        if (!isActive && status === ExecutionStatus.Running && startTime) {
-            // Task was aborted mid-execution
-            const end = Date.now();
-            setEndTime(end);
-            setElapsed(calculateElapsed(startTime));
-            setStatus(ExecutionStatus.Aborted);
-            const taskOutput = {
-                stdout: stdoutRef.current,
-                stderr: stderrRef.current,
-                error: errorRef.current,
-            };
-            onAbortRef.current?.(index, taskOutput);
-        }
-    }, [isActive, status, startTime, index]);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Subtask, { label: label, command: command, status: status, isActive: isActive, startTime: startTime, endTime: endTime, elapsed: status === ExecutionStatus.Running ? currentElapsed : elapsed }), _jsx(Output, { stdout: stdout, stderr: stderr, isFinished: isFinished, status: status }, `${stdout.length}-${stderr.length}`)] }));
-}