prompt-language-shell 0.8.0 → 0.8.4

package/dist/types/guards.js

@@ -0,0 +1,23 @@
+import { TaskType } from './types.js';
+import { TaskSchema } from './schemas.js';
+/**
+ * Type guard to check if a task is a ScheduledTask
+ * ScheduledTask has optional subtasks property or is a Group type
+ */
+export function isScheduledTask(task) {
+    return 'subtasks' in task || task.type === TaskType.Group;
+}
+/**
+ * Type-safe conversion of Task array to ScheduledTask array
+ * This is safe because Tasks can be treated as ScheduledTask when checking for Groups
+ */
+export function asScheduledTasks(tasks) {
+    return tasks;
+}
+/**
+ * Type guard to check if a value is a valid Task.
+ * Uses Zod schema for comprehensive runtime validation.
+ */
+export function isTask(value) {
+    return TaskSchema.safeParse(value).success;
+}

package/dist/types/handlers.js

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

package/dist/types/schemas.js

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+import { Origin, TaskType } from './types.js';
+/**
+ * Zod schema for TaskType enum values.
+ * Validates that task types match the expected enum values.
+ */
+export const TaskTypeSchema = z.enum([
+    TaskType.Config,
+    TaskType.Schedule,
+    TaskType.Execute,
+    TaskType.Answer,
+    TaskType.Introspect,
+    TaskType.Report,
+    TaskType.Define,
+    TaskType.Ignore,
+    TaskType.Select,
+    TaskType.Discard,
+    TaskType.Group,
+]);
+/**
+ * Zod schema for Origin enum values.
+ * Validates capability origin types.
+ */
+export const OriginSchema = z.enum([
+    Origin.BuiltIn,
+    Origin.UserProvided,
+    Origin.Indirect,
+]);
+/**
+ * Zod schema for base Task type.
+ * Validates task structure with required action and type fields.
+ */
+export const TaskSchema = z.object({
+    action: z.string().min(1),
+    type: TaskTypeSchema,
+    params: z.record(z.string(), z.unknown()).optional(),
+    config: z.array(z.string()).optional(),
+});
+/**
+ * Zod schema for recursive ScheduledTask type.
+ * Uses z.lazy for self-referential subtasks validation.
+ */
+export const ScheduledTaskSchema = z.object({
+    action: z.string().min(1),
+    type: TaskTypeSchema,
+    params: z.record(z.string(), z.unknown()).optional(),
+    config: z.array(z.string()).optional(),
+    subtasks: z.lazy(() => ScheduledTaskSchema.array()).optional(),
+});
+/**
+ * Zod schema for ExecuteCommand type.
+ * Validates shell command execution parameters.
+ */
+export const ExecuteCommandSchema = z.object({
+    description: z.string().min(1),
+    command: z.string().min(1),
+    workdir: z.string().optional(),
+    timeout: z.number().int().positive().optional(),
+    critical: z.boolean().optional(),
+});
+/**
+ * Zod schema for Capability type.
+ * Validates skill and capability definitions.
+ */
+export const CapabilitySchema = z.object({
+    name: z.string().min(1),
+    description: z.string().min(1),
+    origin: OriginSchema,
+    isIncomplete: z.boolean().optional(),
+});
+/**
+ * Zod schema for ComponentDefinition type.
+ * Flexible schema for debug component validation.
+ * Accepts both stateless and stateful component structures.
+ */
+export const ComponentDefinitionSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    props: z.record(z.string(), z.unknown()),
+    state: z.record(z.string(), z.unknown()).optional(),
+    status: z.string().optional(),
+});
+/**
+ * Zod schema for CommandResult type.
+ * Validates LLM responses from execute, answer, and schedule tools.
+ */
+export const CommandResultSchema = z.object({
+    message: z.string(),
+    summary: z.string().optional(),
+    tasks: z.array(ScheduledTaskSchema),
+    answer: z.string().optional(),
+    commands: z.array(ExecuteCommandSchema).optional(),
+    debug: z.array(ComponentDefinitionSchema).optional(),
+});
+/**
+ * Zod schema for IntrospectResult type.
+ * Validates LLM responses from introspect tool.
+ */
+export const IntrospectResultSchema = z.object({
+    message: z.string(),
+    capabilities: z.array(CapabilitySchema),
+    debug: z.array(ComponentDefinitionSchema).optional(),
+});

package/dist/types/types.js

@@ -29,9 +29,16 @@ export var TaskType;
     TaskType["Discard"] = "discard";
     TaskType["Group"] = "group";
 })(TaskType || (TaskType = {}));
+export var Origin;
+(function (Origin) {
+    Origin["BuiltIn"] = "system";
+    Origin["UserProvided"] = "user";
+    Origin["Indirect"] = "meta";
+})(Origin || (Origin = {}));
 export var FeedbackType;
 (function (FeedbackType) {
     FeedbackType["Info"] = "info";
+    FeedbackType["Warning"] = "warning";
     FeedbackType["Succeeded"] = "succeeded";
     FeedbackType["Aborted"] = "aborted";
     FeedbackType["Failed"] = "failed";

package/dist/ui/Answer.js

@@ -3,19 +3,18 @@ import { useEffect, useState } 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 { useInput } from '../services/keyboard.js';
 import { formatErrorMessage } from '../services/messages.js';
 import { withMinimumTime } from '../services/timing.js';
 import { Spinner } from './Spinner.js';
 const MINIMUM_PROCESSING_TIME = 400;
-export function Answer({ question, state, status, service, handlers, }) {
+export function Answer({ question, state, status, service, stateHandlers, lifecycleHandlers, errorHandlers, workflowHandlers, }) {
     const isActive = status === ComponentStatus.Active;
     const [error, setError] = useState(null);
     const [answer, setAnswer] = useState(state?.answer ?? null);
     useInput((input, key) => {
         if (key.escape && isActive) {
-            handlers?.onAborted('answer');
+            errorHandlers?.onAborted('answer');
         }
     }, { isActive });
     useEffect(() => {
@@ -23,11 +22,6 @@ export function Answer({ question, state, status, service, handlers, }) {
         if (!isActive) {
             return;
         }
-        // Skip processing if no service available
-        if (!service) {
-            setError('No service available');
-            return;
-        }
         let mounted = true;
         async function process(svc) {
             try {
@@ -35,34 +29,36 @@ export function Answer({ question, state, status, service, handlers, }) {
                 const result = await withMinimumTime(() => svc.processWithTool(question, 'answer'), MINIMUM_PROCESSING_TIME);
                 if (mounted) {
                     // Add debug components to timeline if present
-                    addDebugToTimeline(result.debug, handlers);
+                    if (result.debug?.length) {
+                        workflowHandlers?.addToTimeline(...result.debug);
+                    }
                     // Extract answer from result
                     const answerText = result.answer || '';
                     setAnswer(answerText);
                     // Update component state so answer persists in timeline
-                    handlers?.updateState({
+                    stateHandlers?.updateState({
                         answer: answerText,
                     });
                     // Signal completion
-                    handlers?.completeActive();
+                    lifecycleHandlers?.completeActive();
                 }
             }
             catch (err) {
                 if (mounted) {
                     const errorMessage = formatErrorMessage(err);
                     setError(errorMessage);
-                    handlers?.updateState({
+                    stateHandlers?.updateState({
                         error: errorMessage,
                     });
-                    handlers?.onError(errorMessage);
+                    errorHandlers?.onError(errorMessage);
                 }
             }
         }
-        process(service);
+        void process(service);
         return () => {
             mounted = false;
         };
-    }, [question, isActive, service, handlers]);
+    }, [question, isActive, service]);
     const lines = answer ? answer.split('\n') : [];
     return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isActive && !answer && !error && (_jsxs(Box, { marginLeft: 1, children: [_jsx(Text, { color: getTextColor(isActive), children: "Finding answer. " }), _jsx(Spinner, {})] })), answer && (_jsxs(_Fragment, { children: [_jsx(Box, { marginLeft: 1, marginBottom: 1, children: _jsx(Text, { color: getTextColor(isActive), children: question }) }), _jsx(Box, { flexDirection: "column", paddingLeft: 3, children: lines.map((line, index) => (_jsx(Text, { color: getTextColor(isActive), children: line }, index))) })] })), error && (_jsx(Box, { marginTop: 1, marginLeft: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) }))] }));
 }

package/dist/ui/Command.js

@@ -1,10 +1,10 @@
 import { jsxs as _jsxs, jsx as _jsx } 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 { TaskType } from '../types/types.js';
 import { Colors } from '../services/colors.js';
-import { addDebugToTimeline, createScheduleDefinition, } from '../services/components.js';
+import { createScheduleDefinition } from '../services/components.js';
 import { useInput } from '../services/keyboard.js';
 import { formatErrorMessage } from '../services/messages.js';
 import { handleRefinement } from '../services/refinement.js';
@@ -13,12 +13,12 @@ import { ensureMinimumTime } from '../services/timing.js';
 import { Spinner } from './Spinner.js';
 import { UserQuery } from './UserQuery.js';
 const MIN_PROCESSING_TIME = 400; // purely for visual effect
-export function Command({ command, state, status, service, handlers, onAborted, }) {
+export function Command({ command, state, status, service, stateHandlers, lifecycleHandlers, queueHandlers, errorHandlers, workflowHandlers, onAborted, }) {
     const isActive = status === ComponentStatus.Active;
     const [error, setError] = useState(state?.error ?? null);
     useInput((_, key) => {
         if (key.escape && isActive) {
-            handlers?.onAborted('request');
+            errorHandlers?.onAborted('request');
             onAborted?.('request');
         }
     }, { isActive });
@@ -27,11 +27,6 @@ export function Command({ command, state, status, service, handlers, onAborted,
         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();
@@ -56,30 +51,39 @@ export function Command({ command, state, status, service, handlers, onAborted,
                     const debugComponents = allConfig
                         ? [...scheduleDebug, ...(result.debug || [])]
                         : scheduleDebug;
-                    addDebugToTimeline(debugComponents, handlers);
+                    if (debugComponents.length > 0) {
+                        workflowHandlers?.addToTimeline(...debugComponents);
+                    }
                     // Save result to state for timeline display
-                    handlers?.updateState({
+                    stateHandlers?.updateState({
                         message: result.message,
                         tasks: result.tasks,
                     });
                     // Check if tasks contain DEFINE type (variant selection needed)
                     const hasDefineTask = result.tasks.some((task) => task.type === TaskType.Define);
+                    // Guard: ensure all required handlers are present
+                    if (!queueHandlers ||
+                        !lifecycleHandlers ||
+                        !workflowHandlers ||
+                        !errorHandlers) {
+                        return;
+                    }
                     // Create Schedule definition
                     const scheduleDefinition = createScheduleDefinition(result.message, result.tasks, hasDefineTask
                         ? async (selectedTasks) => {
                             // Refinement flow for DEFINE tasks
-                            await handleRefinement(selectedTasks, svc, command, handlers);
+                            await handleRefinement(selectedTasks, svc, command, queueHandlers, lifecycleHandlers, workflowHandlers, errorHandlers);
                         }
                         : undefined);
                     if (hasDefineTask) {
                         // DEFINE tasks: Move Command to timeline, add Schedule to queue
-                        handlers?.completeActive();
-                        handlers?.addToQueue(scheduleDefinition);
+                        lifecycleHandlers.completeActive();
+                        queueHandlers.addToQueue(scheduleDefinition);
                     }
                     else {
                         // No DEFINE tasks: Complete Command, then route to Confirm flow
-                        handlers?.completeActive();
-                        routeTasksWithConfirm(result.tasks, result.message, svc, command, handlers, false);
+                        lifecycleHandlers.completeActive();
+                        routeTasksWithConfirm(result.tasks, result.message, svc, command, queueHandlers, workflowHandlers, errorHandlers, false);
                     }
                 }
             }
@@ -88,17 +92,17 @@ export function Command({ command, state, status, service, handlers, onAborted,
                 if (mounted) {
                     const errorMessage = formatErrorMessage(err);
                     setError(errorMessage);
-                    handlers?.updateState({
+                    stateHandlers?.updateState({
                         error: errorMessage,
                     });
-                    handlers?.onError(errorMessage);
+                    errorHandlers?.onError(errorMessage);
                 }
             }
         }
-        process(service);
+        void process(service);
         return () => {
             mounted = false;
         };
-    }, [command, isActive, service, handlers]);
+    }, [command, isActive, service]);
     return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [!isActive ? (_jsxs(UserQuery, { children: ["> pls ", command] })) : (_jsxs(Box, { marginLeft: 1, children: [_jsxs(Text, { color: Colors.Text.Active, children: ["> pls ", command] }), _jsx(Text, { children: " " }), _jsx(Spinner, {})] })), error && (_jsx(Box, { marginTop: 1, marginLeft: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) }))] }));
 }

package/dist/ui/Config.js

@@ -8,6 +8,19 @@ import { Colors } from '../services/colors.js';
 import { createFeedback } from '../services/components.js';
 import { DebugLevel } from '../services/configuration.js';
 import { useInput } from '../services/keyboard.js';
+/**
+ * Get postfix with debug brackets if debug is enabled
+ * Info: {key} | Verbose: {key} entry
+ */
+function getPostfix(text, debugLevel) {
+    if (debugLevel === DebugLevel.None || !text) {
+        return '';
+    }
+    if (debugLevel === DebugLevel.Info) {
+        return `{${text}}`;
+    }
+    return `{${text}} entry`;
+}
 export var StepType;
 (function (StepType) {
     StepType["Text"] = "text";
@@ -65,7 +78,8 @@ function SelectionStep({ options, selectedIndex, isCurrentStep, }) {
             return (_jsx(Box, { marginRight: 2, children: _jsx(Text, { dimColor: !isSelected || !isCurrentStep, bold: isSelected, children: option.label }) }, option.value));
         }) }));
 }
-export function Config({ steps, state, status, debug = DebugLevel.None, handlers, onFinished, onAborted, }) {
+export function Config(props) {
+    const { steps, state, status, debug = DebugLevel.None, stateHandlers, lifecycleHandlers, onFinished, onAborted, } = props;
     const isActive = status === ComponentStatus.Active;
     const [step, setStep] = useState(!isActive ? (state?.completedStep ?? steps.length) : 0);
     const [values, setValues] = useState(() => {
@@ -89,8 +103,8 @@ export function Config({ steps, state, status, debug = DebugLevel.None, handlers
                         stepConfig.options[stepConfig.defaultIndex].value;
                     break;
                 default: {
-                    const exhaustiveCheck = stepConfig;
-                    throw new Error(`Unsupported step type: ${exhaustiveCheck}`);
+                    const _exhaustiveCheck = stepConfig;
+                    throw new Error('Unsupported step type');
                 }
             }
         });
@@ -132,7 +146,6 @@ export function Config({ steps, state, status, debug = DebugLevel.None, handlers
             const value = values[configKey] || '';
             setInputValue(value);
         }
-        // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [step, isActive, steps]);
     useInput((_, key) => {
         if (!isActive || step >= steps.length)
@@ -140,27 +153,25 @@ export function Config({ steps, state, status, debug = DebugLevel.None, handlers
         const currentStepConfig = steps[step];
         if (key.escape) {
             // Save current value before aborting
-            if (currentStepConfig) {
-                const configKey = currentStepConfig.path || currentStepConfig.key;
-                let currentValue = '';
-                switch (currentStepConfig.type) {
-                    case StepType.Text:
-                        currentValue = inputValue || values[configKey] || '';
-                        break;
-                    case StepType.Selection:
-                        currentValue = values[configKey] || '';
-                        break;
-                    default: {
-                        const exhaustiveCheck = currentStepConfig;
-                        throw new Error(`Unsupported step type: ${exhaustiveCheck}`);
-                    }
-                }
-                if (currentValue) {
-                    setValues({ ...values, [configKey]: currentValue });
+            const configKey = currentStepConfig.path || currentStepConfig.key;
+            let currentValue = '';
+            switch (currentStepConfig.type) {
+                case StepType.Text:
+                    currentValue = inputValue || values[configKey] || '';
+                    break;
+                case StepType.Selection:
+                    currentValue = values[configKey] || '';
+                    break;
+                default: {
+                    const _exhaustiveCheck = currentStepConfig;
+                    throw new Error('Unsupported step type');
                 }
             }
+            if (currentValue) {
+                setValues({ ...values, [configKey]: currentValue });
+            }
             // Save state before aborting
-            handlers?.updateState({
+            stateHandlers?.updateState({
                 values,
                 completedStep: step,
                 selectedIndex,
@@ -169,7 +180,7 @@ export function Config({ steps, state, status, debug = DebugLevel.None, handlers
                 onAborted('configuration');
             }
             // Complete with abort feedback
-            handlers?.completeActive(createFeedback(FeedbackType.Aborted, 'Configuration cancelled.'));
+            lifecycleHandlers?.completeActive(createFeedback(FeedbackType.Aborted, 'Configuration cancelled.'));
             return;
         }
         // Handle selection step navigation
@@ -204,8 +215,8 @@ export function Config({ steps, state, status, debug = DebugLevel.None, handlers
                 break;
             }
             default: {
-                const exhaustiveCheck = currentStepConfig;
-                throw new Error(`Unsupported step type: ${exhaustiveCheck}`);
+                const _exhaustiveCheck = currentStepConfig;
+                throw new Error('Unsupported step type');
             }
         }
         // Don't allow empty or invalid value
@@ -226,19 +237,19 @@ export function Config({ steps, state, status, debug = DebugLevel.None, handlers
                 completedStep: steps.length,
                 selectedIndex,
             };
-            handlers?.updateState(stateUpdate);
+            stateHandlers?.updateState(stateUpdate);
             // Call onFinished callback and handle result
             try {
                 if (onFinished) {
                     onFinished(newValues);
                 }
                 // Success - complete with success feedback
-                handlers?.completeActive(createFeedback(FeedbackType.Succeeded, 'Configuration saved successfully.'));
+                lifecycleHandlers?.completeActive(createFeedback(FeedbackType.Succeeded, 'Configuration saved successfully.'));
             }
             catch (error) {
                 // Failure - complete with error feedback
                 const errorMessage = error instanceof Error ? error.message : 'Configuration failed';
-                handlers?.completeActive(createFeedback(FeedbackType.Failed, errorMessage));
+                lifecycleHandlers?.completeActive(createFeedback(FeedbackType.Failed, errorMessage));
             }
             setStep(steps.length);
         }
@@ -249,7 +260,7 @@ export function Config({ steps, state, status, debug = DebugLevel.None, handlers
                 completedStep: step + 1,
                 selectedIndex,
             };
-            handlers?.updateState(stateUpdate);
+            stateHandlers?.updateState(stateUpdate);
             const nextStep = step + 1;
             setStep(nextStep);
             // Reset selectedIndex for next step
@@ -278,8 +289,8 @@ export function Config({ steps, state, status, debug = DebugLevel.None, handlers
                 return (_jsx(SelectionStep, { options: stepConfig.options, selectedIndex: selectedIndex, isCurrentStep: true }));
             }
             default: {
-                const exhaustiveCheck = stepConfig;
-                throw new Error(`Unsupported step type: ${exhaustiveCheck}`);
+                const _exhaustiveCheck = stepConfig;
+                throw new Error('Unsupported step type');
             }
         }
     };
@@ -291,6 +302,7 @@ export function Config({ steps, state, status, debug = DebugLevel.None, handlers
             if (!shouldShow) {
                 return null;
             }
-            return (_jsxs(Box, { flexDirection: "column", marginTop: index === 0 ? 0 : 1, children: [_jsxs(Box, { children: [_jsx(Text, { children: stepConfig.description }), _jsx(Text, { children: ": " }), debug !== DebugLevel.None && stepConfig.path && (_jsxs(Text, { color: Colors.Type.Define, children: ['{', stepConfig.path, '}'] }))] }), _jsxs(Box, { children: [_jsx(Text, { children: " " }), _jsx(Text, { color: Colors.Action.Select, dimColor: !isCurrentStep, children: ">" }), _jsx(Text, { children: " " }), renderStepInput(stepConfig, isCurrentStep)] })] }, stepConfig.path || stepConfig.key));
+            const postfix = getPostfix(stepConfig.path, debug);
+            return (_jsxs(Box, { flexDirection: "column", marginTop: index === 0 ? 0 : 1, children: [_jsxs(Box, { children: [_jsx(Text, { children: stepConfig.description }), _jsx(Text, { children: ": " }), postfix && _jsx(Text, { color: Colors.Type.Config, children: postfix })] }), _jsxs(Box, { children: [_jsx(Text, { children: " " }), _jsx(Text, { color: Colors.Action.Select, dimColor: !isCurrentStep, children: ">" }), _jsx(Text, { children: " " }), renderStepInput(stepConfig, isCurrentStep)] })] }, stepConfig.path || stepConfig.key));
         }) }));
 }

package/dist/ui/Confirm.js

@@ -2,10 +2,10 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState } from 'react';
 import { Box, Text } from 'ink';
 import { ComponentStatus } from '../types/components.js';
-import { Colors, Palette } from '../services/colors.js';
+import { Colors, getTextColor, Palette } from '../services/colors.js';
 import { useInput } from '../services/keyboard.js';
 import { UserQuery } from './UserQuery.js';
-export function Confirm({ message, state, status, handlers, onConfirmed, onCancelled, }) {
+export function Confirm({ message, state, status, stateHandlers, onConfirmed, onCancelled, }) {
     const isActive = status === ComponentStatus.Active;
     const [selectedIndex, setSelectedIndex] = useState(state?.selectedIndex ?? 0); // 0 = Yes, 1 = No
     useInput((input, key) => {
@@ -14,23 +14,23 @@ export function Confirm({ message, state, status, handlers, onConfirmed, onCance
         if (key.escape) {
             // Escape: highlight "No" and cancel
             setSelectedIndex(1);
-            handlers?.updateState({ selectedIndex: 1 });
-            onCancelled?.();
+            stateHandlers?.updateState({ selectedIndex: 1 });
+            onCancelled();
         }
         else if (key.tab) {
             // Toggle between Yes (0) and No (1)
             const newIndex = selectedIndex === 0 ? 1 : 0;
             setSelectedIndex(newIndex);
-            handlers?.updateState({ selectedIndex: newIndex });
+            stateHandlers?.updateState({ selectedIndex: newIndex });
         }
         else if (key.return) {
             // Confirm selection
-            handlers?.updateState({ selectedIndex, confirmed: true });
+            stateHandlers?.updateState({ selectedIndex, confirmed: true });
             if (selectedIndex === 0) {
-                onConfirmed?.();
+                onConfirmed();
             }
             else {
-                onCancelled?.();
+                onCancelled();
             }
         }
     }, { isActive });
@@ -42,7 +42,7 @@ export function Confirm({ message, state, status, handlers, onConfirmed, onCance
         // When done, show both the message and user's choice in timeline
         return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, marginLeft: 1, children: _jsx(Text, { color: undefined, children: message }) }), _jsxs(UserQuery, { children: ["> ", options[selectedIndex].label] })] }));
     }
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, marginLeft: 1, children: _jsx(Text, { color: isActive ? Colors.Text.Active : Colors.Text.Inactive, children: message }) }), _jsxs(Box, { marginLeft: 1, children: [_jsx(Text, { color: Colors.Action.Select, children: ">" }), _jsx(Text, { children: " " }), _jsx(Box, { children: options.map((option, index) => {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, marginLeft: 1, children: _jsx(Text, { color: getTextColor(isActive), children: message }) }), _jsxs(Box, { marginLeft: 1, children: [_jsx(Text, { color: Colors.Action.Select, children: ">" }), _jsx(Text, { children: " " }), _jsx(Box, { children: options.map((option, index) => {
                             const isSelected = index === selectedIndex;
                             return (_jsx(Box, { marginRight: 2, children: _jsx(Text, { color: isSelected ? option.color : undefined, dimColor: !isSelected, children: option.label }) }, option.value));
                         }) })] })] }));