prompt-language-shell 0.8.2 → 0.8.6

package/dist/ui/Execute.js

@@ -1,54 +1,65 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useCallback, useEffect, useState } from 'react';
+import { useCallback, useEffect, useReducer } from 'react';
 import { Box, Text } from 'ink';
 import { ComponentStatus, } from '../types/components.js';
-import { Colors, getTextColor } from '../services/colors.js';
-import { addDebugToTimeline } from '../services/components.js';
+import { getTextColor } from '../services/colors.js';
 import { useInput } from '../services/keyboard.js';
-import { loadUserConfig } from '../services/loader.js';
 import { formatErrorMessage } from '../services/messages.js';
-import { replacePlaceholders } from '../services/resolver.js';
 import { ExecutionStatus } from '../services/shell.js';
 import { ensureMinimumTime } from '../services/timing.js';
-import { formatDuration } from '../services/utils.js';
+import { buildAbortedState, handleTaskCompletion, handleTaskFailure, } from '../execution/handlers.js';
+import { processTasks } from '../execution/processing.js';
+import { executeReducer, initialState } from '../execution/reducer.js';
+import { ExecuteActionType } from '../execution/types.js';
+import { Message } from './Message.js';
 import { Spinner } from './Spinner.js';
 import { Task } from './Task.js';
 const MINIMUM_PROCESSING_TIME = 400;
-export function Execute({ tasks, state, status, service, handlers, }) {
+export const ExecuteView = ({ state, status, onTaskComplete, onTaskAbort, onTaskError, }) => {
     const isActive = status === ComponentStatus.Active;
-    const [error, setError] = useState(state?.error ?? null);
-    const [taskInfos, setTaskInfos] = useState(state?.taskInfos ?? []);
-    const [message, setMessage] = useState(state?.message ?? '');
-    const [completed, setCompleted] = useState(state?.completed ?? 0);
-    const [hasProcessed, setHasProcessed] = useState(false);
-    const [taskExecutionTimes, setTaskExecutionTimes] = useState(state?.taskExecutionTimes ?? []);
-    const [completionMessage, setCompletionMessage] = useState(state?.completionMessage ?? null);
-    const [summary, setSummary] = useState(state?.summary ?? '');
+    const { error, taskInfos, message, completed, completionMessage } = state;
+    const hasProcessed = taskInfos.length > 0;
+    // Derive loading state from current conditions
+    const isLoading = isActive && taskInfos.length === 0 && !error && !hasProcessed;
+    const isExecuting = completed < taskInfos.length;
+    // Return null only when loading completes with no commands
+    if (!isActive && taskInfos.length === 0 && !error) {
+        return null;
+    }
+    // Show completed steps when not active
+    const showTasks = !isActive && taskInfos.length > 0;
+    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isLoading && (_jsxs(Box, { marginLeft: 1, children: [_jsx(Text, { color: getTextColor(isActive), children: "Preparing commands. " }), _jsx(Spinner, {})] })), (isExecuting || showTasks) && (_jsxs(Box, { flexDirection: "column", marginLeft: 1, children: [message && (_jsxs(Box, { marginBottom: 1, gap: 1, children: [_jsx(Text, { color: getTextColor(isActive), children: message }), isExecuting && _jsx(Spinner, {})] })), taskInfos.map((taskInfo, index) => (_jsx(Box, { marginBottom: index < taskInfos.length - 1 ? 1 : 0, children: _jsx(Task, { label: taskInfo.label, command: taskInfo.command, isActive: isActive && index === completed, index: index, initialStatus: taskInfo.status, initialElapsed: taskInfo.elapsed, onComplete: onTaskComplete, onAbort: onTaskAbort, onError: onTaskError }) }, index)))] })), completionMessage && !isActive && (_jsx(Box, { marginTop: 1, marginLeft: 1, children: _jsx(Text, { color: getTextColor(false), children: completionMessage }) })), error && _jsx(Message, { text: error, status: status })] }));
+};
+/**
+ * Execute controller: Runs tasks sequentially
+ */
+export function Execute({ tasks, status, service, requestHandlers, lifecycleHandlers, workflowHandlers, }) {
+    const isActive = status === ComponentStatus.Active;
+    const [localState, dispatch] = useReducer(executeReducer, initialState);
+    const { error, taskInfos, message, completed, hasProcessed, taskExecutionTimes, completionMessage, summary, } = localState;
     // Derive loading state from current conditions
     const isLoading = isActive && taskInfos.length === 0 && !error && !hasProcessed;
     const isExecuting = completed < taskInfos.length;
     // Handle cancel with useCallback to ensure we capture latest state
     const handleCancel = useCallback(() => {
-        // Mark tasks based on their status relative to completed:
-        // - Before completed: finished (Success)
-        // - At completed: interrupted (Aborted)
-        // - After completed: never started (Cancelled)
+        dispatch({
+            type: ExecuteActionType.CancelExecution,
+            payload: { completed },
+        });
+        // Get updated task infos after cancel
         const updatedTaskInfos = taskInfos.map((task, taskIndex) => {
             if (taskIndex < completed) {
-                // Tasks that completed before interruption
                 return { ...task, status: ExecutionStatus.Success };
             }
             else if (taskIndex === completed) {
-                // Task that was running when interrupted
                 return { ...task, status: ExecutionStatus.Aborted };
             }
             else {
-                // Tasks that haven't started yet
                 return { ...task, status: ExecutionStatus.Cancelled };
             }
         });
-        setTaskInfos(updatedTaskInfos);
-        handlers?.updateState({
+        // Expose final state
+        const finalState = {
             message,
             summary,
             taskInfos: updatedTaskInfos,
@@ -56,9 +67,17 @@ export function Execute({ tasks, state, status, service, handlers, }) {
             taskExecutionTimes,
             completionMessage: null,
             error: null,
-        });
-        handlers?.onAborted('execution');
-    }, [message, summary, taskInfos, completed, taskExecutionTimes, handlers]);
+        };
+        requestHandlers.onCompleted(finalState);
+        requestHandlers.onAborted('execution');
+    }, [
+        message,
+        summary,
+        taskInfos,
+        completed,
+        taskExecutionTimes,
+        requestHandlers,
+    ]);
     useInput((_, key) => {
         if (key.escape && (isLoading || isExecuting) && isActive) {
             handleCancel();
@@ -73,28 +92,20 @@ export function Execute({ tasks, state, status, service, handlers, }) {
         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) => {
-                    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');
+                const result = await processTasks(tasks, svc);
                 await ensureMinimumTime(startTime, MINIMUM_PROCESSING_TIME);
                 if (!mounted)
                     return;
                 // Add debug components to timeline if present
-                addDebugToTimeline(result.debug, handlers);
-                if (!result.commands || result.commands.length === 0) {
-                    setHasProcessed(true);
-                    handlers?.updateState({
+                if (result.debug?.length) {
+                    workflowHandlers.addToTimeline(...result.debug);
+                }
+                if (result.commands.length === 0) {
+                    dispatch({
+                        type: ExecuteActionType.ProcessingComplete,
+                        payload: { message: result.message },
+                    });
+                    const finalState = {
                         message: result.message,
                         summary: '',
                         taskInfos: [],
@@ -102,44 +113,45 @@ export function Execute({ tasks, state, status, service, handlers, }) {
                         taskExecutionTimes: [],
                         completionMessage: null,
                         error: null,
-                    });
-                    handlers?.completeActive();
+                    };
+                    requestHandlers.onCompleted(finalState);
+                    lifecycleHandlers.completeActive();
                     return;
                 }
-                // Resolve placeholders in command strings
-                const resolvedCommands = result.commands.map((cmd) => ({
-                    ...cmd,
-                    command: replacePlaceholders(cmd.command, userConfig),
-                }));
-                // Set message, summary, and create task infos
-                const newMessage = result.message;
-                const newSummary = result.summary || '';
-                const infos = resolvedCommands.map((cmd, index) => ({
+                // Create task infos from commands
+                const infos = result.commands.map((cmd, index) => ({
                     label: tasks[index]?.action,
                     command: cmd,
                 }));
-                setMessage(newMessage);
-                setSummary(newSummary);
-                setTaskInfos(infos);
-                setCompleted(0); // Start with first task
+                dispatch({
+                    type: ExecuteActionType.CommandsReady,
+                    payload: {
+                        message: result.message,
+                        summary: result.summary,
+                        taskInfos: infos,
+                    },
+                });
                 // Update state after AI processing
-                handlers?.updateState({
-                    message: newMessage,
-                    summary: newSummary,
+                const finalState = {
+                    message: result.message,
+                    summary: result.summary,
                     taskInfos: infos,
                     completed: 0,
                     taskExecutionTimes: [],
                     completionMessage: null,
                     error: null,
-                });
+                };
+                requestHandlers.onCompleted(finalState);
             }
             catch (err) {
                 await ensureMinimumTime(startTime, MINIMUM_PROCESSING_TIME);
                 if (mounted) {
                     const errorMessage = formatErrorMessage(err);
-                    setError(errorMessage);
-                    setHasProcessed(true);
-                    handlers?.updateState({
+                    dispatch({
+                        type: ExecuteActionType.ProcessingError,
+                        payload: { error: errorMessage },
+                    });
+                    const finalState = {
                         message: '',
                         summary: '',
                         taskInfos: [],
@@ -147,8 +159,9 @@ export function Execute({ tasks, state, status, service, handlers, }) {
                         taskExecutionTimes: [],
                         completionMessage: null,
                         error: errorMessage,
-                    });
-                    handlers?.onError(errorMessage);
+                    };
+                    requestHandlers.onCompleted(finalState);
+                    requestHandlers.onError(errorMessage);
                 }
             }
         }
@@ -156,122 +169,82 @@ export function Execute({ tasks, state, status, service, handlers, }) {
         return () => {
             mounted = false;
         };
-    }, [tasks, isActive, service, handlers, taskInfos.length, hasProcessed]);
+    }, [
+        tasks,
+        isActive,
+        service,
+        requestHandlers,
+        lifecycleHandlers,
+        workflowHandlers,
+        taskInfos.length,
+        hasProcessed,
+    ]);
     // Handle task completion - move to next task
     const handleTaskComplete = useCallback((index, _output, elapsed) => {
-        const updatedTimes = [...taskExecutionTimes, elapsed];
-        setTaskExecutionTimes(updatedTimes);
-        // Update task with elapsed time and success status
-        const updatedTaskInfos = taskInfos.map((task, i) => i === index
-            ? { ...task, status: ExecutionStatus.Success, elapsed }
-            : task);
-        setTaskInfos(updatedTaskInfos);
-        if (index < taskInfos.length - 1) {
-            // More tasks to execute
-            setCompleted(index + 1);
-            handlers?.updateState({
-                message,
-                summary,
-                taskInfos: updatedTaskInfos,
-                completed: index + 1,
-                taskExecutionTimes: updatedTimes,
-                completionMessage: null,
-                error: null,
-            });
-        }
-        else {
-            // All tasks complete
-            const totalElapsed = updatedTimes.reduce((sum, time) => sum + time, 0);
-            const summaryText = summary.trim() || 'Execution completed';
-            const completion = `${summaryText} in ${formatDuration(totalElapsed)}.`;
-            setCompletionMessage(completion);
-            handlers?.updateState({
-                message,
-                summary,
-                taskInfos: updatedTaskInfos,
-                completed: index + 1,
-                taskExecutionTimes: updatedTimes,
-                completionMessage: completion,
-                error: null,
-            });
-            handlers?.completeActive();
+        const result = handleTaskCompletion(index, elapsed, {
+            taskInfos,
+            message,
+            summary,
+            taskExecutionTimes,
+        });
+        dispatch(result.action);
+        requestHandlers.onCompleted(result.finalState);
+        if (result.shouldComplete) {
+            lifecycleHandlers.completeActive();
         }
-    }, [taskInfos, message, handlers, taskExecutionTimes, summary]);
+    }, [
+        taskInfos,
+        message,
+        summary,
+        taskExecutionTimes,
+        requestHandlers,
+        lifecycleHandlers,
+    ]);
     const handleTaskError = useCallback((index, error, elapsed) => {
-        const task = taskInfos[index];
-        const isCritical = task.command.critical !== false; // Default to true
-        // Update task with elapsed time and failed status
-        const updatedTaskInfos = taskInfos.map((task, i) => i === index
-            ? { ...task, status: ExecutionStatus.Failed, elapsed }
-            : task);
-        setTaskInfos(updatedTaskInfos);
-        if (isCritical) {
-            // Critical failure - stop execution
-            setError(error);
-            handlers?.updateState({
-                message,
-                summary,
-                taskInfos: updatedTaskInfos,
-                completed: index + 1,
-                taskExecutionTimes,
-                completionMessage: null,
-                error,
-            });
-            handlers?.onError(error);
+        const result = handleTaskFailure(index, error, elapsed, {
+            taskInfos,
+            message,
+            summary,
+            taskExecutionTimes,
+        });
+        dispatch(result.action);
+        requestHandlers.onCompleted(result.finalState);
+        if (result.shouldReportError) {
+            requestHandlers.onError(error);
         }
-        else {
-            // Non-critical failure - continue to next task
-            const updatedTimes = [...taskExecutionTimes, elapsed];
-            setTaskExecutionTimes(updatedTimes);
-            if (index < taskInfos.length - 1) {
-                setCompleted(index + 1);
-                handlers?.updateState({
-                    message,
-                    summary,
-                    taskInfos: updatedTaskInfos,
-                    completed: index + 1,
-                    taskExecutionTimes: updatedTimes,
-                    completionMessage: null,
-                    error: null,
-                });
-            }
-            else {
-                // Last task, complete execution
-                const totalElapsed = updatedTimes.reduce((sum, time) => sum + time, 0);
-                const summaryText = summary.trim() || 'Execution completed';
-                const completion = `${summaryText} in ${formatDuration(totalElapsed)}.`;
-                setCompletionMessage(completion);
-                handlers?.updateState({
-                    message,
-                    summary,
-                    taskInfos: updatedTaskInfos,
-                    completed: index + 1,
-                    taskExecutionTimes: updatedTimes,
-                    completionMessage: completion,
-                    error: null,
-                });
-                handlers?.completeActive();
-            }
+        if (result.shouldComplete) {
+            lifecycleHandlers.completeActive();
         }
-    }, [taskInfos, message, handlers, taskExecutionTimes, summary]);
+    }, [
+        taskInfos,
+        message,
+        summary,
+        taskExecutionTimes,
+        requestHandlers,
+        lifecycleHandlers,
+    ]);
     const handleTaskAbort = useCallback((_index) => {
         // Task was aborted - execution already stopped by Escape handler
         // Just update state, don't call onAborted (already called at Execute level)
-        handlers?.updateState({
-            message,
-            summary,
-            taskInfos,
-            completed,
-            taskExecutionTimes,
-            completionMessage: null,
-            error: null,
-        });
-    }, [taskInfos, message, summary, completed, taskExecutionTimes, handlers]);
-    // Return null only when loading completes with no commands
-    if (!isActive && taskInfos.length === 0 && !error) {
-        return null;
-    }
-    // Show completed steps when not active
-    const showTasks = !isActive && taskInfos.length > 0;
-    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isLoading && (_jsxs(Box, { marginLeft: 1, children: [_jsx(Text, { color: getTextColor(isActive), children: "Preparing commands. " }), _jsx(Spinner, {})] })), (isExecuting || showTasks) && (_jsxs(Box, { flexDirection: "column", marginLeft: 1, children: [message && (_jsxs(Box, { marginBottom: 1, gap: 1, children: [_jsx(Text, { color: getTextColor(isActive), children: message }), isExecuting && _jsx(Spinner, {})] })), taskInfos.map((taskInfo, index) => (_jsx(Box, { marginBottom: index < taskInfos.length - 1 ? 1 : 0, children: _jsx(Task, { label: taskInfo.label, command: taskInfo.command, isActive: isActive && index === completed, index: index, initialStatus: taskInfo.status, initialElapsed: taskInfo.elapsed, onComplete: handleTaskComplete, onAbort: handleTaskAbort, onError: handleTaskError }) }, index)))] })), completionMessage && !isActive && (_jsx(Box, { marginTop: 1, marginLeft: 1, children: _jsx(Text, { color: getTextColor(false), children: completionMessage }) })), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) }))] }));
+        const finalState = buildAbortedState(taskInfos, message, summary, completed, taskExecutionTimes);
+        requestHandlers.onCompleted(finalState);
+    }, [
+        taskInfos,
+        message,
+        summary,
+        completed,
+        taskExecutionTimes,
+        requestHandlers,
+    ]);
+    // Controller always renders View with current state
+    const viewState = {
+        error,
+        taskInfos,
+        message,
+        summary,
+        completed,
+        taskExecutionTimes,
+        completionMessage,
+    };
+    return (_jsx(ExecuteView, { tasks: tasks, state: viewState, status: status, onTaskComplete: handleTaskComplete, onTaskAbort: handleTaskAbort, onTaskError: handleTaskError }));
 }

package/dist/ui/Feedback.js

@@ -5,6 +5,7 @@ import { getFeedbackColor } from '../services/colors.js';
 function getSymbol(type) {
     return {
         [FeedbackType.Info]: 'ℹ',
+        [FeedbackType.Warning]: '⚠',
         [FeedbackType.Succeeded]: '✓',
         [FeedbackType.Aborted]: '⊘',
         [FeedbackType.Failed]: '✗',

package/dist/ui/Introspect.js

@@ -1,22 +1,35 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
 import { Box, Text } from 'ink';
-import { ComponentStatus } from '../types/components.js';
+import { ComponentStatus, } from '../types/components.js';
 import { Colors, getTextColor } from '../services/colors.js';
-import { addDebugToTimeline, createReportDefinition, } from '../services/components.js';
-import { DebugLevel } from '../services/configuration.js';
+import { createReportDefinition } from '../services/components.js';
+import { DebugLevel } from '../configuration/types.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;
-export function Introspect({ tasks, state: _state, status, service, children, debug = DebugLevel.None, handlers, }) {
+export const IntrospectView = ({ state, status, children, }) => {
+    const isActive = status === ComponentStatus.Active;
+    const { error } = state;
+    // Don't render wrapper when done and nothing to show
+    if (!isActive && !error && !children) {
+        return null;
+    }
+    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isActive && (_jsxs(Box, { marginLeft: 1, children: [_jsx(Text, { color: getTextColor(isActive), children: "Listing capabilities. " }), _jsx(Spinner, {})] })), error && (_jsx(Box, { marginTop: 1, marginLeft: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) })), children] }));
+};
+/**
+ * Introspect controller: Lists capabilities via LLM
+ */
+export function Introspect({ tasks, status, service, children, debug = DebugLevel.None, requestHandlers, lifecycleHandlers, workflowHandlers, }) {
     const isActive = status === ComponentStatus.Active;
-    // isActive passed as prop
     const [error, setError] = useState(null);
+    const [capabilities, setCapabilities] = useState(null);
+    const [message, setMessage] = useState(null);
     useInput((input, key) => {
         if (key.escape && isActive) {
-            handlers?.onAborted('introspection');
+            requestHandlers.onAborted('introspection');
         }
     }, { isActive });
     useEffect(() => {
@@ -35,24 +48,29 @@ export function Introspect({ tasks, state: _state, status, service, children, de
                 await ensureMinimumTime(startTime, MIN_PROCESSING_TIME);
                 if (mounted) {
                     // Add debug components to timeline if present
-                    addDebugToTimeline(result.debug, handlers);
+                    if (result.debug?.length) {
+                        workflowHandlers.addToTimeline(...result.debug);
+                    }
                     // Capabilities come directly from result - no parsing needed
-                    let capabilities = result.capabilities;
+                    let caps = result.capabilities;
                     // Filter out internal capabilities when not in debug mode
                     if (debug === DebugLevel.None) {
-                        capabilities = capabilities.filter((cap) => cap.name.toUpperCase() !== 'SCHEDULE' &&
+                        caps = caps.filter((cap) => cap.name.toUpperCase() !== 'SCHEDULE' &&
                             cap.name.toUpperCase() !== 'VALIDATE' &&
                             cap.name.toUpperCase() !== 'REPORT');
                     }
-                    // Save state before completing
-                    handlers?.updateState({
-                        capabilities,
+                    setCapabilities(caps);
+                    setMessage(result.message);
+                    const finalState = {
+                        error: null,
+                        capabilities: caps,
                         message: result.message,
-                    });
+                    };
+                    requestHandlers.onCompleted(finalState);
                     // Add Report component to queue
-                    handlers?.addToQueue(createReportDefinition(result.message, capabilities));
+                    workflowHandlers.addToQueue(createReportDefinition(result.message, caps));
                     // Signal completion
-                    handlers?.completeActive();
+                    lifecycleHandlers.completeActive();
                 }
             }
             catch (err) {
@@ -60,11 +78,13 @@ export function Introspect({ tasks, state: _state, status, service, children, de
                 if (mounted) {
                     const errorMessage = formatErrorMessage(err);
                     setError(errorMessage);
-                    // Save error state
-                    handlers?.updateState({
+                    const finalState = {
                         error: errorMessage,
-                    });
-                    handlers?.onError(errorMessage);
+                        capabilities: [],
+                        message: null,
+                    };
+                    requestHandlers.onCompleted(finalState);
+                    requestHandlers.onError(errorMessage);
                 }
             }
         }
@@ -72,10 +92,19 @@ export function Introspect({ tasks, state: _state, status, service, children, de
         return () => {
             mounted = false;
         };
-    }, [tasks, isActive, service, debug, handlers]);
-    // Don't render wrapper when done and nothing to show
-    if (!isActive && !error && !children) {
-        return null;
-    }
-    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isActive && (_jsxs(Box, { marginLeft: 1, children: [_jsx(Text, { color: getTextColor(isActive), children: "Listing capabilities. " }), _jsx(Spinner, {})] })), error && (_jsx(Box, { marginTop: 1, marginLeft: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) })), children] }));
+    }, [
+        tasks,
+        isActive,
+        service,
+        debug,
+        requestHandlers,
+        lifecycleHandlers,
+        workflowHandlers,
+    ]);
+    const state = {
+        error,
+        capabilities: capabilities || [],
+        message,
+    };
+    return (_jsx(IntrospectView, { state: state, status: status, children: children }));
 }

package/dist/ui/Label.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import { getTaskColors, getTaskTypeLabel } from '../services/colors.js';
-import { DebugLevel } from '../services/configuration.js';
+import { DebugLevel } from '../configuration/types.js';
 import { Separator } from './Separator.js';
 export function Label({ description, taskType, showType = false, isCurrent = false, debug = DebugLevel.None, }) {
     const colors = getTaskColors(taskType, isCurrent);

package/dist/ui/Main.js

@@ -1,13 +1,17 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
+import { DebugLevel } from '../configuration/types.js';
 import { FeedbackType } from '../types/types.js';
-import { createAnthropicService, } from '../services/anthropic.js';
+import { loadConfig, loadDebugSetting, saveConfig, saveDebugSetting, } from '../configuration/io.js';
+import { getConfigurationRequiredMessage } from '../configuration/messages.js';
+import { getMissingConfigKeys } from '../configuration/schema.js';
+import { unflattenConfig } from '../configuration/transformation.js';
+import { createAnthropicService } from '../services/anthropic.js';
 import { createCommandDefinition, createConfigDefinitionWithKeys, createFeedback, createMessage, createWelcomeDefinition, } from '../services/components.js';
-import { DebugLevel, getConfigurationRequiredMessage, getMissingConfigKeys, loadConfig, loadDebugSetting, saveConfig, saveDebugSetting, unflattenConfig, } from '../services/configuration.js';
 import { registerGlobalShortcut } from '../services/keyboard.js';
 import { initializeLogger, setDebugLevel } from '../services/logger.js';
 import { Workflow } from './Workflow.js';
-export const Main = ({ app, command }) => {
+export const Main = ({ app, command, serviceFactory = createAnthropicService, }) => {
     const [service, setService] = useState(null);
     const [initialQueue, setInitialQueue] = useState(null);
     const [debug, setDebugLevelState] = useState(() => loadDebugSetting());
@@ -44,7 +48,7 @@ export const Main = ({ app, command }) => {
             // Config exists - create service immediately
             try {
                 const config = loadConfig();
-                const newService = createAnthropicService(config.anthropic);
+                const newService = serviceFactory(config.anthropic);
                 setService(newService);
             }
             catch (error) {
@@ -56,7 +60,7 @@ export const Main = ({ app, command }) => {
             }
         }
         // If config is missing, service will be created after config completes
-    }, [service]);
+    }, [service, serviceFactory]);
     // Initialize queue after service is ready
     useEffect(() => {
         // Only set initial queue once
@@ -75,7 +79,7 @@ export const Main = ({ app, command }) => {
                     }
                     // Load config and create service
                     const newConfig = loadConfig();
-                    const newService = createAnthropicService(newConfig.anthropic);
+                    const newService = serviceFactory(newConfig.anthropic);
                     setService(newService);
                 }
                 catch (error) {

package/dist/ui/Refinement.js

@@ -4,6 +4,13 @@ import { ComponentStatus } from '../types/components.js';
 import { useInput } from '../services/keyboard.js';
 import { Message } from './Message.js';
 import { Spinner } from './Spinner.js';
+export const RefinementView = ({ text, status }) => {
+    const isActive = status === ComponentStatus.Active;
+    return (_jsxs(Box, { gap: 1, children: [_jsx(Message, { text: text, status: status }), isActive && _jsx(Spinner, {})] }));
+};
+/**
+ * Refinement controller: Handles abort input
+ */
 export const Refinement = ({ text, status, onAborted }) => {
     const isActive = status === ComponentStatus.Active;
     useInput((_, key) => {
@@ -12,5 +19,5 @@ export const Refinement = ({ text, status, onAborted }) => {
             return;
         }
     }, { isActive });
-    return (_jsxs(Box, { gap: 1, children: [_jsx(Message, { text: text }), isActive && _jsx(Spinner, {})] }));
+    return _jsx(RefinementView, { text: text, status: status });
 };