prompt-language-shell 0.5.2 → 0.6.0

package/dist/ui/Confirm.js

@@ -1,26 +1,32 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import React from 'react';
+import { useState } from 'react';
 import { Box, Text } from 'ink';
 import { Colors, Palette } from '../services/colors.js';
 import { useInput } from '../services/keyboard.js';
-export function Confirm({ message, state, onConfirmed, onCancelled, }) {
-    const done = state?.done ?? false;
-    const isCurrent = done === false;
-    const [selectedIndex, setSelectedIndex] = React.useState(0); // 0 = Yes, 1 = No
+import { UserQuery } from './UserQuery.js';
+export function Confirm({ message, state, isActive = true, handlers, onConfirmed, onCancelled, }) {
+    // isActive passed as prop
+    const [selectedIndex, setSelectedIndex] = useState(state?.selectedIndex ?? 0); // 0 = Yes, 1 = No
     useInput((input, key) => {
-        if (done)
+        if (!isActive)
             return;
         if (key.escape) {
             // Escape: highlight "No" and cancel
             setSelectedIndex(1);
+            handlers?.updateState({ selectedIndex: 1 });
             onCancelled?.();
         }
         else if (key.tab) {
             // Toggle between Yes (0) and No (1)
-            setSelectedIndex((prev) => (prev === 0 ? 1 : 0));
+            setSelectedIndex((prev) => {
+                const newIndex = prev === 0 ? 1 : 0;
+                handlers?.updateState({ selectedIndex: newIndex });
+                return newIndex;
+            });
         }
         else if (key.return) {
             // Confirm selection
+            handlers?.updateState({ selectedIndex, confirmed: true });
             if (selectedIndex === 0) {
                 onConfirmed?.();
             }
@@ -28,16 +34,16 @@ export function Confirm({ message, state, onConfirmed, onCancelled, }) {
                 onCancelled?.();
             }
         }
-    }, { isActive: !done });
+    }, { isActive });
     const options = [
         { label: 'yes', value: 'yes', color: Palette.BrightGreen },
         { label: 'no', value: 'no', color: Colors.Status.Error },
     ];
-    if (done) {
+    if (!isActive) {
         // When done, show both the message and user's choice in timeline
-        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: undefined, children: message }) }), _jsx(Box, { paddingX: 1, marginX: -1, alignSelf: "flex-start", backgroundColor: Colors.Background.UserQuery, children: _jsxs(Text, { color: Colors.Text.UserQuery, children: ["> ", options[selectedIndex].label] }) })] }));
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, marginLeft: 1, children: _jsx(Text, { color: undefined, children: message }) }), _jsxs(UserQuery, { children: ["> ", options[selectedIndex].label] })] }));
     }
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: isCurrent ? Colors.Text.Active : Colors.Text.Inactive, children: message }) }), _jsxs(Box, { children: [_jsx(Text, { color: Colors.Action.Select, children: ">" }), _jsx(Text, { children: " " }), _jsx(Box, { children: options.map((option, index) => {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, marginLeft: 1, children: _jsx(Text, { color: isActive ? Colors.Text.Active : Colors.Text.Inactive, children: message }) }), _jsxs(Box, { marginLeft: 1, children: [_jsx(Text, { color: Colors.Action.Select, children: ">" }), _jsx(Text, { children: " " }), _jsx(Box, { children: options.map((option, index) => {
                             const isSelected = index === selectedIndex;
                             return (_jsx(Box, { marginRight: 2, children: _jsx(Text, { color: isSelected ? option.color : undefined, dimColor: !isSelected, children: option.label }) }, option.value));
                         }) })] })] }));

package/dist/ui/Execute.js

@@ -85,41 +85,53 @@ function CommandStatusDisplay({ item, elapsed }) {
     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);
+export function Execute({ tasks, state, isActive = true, service, handlers, }) {
+    // isActive passed as prop
+    const [error, setError] = useState(state?.error ?? null);
     const [isExecuting, setIsExecuting] = useState(false);
-    const [commandStatuses, setCommandStatuses] = useState([]);
-    const [message, setMessage] = useState('');
+    const [commandStatuses, setCommandStatuses] = useState(state?.commandStatuses ?? []);
+    const [message, setMessage] = useState(state?.message ?? '');
     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);
+    const [hasProcessed, setHasProcessed] = useState(false);
+    // Derive loading state from current conditions
+    const isLoading = isActive &&
+        commandStatuses.length === 0 &&
+        !error &&
+        !isExecuting &&
+        !hasProcessed;
+    useInput((_, key) => {
+        if (key.escape && (isLoading || isExecuting) && isActive) {
             setIsExecuting(false);
             setRunningIndex(null);
             // Mark any running command as aborted when cancelled
             const now = Date.now();
-            setCommandStatuses((prev) => prev.map((item) => {
-                if (item.status === ExecutionStatus.Running) {
-                    const elapsed = item.startTime
-                        ? Math.floor((now - item.startTime) / 1000) * 1000
-                        : undefined;
-                    return {
-                        ...item,
-                        status: ExecutionStatus.Aborted,
-                        endTime: now,
-                        elapsed,
-                    };
-                }
-                return item;
-            }));
-            onAborted(calculateTotalElapsed(commandStatuses));
+            setCommandStatuses((prev) => {
+                const updated = prev.map((item) => {
+                    if (item.status === ExecutionStatus.Running) {
+                        const elapsed = item.startTime
+                            ? Math.floor((now - item.startTime) / 1000) * 1000
+                            : undefined;
+                        return {
+                            ...item,
+                            status: ExecutionStatus.Aborted,
+                            endTime: now,
+                            elapsed,
+                        };
+                    }
+                    return item;
+                });
+                // Save state after updating
+                handlers?.updateState({
+                    commandStatuses: updated,
+                    message,
+                });
+                return updated;
+            });
+            handlers?.onAborted('execution');
         }
-    }, { isActive: (isLoading || isExecuting) && !done });
+    }, { isActive: (isLoading || isExecuting) && isActive });
     // Update elapsed time for running command
     useEffect(() => {
         if (runningIndex === null)
@@ -139,15 +151,20 @@ export function Execute({ tasks, state, service, onError, onComplete, onAborted,
     useEffect(() => {
         if (isExecuting || commandStatuses.length === 0 || !outputs.length)
             return;
-        onComplete?.(outputs, calculateTotalElapsed(commandStatuses));
-    }, [isExecuting, commandStatuses, outputs, onComplete]);
+        // Save state before completing
+        handlers?.updateState({
+            message,
+            commandStatuses,
+            error,
+        });
+        handlers?.onComplete();
+    }, [isExecuting, commandStatuses, outputs, handlers, message, error]);
     useEffect(() => {
-        if (done) {
+        if (!isActive) {
             return;
         }
         if (!service) {
             setError('No service available');
-            setIsLoading(false);
             return;
         }
         let mounted = true;
@@ -173,9 +190,14 @@ export function Execute({ tasks, state, service, onError, onComplete, onAborted,
                 if (!mounted)
                     return;
                 if (!result.commands || result.commands.length === 0) {
-                    setIsLoading(false);
                     setOutputs([]);
-                    onComplete?.([], 0);
+                    setHasProcessed(true);
+                    // Save state before completing
+                    handlers?.updateState({
+                        message: result.message,
+                        commandStatuses: [],
+                    });
+                    handlers?.onComplete();
                     return;
                 }
                 // Resolve placeholders in command strings before execution
@@ -190,7 +212,6 @@ export function Execute({ tasks, state, service, onError, onComplete, onAborted,
                     status: ExecutionStatus.Pending,
                     label: tasks[index]?.action,
                 })));
-                setIsLoading(false);
                 setIsExecuting(true);
                 // Execute commands sequentially
                 const outputs = await executeCommands(resolvedCommands, (progress) => {
@@ -236,14 +257,14 @@ export function Execute({ tasks, state, service, onError, onComplete, onAborted,
                 await ensureMinimumTime(startTime, MINIMUM_PROCESSING_TIME);
                 if (mounted) {
                     const errorMessage = formatErrorMessage(err);
-                    setIsLoading(false);
                     setIsExecuting(false);
-                    if (onError) {
-                        onError(errorMessage);
-                    }
-                    else {
-                        setError(errorMessage);
-                    }
+                    setError(errorMessage);
+                    setHasProcessed(true);
+                    // Save error state
+                    handlers?.updateState({
+                        error: errorMessage,
+                    });
+                    handlers?.onError(errorMessage);
                 }
             }
         }
@@ -251,12 +272,12 @@ export function Execute({ tasks, state, service, onError, onComplete, onAborted,
         return () => {
             mounted = false;
         };
-    }, [tasks, done, service, onComplete, onError]);
+    }, [tasks, isActive, service, handlers]);
     // Return null only when loading completes with no commands
-    if (done && commandStatuses.length === 0 && !error) {
+    if (!isActive && 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] }) }))] }));
+    // Show completed steps when not active
+    const showCompletedSteps = !isActive && commandStatuses.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 || showCompletedSteps) && (_jsxs(Box, { flexDirection: "column", marginLeft: 1, children: [message && (_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { color: getTextColor(isActive), 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/Feedback.js

@@ -13,5 +13,5 @@ function getSymbol(type) {
 export function Feedback({ type, message }) {
     const color = getFeedbackColor(type, false);
     const symbol = getSymbol(type);
-    return (_jsx(Box, { children: _jsxs(Text, { color: color, children: [symbol, " ", message] }) }));
+    return (_jsx(Box, { marginLeft: 1, children: _jsxs(Text, { color: color, children: [symbol, " ", message] }) }));
 }

package/dist/ui/Introspect.js

@@ -2,6 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
 import { Box, Text } from 'ink';
 import { Colors, getTextColor } from '../services/colors.js';
+import { createReportDefinition } from '../services/components.js';
 import { useInput } from '../services/keyboard.js';
 import { formatErrorMessage } from '../services/messages.js';
 import { ensureMinimumTime } from '../services/timing.js';
@@ -41,26 +42,22 @@ function parseCapabilityFromTask(task) {
         isIndirect,
     };
 }
-export function Introspect({ tasks, state, service, children, debug = false, onError, onComplete, onAborted, }) {
-    const done = state?.done ?? false;
-    const isCurrent = done === false;
+export function Introspect({ tasks, state, isActive = true, service, children, debug = false, handlers, }) {
+    // isActive passed as prop
     const [error, setError] = useState(null);
-    const [isLoading, setIsLoading] = useState(state?.isLoading ?? !done);
     useInput((input, key) => {
-        if (key.escape && isLoading && !done) {
-            setIsLoading(false);
-            onAborted();
+        if (key.escape && isActive) {
+            handlers?.onAborted('introspection');
         }
-    }, { isActive: isLoading && !done });
+    }, { isActive });
     useEffect(() => {
-        // Skip processing if done
-        if (done) {
+        // Skip processing if not active
+        if (!isActive) {
             return;
         }
         // Skip processing if no service available
         if (!service) {
             setError('No service available');
-            setIsLoading(false);
             return;
         }
         let mounted = true;
@@ -81,21 +78,27 @@ export function Introspect({ tasks, state, service, children, debug = false, onE
                             cap.name.toUpperCase() !== 'VALIDATE' &&
                             cap.name.toUpperCase() !== 'REPORT');
                     }
-                    setIsLoading(false);
-                    onComplete?.(result.message, capabilities);
+                    // Save state before completing
+                    handlers?.updateState({
+                        capabilities,
+                        message: result.message,
+                    });
+                    // Add Report component to queue
+                    handlers?.addToQueue(createReportDefinition(result.message, capabilities));
+                    // Signal completion
+                    handlers?.onComplete();
                 }
             }
             catch (err) {
                 await ensureMinimumTime(startTime, MIN_PROCESSING_TIME);
                 if (mounted) {
                     const errorMessage = formatErrorMessage(err);
-                    setIsLoading(false);
-                    if (onError) {
-                        onError(errorMessage);
-                    }
-                    else {
-                        setError(errorMessage);
-                    }
+                    setError(errorMessage);
+                    // Save error state
+                    handlers?.updateState({
+                        error: errorMessage,
+                    });
+                    handlers?.onError(errorMessage);
                 }
             }
         }
@@ -103,10 +106,10 @@ export function Introspect({ tasks, state, service, children, debug = false, onE
         return () => {
             mounted = false;
         };
-    }, [tasks, done, service, debug, onComplete, onError]);
+    }, [tasks, isActive, service, debug, handlers]);
     // Don't render wrapper when done and nothing to show
-    if (!isLoading && !error && !children) {
+    if (!isActive && !error && !children) {
         return null;
     }
-    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isLoading && (_jsxs(Box, { children: [_jsx(Text, { color: getTextColor(isCurrent), children: "Listing capabilities. " }), _jsx(Spinner, {})] })), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) })), children] }));
+    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isActive && (_jsxs(Box, { marginLeft: 1, children: [_jsx(Text, { color: getTextColor(isActive), children: "Listing capabilities. " }), _jsx(Spinner, {})] })), error && (_jsx(Box, { marginTop: 1, marginLeft: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) })), children] }));
 }

package/dist/ui/Main.js

@@ -1,33 +1,17 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import React from 'react';
+import { useEffect, useState } 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 { createCommandDefinition, createConfigDefinitionWithKeys, createFeedback, createMessage, createWelcomeDefinition, } from '../services/components.js';
+import { getConfigurationRequiredMessage, getMissingConfigKeys, loadConfig, loadDebugSetting, saveAnthropicConfig, saveDebugSetting, } from '../services/configuration.js';
 import { registerGlobalShortcut } from '../services/keyboard.js';
-import { getCancellationMessage } from '../services/messages.js';
-import { exitApp } from '../services/process.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';
+import { Workflow } from './Workflow.js';
 export const Main = ({ app, command }) => {
-    const [service, setService] = React.useState(() => {
-        if (hasValidAnthropicKey()) {
-            const config = loadConfig();
-            return createAnthropicService(config.anthropic);
-        }
-        return null;
-    });
-    const [timeline, setTimeline] = React.useState([]);
-    const [queue, setQueue] = React.useState([]);
-    const [isDebug, setIsDebug] = React.useState(() => loadDebugSetting());
+    const [service, setService] = useState(null);
+    const [initialQueue, setInitialQueue] = useState(null);
+    const [isDebug, setIsDebug] = useState(() => loadDebugSetting());
     // Register global keyboard shortcuts
-    React.useEffect(() => {
+    useEffect(() => {
         registerGlobalShortcut('shift+tab', () => {
             setIsDebug((prev) => {
                 const newValue = !prev;
@@ -36,88 +20,75 @@ export const Main = ({ app, command }) => {
             });
         });
     }, []);
-    const addToTimeline = React.useCallback((...items) => {
-        setTimeline((timeline) => [...timeline, ...items]);
-    }, []);
-    const processNextInQueue = React.useCallback(() => {
-        setQueue((currentQueue) => {
-            if (currentQueue.length === 0)
-                return currentQueue;
-            const [first, ...rest] = currentQueue;
-            if (isStateless(first)) {
-                addToTimeline(first);
-                return rest;
+    // Initialize service on mount
+    useEffect(() => {
+        if (service !== null) {
+            return;
+        }
+        const missingKeys = getMissingConfigKeys();
+        if (missingKeys.length === 0) {
+            // Config exists - create service immediately
+            try {
+                const config = loadConfig();
+                const newService = createAnthropicService(config.anthropic);
+                setService(newService);
             }
-            return currentQueue;
-        });
-    }, [addToTimeline]);
-    // Core abort handler
-    const handleAborted = React.useCallback((operationName) => {
-        setQueue((currentQueue) => {
-            if (currentQueue.length === 0)
-                return currentQueue;
-            const [first] = currentQueue;
-            if (!isStateless(first)) {
-                addToTimeline(markAsDone(first), createFeedback(FeedbackType.Aborted, getCancellationMessage(operationName)));
+            catch (error) {
+                // Service creation failed - show error and exit
+                const errorMessage = error instanceof Error
+                    ? error.message
+                    : 'Failed to initialize service';
+                setInitialQueue([createFeedback(FeedbackType.Failed, errorMessage)]);
             }
-            exitApp(0);
-            return [];
-        });
-    }, [addToTimeline]);
-    // Create operations object
-    const ops = React.useMemo(() => ({
-        addToTimeline,
-        setQueue,
-        service,
-    }), [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) {
-            setQueue([
-                createCommandDefinition(command, service, commandHandlers.onError, commandHandlers.onComplete, commandHandlers.onAborted),
-            ]);
         }
-        else if (command && !hasConfig) {
-            setQueue([
-                createMessage(getConfigurationRequiredMessage()),
-                createConfigDefinition(configHandlers.onFinished, configHandlers.onAborted),
-            ]);
+        // If config is missing, service will be created after config completes
+    }, [service]);
+    // Initialize queue after service is ready
+    useEffect(() => {
+        // Only set initial queue once
+        if (initialQueue !== null) {
+            return;
         }
-        else if (!command && hasConfig) {
-            setQueue([createWelcomeDefinition(app)]);
-        }
-        else {
-            setQueue([
+        const missingKeys = getMissingConfigKeys();
+        if (missingKeys.length > 0) {
+            // Missing config - show initial configuration flow
+            const handleConfigFinished = (config) => {
+                // Save config and create service
+                try {
+                    const newConfig = saveAnthropicConfig(config);
+                    const newService = createAnthropicService(newConfig.anthropic);
+                    setService(newService);
+                }
+                catch (error) {
+                    // Config creation failed - show error
+                    const errorMessage = error instanceof Error
+                        ? error.message
+                        : 'Failed to save configuration';
+                    setInitialQueue([createFeedback(FeedbackType.Failed, errorMessage)]);
+                }
+            };
+            const handleConfigAborted = (operation) => {
+                // Config was cancelled - just exit
+            };
+            setInitialQueue([
                 createWelcomeDefinition(app),
-                createMessage(getConfigurationRequiredMessage(true)),
-                createConfigDefinition(configHandlers.onFinished, configHandlers.onAborted),
+                createMessage(getConfigurationRequiredMessage()),
+                createConfigDefinitionWithKeys(missingKeys, handleConfigFinished, handleConfigAborted),
             ]);
         }
-    }, []);
-    // Process queue whenever it changes
-    React.useEffect(() => {
-        processNextInQueue();
-    }, [queue, processNextInQueue]);
-    // Exit when queue is empty and timeline has content
-    React.useEffect(() => {
-        if (queue.length === 0 && timeline.length > 0) {
-            exitApp(0);
+        else if (service && command) {
+            // Valid service exists and command provided - execute command
+            setInitialQueue([createCommandDefinition(command, service)]);
+        }
+        else if (service && !command) {
+            // Valid service exists, no command - show welcome
+            setInitialQueue([createWelcomeDefinition(app)]);
         }
-    }, [queue, timeline]);
-    const current = queue.length > 0 ? queue[0] : null;
-    const items = React.useMemo(() => [...timeline, ...(current ? [current] : [])], [timeline, current]);
-    return _jsx(Column, { items: items, debug: isDebug });
+        // Wait for service to be initialized before setting queue
+    }, [app, command, service, initialQueue]);
+    // Don't render until initial queue is ready
+    if (initialQueue === null) {
+        return null;
+    }
+    return _jsx(Workflow, { initialQueue: initialQueue, debug: isDebug });
 };

package/dist/ui/Message.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 export const Message = ({ text }) => {
-    return (_jsx(Box, { children: _jsx(Text, { children: text }) }));
+    return (_jsx(Box, { marginLeft: 1, children: _jsx(Text, { children: text }) }));
 };