prompt-language-shell 0.5.2 → 0.6.2

package/dist/services/configuration.js

@@ -123,6 +123,7 @@ export function saveConfig(section, config) {
 }
 export function saveAnthropicConfig(config) {
     saveConfig('anthropic', config);
+    return loadConfig();
 }
 export function saveDebugSetting(debug) {
     saveConfig('settings', { debug });
@@ -201,21 +202,75 @@ export function getConfigSchema() {
     };
 }
 /**
- * Get available config structure for CONFIG tool
- * Returns keys with descriptions only (no values for privacy)
+ * Get missing required configuration keys
+ * Returns array of keys that are required but not present or invalid in config
  */
-export function getAvailableConfigStructure() {
+export function getMissingConfigKeys() {
     const schema = getConfigSchema();
-    const structure = {};
-    // Add core schema keys with descriptions
+    const missing = [];
+    let currentConfig = null;
+    try {
+        currentConfig = loadConfig();
+    }
+    catch {
+        // Config doesn't exist
+    }
     for (const [key, definition] of Object.entries(schema)) {
-        structure[key] = definition.description;
+        if (!definition.required) {
+            continue;
+        }
+        // Get current value for this key
+        const parts = key.split('.');
+        let value = currentConfig;
+        for (const part of parts) {
+            if (value && typeof value === 'object' && part in value) {
+                value = value[part];
+            }
+            else {
+                value = undefined;
+                break;
+            }
+        }
+        // Check if value is missing or invalid
+        if (value === undefined || value === null) {
+            missing.push(key);
+            continue;
+        }
+        // Validate based on type
+        let isValid = false;
+        switch (definition.type) {
+            case 'regexp':
+                isValid = typeof value === 'string' && definition.pattern.test(value);
+                break;
+            case 'string':
+                isValid = typeof value === 'string';
+                break;
+            case 'enum':
+                isValid =
+                    typeof value === 'string' && definition.values.includes(value);
+                break;
+            case 'number':
+                isValid = typeof value === 'number';
+                break;
+            case 'boolean':
+                isValid = typeof value === 'boolean';
+                break;
+        }
+        if (!isValid) {
+            missing.push(key);
+        }
     }
-    // Add discovered keys from config file (if it exists)
+    return missing;
+}
+/**
+ * Get list of configured keys from config file
+ * Returns array of dot-notation keys that exist in the config file
+ */
+export function getConfiguredKeys() {
     try {
         const configFile = getConfigFile();
         if (!existsSync(configFile)) {
-            return structure;
+            return [];
         }
         const content = readFileSync(configFile, 'utf-8');
         const parsed = YAML.parse(content);
@@ -234,15 +289,116 @@ export function getAvailableConfigStructure() {
             return result;
         }
         const flatConfig = flattenConfig(parsed);
-        // Add discovered keys that aren't in schema
-        for (const key of Object.keys(flatConfig)) {
-            if (!structure[key]) {
-                structure[key] = `${key} (discovered)`;
+        return Object.keys(flatConfig);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Get available config structure for CONFIG tool
+ * Returns keys with descriptions only (no values for privacy)
+ * Marks optional keys as "(optional)"
+ */
+export function getAvailableConfigStructure() {
+    const schema = getConfigSchema();
+    const structure = {};
+    // Try to load existing config to see which keys are already set
+    let flatConfig = {};
+    try {
+        const configFile = getConfigFile();
+        if (existsSync(configFile)) {
+            const content = readFileSync(configFile, 'utf-8');
+            const parsed = YAML.parse(content);
+            // Flatten nested config to dot notation
+            function flattenConfig(obj, prefix = '') {
+                const result = {};
+                for (const [key, value] of Object.entries(obj)) {
+                    const fullKey = prefix ? `${prefix}.${key}` : key;
+                    if (value && typeof value === 'object' && !Array.isArray(value)) {
+                        Object.assign(result, flattenConfig(value, fullKey));
+                    }
+                    else {
+                        result[fullKey] = value;
+                    }
+                }
+                return result;
             }
+            flatConfig = flattenConfig(parsed);
         }
     }
     catch {
-        // Config file doesn't exist or can't be read, only use schema
+        // Config file doesn't exist or can't be read
+    }
+    // Add schema keys with descriptions
+    // Mark optional keys as (optional)
+    for (const [key, definition] of Object.entries(schema)) {
+        const isOptional = !definition.required;
+        if (isOptional) {
+            structure[key] = `${definition.description} (optional)`;
+        }
+        else {
+            structure[key] = definition.description;
+        }
+    }
+    // Add discovered keys that aren't in schema
+    for (const key of Object.keys(flatConfig)) {
+        if (!(key in structure)) {
+            structure[key] = `${key} (discovered)`;
+        }
     }
     return structure;
 }
+/**
+ * Convert string value to appropriate type based on schema definition
+ */
+function parseConfigValue(key, stringValue, schema) {
+    // If we have a schema definition, use its type
+    if (key in schema) {
+        const definition = schema[key];
+        switch (definition.type) {
+            case 'boolean':
+                return stringValue === 'true';
+            case 'number':
+                return Number(stringValue);
+            case 'string':
+            case 'regexp':
+            case 'enum':
+                return stringValue;
+        }
+    }
+    // No schema definition - try to infer type from string value
+    // This handles skill-defined configs that may not be in schema yet
+    if (stringValue === 'true' || stringValue === 'false') {
+        return stringValue === 'true';
+    }
+    if (!isNaN(Number(stringValue)) && stringValue.trim() !== '') {
+        return Number(stringValue);
+    }
+    return stringValue;
+}
+/**
+ * Unflatten dotted keys into nested structure
+ * Example: { "product.alpha.path": "value" } -> { product: { alpha: { path: "value" } } }
+ * Converts string values to appropriate types based on config schema
+ */
+export function unflattenConfig(dotted) {
+    const result = {};
+    const schema = getConfigSchema();
+    for (const [dottedKey, stringValue] of Object.entries(dotted)) {
+        const parts = dottedKey.split('.');
+        const section = parts[0];
+        // Initialize section if needed
+        result[section] = result[section] ?? {};
+        // Build nested structure for this section
+        let current = result[section];
+        for (let i = 1; i < parts.length - 1; i++) {
+            current[parts[i]] = current[parts[i]] ?? {};
+            current = current[parts[i]];
+        }
+        // Convert string value to appropriate type and set
+        const typedValue = parseConfigValue(dottedKey, stringValue, schema);
+        current[parts[parts.length - 1]] = typedValue;
+    }
+    return result;
+}

package/dist/services/messages.js

@@ -43,6 +43,28 @@ export function getCancellationMessage(operation) {
     ];
     return templates[Math.floor(Math.random() * templates.length)];
 }
+/**
+ * Returns an error message when the request cannot be understood.
+ * Randomly selects from variations to sound natural.
+ */
+export function getUnknownRequestMessage() {
+    const messages = [
+        'I do not understand the request.',
+        'I cannot understand what you want me to do.',
+        "I'm not sure what you're asking for.",
+        'I cannot determine what action to take.',
+        'This request is unclear to me.',
+        'I do not recognize this command.',
+    ];
+    return messages[Math.floor(Math.random() * messages.length)];
+}
+/**
+ * Returns an error message for mixed task types.
+ */
+export function getMixedTaskTypesError(types) {
+    const typeList = types.join(', ');
+    return `Mixed task types are not supported. Found: ${typeList}. All tasks in a plan must have the same type.`;
+}
 /**
  * Feedback messages for various operations
  */

package/dist/services/queue.js

@@ -1,5 +1,5 @@
 import { FeedbackType } from '../types/types.js';
-import { createFeedback, markAsDone } from './components.js';
+import { createFeedback } from './components.js';
 import { FeedbackMessages } from './messages.js';
 import { exitApp } from './process.js';
 /**
@@ -37,7 +37,7 @@ export function withQueueHandler(componentName, callback, shouldExit = false, ex
  */
 export function createErrorHandler(componentName, addToTimeline) {
     return (error) => withQueueHandler(componentName, (first) => {
-        addToTimeline(markAsDone(first), createFeedback(FeedbackType.Failed, FeedbackMessages.UnexpectedError, error));
+        addToTimeline(first, createFeedback(FeedbackType.Failed, FeedbackMessages.UnexpectedError, error));
         return undefined;
     }, true, 1);
 }

package/dist/services/refinement.js

@@ -0,0 +1,37 @@
+import { createRefinement } from './components.js';
+import { formatErrorMessage, getRefiningMessage } from './messages.js';
+import { routeTasksWithConfirm } from './task-router.js';
+/**
+ * Handle refinement flow for DEFINE tasks
+ * Called when user selects options from a plan with DEFINE tasks
+ */
+export async function handleRefinement(selectedTasks, service, originalCommand, handlers) {
+    // Create and add refinement component to queue
+    const refinementDef = createRefinement(getRefiningMessage(), (operation) => {
+        handlers.onAborted(operation);
+    });
+    handlers.addToQueue(refinementDef);
+    try {
+        // Build refined command from selected tasks
+        const refinedCommand = selectedTasks
+            .map((task) => {
+            const action = task.action.toLowerCase().replace(/,/g, ' -');
+            const type = task.type;
+            return `${action} (type: ${type})`;
+        })
+            .join(', ');
+        // Call LLM to refine plan with selected tasks
+        const refinedResult = await service.processWithTool(refinedCommand, 'plan');
+        // Complete the Refinement component
+        handlers.completeActive();
+        // Route refined tasks to appropriate components
+        routeTasksWithConfirm(refinedResult.tasks, refinedResult.message, service, originalCommand, handlers, false, // No DEFINE tasks in refined result
+        undefined // No commandComponent - use normal flow
+        );
+    }
+    catch (err) {
+        handlers.completeActive();
+        const errorMessage = formatErrorMessage(err);
+        handlers.onError(errorMessage);
+    }
+}

package/dist/services/task-router.js

@@ -0,0 +1,141 @@
+import { TaskType } from '../types/types.js';
+import { createAnswerDefinition, createConfigDefinitionWithKeys, createConfirmDefinition, createExecuteDefinition, createFeedback, createIntrospectDefinition, createMessage, createPlanDefinition, createValidateDefinition, } from './components.js';
+import { saveConfig, unflattenConfig } from './configuration.js';
+import { FeedbackType } from '../types/types.js';
+import { validateExecuteTasks } from './execution-validator.js';
+import { getMixedTaskTypesError, getUnknownRequestMessage, } from './messages.js';
+/**
+ * Determine the operation name based on task types
+ */
+export function getOperationName(tasks) {
+    const allIntrospect = tasks.every((task) => task.type === TaskType.Introspect);
+    const allAnswer = tasks.every((task) => task.type === TaskType.Answer);
+    if (allIntrospect)
+        return 'introspection';
+    if (allAnswer)
+        return 'answer';
+    return 'execution';
+}
+/**
+ * Route tasks to appropriate components with Confirm flow
+ * Handles the complete flow: Plan → Confirm → Execute/Answer/Introspect
+ */
+export function routeTasksWithConfirm(tasks, message, service, userRequest, handlers, hasDefineTask = false, commandComponent) {
+    if (tasks.length === 0)
+        return;
+    // Filter out ignore and discard tasks early
+    const validTasks = tasks.filter((task) => task.type !== TaskType.Ignore && task.type !== TaskType.Discard);
+    // Check if no valid tasks remain after filtering
+    if (validTasks.length === 0) {
+        const message = createMessage(getUnknownRequestMessage());
+        handlers.addToQueue(message);
+        return;
+    }
+    const operation = getOperationName(validTasks);
+    // Create plan definition with valid tasks only
+    const planDefinition = createPlanDefinition(message, validTasks);
+    if (hasDefineTask) {
+        // Has DEFINE tasks - add Plan to queue for user selection
+        // Refinement flow will call this function again with refined tasks
+        handlers.addToQueue(planDefinition);
+    }
+    else {
+        // No DEFINE tasks - add Plan to timeline, create Confirm
+        const confirmDefinition = createConfirmDefinition(() => {
+            // User confirmed - route to appropriate component
+            handlers.completeActive();
+            executeTasksAfterConfirm(validTasks, service, userRequest, handlers);
+        }, () => {
+            // User cancelled
+            handlers.onAborted(operation);
+        });
+        // Use atomic update if commandComponent provided, else normal flow
+        if (commandComponent) {
+            handlers.completeActive(planDefinition);
+        }
+        else {
+            handlers.addToTimeline(planDefinition);
+        }
+        handlers.addToQueue(confirmDefinition);
+    }
+}
+/**
+ * Validate that all tasks have the same type
+ * Per FLOWS.md: "Mixed types → Error (not supported)"
+ */
+function validateTaskTypes(tasks) {
+    if (tasks.length === 0)
+        return;
+    const types = new Set(tasks.map((task) => task.type));
+    if (types.size > 1) {
+        throw new Error(getMixedTaskTypesError(Array.from(types)));
+    }
+}
+/**
+ * Execute tasks after confirmation (internal helper)
+ * Validates task types after user has seen and confirmed the plan
+ */
+function executeTasksAfterConfirm(tasks, service, userRequest, handlers) {
+    // Validate all tasks have the same type after user confirmation
+    // Per FLOWS.md: "Confirm component completes → Execution handler analyzes task types"
+    try {
+        validateTaskTypes(tasks);
+    }
+    catch (error) {
+        handlers.onError(error instanceof Error ? error.message : String(error));
+        return;
+    }
+    const allIntrospect = tasks.every((task) => task.type === TaskType.Introspect);
+    const allAnswer = tasks.every((task) => task.type === TaskType.Answer);
+    const allConfig = tasks.every((task) => task.type === TaskType.Config);
+    if (allAnswer) {
+        const question = tasks[0].action;
+        handlers.addToQueue(createAnswerDefinition(question, service));
+    }
+    else if (allIntrospect) {
+        handlers.addToQueue(createIntrospectDefinition(tasks, service));
+    }
+    else if (allConfig) {
+        // Route to Config flow - extract keys from task params
+        const configKeys = tasks
+            .map((task) => task.params?.key)
+            .filter((key) => key !== undefined);
+        handlers.addToQueue(createConfigDefinitionWithKeys(configKeys, (config) => {
+            // Save config using the same pattern as Validate component
+            try {
+                // Convert flat dotted keys to nested structure grouped by section
+                const configBySection = unflattenConfig(config);
+                // Save each section
+                for (const [section, sectionConfig] of Object.entries(configBySection)) {
+                    saveConfig(section, sectionConfig);
+                }
+                handlers.completeActive();
+                handlers.addToQueue(createFeedback(FeedbackType.Succeeded, 'Configuration updated successfully.'));
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error
+                    ? error.message
+                    : 'Failed to save configuration';
+                handlers.onError(errorMessage);
+            }
+        }, (operation) => {
+            handlers.onAborted(operation);
+        }));
+    }
+    else {
+        // Execute tasks with validation
+        const missingConfig = validateExecuteTasks(tasks);
+        if (missingConfig.length > 0) {
+            handlers.addToQueue(createValidateDefinition(missingConfig, userRequest, service, (error) => {
+                handlers.onError(error);
+            }, () => {
+                handlers.addToQueue(createExecuteDefinition(tasks, service));
+            }, (operation) => {
+                handlers.onAborted(operation);
+            }));
+        }
+        else {
+            handlers.addToQueue(createExecuteDefinition(tasks, service));
+        }
+    }
+}

package/dist/types/types.js

@@ -11,7 +11,6 @@ export var ComponentName;
     ComponentName["Introspect"] = "introspect";
     ComponentName["Report"] = "report";
     ComponentName["Answer"] = "answer";
-    ComponentName["AnswerDisplay"] = "answerDisplay";
     ComponentName["Execute"] = "execute";
     ComponentName["Validate"] = "validate";
 })(ComponentName || (ComponentName = {}));

package/dist/ui/Answer.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
 import { Box, Text } from 'ink';
 import { Colors, getTextColor } from '../services/colors.js';
@@ -7,26 +7,22 @@ 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, service, onError, onComplete, onAborted, }) {
-    const done = state?.done ?? false;
-    const isCurrent = done === false;
+export function Answer({ question, state, isActive = true, service, handlers, }) {
     const [error, setError] = useState(null);
-    const [isLoading, setIsLoading] = useState(state?.isLoading ?? !done);
+    const [answer, setAnswer] = useState(state?.answer ?? null);
     useInput((input, key) => {
-        if (key.escape && isLoading && !done) {
-            setIsLoading(false);
-            onAborted();
+        if (key.escape && isActive) {
+            handlers?.onAborted('answer');
         }
-    }, { isActive: isLoading && !done });
+    }, { isActive });
     useEffect(() => {
         // Skip processing if done
-        if (done) {
+        if (!isActive) {
             return;
         }
         // Skip processing if no service available
         if (!service) {
             setError('No service available');
-            setIsLoading(false);
             return;
         }
         let mounted = true;
@@ -36,21 +32,19 @@ export function Answer({ question, state, service, onError, onComplete, onAborte
                 const result = await withMinimumTime(() => svc.processWithTool(question, 'answer'), MINIMUM_PROCESSING_TIME);
                 if (mounted) {
                     // Extract answer from result
-                    const answer = result.answer || '';
-                    setIsLoading(false);
-                    onComplete?.(answer);
+                    const answerText = result.answer || '';
+                    setAnswer(answerText);
+                    // Update component state so answer persists in timeline
+                    handlers?.updateState({ answer: answerText });
+                    // Signal completion
+                    handlers?.completeActive();
                 }
             }
             catch (err) {
                 if (mounted) {
                     const errorMessage = formatErrorMessage(err);
-                    setIsLoading(false);
-                    if (onError) {
-                        onError(errorMessage);
-                    }
-                    else {
-                        setError(errorMessage);
-                    }
+                    setError(errorMessage);
+                    handlers?.onError(errorMessage);
                 }
             }
         }
@@ -58,10 +52,7 @@ export function Answer({ question, state, service, onError, onComplete, onAborte
         return () => {
             mounted = false;
         };
-    }, [question, done, service, onComplete, onError]);
-    // Return null when done (like Introspect)
-    if (done || (!isLoading && !error)) {
-        return null;
-    }
-    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isLoading && (_jsxs(Box, { children: [_jsx(Text, { color: getTextColor(isCurrent), children: "Finding answer. " }), _jsx(Spinner, {})] })), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) }))] }));
+    }, [question, isActive, service, handlers]);
+    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,32 +1,33 @@
-import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
 import { Box, Text } from 'ink';
 import { TaskType } from '../types/types.js';
 import { Colors } from '../services/colors.js';
-import { useInput } from '../services/keyboard.js';
+import { createPlanDefinition } from '../services/components.js';
 import { formatErrorMessage } from '../services/messages.js';
+import { useInput } from '../services/keyboard.js';
+import { handleRefinement } from '../services/refinement.js';
+import { routeTasksWithConfirm } from '../services/task-router.js';
 import { ensureMinimumTime } from '../services/timing.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, }) {
-    const done = state?.done ?? false;
-    const [error, setError] = useState(null);
-    const [isLoading, setIsLoading] = useState(state?.isLoading ?? !done);
-    useInput((input, key) => {
-        if (key.escape && isLoading && !done) {
-            setIsLoading(false);
-            onAborted();
+import { UserQuery } from './UserQuery.js';
+const MIN_PROCESSING_TIME = 400; // purely for visual effect
+export function Command({ command, state, isActive = true, service, handlers, onAborted, }) {
+    const [error, setError] = useState(state?.error ?? null);
+    useInput((_, key) => {
+        if (key.escape && isActive) {
+            handlers?.onAborted('request');
+            onAborted?.('request');
         }
-    }, { isActive: isLoading && !done });
+    }, { isActive });
     useEffect(() => {
-        // Skip processing if done (showing historical/final state)
-        if (done) {
+        // Skip processing if not active (showing historical/final state)
+        if (!isActive) {
             return;
         }
         // Skip processing if no service available
         if (!service) {
             setError('No service available');
-            setIsLoading(false);
             return;
         }
         let mounted = true;
@@ -45,21 +46,38 @@ export function Command({ command, state, service, children, onError, onComplete
                 }
                 await ensureMinimumTime(startTime, MIN_PROCESSING_TIME);
                 if (mounted) {
-                    setIsLoading(false);
-                    onComplete?.(result.message, result.tasks);
+                    // Save result to state for timeline display
+                    handlers?.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);
+                    // Create Plan definition
+                    const planDefinition = createPlanDefinition(result.message, result.tasks, hasDefineTask
+                        ? async (selectedTasks) => {
+                            // Refinement flow for DEFINE tasks
+                            await handleRefinement(selectedTasks, svc, command, handlers);
+                        }
+                        : undefined);
+                    if (hasDefineTask) {
+                        // DEFINE tasks: Move Command to timeline, add Plan to queue
+                        handlers?.completeActive();
+                        handlers?.addToQueue(planDefinition);
+                    }
+                    else {
+                        // No DEFINE tasks: Pass Plan to be added atomically with Command
+                        routeTasksWithConfirm(result.tasks, result.message, svc, command, handlers, false, planDefinition // Pass Plan for atomic update
+                        );
+                    }
                 }
             }
             catch (err) {
                 await ensureMinimumTime(startTime, MIN_PROCESSING_TIME);
                 if (mounted) {
                     const errorMessage = formatErrorMessage(err);
-                    setIsLoading(false);
-                    if (onError) {
-                        onError(errorMessage);
-                    }
-                    else {
-                        setError(errorMessage);
-                    }
+                    setError(errorMessage);
+                    handlers?.onError(errorMessage);
                 }
             }
         }
@@ -67,7 +85,6 @@ export function Command({ command, state, service, children, onError, onComplete
         return () => {
             mounted = false;
         };
-    }, [command, done, service]);
-    const isCurrent = done === false;
-    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [_jsxs(Box, { paddingX: done ? 1 : 0, marginX: done ? -1 : 0, backgroundColor: done ? Colors.Background.UserQuery : undefined, children: [_jsxs(Text, { color: isCurrent ? Colors.Text.Active : Colors.Text.UserQuery, children: ["> pls ", command] }), isLoading && (_jsxs(_Fragment, { children: [_jsx(Text, { children: " " }), _jsx(Spinner, {})] }))] }), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) })), children] }));
+    }, [command, isActive, service, handlers]);
+    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] }) }))] }));
 }