prompt-language-shell 0.4.8 → 0.4.9

package/dist/ui/Execute.js

@@ -0,0 +1,217 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { Box, Text } from 'ink';
+import { Colors, getTextColor, Palette } from '../services/colors.js';
+import { useInput } from '../services/keyboard.js';
+import { formatErrorMessage } from '../services/messages.js';
+import { formatDuration } from '../services/utils.js';
+import { ExecutionStatus, executeCommands, } from '../services/shell.js';
+import { Spinner } from './Spinner.js';
+const MINIMUM_PROCESSING_TIME = 400;
+const STATUS_ICONS = {
+    [ExecutionStatus.Pending]: '- ',
+    [ExecutionStatus.Running]: '• ',
+    [ExecutionStatus.Success]: '✓ ',
+    [ExecutionStatus.Failed]: '✗ ',
+};
+function getStatusColors(status) {
+    switch (status) {
+        case ExecutionStatus.Pending:
+            return {
+                icon: Palette.Gray,
+                description: Palette.Gray,
+                command: Palette.DarkGray,
+                symbol: Palette.DarkGray,
+            };
+        case ExecutionStatus.Running:
+            return {
+                icon: Palette.Gray,
+                description: getTextColor(true),
+                command: Palette.LightGreen,
+                symbol: Palette.AshGray,
+            };
+        case ExecutionStatus.Success:
+            return {
+                icon: Colors.Status.Success,
+                description: getTextColor(true),
+                command: Palette.Gray,
+                symbol: Palette.Gray,
+            };
+        case ExecutionStatus.Failed:
+            return {
+                icon: Colors.Status.Error,
+                description: Colors.Status.Error,
+                command: Colors.Status.Error,
+                symbol: Palette.Gray,
+            };
+    }
+}
+function CommandStatusDisplay({ item, elapsed }) {
+    const colors = getStatusColors(item.status);
+    const getElapsedTime = () => {
+        if (item.status === ExecutionStatus.Running && elapsed !== undefined) {
+            return elapsed;
+        }
+        else if (item.startTime && item.endTime) {
+            return item.endTime - item.startTime;
+        }
+        return undefined;
+    };
+    const elapsedTime = getElapsedTime();
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { paddingLeft: 2, children: [_jsx(Text, { color: colors.icon, children: STATUS_ICONS[item.status] }), _jsx(Text, { color: colors.description, children: item.label || item.command.description }), elapsedTime !== undefined && (_jsxs(Text, { color: Palette.DarkGray, children: [" (", formatDuration(elapsedTime), ")"] }))] }), _jsxs(Box, { paddingLeft: 5, children: [_jsx(Text, { color: colors.symbol, children: "\u221F " }), _jsx(Text, { color: colors.command, children: item.command.command }), item.status === ExecutionStatus.Running && (_jsxs(Text, { children: [' ', _jsx(Spinner, {})] }))] })] }));
+}
+export function Execute({ tasks, state, service, onError, onComplete, onAborted, }) {
+    const done = state?.done ?? false;
+    const isCurrent = done === false;
+    const [error, setError] = useState(null);
+    const [isLoading, setIsLoading] = useState(state?.isLoading ?? !done);
+    const [isExecuting, setIsExecuting] = useState(false);
+    const [commandStatuses, setCommandStatuses] = useState([]);
+    const [message, setMessage] = useState('');
+    const [currentElapsed, setCurrentElapsed] = useState(0);
+    const [runningIndex, setRunningIndex] = useState(null);
+    const [outputs, setOutputs] = useState([]);
+    useInput((input, key) => {
+        if (key.escape && (isLoading || isExecuting) && !done) {
+            setIsLoading(false);
+            setIsExecuting(false);
+            onAborted();
+        }
+    }, { isActive: (isLoading || isExecuting) && !done });
+    // Update elapsed time for running command
+    useEffect(() => {
+        if (runningIndex === null)
+            return;
+        const item = commandStatuses[runningIndex];
+        if (!item?.startTime)
+            return;
+        const interval = setInterval(() => {
+            setCurrentElapsed((prev) => {
+                const next = Date.now() - item.startTime;
+                return next !== prev ? next : prev;
+            });
+        }, 1000);
+        return () => clearInterval(interval);
+    }, [runningIndex, commandStatuses]);
+    // Handle completion callback when execution finishes
+    useEffect(() => {
+        if (isExecuting || commandStatuses.length === 0 || !outputs.length)
+            return;
+        // Sum up elapsed times from all commands
+        const totalElapsed = commandStatuses.reduce((sum, cmd) => sum + (cmd.elapsed ?? 0), 0);
+        onComplete?.(outputs, totalElapsed);
+    }, [isExecuting, commandStatuses, outputs, onComplete]);
+    useEffect(() => {
+        if (done) {
+            return;
+        }
+        if (!service) {
+            setError('No service available');
+            setIsLoading(false);
+            return;
+        }
+        let mounted = true;
+        async function process(svc) {
+            const startTime = Date.now();
+            try {
+                // Format tasks for the execute tool
+                const taskDescriptions = tasks
+                    .map((task) => {
+                    const params = task.params
+                        ? ` (params: ${JSON.stringify(task.params)})`
+                        : '';
+                    return `- ${task.action}${params}`;
+                })
+                    .join('\n');
+                // Call execute tool to get commands
+                const result = await svc.processWithTool(taskDescriptions, 'execute');
+                const elapsed = Date.now() - startTime;
+                const remainingTime = Math.max(0, MINIMUM_PROCESSING_TIME - elapsed);
+                await new Promise((resolve) => setTimeout(resolve, remainingTime));
+                if (!mounted)
+                    return;
+                if (!result.commands || result.commands.length === 0) {
+                    setIsLoading(false);
+                    setOutputs([]);
+                    onComplete?.([], 0);
+                    return;
+                }
+                // Set message and initialize command statuses
+                setMessage(result.message);
+                setCommandStatuses(result.commands.map((cmd, index) => ({
+                    command: cmd,
+                    status: ExecutionStatus.Pending,
+                    label: tasks[index]?.action,
+                })));
+                setIsLoading(false);
+                setIsExecuting(true);
+                // Execute commands sequentially
+                const outputs = await executeCommands(result.commands, (progress) => {
+                    if (!mounted)
+                        return;
+                    const now = Date.now();
+                    setCommandStatuses((prev) => prev.map((item, idx) => {
+                        if (idx === progress.currentIndex) {
+                            const isStarting = progress.status === ExecutionStatus.Running &&
+                                !item.startTime;
+                            const isEnding = progress.status !== ExecutionStatus.Running &&
+                                progress.status !== ExecutionStatus.Pending;
+                            const endTime = isEnding ? now : item.endTime;
+                            const elapsed = isEnding && item.startTime
+                                ? Math.floor((now - item.startTime) / 1000) * 1000
+                                : item.elapsed;
+                            return {
+                                ...item,
+                                status: progress.status,
+                                output: progress.output,
+                                startTime: isStarting ? now : item.startTime,
+                                endTime,
+                                elapsed,
+                            };
+                        }
+                        return item;
+                    }));
+                    if (progress.status === ExecutionStatus.Running) {
+                        setRunningIndex((prev) => prev !== progress.currentIndex ? progress.currentIndex : prev);
+                        setCurrentElapsed((prev) => (prev !== 0 ? 0 : prev));
+                    }
+                    else if (progress.status === ExecutionStatus.Success ||
+                        progress.status === ExecutionStatus.Failed) {
+                        setRunningIndex((prev) => (prev !== null ? null : prev));
+                    }
+                });
+                if (mounted) {
+                    setOutputs(outputs);
+                    setIsExecuting(false);
+                }
+            }
+            catch (err) {
+                const elapsed = Date.now() - startTime;
+                const remainingTime = Math.max(0, MINIMUM_PROCESSING_TIME - elapsed);
+                await new Promise((resolve) => setTimeout(resolve, remainingTime));
+                if (mounted) {
+                    const errorMessage = formatErrorMessage(err);
+                    setIsLoading(false);
+                    setIsExecuting(false);
+                    if (onError) {
+                        onError(errorMessage);
+                    }
+                    else {
+                        setError(errorMessage);
+                    }
+                }
+            }
+        }
+        process(service);
+        return () => {
+            mounted = false;
+        };
+    }, [tasks, done, service, onComplete, onError]);
+    // Return null only when loading completes with no commands
+    if (done && commandStatuses.length === 0 && !error) {
+        return null;
+    }
+    // Show completed steps when done
+    const showCompletedSteps = done && commandStatuses.length > 0;
+    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isLoading && (_jsxs(Box, { children: [_jsx(Text, { color: getTextColor(isCurrent), children: "Preparing commands. " }), _jsx(Spinner, {})] })), (isExecuting || showCompletedSteps) && (_jsxs(Box, { flexDirection: "column", children: [message && (_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { color: getTextColor(isCurrent), children: message }), isExecuting && (_jsxs(Text, { children: [' ', _jsx(Spinner, {})] }))] })), commandStatuses.map((item, index) => (_jsx(Box, { marginBottom: index < commandStatuses.length - 1 ? 1 : 0, children: _jsx(CommandStatusDisplay, { item: item, elapsed: index === runningIndex ? currentElapsed : undefined }) }, index)))] })), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) }))] }));
+}

package/dist/ui/Main.js

@@ -2,20 +2,20 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import React from 'react';
 import { FeedbackType } from '../types/types.js';
 import { createAnthropicService, } from '../services/anthropic.js';
+import { createCommandDefinition, createConfigDefinition, createFeedback, createMessage, createWelcomeDefinition, isStateless, markAsDone, } from '../services/components.js';
 import { getConfigurationRequiredMessage, hasValidAnthropicKey, loadConfig, loadDebugSetting, saveDebugSetting, } from '../services/configuration.js';
 import { registerGlobalShortcut } from '../services/keyboard.js';
 import { getCancellationMessage } from '../services/messages.js';
-import { createCommandDefinition, createConfigDefinition, createFeedback, createMessage, createWelcomeDefinition, isStateless, markAsDone, } from '../services/components.js';
 import { exitApp } from '../services/process.js';
-import { createAnswerAbortedHandler, createAnswerCompleteHandler, createAnswerErrorHandler, } from '../handlers/answer.js';
-import { createCommandAbortedHandler, createCommandCompleteHandler, createCommandErrorHandler, } from '../handlers/command.js';
-import { createConfigAbortedHandler, createConfigFinishedHandler, } from '../handlers/config.js';
-import { createExecutionCancelledHandler, createExecutionConfirmedHandler, } from '../handlers/execution.js';
-import { createIntrospectAbortedHandler, createIntrospectCompleteHandler, createIntrospectErrorHandler, } from '../handlers/introspect.js';
-import { createPlanAbortedHandler, createPlanAbortHandlerFactory, createPlanSelectionConfirmedHandler, } from '../handlers/plan.js';
+import { createAnswerHandlers } from '../handlers/answer.js';
+import { createCommandHandlers } from '../handlers/command.js';
+import { createConfigHandlers } from '../handlers/config.js';
+import { createExecuteHandlers } from '../handlers/execute.js';
+import { createExecutionHandlers } from '../handlers/execution.js';
+import { createIntrospectHandlers } from '../handlers/introspect.js';
+import { createPlanHandlers } from '../handlers/plan.js';
 import { Column } from './Column.js';
 export const Main = ({ app, command }) => {
-    // Initialize service from existing config if available
     const [service, setService] = React.useState(() => {
         if (hasValidAnthropicKey()) {
             const config = loadConfig();
@@ -26,14 +26,8 @@ export const Main = ({ app, command }) => {
     const [timeline, setTimeline] = React.useState([]);
     const [queue, setQueue] = React.useState([]);
     const [isDebug, setIsDebug] = React.useState(() => loadDebugSetting());
-    // Use ref to track latest timeline for callbacks
-    const timelineRef = React.useRef(timeline);
-    React.useEffect(() => {
-        timelineRef.current = timeline;
-    }, [timeline]);
     // Register global keyboard shortcuts
     React.useEffect(() => {
-        // Shift+Tab: Toggle debug mode
         registerGlobalShortcut('shift+tab', () => {
             setIsDebug((prev) => {
                 const newValue = !prev;
@@ -50,7 +44,6 @@ export const Main = ({ app, command }) => {
             if (currentQueue.length === 0)
                 return currentQueue;
             const [first, ...rest] = currentQueue;
-            // Stateless components auto-complete immediately
             if (isStateless(first)) {
                 addToTimeline(first);
                 return rest;
@@ -58,7 +51,7 @@ export const Main = ({ app, command }) => {
             return currentQueue;
         });
     }, [addToTimeline]);
-    const handleCommandError = React.useCallback((error) => setQueue(createCommandErrorHandler(addToTimeline)(error)), [addToTimeline]);
+    // Core abort handler
     const handleAborted = React.useCallback((operationName) => {
         setQueue((currentQueue) => {
             if (currentQueue.length === 0)
@@ -71,86 +64,54 @@ export const Main = ({ app, command }) => {
             return [];
         });
     }, [addToTimeline]);
-    const handleConfigAborted = React.useCallback(createConfigAbortedHandler(handleAborted), [handleAborted]);
-    const handlePlanAborted = React.useCallback(createPlanAbortedHandler(handleAborted), [handleAborted]);
-    const createPlanAbortHandler = React.useCallback(createPlanAbortHandlerFactory(handleAborted, handlePlanAborted), [handleAborted, handlePlanAborted]);
-    const handleCommandAborted = React.useCallback(createCommandAbortedHandler(handleAborted), [handleAborted]);
-    const handleRefinementAborted = React.useCallback(() => {
-        handleAborted('Plan refinement');
-    }, [handleAborted]);
-    const handleIntrospectAborted = React.useCallback(createIntrospectAbortedHandler(handleAborted), [handleAborted]);
-    const handleIntrospectError = React.useCallback((error) => setQueue(createIntrospectErrorHandler(addToTimeline)(error)), [addToTimeline]);
-    const handleIntrospectComplete = React.useCallback((message, capabilities) => setQueue(createIntrospectCompleteHandler(addToTimeline)(message, capabilities)), [addToTimeline]);
-    const handleAnswerAborted = React.useCallback(createAnswerAbortedHandler(handleAborted), [handleAborted]);
-    const handleAnswerError = React.useCallback((error) => setQueue(createAnswerErrorHandler(addToTimeline)(error)), [addToTimeline]);
-    const handleAnswerComplete = React.useCallback((answer) => setQueue(createAnswerCompleteHandler(addToTimeline)(answer)), [addToTimeline]);
-    const handleExecutionConfirmed = React.useCallback(() => setQueue(createExecutionConfirmedHandler(timelineRef, addToTimeline, service, handleIntrospectError, handleIntrospectComplete, handleIntrospectAborted, handleAnswerError, handleAnswerComplete, handleAnswerAborted, setQueue)()), [
-        addToTimeline,
-        service,
-        handleIntrospectError,
-        handleIntrospectComplete,
-        handleIntrospectAborted,
-        handleAnswerError,
-        handleAnswerComplete,
-        handleAnswerAborted,
-    ]);
-    const handleExecutionCancelled = React.useCallback(() => setQueue(createExecutionCancelledHandler(timelineRef, addToTimeline)()), [addToTimeline]);
-    const handlePlanSelectionConfirmed = React.useCallback(createPlanSelectionConfirmedHandler(addToTimeline, service, handleRefinementAborted, createPlanAbortHandler, handleExecutionConfirmed, handleExecutionCancelled, setQueue), [
+    // Create operations object
+    const ops = React.useMemo(() => ({
         addToTimeline,
+        setQueue,
         service,
-        handleRefinementAborted,
-        createPlanAbortHandler,
-        handleExecutionConfirmed,
-        handleExecutionCancelled,
-    ]);
-    const handleCommandComplete = React.useCallback((message, tasks) => setQueue(createCommandCompleteHandler(addToTimeline, createPlanAbortHandler, handlePlanSelectionConfirmed, handleExecutionConfirmed, handleExecutionCancelled)(message, tasks)), [
-        addToTimeline,
-        createPlanAbortHandler,
-        handlePlanSelectionConfirmed,
-        handleExecutionConfirmed,
-        handleExecutionCancelled,
-    ]);
-    const handleConfigFinished = React.useCallback((config) => setQueue(createConfigFinishedHandler(addToTimeline, command, handleCommandError, handleCommandComplete, handleCommandAborted, setService)(config)), [
-        addToTimeline,
-        command,
-        handleCommandError,
-        handleCommandComplete,
-        handleCommandAborted,
-    ]);
+    }), [addToTimeline, service]);
+    // Create handlers in dependency order
+    const introspectHandlers = React.useMemo(() => createIntrospectHandlers(ops, handleAborted), [ops, handleAborted]);
+    const answerHandlers = React.useMemo(() => createAnswerHandlers(ops, handleAborted), [ops, handleAborted]);
+    const executeHandlers = React.useMemo(() => createExecuteHandlers(ops, handleAborted), [ops, handleAborted]);
+    const executionHandlers = React.useMemo(() => createExecutionHandlers(ops, {
+        introspect: introspectHandlers,
+        answer: answerHandlers,
+        execute: executeHandlers,
+    }), [ops, introspectHandlers, answerHandlers, executeHandlers]);
+    const planHandlers = React.useMemo(() => createPlanHandlers(ops, handleAborted, executionHandlers), [ops, handleAborted, executionHandlers]);
+    const commandHandlers = React.useMemo(() => createCommandHandlers(ops, handleAborted, planHandlers, executionHandlers), [ops, handleAborted, planHandlers, executionHandlers]);
+    const configHandlers = React.useMemo(() => createConfigHandlers(ops, handleAborted, command, commandHandlers, setService), [ops, handleAborted, command, commandHandlers]);
     // Initialize queue on mount
     React.useEffect(() => {
         const hasConfig = !!service;
         if (command && hasConfig) {
-            // With command + valid config: [Command]
             setQueue([
-                createCommandDefinition(command, service, handleCommandError, handleCommandComplete, handleCommandAborted),
+                createCommandDefinition(command, service, commandHandlers.onError, commandHandlers.onComplete, commandHandlers.onAborted),
             ]);
         }
         else if (command && !hasConfig) {
-            // With command + no config: [Message, Config] (Command added after config)
             setQueue([
                 createMessage(getConfigurationRequiredMessage()),
-                createConfigDefinition(handleConfigFinished, handleConfigAborted),
+                createConfigDefinition(configHandlers.onFinished, configHandlers.onAborted),
             ]);
         }
         else if (!command && hasConfig) {
-            // No command + valid config: [Welcome]
             setQueue([createWelcomeDefinition(app)]);
         }
         else {
-            // No command + no config: [Welcome, Message, Config]
             setQueue([
                 createWelcomeDefinition(app),
                 createMessage(getConfigurationRequiredMessage(true)),
-                createConfigDefinition(handleConfigFinished, handleConfigAborted),
+                createConfigDefinition(configHandlers.onFinished, configHandlers.onAborted),
             ]);
         }
-    }, []); // Only run on mount
+    }, []);
     // Process queue whenever it changes
     React.useEffect(() => {
         processNextInQueue();
     }, [queue, processNextInQueue]);
-    // Exit when queue is empty and timeline has content (all stateless components done)
+    // Exit when queue is empty and timeline has content
     React.useEffect(() => {
         if (queue.length === 0 && timeline.length > 0) {
             exitApp(0);

package/dist/ui/Spinner.js

@@ -3,15 +3,20 @@ import { useEffect, useState } from 'react';
 import { Text } from 'ink';
 const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 const INTERVAL = 80;
+const CYCLE = FRAMES.length * INTERVAL;
+function getFrame() {
+    return Math.floor((Date.now() % CYCLE) / INTERVAL);
+}
 export function Spinner() {
-    const [frame, setFrame] = useState(0);
+    const [frame, setFrame] = useState(getFrame);
     useEffect(() => {
         const timer = setInterval(() => {
-            setFrame((prev) => (prev + 1) % FRAMES.length);
+            setFrame((prev) => {
+                const next = getFrame();
+                return next !== prev ? next : prev;
+            });
         }, INTERVAL);
-        return () => {
-            clearInterval(timer);
-        };
+        return () => clearInterval(timer);
     }, []);
     return _jsx(Text, { color: "blueBright", children: FRAMES[frame] });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prompt-language-shell",
-  "version": "0.4.8",
+  "version": "0.4.9",
   "description": "Your personal command-line concierge. Ask politely, and it gets things done.",
   "type": "module",
   "main": "dist/index.js",
@@ -46,22 +46,22 @@
   },
   "homepage": "https://github.com/aswitalski/pls#readme",
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.69.0",
-    "ink": "^6.5.0",
+    "@anthropic-ai/sdk": "^0.70.1",
+    "ink": "^6.5.1",
     "ink-text-input": "^6.0.0",
     "react": "^19.2.0",
     "yaml": "^2.8.1"
   },
   "devDependencies": {
     "@types/node": "^24.10.1",
-    "@types/react": "^19.2.5",
-    "@vitest/coverage-v8": "^4.0.9",
+    "@types/react": "^19.2.6",
+    "@vitest/coverage-v8": "^4.0.12",
     "eslint": "^9.39.1",
     "husky": "^9.1.7",
     "ink-testing-library": "^4.0.0",
     "prettier": "^3.6.2",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.46.4",
-    "vitest": "^4.0.9"
+    "typescript-eslint": "^8.47.0",
+    "vitest": "^4.0.12"
   }
 }