prompt-language-shell 0.8.8 → 0.9.0

package/dist/ui/Task.js

@@ -1,14 +1,35 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { useEffect, useState } from 'react';
-import { ExecutionResult, ExecutionStatus, executeCommand, } from '../services/shell.js';
+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, index, initialStatus, initialElapsed, onComplete, onAbort, onError, }) {
+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)
@@ -37,8 +58,43 @@ export function Task({ label, command, isActive, index, initialStatus, initialEl
             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();
@@ -49,13 +105,28 @@ export function Task({ label, command, isActive, index, initialStatus, initialEl
                     ? ExecutionStatus.Success
                     : ExecutionStatus.Failed);
                 if (output.result === ExecutionResult.Success) {
-                    onComplete?.(index, output, taskDuration);
+                    const taskOutput = {
+                        stdout: output.output,
+                        stderr: output.errors,
+                        error: '',
+                        workdir: output.workdir,
+                    };
+                    onCompleteRef.current?.(index, taskDuration, taskOutput);
                 }
                 else {
-                    onError?.(index, output.errors || 'Command failed', taskDuration);
+                    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();
@@ -63,7 +134,20 @@ export function Task({ label, command, isActive, index, initialStatus, initialEl
                 const errorDuration = calculateElapsed(start);
                 setElapsed(errorDuration);
                 setStatus(ExecutionStatus.Failed);
-                onError?.(index, err instanceof Error ? err.message : 'Unknown error', errorDuration);
+                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();
@@ -79,8 +163,13 @@ export function Task({ label, command, isActive, index, initialStatus, initialEl
             setEndTime(end);
             setElapsed(calculateElapsed(startTime));
             setStatus(ExecutionStatus.Aborted);
-            onAbort?.(index);
+            const taskOutput = {
+                stdout: stdoutRef.current,
+                stderr: stderrRef.current,
+                error: errorRef.current,
+            };
+            onAbortRef.current?.(index, taskOutput);
         }
-    }, [isActive, status, startTime, index, onAbort]);
-    return (_jsx(Subtask, { label: label, command: command, status: status, isActive: isActive, startTime: startTime, endTime: endTime, elapsed: status === ExecutionStatus.Running ? currentElapsed : elapsed }));
+    }, [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}`)] }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prompt-language-shell",
-  "version": "0.8.8",
+  "version": "0.9.0",
   "description": "Your personal command-line concierge. Ask politely, and it gets things done.",
   "type": "module",
   "main": "dist/index.js",