prompt-language-shell 0.4.8 → 0.4.9

package/dist/handlers/execution.js

@@ -1,88 +1,73 @@
 import { ComponentName, FeedbackType, TaskType } from '../types/types.js';
-import { createAnswerDefinition, createConfigDefinitionWithKeys, createFeedback, createIntrospectDefinition, markAsDone, } from '../services/components.js';
-import { createConfigExecutionAbortedHandler, createConfigExecutionFinishedHandler, } from './config.js';
+import { createAnswerDefinition, createConfigDefinitionWithKeys, createExecuteDefinition, createFeedback, createIntrospectDefinition, markAsDone, } from '../services/components.js';
 import { getCancellationMessage } from '../services/messages.js';
 import { exitApp } from '../services/process.js';
 import { withQueueHandler } from '../services/queue.js';
+import { createConfigExecutionAbortedHandler, createConfigExecutionFinishedHandler, } from './config.js';
 /**
- * Creates execution confirmed handler
- */
-export function createExecutionConfirmedHandler(timelineRef, addToTimeline, service, handleIntrospectError, handleIntrospectComplete, handleIntrospectAborted, handleAnswerError, handleAnswerComplete, handleAnswerAborted, setQueue) {
-    return () => withQueueHandler(ComponentName.Confirm, (first) => {
-        // Find the most recent Plan in timeline to get tasks
-        const currentTimeline = timelineRef.current;
-        const lastPlanIndex = [...currentTimeline]
-            .reverse()
-            .findIndex((item) => item.name === ComponentName.Plan);
-        const lastPlan = lastPlanIndex >= 0
-            ? currentTimeline[currentTimeline.length - 1 - lastPlanIndex]
-            : null;
-        const tasks = lastPlan?.name === ComponentName.Plan &&
-            Array.isArray(lastPlan.props.tasks)
-            ? lastPlan.props.tasks
-            : [];
-        const allIntrospect = tasks.every((task) => task.type === TaskType.Introspect);
-        const allAnswer = tasks.every((task) => task.type === TaskType.Answer);
-        const allConfig = tasks.every((task) => task.type === TaskType.Config);
-        if (allIntrospect && tasks.length > 0) {
-            // Execute introspection
-            addToTimeline(markAsDone(first));
-            return [
-                createIntrospectDefinition(tasks, service, handleIntrospectError, handleIntrospectComplete, handleIntrospectAborted),
-            ];
-        }
-        else if (allAnswer && tasks.length > 0) {
-            // Execute answer - extract question from first task
-            const question = tasks[0].action;
-            addToTimeline(markAsDone(first));
-            return [
-                createAnswerDefinition(question, service, handleAnswerError, handleAnswerComplete, handleAnswerAborted),
-            ];
-        }
-        else if (allConfig && tasks.length > 0) {
-            // Execute config - extract keys from task params
-            const keys = tasks
-                .map((task) => task.params?.key)
-                .filter((key) => typeof key === 'string');
-            addToTimeline(markAsDone(first));
-            // Create handlers with keys for proper saving
-            // Wrap in setQueue to properly update queue when Config finishes
-            const handleConfigFinished = (config) => {
-                setQueue(createConfigExecutionFinishedHandler(addToTimeline, keys)(config));
-            };
-            const handleConfigAborted = () => {
-                setQueue(createConfigExecutionAbortedHandler(addToTimeline)());
-            };
-            return [
-                createConfigDefinitionWithKeys(keys, handleConfigFinished, handleConfigAborted),
-            ];
-        }
-        else {
-            // Regular execution - just exit for now
-            addToTimeline(markAsDone(first));
-            exitApp(0);
-            return [];
-        }
-    });
-}
-/**
- * Creates execution cancelled handler
+ * Creates all execution handlers
  */
-export function createExecutionCancelledHandler(timelineRef, addToTimeline) {
-    return () => withQueueHandler(ComponentName.Confirm, (first) => {
-        // Find the most recent Plan in timeline to check task types
-        const currentTimeline = timelineRef.current;
-        const lastPlanIndex = [...currentTimeline]
-            .reverse()
-            .findIndex((item) => item.name === ComponentName.Plan);
-        const lastPlan = lastPlanIndex >= 0
-            ? currentTimeline[currentTimeline.length - 1 - lastPlanIndex]
-            : null;
-        const allIntrospect = lastPlan?.name === ComponentName.Plan &&
-            Array.isArray(lastPlan.props.tasks) &&
-            lastPlan.props.tasks.every((task) => task.type === TaskType.Introspect);
-        const operation = allIntrospect ? 'introspection' : 'execution';
-        addToTimeline(markAsDone(first), createFeedback(FeedbackType.Aborted, getCancellationMessage(operation)));
-        return undefined;
-    }, true, 0);
+export function createExecutionHandlers(ops, taskHandlers) {
+    const onConfirmed = (tasks) => {
+        ops.setQueue(withQueueHandler(ComponentName.Confirm, (first) => {
+            const allIntrospect = tasks.every((task) => task.type === TaskType.Introspect);
+            const allAnswer = tasks.every((task) => task.type === TaskType.Answer);
+            const allConfig = tasks.every((task) => task.type === TaskType.Config);
+            const allExecute = tasks.every((task) => task.type === TaskType.Execute);
+            const service = ops.service;
+            if (!service) {
+                ops.addToTimeline(markAsDone(first), createFeedback(FeedbackType.Failed, 'Service not available'));
+                exitApp(1);
+                return [];
+            }
+            if (allIntrospect && tasks.length > 0) {
+                ops.addToTimeline(markAsDone(first));
+                return [
+                    createIntrospectDefinition(tasks, service, taskHandlers.introspect.onError, taskHandlers.introspect.onComplete, taskHandlers.introspect.onAborted),
+                ];
+            }
+            else if (allAnswer && tasks.length > 0) {
+                const question = tasks[0].action;
+                ops.addToTimeline(markAsDone(first));
+                return [
+                    createAnswerDefinition(question, service, taskHandlers.answer.onError, taskHandlers.answer.onComplete, taskHandlers.answer.onAborted),
+                ];
+            }
+            else if (allConfig && tasks.length > 0) {
+                const keys = tasks
+                    .map((task) => task.params?.key)
+                    .filter((key) => typeof key === 'string');
+                ops.addToTimeline(markAsDone(first));
+                const handleConfigFinished = (config) => {
+                    ops.setQueue(createConfigExecutionFinishedHandler(ops.addToTimeline, keys)(config));
+                };
+                const handleConfigAborted = () => {
+                    ops.setQueue(createConfigExecutionAbortedHandler(ops.addToTimeline)());
+                };
+                return [
+                    createConfigDefinitionWithKeys(keys, handleConfigFinished, handleConfigAborted),
+                ];
+            }
+            else if (allExecute && tasks.length > 0) {
+                ops.addToTimeline(markAsDone(first));
+                return [
+                    createExecuteDefinition(tasks, service, taskHandlers.execute.onError, taskHandlers.execute.onComplete, taskHandlers.execute.onAborted),
+                ];
+            }
+            else {
+                ops.addToTimeline(markAsDone(first), createFeedback(FeedbackType.Failed, 'I can only process one type of task at a time for now.'));
+                exitApp(0);
+                return [];
+            }
+        }));
+    };
+    const onCancelled = (tasks) => {
+        ops.setQueue(withQueueHandler(ComponentName.Confirm, (first) => {
+            const allIntrospect = tasks.every((task) => task.type === TaskType.Introspect);
+            const operation = allIntrospect ? 'introspection' : 'execution';
+            ops.addToTimeline(markAsDone(first), createFeedback(FeedbackType.Aborted, getCancellationMessage(operation)));
+            return undefined;
+        }, true, 0));
+    };
+    return { onConfirmed, onCancelled };
 }

package/dist/handlers/introspect.js

@@ -2,27 +2,20 @@ import { ComponentName } from '../types/types.js';
 import { createReportDefinition } from '../services/components.js';
 import { createErrorHandler, withQueueHandler } from '../services/queue.js';
 /**
- * Creates introspect error handler
+ * Creates all introspect handlers
  */
-export function createIntrospectErrorHandler(addToTimeline) {
-    return (error) => createErrorHandler(ComponentName.Introspect, addToTimeline)(error);
-}
-/**
- * Creates introspect completion handler
- */
-export function createIntrospectCompleteHandler(addToTimeline) {
-    return (message, capabilities) => withQueueHandler(ComponentName.Introspect, () => {
-        // Don't add the Introspect component to timeline (it renders null)
-        // Only add the Report component
-        addToTimeline(createReportDefinition(message, capabilities));
-        return undefined;
-    }, true, 0);
-}
-/**
- * Creates introspect aborted handler
- */
-export function createIntrospectAbortedHandler(handleAborted) {
-    return () => {
+export function createIntrospectHandlers(ops, handleAborted) {
+    const onError = (error) => {
+        ops.setQueue(createErrorHandler(ComponentName.Introspect, ops.addToTimeline)(error));
+    };
+    const onComplete = (message, capabilities) => {
+        ops.setQueue(withQueueHandler(ComponentName.Introspect, () => {
+            ops.addToTimeline(createReportDefinition(message, capabilities));
+            return undefined;
+        }, true, 0));
+    };
+    const onAborted = () => {
         handleAborted('Introspection');
     };
+    return { onError, onComplete, onAborted };
 }

package/dist/handlers/plan.js

@@ -3,46 +3,41 @@ import { createConfirmDefinition, createFeedback, createPlanDefinition, markAsDo
 import { FeedbackMessages, formatErrorMessage, getRefiningMessage, } from '../services/messages.js';
 import { exitApp } from '../services/process.js';
 /**
- * Creates plan aborted handler
+ * Creates all plan handlers
  */
-export function createPlanAbortedHandler(handleAborted) {
-    return () => {
+export function createPlanHandlers(ops, handleAborted, executionHandlers) {
+    const onAborted = () => {
         handleAborted('Task selection');
     };
-}
-/**
- * Creates plan abort handler factory
- */
-export function createPlanAbortHandlerFactory(handleAborted, handlePlanAborted) {
-    return (tasks) => {
+    const createAbortHandler = (tasks) => {
         const allIntrospect = tasks.every((task) => task.type === TaskType.Introspect);
         if (allIntrospect) {
             return () => {
                 handleAborted('Introspection');
             };
         }
-        return handlePlanAborted;
+        return onAborted;
     };
-}
-/**
- * Creates plan selection confirmed handler
- */
-export function createPlanSelectionConfirmedHandler(addToTimeline, service, handleRefinementAborted, createPlanAbortHandler, handleExecutionConfirmed, handleExecutionCancelled, setQueue) {
-    return async (selectedTasks) => {
-        // Mark current plan as done and add refinement to queue
-        const refinementDef = createRefinement(getRefiningMessage(), handleRefinementAborted);
-        setQueue((currentQueue) => {
+    const onSelectionConfirmed = async (selectedTasks) => {
+        const refinementDef = createRefinement(getRefiningMessage(), () => {
+            handleAborted('Plan refinement');
+        });
+        ops.setQueue((currentQueue) => {
             if (currentQueue.length === 0)
                 return currentQueue;
             const [first] = currentQueue;
             if (first.name === ComponentName.Plan) {
-                addToTimeline(markAsDone(first));
+                ops.addToTimeline(markAsDone(first));
             }
-            // Add refinement to queue so it becomes the active component
             return [refinementDef];
         });
-        // Process refined command in background
         try {
+            const service = ops.service;
+            if (!service) {
+                ops.addToTimeline(createFeedback(FeedbackType.Failed, FeedbackMessages.UnexpectedError, 'Service not available'));
+                exitApp(1);
+                return;
+            }
             const refinedCommand = selectedTasks
                 .map((task) => {
                 const action = task.action.toLowerCase().replace(/,/g, ' -');
@@ -51,32 +46,34 @@ export function createPlanSelectionConfirmedHandler(addToTimeline, service, hand
             })
                 .join(', ');
             const result = await service.processWithTool(refinedCommand, 'plan');
-            // Mark refinement as done and move to timeline
-            setQueue((currentQueue) => {
+            ops.setQueue((currentQueue) => {
                 if (currentQueue.length > 0 &&
                     currentQueue[0].id === refinementDef.id) {
-                    addToTimeline(markAsDone(currentQueue[0]));
+                    ops.addToTimeline(markAsDone(currentQueue[0]));
                 }
                 return [];
             });
-            // Show final execution plan with confirmation
-            const planDefinition = createPlanDefinition(result.message, result.tasks, createPlanAbortHandler(result.tasks), undefined);
-            const confirmDefinition = createConfirmDefinition(handleExecutionConfirmed, handleExecutionCancelled);
-            addToTimeline(planDefinition);
-            setQueue([confirmDefinition]);
+            const planDefinition = createPlanDefinition(result.message, result.tasks, createAbortHandler(result.tasks), undefined);
+            const confirmDefinition = createConfirmDefinition(() => {
+                executionHandlers.onConfirmed(result.tasks);
+            }, () => {
+                executionHandlers.onCancelled(result.tasks);
+            });
+            ops.addToTimeline(planDefinition);
+            ops.setQueue([confirmDefinition]);
         }
         catch (error) {
             const errorMessage = formatErrorMessage(error);
-            // Mark refinement as done and move to timeline before showing error
-            setQueue((currentQueue) => {
+            ops.setQueue((currentQueue) => {
                 if (currentQueue.length > 0 &&
                     currentQueue[0].id === refinementDef.id) {
-                    addToTimeline(markAsDone(currentQueue[0]));
+                    ops.addToTimeline(markAsDone(currentQueue[0]));
                 }
                 return [];
             });
-            addToTimeline(createFeedback(FeedbackType.Failed, FeedbackMessages.UnexpectedError, errorMessage));
+            ops.addToTimeline(createFeedback(FeedbackType.Failed, FeedbackMessages.UnexpectedError, errorMessage));
             exitApp(1);
         }
     };
+    return { onAborted, createAbortHandler, onSelectionConfirmed };
 }

package/dist/services/anthropic.js

@@ -16,7 +16,9 @@ export class AnthropicService {
         // Build system prompt with additional context based on tool
         let systemPrompt = instructions;
         // Add skills section for applicable tools
-        if (toolName === 'plan' || toolName === 'introspect') {
+        if (toolName === 'plan' ||
+            toolName === 'introspect' ||
+            toolName === 'execute') {
             const skills = loadSkills();
             const skillsSection = formatSkillsForPrompt(skills);
             systemPrompt += skillsSection;
@@ -74,6 +76,29 @@ export class AnthropicService {
         const content = toolUseContent;
         // Extract and validate response based on tool type
         const input = content.input;
+        // Handle execute tool response
+        if (toolName === 'execute') {
+            if (!input.message || typeof input.message !== 'string') {
+                throw new Error('Invalid tool response: missing or invalid message field');
+            }
+            if (!input.commands || !Array.isArray(input.commands)) {
+                throw new Error('Invalid tool response: missing or invalid commands array');
+            }
+            // Validate each command has required fields
+            input.commands.forEach((cmd, i) => {
+                if (!cmd.description || typeof cmd.description !== 'string') {
+                    throw new Error(`Invalid command at index ${String(i)}: missing or invalid 'description' field`);
+                }
+                if (!cmd.command || typeof cmd.command !== 'string') {
+                    throw new Error(`Invalid command at index ${String(i)}: missing or invalid 'command' field`);
+                }
+            });
+            return {
+                message: input.message,
+                tasks: [],
+                commands: input.commands,
+            };
+        }
         // Handle answer tool response
         if (toolName === 'answer') {
             if (!input.question || typeof input.question !== 'string') {

package/dist/services/colors.js

@@ -12,7 +12,7 @@ export const Palette = {
     CharcoalGray: '#282828',
     Green: '#5aaa8a',
     LightGreen: '#65b595',
-    BrightGreen: '#22aa22',
+    BrightGreen: '#3e9a3e',
     Yellow: '#cccc5c',
     LightYellow: '#d4d47a',
     Orange: '#cc9c5c',

package/dist/services/components.js

@@ -301,3 +301,20 @@ export function createAnswerDisplayDefinition(answer) {
 export function isStateless(component) {
     return !('state' in component);
 }
+export function createExecuteDefinition(tasks, service, onError, onComplete, onAborted) {
+    return {
+        id: randomUUID(),
+        name: ComponentName.Execute,
+        state: {
+            done: false,
+            isLoading: true,
+        },
+        props: {
+            tasks,
+            service,
+            onError,
+            onComplete,
+            onAborted,
+        },
+    };
+}

package/dist/services/messages.js

@@ -1,4 +1,5 @@
 import { loadDebugSetting } from './configuration.js';
+export { formatDuration } from './utils.js';
 /**
  * Returns a natural language confirmation message for plan execution.
  * Randomly selects from variations to sound less robotic.

package/dist/services/shell.js

@@ -0,0 +1,117 @@
+export var ExecutionStatus;
+(function (ExecutionStatus) {
+    ExecutionStatus["Pending"] = "pending";
+    ExecutionStatus["Running"] = "running";
+    ExecutionStatus["Success"] = "success";
+    ExecutionStatus["Failed"] = "failed";
+})(ExecutionStatus || (ExecutionStatus = {}));
+export var ExecutionResult;
+(function (ExecutionResult) {
+    ExecutionResult["Success"] = "success";
+    ExecutionResult["Error"] = "error";
+    ExecutionResult["Aborted"] = "aborted";
+})(ExecutionResult || (ExecutionResult = {}));
+const DEFAULT_DELAY_GENERATOR = (index) => (Math.pow(3, index + 1) * Math.max(Math.random(), Math.random()) + 1) * 1000;
+/**
+ * Dummy executor that simulates command execution with configurable delays.
+ * Supports mocked responses for testing different scenarios.
+ */
+export class DummyExecutor {
+    mockedResponses = new Map();
+    delayGenerator;
+    constructor(delayGenerator = DEFAULT_DELAY_GENERATOR) {
+        this.delayGenerator = delayGenerator;
+    }
+    /**
+     * Set a mocked response for a specific command
+     */
+    mock(command, response) {
+        this.mockedResponses.set(command, response);
+    }
+    /**
+     * Clear all mocked responses
+     */
+    clearMocks() {
+        this.mockedResponses.clear();
+    }
+    execute(cmd, onProgress, index = 0) {
+        return new Promise((resolve) => {
+            onProgress?.(ExecutionStatus.Running);
+            const delay = this.delayGenerator(index);
+            setTimeout(() => {
+                const mocked = this.mockedResponses.get(cmd.command);
+                const commandResult = {
+                    description: cmd.description,
+                    command: cmd.command,
+                    output: mocked?.output ?? '',
+                    errors: mocked?.errors ?? '',
+                    result: mocked?.result ?? ExecutionResult.Success,
+                    error: mocked?.error,
+                };
+                onProgress?.(commandResult.result === ExecutionResult.Success
+                    ? ExecutionStatus.Success
+                    : ExecutionStatus.Failed);
+                resolve(commandResult);
+            }, delay);
+        });
+    }
+}
+/**
+ * Default executor uses DummyExecutor for development and testing.
+ * To implement real shell execution, create a RealExecutor class that:
+ * - Spawns process with cmd.command in shell mode using child_process.spawn()
+ * - Sets working directory from cmd.workdir
+ * - Handles cmd.timeout for command timeout
+ * - Captures stdout and stderr streams
+ * - Calls onProgress with Running/Success/Failed status
+ * - Returns CommandOutput with actual stdout, stderr, exitCode
+ * - Handles errors (spawn failures, timeouts, non-zero exit codes)
+ */
+const executor = new DummyExecutor();
+/**
+ * Execute a single shell command
+ */
+export function executeCommand(cmd, onProgress, index = 0) {
+    return executor.execute(cmd, onProgress, index);
+}
+/**
+ * Execute multiple commands sequentially
+ */
+export async function executeCommands(commands, onProgress) {
+    const results = [];
+    for (let i = 0; i < commands.length; i++) {
+        const cmd = commands[i];
+        onProgress?.({
+            currentIndex: i,
+            total: commands.length,
+            command: cmd,
+            status: ExecutionStatus.Running,
+        });
+        const output = await executeCommand(cmd, (status) => {
+            onProgress?.({
+                currentIndex: i,
+                total: commands.length,
+                command: cmd,
+                status,
+                output: status !== ExecutionStatus.Running ? results[i] : undefined,
+            });
+        }, i);
+        results.push(output);
+        // Update with final status
+        onProgress?.({
+            currentIndex: i,
+            total: commands.length,
+            command: cmd,
+            status: output.result === ExecutionResult.Success
+                ? ExecutionStatus.Success
+                : ExecutionStatus.Failed,
+            output,
+        });
+        // Stop if critical command failed
+        const isCritical = cmd.critical !== false;
+        if (output.result !== ExecutionResult.Success && isCritical) {
+            break;
+        }
+    }
+    return results;
+}

package/dist/services/tool-registry.js

@@ -35,6 +35,7 @@ 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';
 toolRegistry.register('plan', {
@@ -53,3 +54,7 @@ toolRegistry.register('config', {
     schema: configTool,
     instructionsPath: 'config/CONFIG.md',
 });
+toolRegistry.register('execute', {
+    schema: executeTool,
+    instructionsPath: 'config/EXECUTE.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/types/handlers.js

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

package/dist/types/types.js

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

package/dist/ui/Component.js

@@ -6,6 +6,7 @@ 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';
@@ -60,5 +61,10 @@ 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 });
+        }
     }
 });

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) {