prompt-language-shell 0.4.6 → 0.4.9

package/dist/ui/Answer.js

@@ -1,9 +1,11 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
-import { Box, Text, useInput } from 'ink';
+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 { Spinner } from './Spinner.js';
-const MinimumProcessingTime = 400;
+const MINIMUM_PROCESSING_TIME = 400;
 export function Answer({ question, state, service, onError, onComplete, onAborted, }) {
     const done = state?.done ?? false;
     const isCurrent = done === false;
@@ -33,7 +35,7 @@ export function Answer({ question, state, service, onError, onComplete, onAborte
                 // Call answer tool
                 const result = await svc.processWithTool(question, 'answer');
                 const elapsed = Date.now() - startTime;
-                const remainingTime = Math.max(0, MinimumProcessingTime - elapsed);
+                const remainingTime = Math.max(0, MINIMUM_PROCESSING_TIME - elapsed);
                 await new Promise((resolve) => setTimeout(resolve, remainingTime));
                 if (mounted) {
                     // Extract answer from result
@@ -44,10 +46,10 @@ export function Answer({ question, state, service, onError, onComplete, onAborte
             }
             catch (err) {
                 const elapsed = Date.now() - startTime;
-                const remainingTime = Math.max(0, MinimumProcessingTime - elapsed);
+                const remainingTime = Math.max(0, MINIMUM_PROCESSING_TIME - elapsed);
                 await new Promise((resolve) => setTimeout(resolve, remainingTime));
                 if (mounted) {
-                    const errorMessage = err instanceof Error ? err.message : 'Unknown error occurred';
+                    const errorMessage = formatErrorMessage(err);
                     setIsLoading(false);
                     if (onError) {
                         onError(errorMessage);

package/dist/ui/Command.js

@@ -1,7 +1,10 @@
 import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
-import { Box, Text, useInput } from 'ink';
+import { Box, Text } from 'ink';
+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 { Spinner } from './Spinner.js';
 const MIN_PROCESSING_TIME = 1000; // purely for visual effect
 export function Command({ command, state, service, children, onError, onComplete, onAborted, }) {
@@ -29,7 +32,16 @@ export function Command({ command, state, service, children, onError, onComplete
         async function process(svc) {
             const startTime = Date.now();
             try {
-                const result = await svc.processWithTool(command, 'plan');
+                let result = await svc.processWithTool(command, 'plan');
+                // If all tasks are config type, delegate to CONFIG tool
+                const allConfig = result.tasks.length > 0 &&
+                    result.tasks.every((task) => task.type === TaskType.Config);
+                if (allConfig) {
+                    // Extract query from first config task params, default to 'app'
+                    const query = result.tasks[0].params?.query || 'app';
+                    // 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));
@@ -43,7 +55,7 @@ export function Command({ command, state, service, children, onError, onComplete
                 const remainingTime = Math.max(0, MIN_PROCESSING_TIME - elapsed);
                 await new Promise((resolve) => setTimeout(resolve, remainingTime));
                 if (mounted) {
-                    const errorMessage = err instanceof Error ? err.message : 'Unknown error occurred';
+                    const errorMessage = formatErrorMessage(err);
                     setIsLoading(false);
                     if (onError) {
                         onError(errorMessage);

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';
@@ -49,7 +50,7 @@ export const Component = React.memo(function Component({ def, debug, }) {
         case ComponentName.Introspect: {
             const props = def.props;
             const state = def.state;
-            return _jsx(Introspect, { ...props, state: state });
+            return _jsx(Introspect, { ...props, state: state, debug: debug });
         }
         case ComponentName.Report:
             return _jsx(Report, { ...def.props });
@@ -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/Config.js

@@ -1,8 +1,9 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React from 'react';
-import { Box, Text, useFocus, useInput } from 'ink';
+import { Box, Text, useFocus } from 'ink';
 import TextInput from 'ink-text-input';
 import { Colors } from '../services/colors.js';
+import { useInput } from '../services/keyboard.js';
 export var StepType;
 (function (StepType) {
     StepType["Text"] = "text";
@@ -20,11 +21,13 @@ function TextStep({ value, placeholder, validate, onChange, onSubmit, }) {
         }
     };
     const handleSubmit = (value) => {
-        if (!validate(value)) {
+        // Use placeholder if input is empty
+        const finalValue = value || placeholder || '';
+        if (!validate(finalValue)) {
             setValidationFailed(true);
             return;
         }
-        onSubmit(value);
+        onSubmit(finalValue);
     };
     // Handle input manually when validation fails
     useInput((input, key) => {

package/dist/ui/Confirm.js

@@ -1,7 +1,8 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React from 'react';
-import { Box, Text, useInput } from 'ink';
-import { Colors } from '../services/colors.js';
+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;
@@ -29,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,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/Introspect.js

@@ -1,7 +1,9 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
-import { Box, Text, useInput } from 'ink';
+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 { Spinner } from './Spinner.js';
 const MIN_PROCESSING_TIME = 1000;
 const BUILT_IN_CAPABILITIES = new Set([
@@ -12,26 +14,32 @@ const BUILT_IN_CAPABILITIES = new Set([
     'EXECUTE',
     'REPORT',
 ]);
+const INDIRECT_CAPABILITIES = new Set(['PLAN', 'REPORT']);
 function parseCapabilityFromTask(task) {
     // Parse "NAME: Description" format from task.action
     const colonIndex = task.action.indexOf(':');
     if (colonIndex === -1) {
+        const upperName = task.action.toUpperCase();
         return {
             name: task.action,
             description: '',
-            isBuiltIn: BUILT_IN_CAPABILITIES.has(task.action.toUpperCase()),
+            isBuiltIn: BUILT_IN_CAPABILITIES.has(upperName),
+            isIndirect: INDIRECT_CAPABILITIES.has(upperName),
         };
     }
     const name = task.action.substring(0, colonIndex).trim();
     const description = task.action.substring(colonIndex + 1).trim();
-    const isBuiltIn = BUILT_IN_CAPABILITIES.has(name.toUpperCase());
+    const upperName = name.toUpperCase();
+    const isBuiltIn = BUILT_IN_CAPABILITIES.has(upperName);
+    const isIndirect = INDIRECT_CAPABILITIES.has(upperName);
     return {
         name,
         description,
         isBuiltIn,
+        isIndirect,
     };
 }
-export function Introspect({ tasks, state, service, children, onError, onComplete, onAborted, }) {
+export function Introspect({ tasks, state, service, children, debug = false, onError, onComplete, onAborted, }) {
     const done = state?.done ?? false;
     const isCurrent = done === false;
     const [error, setError] = useState(null);
@@ -66,7 +74,12 @@ export function Introspect({ tasks, state, service, children, onError, onComplet
                 await new Promise((resolve) => setTimeout(resolve, remainingTime));
                 if (mounted) {
                     // Parse capabilities from returned tasks
-                    const capabilities = result.tasks.map(parseCapabilityFromTask);
+                    let capabilities = result.tasks.map(parseCapabilityFromTask);
+                    // Filter out internal capabilities when not in debug mode
+                    if (!debug) {
+                        capabilities = capabilities.filter((cap) => cap.name.toUpperCase() !== 'PLAN' &&
+                            cap.name.toUpperCase() !== 'REPORT');
+                    }
                     setIsLoading(false);
                     onComplete?.(result.message, capabilities);
                 }
@@ -76,7 +89,7 @@ export function Introspect({ tasks, state, service, children, onError, onComplet
                 const remainingTime = Math.max(0, MIN_PROCESSING_TIME - elapsed);
                 await new Promise((resolve) => setTimeout(resolve, remainingTime));
                 if (mounted) {
-                    const errorMessage = err instanceof Error ? err.message : 'Unknown error occurred';
+                    const errorMessage = formatErrorMessage(err);
                     setIsLoading(false);
                     if (onError) {
                         onError(errorMessage);
@@ -91,7 +104,7 @@ export function Introspect({ tasks, state, service, children, onError, onComplet
         return () => {
             mounted = false;
         };
-    }, [tasks, done, service]);
+    }, [tasks, done, service, debug, onComplete, onError]);
     // Don't render wrapper when done and nothing to show
     if (!isLoading && !error && !children) {
         return null;

package/dist/ui/Main.js

@@ -1,21 +1,21 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import React from 'react';
-import { useInput } from 'ink';
 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,22 +26,16 @@ 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);
+    // Register global keyboard shortcuts
     React.useEffect(() => {
-        timelineRef.current = timeline;
-    }, [timeline]);
-    // Top-level Shift+Tab handler for debug mode toggle
-    // Child components must ignore Shift+Tab to prevent conflicts
-    useInput((input, key) => {
-        if (key.shift && key.tab) {
+        registerGlobalShortcut('shift+tab', () => {
             setIsDebug((prev) => {
                 const newValue = !prev;
                 saveDebugSetting(newValue);
                 return newValue;
             });
-        }
-    }, { isActive: true });
+        });
+    }, []);
     const addToTimeline = React.useCallback((...items) => {
         setTimeline((timeline) => [...timeline, ...items]);
     }, []);
@@ -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)()), [
+    // Create operations object
+    const ops = React.useMemo(() => ({
         addToTimeline,
+        setQueue,
         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), [
-        addToTimeline,
-        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/Plan.js

@@ -1,8 +1,9 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
-import { Box, useInput } from 'ink';
+import { Box } from 'ink';
 import { TaskType } from '../types/types.js';
 import { getTaskColors } from '../services/colors.js';
+import { useInput } from '../services/keyboard.js';
 import { Label } from './Label.js';
 import { List } from './List.js';
 function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutSelection = false, isCurrent = false) {

package/dist/ui/Refinement.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box, useInput } from 'ink';
+import { Box } from 'ink';
+import { useInput } from '../services/keyboard.js';
 import { Message } from './Message.js';
 import { Spinner } from './Spinner.js';
 export const Refinement = ({ text, state, onAborted }) => {