prompt-language-shell 0.4.9 → 0.5.2

package/dist/tools/validate.tool.js

@@ -0,0 +1,43 @@
+export const validateTool = {
+    name: 'validate',
+    description: 'Validate skill requirements and generate natural language descriptions for missing configuration values. Given skill context and missing config paths, create CONFIG tasks with helpful, contextual descriptions.',
+    input_schema: {
+        type: 'object',
+        properties: {
+            message: {
+                type: 'string',
+                description: 'Empty string or brief message (not shown to user, can be left empty)',
+            },
+            tasks: {
+                type: 'array',
+                description: 'Array of CONFIG tasks with natural language descriptions for missing config values',
+                items: {
+                    type: 'object',
+                    properties: {
+                        action: {
+                            type: 'string',
+                            description: 'Natural language description explaining what the config value is for, followed by the config path in curly brackets {config.path}. Example: "Path to Alpha project repository (legacy implementation) {project.alpha.repo}"',
+                        },
+                        type: {
+                            type: 'string',
+                            description: 'Must be "config" for all tasks returned by this tool',
+                        },
+                        params: {
+                            type: 'object',
+                            description: 'Must include key field with the config path',
+                            properties: {
+                                key: {
+                                    type: 'string',
+                                    description: 'The config path (e.g., "opera.gx.repo")',
+                                },
+                            },
+                            required: ['key'],
+                        },
+                    },
+                    required: ['action', 'type', 'params'],
+                },
+            },
+        },
+        required: ['message', 'tasks'],
+    },
+};

package/dist/types/skills.js

@@ -0,0 +1,4 @@
+/**
+ * Type definitions for the structured skill system
+ */
+export {};

package/dist/types/types.js

@@ -13,6 +13,7 @@ export var ComponentName;
     ComponentName["Answer"] = "answer";
     ComponentName["AnswerDisplay"] = "answerDisplay";
     ComponentName["Execute"] = "execute";
+    ComponentName["Validate"] = "validate";
 })(ComponentName || (ComponentName = {}));
 export var TaskType;
 (function (TaskType) {

package/dist/ui/Answer.js

@@ -4,6 +4,7 @@ import { Box, Text } from 'ink';
 import { Colors, getTextColor } from '../services/colors.js';
 import { useInput } from '../services/keyboard.js';
 import { formatErrorMessage } from '../services/messages.js';
+import { withMinimumTime } from '../services/timing.js';
 import { Spinner } from './Spinner.js';
 const MINIMUM_PROCESSING_TIME = 400;
 export function Answer({ question, state, service, onError, onComplete, onAborted, }) {
@@ -30,13 +31,9 @@ export function Answer({ question, state, service, onError, onComplete, onAborte
         }
         let mounted = true;
         async function process(svc) {
-            const startTime = Date.now();
             try {
-                // Call answer tool
-                const result = await svc.processWithTool(question, 'answer');
-                const elapsed = Date.now() - startTime;
-                const remainingTime = Math.max(0, MINIMUM_PROCESSING_TIME - elapsed);
-                await new Promise((resolve) => setTimeout(resolve, remainingTime));
+                // Call answer tool with minimum processing time for UX polish
+                const result = await withMinimumTime(() => svc.processWithTool(question, 'answer'), MINIMUM_PROCESSING_TIME);
                 if (mounted) {
                     // Extract answer from result
                     const answer = result.answer || '';
@@ -45,9 +42,6 @@ export function Answer({ question, state, service, onError, onComplete, onAborte
                 }
             }
             catch (err) {
-                const elapsed = Date.now() - startTime;
-                const remainingTime = Math.max(0, MINIMUM_PROCESSING_TIME - elapsed);
-                await new Promise((resolve) => setTimeout(resolve, remainingTime));
                 if (mounted) {
                     const errorMessage = formatErrorMessage(err);
                     setIsLoading(false);

package/dist/ui/Command.js

@@ -5,6 +5,7 @@ import { TaskType } from '../types/types.js';
 import { Colors } from '../services/colors.js';
 import { useInput } from '../services/keyboard.js';
 import { formatErrorMessage } from '../services/messages.js';
+import { 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, }) {
@@ -42,18 +43,14 @@ export function Command({ command, state, service, children, onError, onComplete
                     // Call CONFIG tool to get specific config keys
                     result = await svc.processWithTool(query, 'config');
                 }
-                const elapsed = Date.now() - startTime;
-                const remainingTime = Math.max(0, MIN_PROCESSING_TIME - elapsed);
-                await new Promise((resolve) => setTimeout(resolve, remainingTime));
+                await ensureMinimumTime(startTime, MIN_PROCESSING_TIME);
                 if (mounted) {
                     setIsLoading(false);
                     onComplete?.(result.message, result.tasks);
                 }
             }
             catch (err) {
-                const elapsed = Date.now() - startTime;
-                const remainingTime = Math.max(0, MIN_PROCESSING_TIME - elapsed);
-                await new Promise((resolve) => setTimeout(resolve, remainingTime));
+                await ensureMinimumTime(startTime, MIN_PROCESSING_TIME);
                 if (mounted) {
                     const errorMessage = formatErrorMessage(err);
                     setIsLoading(false);

package/dist/ui/Component.js

@@ -13,6 +13,7 @@ import { Message } from './Message.js';
 import { Plan } from './Plan.js';
 import { Refinement } from './Refinement.js';
 import { Report } from './Report.js';
+import { Validate } from './Validate.js';
 import { Welcome } from './Welcome.js';
 export const Component = React.memo(function Component({ def, debug, }) {
     switch (def.name) {
@@ -21,7 +22,7 @@ export const Component = React.memo(function Component({ def, debug, }) {
         case ComponentName.Config: {
             const props = def.props;
             const state = def.state;
-            return _jsx(Config, { ...props, state: state });
+            return _jsx(Config, { ...props, state: state, debug: debug });
         }
         case ComponentName.Command: {
             const props = def.props;
@@ -66,5 +67,10 @@ export const Component = React.memo(function Component({ def, debug, }) {
             const state = def.state;
             return _jsx(Execute, { ...props, state: state });
         }
+        case ComponentName.Validate: {
+            const props = def.props;
+            const state = def.state;
+            return _jsx(Validate, { ...props, state: state });
+        }
     }
 });

package/dist/ui/Config.js

@@ -57,7 +57,7 @@ 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, onFinished, onAborted }) {
+export function Config({ steps, state, debug, onFinished, onAborted }) {
     const done = state?.done ?? false;
     const [step, setStep] = React.useState(done ? steps.length : 0);
     const [values, setValues] = React.useState(() => {
@@ -220,6 +220,6 @@ export function Config({ steps, state, onFinished, onAborted }) {
             if (!shouldShow) {
                 return null;
             }
-            return (_jsxs(Box, { flexDirection: "column", marginTop: index === 0 ? 0 : 1, children: [_jsx(Box, { children: _jsxs(Text, { children: [stepConfig.description, ":"] }) }), _jsxs(Box, { children: [_jsx(Text, { children: " " }), _jsx(Text, { color: Colors.Action.Select, dimColor: !isCurrentStep, children: ">" }), _jsx(Text, { children: " " }), renderStepInput(stepConfig, isCurrentStep)] })] }, stepConfig.key));
+            return (_jsxs(Box, { flexDirection: "column", marginTop: index === 0 ? 0 : 1, children: [_jsxs(Box, { children: [_jsx(Text, { children: stepConfig.description }), _jsx(Text, { children: ": " }), debug && 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.key));
         }) }));
 }

package/dist/ui/Execute.js

@@ -6,6 +6,9 @@ import { useInput } from '../services/keyboard.js';
 import { formatErrorMessage } from '../services/messages.js';
 import { formatDuration } from '../services/utils.js';
 import { ExecutionStatus, executeCommands, } from '../services/shell.js';
+import { replacePlaceholders } from '../services/placeholder-resolver.js';
+import { loadUserConfig } from '../services/config-loader.js';
+import { ensureMinimumTime } from '../services/timing.js';
 import { Spinner } from './Spinner.js';
 const MINIMUM_PROCESSING_TIME = 400;
 const STATUS_ICONS = {
@@ -13,7 +16,22 @@ const STATUS_ICONS = {
     [ExecutionStatus.Running]: '• ',
     [ExecutionStatus.Success]: '✓ ',
     [ExecutionStatus.Failed]: '✗ ',
+    [ExecutionStatus.Aborted]: '⊘ ',
 };
+function calculateTotalElapsed(commandStatuses) {
+    return commandStatuses.reduce((sum, cmd) => {
+        if (cmd.elapsed !== undefined) {
+            return sum + cmd.elapsed;
+        }
+        if (cmd.startTime) {
+            const elapsed = cmd.endTime
+                ? cmd.endTime - cmd.startTime
+                : Date.now() - cmd.startTime;
+            return sum + elapsed;
+        }
+        return sum;
+    }, 0);
+}
 function getStatusColors(status) {
     switch (status) {
         case ExecutionStatus.Pending:
@@ -44,6 +62,13 @@ function getStatusColors(status) {
                 command: Colors.Status.Error,
                 symbol: Palette.Gray,
             };
+        case ExecutionStatus.Aborted:
+            return {
+                icon: Palette.DarkOrange,
+                description: getTextColor(true),
+                command: Palette.DarkOrange,
+                symbol: Palette.Gray,
+            };
     }
 }
 function CommandStatusDisplay({ item, elapsed }) {
@@ -75,7 +100,24 @@ export function Execute({ tasks, state, service, onError, onComplete, onAborted,
         if (key.escape && (isLoading || isExecuting) && !done) {
             setIsLoading(false);
             setIsExecuting(false);
-            onAborted();
+            setRunningIndex(null);
+            // Mark any running command as aborted when cancelled
+            const now = Date.now();
+            setCommandStatuses((prev) => prev.map((item) => {
+                if (item.status === ExecutionStatus.Running) {
+                    const elapsed = item.startTime
+                        ? Math.floor((now - item.startTime) / 1000) * 1000
+                        : undefined;
+                    return {
+                        ...item,
+                        status: ExecutionStatus.Aborted,
+                        endTime: now,
+                        elapsed,
+                    };
+                }
+                return item;
+            }));
+            onAborted(calculateTotalElapsed(commandStatuses));
         }
     }, { isActive: (isLoading || isExecuting) && !done });
     // Update elapsed time for running command
@@ -97,9 +139,7 @@ export function Execute({ tasks, state, service, onError, onComplete, onAborted,
     useEffect(() => {
         if (isExecuting || commandStatuses.length === 0 || !outputs.length)
             return;
-        // Sum up elapsed times from all commands
-        const totalElapsed = commandStatuses.reduce((sum, cmd) => sum + (cmd.elapsed ?? 0), 0);
-        onComplete?.(outputs, totalElapsed);
+        onComplete?.(outputs, calculateTotalElapsed(commandStatuses));
     }, [isExecuting, commandStatuses, outputs, onComplete]);
     useEffect(() => {
         if (done) {
@@ -114,20 +154,22 @@ export function Execute({ tasks, state, service, onError, onComplete, onAborted,
         async function process(svc) {
             const startTime = Date.now();
             try {
-                // Format tasks for the execute tool
+                // Load user config for placeholder resolution
+                const userConfig = loadUserConfig();
+                // Format tasks for the execute tool and resolve placeholders
                 const taskDescriptions = tasks
                     .map((task) => {
+                    // Resolve placeholders in task action
+                    const resolvedAction = replacePlaceholders(task.action, userConfig);
                     const params = task.params
                         ? ` (params: ${JSON.stringify(task.params)})`
                         : '';
-                    return `- ${task.action}${params}`;
+                    return `- ${resolvedAction}${params}`;
                 })
                     .join('\n');
                 // Call execute tool to get commands
                 const result = await svc.processWithTool(taskDescriptions, 'execute');
-                const elapsed = Date.now() - startTime;
-                const remainingTime = Math.max(0, MINIMUM_PROCESSING_TIME - elapsed);
-                await new Promise((resolve) => setTimeout(resolve, remainingTime));
+                await ensureMinimumTime(startTime, MINIMUM_PROCESSING_TIME);
                 if (!mounted)
                     return;
                 if (!result.commands || result.commands.length === 0) {
@@ -136,9 +178,14 @@ export function Execute({ tasks, state, service, onError, onComplete, onAborted,
                     onComplete?.([], 0);
                     return;
                 }
+                // Resolve placeholders in command strings before execution
+                const resolvedCommands = result.commands.map((cmd) => ({
+                    ...cmd,
+                    command: replacePlaceholders(cmd.command, userConfig),
+                }));
                 // Set message and initialize command statuses
                 setMessage(result.message);
-                setCommandStatuses(result.commands.map((cmd, index) => ({
+                setCommandStatuses(resolvedCommands.map((cmd, index) => ({
                     command: cmd,
                     status: ExecutionStatus.Pending,
                     label: tasks[index]?.action,
@@ -146,7 +193,7 @@ export function Execute({ tasks, state, service, onError, onComplete, onAborted,
                 setIsLoading(false);
                 setIsExecuting(true);
                 // Execute commands sequentially
-                const outputs = await executeCommands(result.commands, (progress) => {
+                const outputs = await executeCommands(resolvedCommands, (progress) => {
                     if (!mounted)
                         return;
                     const now = Date.now();
@@ -186,9 +233,7 @@ export function Execute({ tasks, state, service, onError, onComplete, onAborted,
                 }
             }
             catch (err) {
-                const elapsed = Date.now() - startTime;
-                const remainingTime = Math.max(0, MINIMUM_PROCESSING_TIME - elapsed);
-                await new Promise((resolve) => setTimeout(resolve, remainingTime));
+                await ensureMinimumTime(startTime, MINIMUM_PROCESSING_TIME);
                 if (mounted) {
                     const errorMessage = formatErrorMessage(err);
                     setIsLoading(false);

package/dist/ui/Introspect.js

@@ -4,6 +4,7 @@ import { Box, Text } from 'ink';
 import { Colors, getTextColor } from '../services/colors.js';
 import { useInput } from '../services/keyboard.js';
 import { formatErrorMessage } from '../services/messages.js';
+import { ensureMinimumTime } from '../services/timing.js';
 import { Spinner } from './Spinner.js';
 const MIN_PROCESSING_TIME = 1000;
 const BUILT_IN_CAPABILITIES = new Set([
@@ -12,9 +13,10 @@ const BUILT_IN_CAPABILITIES = new Set([
     'INTROSPECT',
     'ANSWER',
     'EXECUTE',
+    'VALIDATE',
     'REPORT',
 ]);
-const INDIRECT_CAPABILITIES = new Set(['PLAN', 'REPORT']);
+const INDIRECT_CAPABILITIES = new Set(['PLAN', 'VALIDATE', 'REPORT']);
 function parseCapabilityFromTask(task) {
     // Parse "NAME: Description" format from task.action
     const colonIndex = task.action.indexOf(':');
@@ -69,15 +71,14 @@ export function Introspect({ tasks, state, service, children, debug = false, onE
                 const introspectAction = tasks[0]?.action || 'list capabilities';
                 // Call introspect tool
                 const result = await svc.processWithTool(introspectAction, 'introspect');
-                const elapsed = Date.now() - startTime;
-                const remainingTime = Math.max(0, MIN_PROCESSING_TIME - elapsed);
-                await new Promise((resolve) => setTimeout(resolve, remainingTime));
+                await ensureMinimumTime(startTime, MIN_PROCESSING_TIME);
                 if (mounted) {
                     // Parse capabilities from returned tasks
                     let capabilities = result.tasks.map(parseCapabilityFromTask);
                     // Filter out internal capabilities when not in debug mode
                     if (!debug) {
                         capabilities = capabilities.filter((cap) => cap.name.toUpperCase() !== 'PLAN' &&
+                            cap.name.toUpperCase() !== 'VALIDATE' &&
                             cap.name.toUpperCase() !== 'REPORT');
                     }
                     setIsLoading(false);
@@ -85,9 +86,7 @@ export function Introspect({ tasks, state, service, children, debug = false, onE
                 }
             }
             catch (err) {
-                const elapsed = Date.now() - startTime;
-                const remainingTime = Math.max(0, MIN_PROCESSING_TIME - elapsed);
-                await new Promise((resolve) => setTimeout(resolve, remainingTime));
+                await ensureMinimumTime(startTime, MIN_PROCESSING_TIME);
                 if (mounted) {
                     const errorMessage = formatErrorMessage(err);
                     setIsLoading(false);

package/dist/ui/Validate.js

@@ -0,0 +1,120 @@
+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, getTextColor } from '../services/colors.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 Validate({ missingConfig, userRequest, state, service, children, onError, onComplete, onAborted, }) {
+    const done = state?.done ?? false;
+    const isCurrent = done === false;
+    const [error, setError] = useState(null);
+    const [isLoading, setIsLoading] = useState(state?.isLoading ?? !done);
+    const [completionMessage, setCompletionMessage] = useState(null);
+    useInput((input, key) => {
+        if (key.escape && isLoading && !done) {
+            setIsLoading(false);
+            onAborted();
+        }
+    }, { isActive: isLoading && !done });
+    useEffect(() => {
+        // Skip processing if done
+        if (done) {
+            return;
+        }
+        // Skip processing if no service available
+        if (!service) {
+            setError('No service available');
+            setIsLoading(false);
+            return;
+        }
+        let mounted = true;
+        async function process(svc) {
+            const startTime = Date.now();
+            try {
+                // Build prompt for VALIDATE tool
+                const prompt = buildValidatePrompt(missingConfig, userRequest);
+                // Call validate tool
+                const result = await svc.processWithTool(prompt, 'validate');
+                await ensureMinimumTime(startTime, MIN_PROCESSING_TIME);
+                if (mounted) {
+                    // Extract CONFIG tasks with descriptions from result
+                    const configTasks = result.tasks.filter((task) => task.type === TaskType.Config);
+                    // Build ConfigRequirements with descriptions
+                    const withDescriptions = configTasks.map((task) => {
+                        const key = typeof task.params?.key === 'string'
+                            ? task.params.key
+                            : 'unknown';
+                        const original = missingConfig.find((req) => req.path === key);
+                        return {
+                            path: key,
+                            type: original?.type || 'string',
+                            description: task.action,
+                        };
+                    });
+                    // Build completion message showing which config properties are needed
+                    const count = withDescriptions.length;
+                    const propertyWord = count === 1 ? 'property' : 'properties';
+                    // Shuffle between different message variations
+                    const messages = [
+                        `Additional configuration ${propertyWord} required.`,
+                        `Configuration ${propertyWord} needed.`,
+                        `Missing configuration ${propertyWord} detected.`,
+                        `Setup requires configuration ${propertyWord}.`,
+                    ];
+                    const message = messages[Math.floor(Math.random() * messages.length)];
+                    setCompletionMessage(message);
+                    setIsLoading(false);
+                    onComplete?.(withDescriptions);
+                }
+            }
+            catch (err) {
+                await ensureMinimumTime(startTime, MIN_PROCESSING_TIME);
+                if (mounted) {
+                    const errorMessage = formatErrorMessage(err);
+                    setIsLoading(false);
+                    if (onError) {
+                        onError(errorMessage);
+                    }
+                    else {
+                        setError(errorMessage);
+                    }
+                }
+            }
+        }
+        process(service);
+        return () => {
+            mounted = false;
+        };
+    }, [
+        missingConfig,
+        userRequest,
+        done,
+        service,
+        onComplete,
+        onError,
+        onAborted,
+    ]);
+    // Don't render when done and nothing to show
+    if (done && !completionMessage && !error && !children) {
+        return null;
+    }
+    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isLoading && (_jsxs(Box, { children: [_jsxs(Text, { color: getTextColor(isCurrent), children: ["Validating configuration requirements.", ' '] }), _jsx(Spinner, {})] })), completionMessage && !isLoading && (_jsx(Box, { children: _jsx(Text, { color: getTextColor(isCurrent), children: completionMessage }) })), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) })), children] }));
+}
+/**
+ * Build prompt for VALIDATE tool
+ */
+function buildValidatePrompt(missingConfig, userRequest) {
+    const configList = missingConfig
+        .map((req) => `- Config path: ${req.path}\n  Type: ${req.type}`)
+        .join('\n');
+    return `User requested: "${userRequest}"
+
+Missing configuration values:
+${configList}
+
+Generate natural language descriptions for these configuration values based on the skill context.`;
+}

package/dist/ui/Welcome.js

@@ -1,22 +1,29 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
+import { Palette } from '../services/colors.js';
 import { Panel } from './Panel.js';
+export function Welcome({ app }) {
+    return (_jsx(Box, { alignSelf: "flex-start", children: _jsxs(Panel, { children: [_jsx(Header, { app: app }), _jsx(Description, { description: app.description }), _jsx(Usage, {})] }) }));
+}
 function Header({ app }) {
     const words = app.name
         .split('-')
         .map((word) => word.charAt(0).toUpperCase() + word.slice(1));
-    return (_jsxs(Box, { marginBottom: 1, gap: 1, children: [words.map((word, index) => (_jsx(Text, { color: "greenBright", bold: true, children: word }, index))), _jsxs(Text, { color: "whiteBright", dimColor: true, children: ["v", app.version] }), app.isDev && _jsx(Text, { color: "yellowBright", children: "dev" })] }));
+    return (_jsxs(Box, { marginBottom: 1, gap: 1, children: [words.map((word, index) => (_jsx(Text, { color: Palette.BrightGreen, bold: true, children: word }, index))), _jsxs(Text, { color: Palette.AshGray, children: ["v", app.version] }), app.isDev && _jsx(Text, { color: Palette.Yellow, children: "dev" })] }));
 }
 function Description({ description }) {
     const lines = description
         .split('. ')
         .map((line) => line.replace(/\.$/, ''))
         .filter(Boolean);
-    return (_jsx(_Fragment, { children: lines.map((line, index) => (_jsx(Box, { children: _jsxs(Text, { color: "white", children: [line, "."] }) }, index))) }));
+    return (_jsx(_Fragment, { children: lines.map((line, index) => (_jsx(Box, { children: _jsxs(Text, { color: Palette.White, children: [line, "."] }) }, index))) }));
 }
 function Usage() {
-    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: "brightWhite", bold: true, children: "Usage:" }), _jsxs(Box, { gap: 1, children: [_jsx(Text, { color: "whiteBright", dimColor: true, children: ">" }), _jsxs(Box, { gap: 1, children: [_jsx(Text, { color: "greenBright", bold: true, children: "pls" }), _jsx(Text, { color: "yellow", bold: true, children: "[describe your request]" })] })] })] }));
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, gap: 1, children: [_jsx(Section, { title: "Get started:", children: _jsx(Example, { children: "list skills" }) }), _jsx(Section, { title: "Usage:", children: _jsx(Example, { children: "[describe your request]" }) })] }));
 }
-export function Welcome({ app }) {
-    return (_jsx(Box, { alignSelf: "flex-start", children: _jsxs(Panel, { children: [_jsx(Header, { app: app }), _jsx(Description, { description: app.description }), _jsx(Usage, {})] }) }));
+function Section({ title, children, }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: Palette.White, children: title }), children] }));
+}
+function Example({ children }) {
+    return (_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: Palette.Gray, children: ">" }), _jsx(Text, { color: Palette.BrightGreen, bold: true, children: "pls" }), _jsx(Text, { color: Palette.Yellow, children: children })] }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prompt-language-shell",
-  "version": "0.4.9",
+  "version": "0.5.2",
   "description": "Your personal command-line concierge. Ask politely, and it gets things done.",
   "type": "module",
   "main": "dist/index.js",