prompt-language-shell 0.4.8 → 0.5.0

package/dist/services/skills.js

@@ -1,6 +1,7 @@
 import { existsSync, readdirSync, readFileSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
+import { parseSkillMarkdown } from './skill-parser.js';
 /**
  * Get the path to the skills directory
  */
@@ -32,6 +33,31 @@ export function loadSkills() {
         return [];
     }
 }
+/**
+ * Load and parse all skill definitions
+ * Returns structured skill definitions
+ */
+export function loadSkillDefinitions() {
+    const skillContents = loadSkills();
+    const definitions = [];
+    for (const content of skillContents) {
+        const parsed = parseSkillMarkdown(content);
+        if (parsed) {
+            definitions.push(parsed);
+        }
+    }
+    return definitions;
+}
+/**
+ * Create skill lookup function from definitions
+ */
+export function createSkillLookup(definitions) {
+    const map = new Map();
+    for (const definition of definitions) {
+        map.set(definition.name, definition);
+    }
+    return (name) => map.get(name) || null;
+}
 /**
  * Format skills for inclusion in the planning prompt
  */

package/dist/services/timing.js

@@ -0,0 +1,38 @@
+/**
+ * Timing utilities for UI components
+ */
+/**
+ * Waits for at least the minimum processing time.
+ * Ensures async operations don't complete too quickly for good UX.
+ *
+ * @param startTime - The timestamp when the operation started
+ * @param minimumTime - The minimum total time the operation should take
+ */
+export async function ensureMinimumTime(startTime, minimumTime) {
+    const elapsed = Date.now() - startTime;
+    const remainingTime = Math.max(0, minimumTime - elapsed);
+    if (remainingTime > 0) {
+        await new Promise((resolve) => setTimeout(resolve, remainingTime));
+    }
+}
+/**
+ * Wraps an async operation with minimum processing time UX polish.
+ * Ensures successful operations take at least `minimumTime` milliseconds.
+ * Errors are thrown immediately without delay for better UX.
+ *
+ * @param operation - The async operation to perform
+ * @param minimumTime - Minimum time in milliseconds for UX polish on success
+ * @returns The result of the operation
+ */
+export async function withMinimumTime(operation, minimumTime) {
+    const startTime = Date.now();
+    try {
+        const result = await operation();
+        await ensureMinimumTime(startTime, minimumTime);
+        return result;
+    }
+    catch (error) {
+        // Don't wait on error - fail fast for better UX
+        throw error;
+    }
+}

package/dist/services/tool-registry.js

@@ -35,8 +35,10 @@ export const toolRegistry = new ToolRegistry();
 // Register built-in tools
 import { answerTool } from '../tools/answer.tool.js';
 import { configTool } from '../tools/config.tool.js';
+import { executeTool } from '../tools/execute.tool.js';
 import { introspectTool } from '../tools/introspect.tool.js';
 import { planTool } from '../tools/plan.tool.js';
+import { validateTool } from '../tools/validate.tool.js';
 toolRegistry.register('plan', {
     schema: planTool,
     instructionsPath: 'config/PLAN.md',
@@ -53,3 +55,11 @@ toolRegistry.register('config', {
     schema: configTool,
     instructionsPath: 'config/CONFIG.md',
 });
+toolRegistry.register('execute', {
+    schema: executeTool,
+    instructionsPath: 'config/EXECUTE.md',
+});
+toolRegistry.register('validate', {
+    schema: validateTool,
+    instructionsPath: 'config/VALIDATE.md',
+});

package/dist/services/utils.js

@@ -0,0 +1,21 @@
+/**
+ * Formats a duration in milliseconds to a human-readable string.
+ * Uses correct singular/plural forms.
+ */
+export function formatDuration(ms) {
+    const totalSeconds = Math.floor(ms / 1000);
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    const parts = [];
+    if (hours > 0) {
+        parts.push(`${String(hours)} ${hours === 1 ? 'hour' : 'hours'}`);
+    }
+    if (minutes > 0) {
+        parts.push(`${String(minutes)} ${minutes === 1 ? 'minute' : 'minutes'}`);
+    }
+    if (seconds > 0 || parts.length === 0) {
+        parts.push(`${String(seconds)} ${seconds === 1 ? 'second' : 'seconds'}`);
+    }
+    return parts.join(' ');
+}

package/dist/tools/execute.tool.js

@@ -0,0 +1,44 @@
+export const executeTool = {
+    name: 'execute',
+    description: 'Execute shell commands from planned tasks. Translates task descriptions into specific shell commands that can be run in the terminal. Called after PLAN has created execute tasks and user has confirmed.',
+    input_schema: {
+        type: 'object',
+        properties: {
+            message: {
+                type: 'string',
+                description: 'Brief status message about the execution. Must be a single sentence, maximum 64 characters, ending with a period.',
+            },
+            commands: {
+                type: 'array',
+                description: 'Array of commands to execute sequentially',
+                items: {
+                    type: 'object',
+                    properties: {
+                        description: {
+                            type: 'string',
+                            description: 'Brief description of what this command does. Maximum 64 characters.',
+                        },
+                        command: {
+                            type: 'string',
+                            description: 'The exact shell command to run. Must be a valid shell command.',
+                        },
+                        workdir: {
+                            type: 'string',
+                            description: 'Optional working directory for the command. Defaults to current directory if not specified.',
+                        },
+                        timeout: {
+                            type: 'number',
+                            description: 'Optional timeout in milliseconds. Defaults to 30000 (30 seconds).',
+                        },
+                        critical: {
+                            type: 'boolean',
+                            description: 'Whether failure should stop execution of subsequent commands. Defaults to true.',
+                        },
+                    },
+                    required: ['description', 'command'],
+                },
+            },
+        },
+        required: ['message', 'commands'],
+    },
+};

package/dist/tools/validate.tool.js

@@ -0,0 +1,43 @@
+export const validateTool = {
+    name: 'validate',
+    description: 'Validate skill requirements and generate natural language descriptions for missing configuration values. Given skill context and missing config paths, create CONFIG tasks with helpful, contextual descriptions.',
+    input_schema: {
+        type: 'object',
+        properties: {
+            message: {
+                type: 'string',
+                description: 'Empty string or brief message (not shown to user, can be left empty)',
+            },
+            tasks: {
+                type: 'array',
+                description: 'Array of CONFIG tasks with natural language descriptions for missing config values',
+                items: {
+                    type: 'object',
+                    properties: {
+                        action: {
+                            type: 'string',
+                            description: 'Natural language description explaining what the config value is for, followed by the config path in curly brackets {config.path}. Example: "Path to Alpha project repository (legacy implementation) {project.alpha.repo}"',
+                        },
+                        type: {
+                            type: 'string',
+                            description: 'Must be "config" for all tasks returned by this tool',
+                        },
+                        params: {
+                            type: 'object',
+                            description: 'Must include key field with the config path',
+                            properties: {
+                                key: {
+                                    type: 'string',
+                                    description: 'The config path (e.g., "opera.gx.repo")',
+                                },
+                            },
+                            required: ['key'],
+                        },
+                    },
+                    required: ['action', 'type', 'params'],
+                },
+            },
+        },
+        required: ['message', 'tasks'],
+    },
+};

package/dist/types/handlers.js

@@ -0,0 +1 @@
+export {};

package/dist/types/skills.js

@@ -0,0 +1,4 @@
+/**
+ * Type definitions for the structured skill system
+ */
+export {};

package/dist/types/types.js

@@ -12,6 +12,8 @@ export var ComponentName;
     ComponentName["Report"] = "report";
     ComponentName["Answer"] = "answer";
     ComponentName["AnswerDisplay"] = "answerDisplay";
+    ComponentName["Execute"] = "execute";
+    ComponentName["Validate"] = "validate";
 })(ComponentName || (ComponentName = {}));
 export var TaskType;
 (function (TaskType) {

package/dist/ui/Answer.js

@@ -4,6 +4,7 @@ import { Box, Text } from 'ink';
 import { Colors, getTextColor } from '../services/colors.js';
 import { useInput } from '../services/keyboard.js';
 import { formatErrorMessage } from '../services/messages.js';
+import { withMinimumTime } from '../services/timing.js';
 import { Spinner } from './Spinner.js';
 const MINIMUM_PROCESSING_TIME = 400;
 export function Answer({ question, state, service, onError, onComplete, onAborted, }) {
@@ -30,13 +31,9 @@ export function Answer({ question, state, service, onError, onComplete, onAborte
         }
         let mounted = true;
         async function process(svc) {
-            const startTime = Date.now();
             try {
-                // Call answer tool
-                const result = await svc.processWithTool(question, 'answer');
-                const elapsed = Date.now() - startTime;
-                const remainingTime = Math.max(0, MINIMUM_PROCESSING_TIME - elapsed);
-                await new Promise((resolve) => setTimeout(resolve, remainingTime));
+                // Call answer tool with minimum processing time for UX polish
+                const result = await withMinimumTime(() => svc.processWithTool(question, 'answer'), MINIMUM_PROCESSING_TIME);
                 if (mounted) {
                     // Extract answer from result
                     const answer = result.answer || '';
@@ -45,9 +42,6 @@ export function Answer({ question, state, service, onError, onComplete, onAborte
                 }
             }
             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);

package/dist/ui/Command.js

@@ -5,6 +5,7 @@ import { TaskType } from '../types/types.js';
 import { Colors } from '../services/colors.js';
 import { useInput } from '../services/keyboard.js';
 import { formatErrorMessage } from '../services/messages.js';
+import { ensureMinimumTime } from '../services/timing.js';
 import { Spinner } from './Spinner.js';
 const MIN_PROCESSING_TIME = 1000; // purely for visual effect
 export function Command({ command, state, service, children, onError, onComplete, onAborted, }) {
@@ -42,18 +43,14 @@ export function Command({ command, state, service, children, onError, onComplete
                     // Call CONFIG tool to get specific config keys
                     result = await svc.processWithTool(query, 'config');
                 }
-                const elapsed = Date.now() - startTime;
-                const remainingTime = Math.max(0, MIN_PROCESSING_TIME - elapsed);
-                await new Promise((resolve) => setTimeout(resolve, remainingTime));
+                await ensureMinimumTime(startTime, MIN_PROCESSING_TIME);
                 if (mounted) {
                     setIsLoading(false);
                     onComplete?.(result.message, result.tasks);
                 }
             }
             catch (err) {
-                const elapsed = Date.now() - startTime;
-                const remainingTime = Math.max(0, MIN_PROCESSING_TIME - elapsed);
-                await new Promise((resolve) => setTimeout(resolve, remainingTime));
+                await ensureMinimumTime(startTime, MIN_PROCESSING_TIME);
                 if (mounted) {
                     const errorMessage = formatErrorMessage(err);
                     setIsLoading(false);

package/dist/ui/Component.js

@@ -6,12 +6,14 @@ import { AnswerDisplay } from './AnswerDisplay.js';
 import { Command } from './Command.js';
 import { Confirm } from './Confirm.js';
 import { Config } from './Config.js';
+import { Execute } from './Execute.js';
 import { Feedback } from './Feedback.js';
 import { Introspect } from './Introspect.js';
 import { Message } from './Message.js';
 import { Plan } from './Plan.js';
 import { Refinement } from './Refinement.js';
 import { Report } from './Report.js';
+import { Validate } from './Validate.js';
 import { Welcome } from './Welcome.js';
 export const Component = React.memo(function Component({ def, debug, }) {
     switch (def.name) {
@@ -20,7 +22,7 @@ export const Component = React.memo(function Component({ def, debug, }) {
         case ComponentName.Config: {
             const props = def.props;
             const state = def.state;
-            return _jsx(Config, { ...props, state: state });
+            return _jsx(Config, { ...props, state: state, debug: debug });
         }
         case ComponentName.Command: {
             const props = def.props;
@@ -60,5 +62,15 @@ export const Component = React.memo(function Component({ def, debug, }) {
         }
         case ComponentName.AnswerDisplay:
             return _jsx(AnswerDisplay, { ...def.props });
+        case ComponentName.Execute: {
+            const props = def.props;
+            const state = def.state;
+            return _jsx(Execute, { ...props, state: state });
+        }
+        case ComponentName.Validate: {
+            const props = def.props;
+            const state = def.state;
+            return _jsx(Validate, { ...props, state: state });
+        }
     }
 });

package/dist/ui/Config.js

@@ -57,7 +57,7 @@ function SelectionStep({ options, selectedIndex, isCurrentStep, }) {
             return (_jsx(Box, { marginRight: 2, children: _jsx(Text, { dimColor: !isSelected || !isCurrentStep, bold: isSelected, children: option.label }) }, option.value));
         }) }));
 }
-export function Config({ steps, state, onFinished, onAborted }) {
+export function Config({ steps, state, debug, onFinished, onAborted }) {
     const done = state?.done ?? false;
     const [step, setStep] = React.useState(done ? steps.length : 0);
     const [values, setValues] = React.useState(() => {
@@ -220,6 +220,6 @@ export function Config({ steps, state, onFinished, onAborted }) {
             if (!shouldShow) {
                 return null;
             }
-            return (_jsxs(Box, { flexDirection: "column", marginTop: index === 0 ? 0 : 1, children: [_jsx(Box, { children: _jsxs(Text, { children: [stepConfig.description, ":"] }) }), _jsxs(Box, { children: [_jsx(Text, { children: " " }), _jsx(Text, { color: Colors.Action.Select, dimColor: !isCurrentStep, children: ">" }), _jsx(Text, { children: " " }), renderStepInput(stepConfig, isCurrentStep)] })] }, stepConfig.key));
+            return (_jsxs(Box, { flexDirection: "column", marginTop: index === 0 ? 0 : 1, children: [_jsxs(Box, { children: [_jsx(Text, { children: stepConfig.description }), _jsx(Text, { children: ": " }), debug && stepConfig.path && (_jsxs(Text, { color: Colors.Type.Define, children: ['{', stepConfig.path, '}'] }))] }), _jsxs(Box, { children: [_jsx(Text, { children: " " }), _jsx(Text, { color: Colors.Action.Select, dimColor: !isCurrentStep, children: ">" }), _jsx(Text, { children: " " }), renderStepInput(stepConfig, isCurrentStep)] })] }, stepConfig.key));
         }) }));
 }

package/dist/ui/Confirm.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React from 'react';
 import { Box, Text } from 'ink';
-import { Colors } from '../services/colors.js';
+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;
@@ -30,7 +30,7 @@ export function Confirm({ message, state, onConfirmed, onCancelled, }) {
         }
     }, { isActive: !done });
     const options = [
-        { label: 'yes', value: 'yes', color: Colors.Action.Execute },
+        { label: 'yes', value: 'yes', color: Palette.BrightGreen },
         { label: 'no', value: 'no', color: Colors.Status.Error },
     ];
     if (done) {

package/dist/ui/Execute.js

@@ -0,0 +1,262 @@
+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 { replacePlaceholders } from '../services/placeholder-resolver.js';
+import { loadUserConfig } from '../services/config-loader.js';
+import { ensureMinimumTime } from '../services/timing.js';
+import { Spinner } from './Spinner.js';
+const MINIMUM_PROCESSING_TIME = 400;
+const STATUS_ICONS = {
+    [ExecutionStatus.Pending]: '- ',
+    [ExecutionStatus.Running]: '• ',
+    [ExecutionStatus.Success]: '✓ ',
+    [ExecutionStatus.Failed]: '✗ ',
+    [ExecutionStatus.Aborted]: '⊘ ',
+};
+function calculateTotalElapsed(commandStatuses) {
+    return commandStatuses.reduce((sum, cmd) => {
+        if (cmd.elapsed !== undefined) {
+            return sum + cmd.elapsed;
+        }
+        if (cmd.startTime) {
+            const elapsed = cmd.endTime
+                ? cmd.endTime - cmd.startTime
+                : Date.now() - cmd.startTime;
+            return sum + elapsed;
+        }
+        return sum;
+    }, 0);
+}
+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,
+            };
+        case ExecutionStatus.Aborted:
+            return {
+                icon: Palette.DarkOrange,
+                description: getTextColor(true),
+                command: Palette.DarkOrange,
+                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);
+            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));
+        }
+    }, { 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;
+        onComplete?.(outputs, calculateTotalElapsed(commandStatuses));
+    }, [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 {
+                // Load user config for placeholder resolution
+                const userConfig = loadUserConfig();
+                // Format tasks for the execute tool and resolve placeholders
+                const taskDescriptions = tasks
+                    .map((task) => {
+                    // Resolve placeholders in task action
+                    const resolvedAction = replacePlaceholders(task.action, userConfig);
+                    const params = task.params
+                        ? ` (params: ${JSON.stringify(task.params)})`
+                        : '';
+                    return `- ${resolvedAction}${params}`;
+                })
+                    .join('\n');
+                // Call execute tool to get commands
+                const result = await svc.processWithTool(taskDescriptions, 'execute');
+                await ensureMinimumTime(startTime, MINIMUM_PROCESSING_TIME);
+                if (!mounted)
+                    return;
+                if (!result.commands || result.commands.length === 0) {
+                    setIsLoading(false);
+                    setOutputs([]);
+                    onComplete?.([], 0);
+                    return;
+                }
+                // Resolve placeholders in command strings before execution
+                const resolvedCommands = result.commands.map((cmd) => ({
+                    ...cmd,
+                    command: replacePlaceholders(cmd.command, userConfig),
+                }));
+                // Set message and initialize command statuses
+                setMessage(result.message);
+                setCommandStatuses(resolvedCommands.map((cmd, index) => ({
+                    command: cmd,
+                    status: ExecutionStatus.Pending,
+                    label: tasks[index]?.action,
+                })));
+                setIsLoading(false);
+                setIsExecuting(true);
+                // Execute commands sequentially
+                const outputs = await executeCommands(resolvedCommands, (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) {
+                await ensureMinimumTime(startTime, MINIMUM_PROCESSING_TIME);
+                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] }) }))] }));
+}