prompt-language-shell 0.8.0 → 0.8.4

package/dist/ui/Main.js

@@ -1,13 +1,13 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
 import { FeedbackType } from '../types/types.js';
-import { createAnthropicService, } from '../services/anthropic.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 +44,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 +56,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 +75,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) {
@@ -86,7 +86,7 @@ export const Main = ({ app, command }) => {
                     throw new Error(errorMessage);
                 }
             };
-            const handleConfigAborted = (operation) => {
+            const handleConfigAborted = (_operation) => {
                 // Config was cancelled
             };
             setInitialQueue([

package/dist/ui/Report.js

@@ -1,14 +1,10 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
-import { Colors } from '../services/colors.js';
-function CapabilityItem({ name, description, isBuiltIn, isIndirect, isIncomplete, }) {
-    const color = isIndirect
-        ? Colors.Origin.Indirect
-        : isBuiltIn
-            ? Colors.Origin.BuiltIn
-            : Colors.Origin.UserProvided;
+import { Colors, getOriginColor } from '../services/colors.js';
+function CapabilityItem({ name, description, origin, isIncomplete, }) {
+    const color = getOriginColor(origin);
     return (_jsxs(Box, { children: [_jsx(Text, { children: "- " }), _jsx(Text, { color: color, children: name }), _jsxs(Text, { children: [" - ", description] }), isIncomplete && _jsx(Text, { color: Colors.Status.Warning, children: " (incomplete)" })] }));
 }
 export function Report({ message, capabilities }) {
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginLeft: 1, children: _jsx(Text, { children: message }) }), _jsx(Box, { flexDirection: "column", marginLeft: 3, marginTop: 1, children: capabilities.map((capability, index) => (_jsx(CapabilityItem, { name: capability.name, description: capability.description, isBuiltIn: capability.isBuiltIn, isIndirect: capability.isIndirect, isIncomplete: capability.isIncomplete }, index))) })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginLeft: 1, children: _jsx(Text, { children: message }) }), _jsx(Box, { flexDirection: "column", marginLeft: 3, marginTop: 1, children: capabilities.map((capability, index) => (_jsx(CapabilityItem, { name: capability.name, description: capability.description, origin: capability.origin, isIncomplete: capability.isIncomplete }, index))) })] }));
 }

package/dist/ui/Schedule.js

@@ -37,7 +37,7 @@ function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutS
             const planColors = getTaskColors(TaskType.Schedule, isCurrent);
             return {
                 description: {
-                    text: String(option),
+                    text: option,
                     color: colors.description,
                     highlightedColor: planColors.description,
                 },
@@ -71,7 +71,7 @@ function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutS
     }
     return item;
 }
-export function Schedule({ message, tasks, state, status, debug = DebugLevel.None, handlers, onSelectionConfirmed, }) {
+export function Schedule({ message, tasks, state, status, debug = DebugLevel.None, stateHandlers, lifecycleHandlers, errorHandlers, onSelectionConfirmed, }) {
     const isActive = status === ComponentStatus.Active;
     // isActive passed as prop
     const [highlightedIndex, setHighlightedIndex] = useState(state?.highlightedIndex ?? null);
@@ -95,15 +95,15 @@ export function Schedule({ message, tasks, state, status, debug = DebugLevel.Non
             const concreteTasks = tasks.filter((task) => task.type !== TaskType.Ignore && task.type !== TaskType.Discard);
             // Complete the selection phase - it goes to timeline
             // Callback will create a new Plan showing refined tasks (pending) + Confirm (active)
-            handlers?.completeActive();
-            onSelectionConfirmed(concreteTasks);
+            lifecycleHandlers?.completeActive();
+            void onSelectionConfirmed(concreteTasks);
         }
     }, [
         isActive,
         defineTaskIndices.length,
         tasks,
         onSelectionConfirmed,
-        handlers,
+        lifecycleHandlers,
     ]);
     useInput((input, key) => {
         // Don't handle input if not active or no define task
@@ -111,7 +111,7 @@ export function Schedule({ message, tasks, state, status, debug = DebugLevel.Non
             return;
         }
         if (key.escape) {
-            handlers?.onAborted('task selection');
+            errorHandlers?.onAborted('task selection');
             return;
         }
         if (key.downArrow) {
@@ -153,7 +153,7 @@ export function Schedule({ message, tasks, state, status, debug = DebugLevel.Non
                         // This is a Define task - only include the selected option
                         const options = task.params.options;
                         const selectedIndex = newCompletedSelections[defineGroupIndex];
-                        const selectedOption = String(options[selectedIndex]);
+                        const selectedOption = options[selectedIndex];
                         // Use Execute as default - LLM will properly classify during refinement
                         refinedTasks.push({
                             action: selectedOption,
@@ -170,12 +170,12 @@ export function Schedule({ message, tasks, state, status, debug = DebugLevel.Non
                 if (onSelectionConfirmed) {
                     // Complete the selection phase - it goes to timeline
                     // Callback will create a new Plan showing refined tasks (pending) + Confirm (active)
-                    handlers?.completeActive();
-                    onSelectionConfirmed(refinedTasks);
+                    lifecycleHandlers?.completeActive();
+                    void onSelectionConfirmed(refinedTasks);
                 }
                 else {
                     // No selection callback, just complete normally
-                    handlers?.completeActive();
+                    lifecycleHandlers?.completeActive();
                 }
             }
         }
@@ -183,7 +183,7 @@ export function Schedule({ message, tasks, state, status, debug = DebugLevel.Non
     // Sync state back to component definition
     // This ensures timeline can render historical state and tests can validate behavior
     useEffect(() => {
-        handlers?.updateState({
+        stateHandlers?.updateState({
             highlightedIndex,
             currentDefineGroupIndex,
             completedSelections,
@@ -192,7 +192,7 @@ export function Schedule({ message, tasks, state, status, debug = DebugLevel.Non
         highlightedIndex,
         currentDefineGroupIndex,
         completedSelections,
-        handlers,
+        stateHandlers,
     ]);
     const listItems = tasks.map((task, idx) => {
         // Find which define group this task belongs to (if any)

package/dist/ui/Spinner.js

@@ -17,7 +17,9 @@ export function Spinner() {
                 return next !== prev ? next : prev;
             });
         }, INTERVAL);
-        return () => clearInterval(timer);
+        return () => {
+            clearInterval(timer);
+        };
     }, []);
     return _jsx(Text, { color: Palette.Cyan, children: FRAMES[frame] });
 }

package/dist/ui/Subtask.js

@@ -4,7 +4,7 @@ import { getStatusColors, Palette, STATUS_ICONS } from '../services/colors.js';
 import { ExecutionStatus } from '../services/shell.js';
 import { formatDuration } from '../services/utils.js';
 import { Spinner } from './Spinner.js';
-export function Subtask({ label, command, status, isActive, startTime, endTime, elapsed, }) {
+export function Subtask({ label, command, status, isActive: _isActive, startTime, endTime, elapsed, }) {
     const colors = getStatusColors(status);
     const isCancelled = status === ExecutionStatus.Cancelled;
     const isAborted = status === ExecutionStatus.Aborted;

package/dist/ui/Task.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
-import { ExecutionStatus, executeCommand, } from '../services/shell.js';
+import { ExecutionResult, ExecutionStatus, executeCommand, } from '../services/shell.js';
 import { calculateElapsed } from '../services/utils.js';
 import { Subtask } from './Subtask.js';
 export function Task({ label, command, isActive, index, initialStatus, initialElapsed, onComplete, onAbort, onError, }) {
@@ -19,7 +19,9 @@ export function Task({ label, command, isActive, index, initialStatus, initialEl
                 return next !== prev ? next : prev;
             });
         }, 1000);
-        return () => clearInterval(interval);
+        return () => {
+            clearInterval(interval);
+        };
     }, [status, startTime]);
     // Execute command when becoming active
     useEffect(() => {
@@ -43,10 +45,10 @@ export function Task({ label, command, isActive, index, initialStatus, initialEl
                 setEndTime(end);
                 const taskDuration = calculateElapsed(start);
                 setElapsed(taskDuration);
-                setStatus(output.result === 'success'
+                setStatus(output.result === ExecutionResult.Success
                     ? ExecutionStatus.Success
                     : ExecutionStatus.Failed);
-                if (output.result === 'success') {
+                if (output.result === ExecutionResult.Success) {
                     onComplete?.(index, output, taskDuration);
                 }
                 else {
@@ -64,11 +66,10 @@ export function Task({ label, command, isActive, index, initialStatus, initialEl
                 onError?.(index, err instanceof Error ? err.message : 'Unknown error', errorDuration);
             }
         }
-        execute();
+        void execute();
         return () => {
             mounted = false;
         };
-        // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [isActive]);
     // Handle abort when task becomes inactive while running
     useEffect(() => {

package/dist/ui/Validate.js

@@ -4,35 +4,30 @@ import { Box, Text } from 'ink';
 import { ComponentStatus } from '../types/components.js';
 import { TaskType } from '../types/types.js';
 import { Colors, getTextColor } from '../services/colors.js';
-import { addDebugToTimeline, createConfigStepsFromSchema, } from '../services/components.js';
+import { createConfigStepsFromSchema } from '../services/components.js';
 import { DebugLevel, saveConfig, unflattenConfig, } from '../services/configuration.js';
+import { saveConfigLabels } from '../services/config-labels.js';
 import { useInput } from '../services/keyboard.js';
 import { formatErrorMessage } from '../services/messages.js';
 import { ensureMinimumTime } from '../services/timing.js';
 import { Config } from './Config.js';
 import { Spinner } from './Spinner.js';
 const MIN_PROCESSING_TIME = 1000;
-export function Validate({ missingConfig, userRequest, state, status, service, children, debug = DebugLevel.None, onError, onComplete, onAborted, handlers, }) {
+export function Validate({ missingConfig, userRequest, state, status, service, children, debug = DebugLevel.None, onError, onComplete, onAborted, stateHandlers, lifecycleHandlers, workflowHandlers, }) {
     const isActive = status === ComponentStatus.Active;
     const [error, setError] = useState(state?.error ?? null);
     const [completionMessage, setCompletionMessage] = useState(state?.completionMessage ?? null);
     const [configRequirements, setConfigRequirements] = useState(state?.configRequirements ?? null);
-    const [showConfig, setShowConfig] = useState(false);
     useInput((_, key) => {
-        if (key.escape && isActive && !showConfig) {
+        if (key.escape && isActive) {
             onAborted('validation');
         }
-    }, { isActive: isActive && !showConfig });
+    }, { isActive });
     useEffect(() => {
         // Skip processing if not active
         if (!isActive) {
             return;
         }
-        // Skip processing if no service available
-        if (!service) {
-            setError('No service available');
-            return;
-        }
         let mounted = true;
         async function process(svc) {
             const startTime = Date.now();
@@ -44,7 +39,9 @@ export function Validate({ missingConfig, userRequest, state, status, service, c
                 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);
+                    }
                     // Extract CONFIG tasks with descriptions from result
                     const configTasks = result.tasks.filter((task) => task.type === TaskType.Config);
                     // Build ConfigRequirements with descriptions
@@ -73,7 +70,7 @@ export function Validate({ missingConfig, userRequest, state, status, service, c
                     setCompletionMessage(message);
                     setConfigRequirements(withDescriptions);
                     // Save state after validation completes
-                    handlers?.updateState({
+                    stateHandlers?.updateState({
                         completionMessage: message,
                         configRequirements: withDescriptions,
                         validated: true,
@@ -87,19 +84,17 @@ export function Validate({ missingConfig, userRequest, state, status, service, c
                     const errorMessage = formatErrorMessage(err);
                     setError(errorMessage);
                     // Save error state
-                    handlers?.updateState({
+                    stateHandlers?.updateState({
                         error: errorMessage,
                         completionMessage: null,
                         configRequirements: null,
                         validated: false,
                     });
-                    if (onError) {
-                        onError(errorMessage);
-                    }
+                    onError(errorMessage);
                 }
             }
         }
-        process(service);
+        void process(service);
         return () => {
             mounted = false;
         };
@@ -133,22 +128,34 @@ export function Validate({ missingConfig, userRequest, state, status, service, c
     const handleConfigFinished = (config) => {
         // Convert flat dotted keys to nested structure grouped by section
         const configBySection = unflattenConfig(config);
+        // Extract and save labels to cache
+        if (configRequirements) {
+            const labels = {};
+            for (const req of configRequirements) {
+                if (req.description) {
+                    labels[req.path] = req.description;
+                }
+            }
+            saveConfigLabels(labels);
+        }
         // Save each section
         for (const [section, sectionConfig] of Object.entries(configBySection)) {
             saveConfig(section, sectionConfig);
         }
         // Mark validation component as complete before invoking callback
         // This allows the workflow to proceed to execution
-        handlers?.completeActive();
+        lifecycleHandlers?.completeActive();
         // Invoke callback which will queue the Execute component
-        onComplete?.(configRequirements);
+        if (configRequirements) {
+            onComplete(configRequirements);
+        }
     };
     const handleConfigAborted = (operation) => {
         // Mark validation component as complete when aborted
-        handlers?.completeActive();
+        lifecycleHandlers?.completeActive();
         onAborted(operation);
     };
-    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isActive && !completionMessage && !error && (_jsxs(Box, { marginLeft: 1, children: [_jsxs(Text, { color: getTextColor(isActive), children: ["Validating configuration requirements.", ' '] }), _jsx(Spinner, {})] })), completionMessage && (_jsx(Box, { marginLeft: 1, children: _jsx(Text, { color: getTextColor(isActive), children: completionMessage }) })), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) })), configSteps && configSteps.length > 0 && !error && (_jsx(Box, { marginTop: 1, children: _jsx(Config, { steps: configSteps, status: status, debug: debug, onFinished: handleConfigFinished, onAborted: handleConfigAborted, handlers: handlers }) })), configSteps && configSteps.length === 0 && !error && (_jsx(Box, { marginTop: 1, marginLeft: 1, children: _jsx(Text, { color: Colors.Status.Error, children: "Error: No configuration steps generated. Please try again." }) })), children] }));
+    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isActive && !completionMessage && !error && (_jsxs(Box, { marginLeft: 1, children: [_jsxs(Text, { color: getTextColor(isActive), children: ["Validating configuration requirements.", ' '] }), _jsx(Spinner, {})] })), completionMessage && (_jsx(Box, { marginLeft: 1, children: _jsx(Text, { color: getTextColor(isActive), children: completionMessage }) })), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) })), configSteps && configSteps.length > 0 && !error && (_jsx(Box, { marginTop: 1, children: _jsx(Config, { steps: configSteps, status: status, debug: debug, onFinished: handleConfigFinished, onAborted: handleConfigAborted }) })), configSteps && configSteps.length === 0 && !error && (_jsx(Box, { marginTop: 1, marginLeft: 1, children: _jsx(Text, { color: Colors.Status.Error, children: "Error: No configuration steps generated. Please try again." }) })), children] }));
 }
 /**
  * Build prompt for VALIDATE tool

package/dist/ui/Workflow.js

@@ -5,6 +5,7 @@ import { ComponentStatus, } from '../types/components.js';
 import { ComponentName, FeedbackType } from '../types/types.js';
 import { createFeedback, isStateless, markAsDone, } from '../services/components.js';
 import { DebugLevel } from '../services/configuration.js';
+import { getWarnings } from '../services/logger.js';
 import { getCancellationMessage } from '../services/messages.js';
 import { exitApp } from '../services/process.js';
 import { Component } from './Component.js';
@@ -35,11 +36,8 @@ export const Workflow = ({ initialQueue, debug }) => {
             return { active: null, pending };
         });
     }, []);
-    // Global handlers for all stateful components
-    const handlers = useMemo(() => ({
-        addToQueue: (...items) => {
-            setQueue((queue) => [...queue, ...items]);
-        },
+    // Focused handler instances - segregated by responsibility
+    const stateHandlers = useMemo(() => ({
         updateState: (newState) => {
             setCurrent((curr) => {
                 const { active, pending } = curr;
@@ -56,12 +54,41 @@ export const Workflow = ({ initialQueue, debug }) => {
                 return { active: updated, pending };
             });
         },
+    }), []);
+    const lifecycleHandlers = useMemo(() => ({
         completeActive: (...items) => {
             moveActiveToPending();
             if (items.length > 0) {
                 setQueue((queue) => [...items, ...queue]);
             }
         },
+    }), [moveActiveToPending]);
+    const queueHandlers = useMemo(() => ({
+        addToQueue: (...items) => {
+            setQueue((queue) => [...queue, ...items]);
+        },
+    }), []);
+    const errorHandlers = useMemo(() => ({
+        onAborted: (operation) => {
+            moveActiveToTimeline();
+            // Add feedback to queue
+            const message = getCancellationMessage(operation);
+            setQueue((queue) => [
+                ...queue,
+                createFeedback(FeedbackType.Aborted, message),
+            ]);
+        },
+        onError: (error) => {
+            moveActiveToTimeline();
+            // Add feedback to queue
+            setQueue((queue) => [
+                ...queue,
+                createFeedback(FeedbackType.Failed, error),
+            ]);
+        },
+    }), [moveActiveToTimeline]);
+    // Workflow handlers - used for timeline/queue management
+    const workflowHandlers = useMemo(() => ({
         completeActiveAndPending: (...items) => {
             setCurrent((curr) => {
                 const { active, pending } = curr;
@@ -83,24 +110,7 @@ export const Workflow = ({ initialQueue, debug }) => {
         addToTimeline: (...items) => {
             setTimeline((prev) => [...prev, ...items]);
         },
-        onAborted: (operation) => {
-            moveActiveToTimeline();
-            // Add feedback to queue
-            const message = getCancellationMessage(operation);
-            setQueue((queue) => [
-                ...queue,
-                createFeedback(FeedbackType.Aborted, message),
-            ]);
-        },
-        onError: (error) => {
-            moveActiveToTimeline();
-            // Add feedback to queue
-            setQueue((queue) => [
-                ...queue,
-                createFeedback(FeedbackType.Failed, error),
-            ]);
-        },
-    }), [moveActiveToPending, moveActiveToTimeline]);
+    }), []);
     // Global Esc handler removed - components handle their own Esc individually
     // Move next item from queue to active
     useEffect(() => {
@@ -138,6 +148,14 @@ export const Workflow = ({ initialQueue, debug }) => {
         }
         // Stateful components stay in active until handlers move them to pending
     }, [current]);
+    // Check for accumulated warnings and add them to timeline
+    useEffect(() => {
+        const warningMessages = getWarnings();
+        if (warningMessages.length > 0) {
+            const warningComponents = warningMessages.map((msg) => markAsDone(createFeedback(FeedbackType.Warning, msg)));
+            setTimeline((prev) => [...prev, ...warningComponents]);
+        }
+    }, [timeline, current]);
     // Move final pending to timeline and exit when all done
     useEffect(() => {
         const { active, pending } = current;
@@ -171,23 +189,77 @@ export const Workflow = ({ initialQueue, debug }) => {
         if (isStateless(active)) {
             return _jsx(Component, { def: active, debug: debug }, active.id);
         }
-        // For stateful components, inject global handlers
+        // For stateful components, inject focused handlers
         const statefulActive = active;
         const wrappedDef = {
             ...statefulActive,
             props: {
                 ...statefulActive.props,
-                handlers,
+                stateHandlers,
+                lifecycleHandlers,
+                queueHandlers,
+                errorHandlers,
+                workflowHandlers,
             },
         };
         return _jsx(Component, { def: wrappedDef, debug: debug }, active.id);
-    }, [current, debug, handlers]);
+    }, [
+        current,
+        debug,
+        stateHandlers,
+        lifecycleHandlers,
+        queueHandlers,
+        errorHandlers,
+        workflowHandlers,
+    ]);
     const pendingComponent = useMemo(() => {
         const { pending } = current;
         if (!pending)
             return null;
-        // Pending components don't receive input
-        return _jsx(Component, { def: pending, debug: debug }, pending.id);
-    }, [current, debug]);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: timeline, children: (item) => (_jsx(Box, { marginTop: 1, children: _jsx(Component, { def: item, debug: DebugLevel.None }) }, item.id)) }, "timeline"), pendingComponent && _jsx(Box, { marginTop: 1, children: pendingComponent }), activeComponent && _jsx(Box, { marginTop: 1, children: activeComponent })] }));
+        // For stateless components, render as-is
+        if (isStateless(pending)) {
+            return _jsx(Component, { def: pending, debug: debug }, pending.id);
+        }
+        // For stateful components, inject focused handlers (they may have useEffect hooks)
+        const statefulPending = pending;
+        const wrappedDef = {
+            ...statefulPending,
+            props: {
+                ...statefulPending.props,
+                stateHandlers,
+                lifecycleHandlers,
+                queueHandlers,
+                errorHandlers,
+                workflowHandlers,
+            },
+        };
+        return _jsx(Component, { def: wrappedDef, debug: debug }, pending.id);
+    }, [
+        current,
+        debug,
+        stateHandlers,
+        lifecycleHandlers,
+        queueHandlers,
+        errorHandlers,
+        workflowHandlers,
+    ]);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: timeline, children: (item) => {
+                    // For stateful timeline components, inject handlers (useEffect hooks may still run)
+                    let def = item;
+                    if (!isStateless(item)) {
+                        const statefulItem = item;
+                        def = {
+                            ...statefulItem,
+                            props: {
+                                ...statefulItem.props,
+                                stateHandlers,
+                                lifecycleHandlers,
+                                queueHandlers,
+                                errorHandlers,
+                                workflowHandlers,
+                            },
+                        };
+                    }
+                    return (_jsx(Box, { marginTop: 1, children: _jsx(Component, { def: def, debug: DebugLevel.None }) }, item.id));
+                } }, "timeline"), pendingComponent && _jsx(Box, { marginTop: 1, children: pendingComponent }), activeComponent && _jsx(Box, { marginTop: 1, children: activeComponent })] }));
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prompt-language-shell",
-  "version": "0.8.0",
+  "version": "0.8.4",
   "description": "Your personal command-line concierge. Ask politely, and it gets things done.",
   "type": "module",
   "main": "dist/index.js",
@@ -51,7 +51,8 @@
     "ink": "^6.6.0",
     "ink-text-input": "^6.0.0",
     "react": "^19.2.3",
-    "yaml": "^2.8.2"
+    "yaml": "^2.8.2",
+    "zod": "^4.2.1"
   },
   "devDependencies": {
     "@types/node": "^25.0.3",