prompt-language-shell 0.7.8 → 0.8.2

package/dist/skills/schedule.md

@@ -83,12 +83,17 @@ settings", type "configure", params { query: "app" }
 
 Before creating tasks, evaluate the request type:
 
-1. **Information requests** (questions) - Use question keywords:
+1. **Introspection requests** - User asks about your capabilities:
+   - "list your skills", "what can you do", "flex", "show off", "list
+     capabilities", "show skills"
+   - Example: "flex" → introspect type
+
+2. **Information requests** (questions) - Use question keywords:
    - "explain", "describe", "tell me", "what is", "how does", "find",
      "search"
    - Example: "explain docker" → answer type
 
-2. **Action requests** (commands) - Must match available skills:
+3. **Action requests** (commands) - Must match available skills:
    - Action verbs like "compile", "deploy", "process", "validate"
    - If verb matches a skill → extract skill steps as subtasks
    - If verb does NOT match any skill → ignore type with action
@@ -98,7 +103,7 @@ Before creating tasks, evaluate the request type:
    - Example: "validate" with no skill → action "Ignore unknown
      'validate' request"
 
-3. **Vague/ambiguous requests** without clear verb:
+4. **Vague/ambiguous requests** without clear verb:
    - Phrases like "do something", "handle it" → ignore type
    - Action format: "Ignore unknown 'X' request" where X is the phrase
 

package/dist/tools/introspect.tool.js

@@ -1,6 +1,6 @@
 export const introspectTool = {
     name: 'introspect',
-    description: 'Execute a task with type "introspect" to list available capabilities and skills. Called after SCHEDULE has identified an introspection request and user has confirmed. Takes the task action and optional filter parameter to present built-in capabilities and user-defined skills.',
+    description: 'Execute a task with type "introspect" to list available capabilities and skills. Called after SCHEDULE has identified an introspection request and user has confirmed. Takes the task action and optional filter parameter to present system capabilities and user-provided skills.',
     input_schema: {
         type: 'object',
         properties: {
@@ -8,25 +8,34 @@ export const introspectTool = {
                 type: 'string',
                 description: 'Introductory reply to display before the capabilities list. Must be a single sentence, maximum 64 characters (including the colon at the end). Vary this naturally - try to use a different phrase each time. Always end with a colon.',
             },
-            tasks: {
+            capabilities: {
                 type: 'array',
-                description: 'Array of capabilities, each with type "introspect". Include built-in capabilities (SCHEDULE, INTROSPECT, ANSWER, EXECUTE, REPORT, CONFIGURE) and user-defined skills from the Available Skills section.',
+                description: 'Array of capabilities and skills. Include system capabilities (Introspect, Configure, Answer, Execute) with origin "system", meta workflow capabilities (Schedule, Validate, Report) with origin "meta", and user-provided skills from the Available Skills section with origin "user".',
                 items: {
                     type: 'object',
                     properties: {
-                        action: {
+                        name: {
                             type: 'string',
-                            description: 'Capability name and description. Format: "NAME: Brief description". Maximum 64 characters. Examples: "SCHEDULE: Break down requests into steps", "Deploy App: Build and deploy application".',
+                            description: 'Capability or skill name. Use title case. Maximum 32 characters. Examples: "Execute", "Deploy Application", "Process Data".',
                         },
-                        type: {
+                        description: {
                             type: 'string',
-                            description: 'Always "introspect" for capability listings.',
+                            description: 'Brief description of what this capability does. Start with lowercase letter, no ending punctuation. Maximum 64 characters. Examples: "run shell commands and operations", "build and deploy to production".',
+                        },
+                        origin: {
+                            type: 'string',
+                            enum: ['system', 'user', 'meta'],
+                            description: 'Origin of the capability. Use "system" for system capabilities (Introspect, Configure, Answer, Execute), "meta" for meta workflow capabilities (Schedule, Validate, Report), and "user" for user-provided skills.',
+                        },
+                        isIncomplete: {
+                            type: 'boolean',
+                            description: 'Optional. Set to true if the skill is marked as incomplete.',
                         },
                     },
-                    required: ['action', 'type'],
+                    required: ['name', 'description', 'origin'],
                 },
             },
         },
-        required: ['message', 'tasks'],
+        required: ['message', 'capabilities'],
     },
 };

package/dist/types/guards.js

@@ -0,0 +1,25 @@
+import { TaskType } from './types.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
+ */
+export function isTask(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'action' in value &&
+        typeof value.action === 'string' &&
+        'type' in value);
+}

package/dist/types/types.js

@@ -29,6 +29,12 @@ 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";

package/dist/ui/Answer.js

@@ -23,11 +23,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 {
@@ -40,7 +35,9 @@ export function Answer({ question, state, status, service, handlers, }) {
                     const answerText = result.answer || '';
                     setAnswer(answerText);
                     // Update component state so answer persists in timeline
-                    handlers?.updateState({ answer: answerText });
+                    handlers?.updateState({
+                        answer: answerText,
+                    });
                     // Signal completion
                     handlers?.completeActive();
                 }
@@ -49,11 +46,14 @@ export function Answer({ question, state, status, service, handlers, }) {
                 if (mounted) {
                     const errorMessage = formatErrorMessage(err);
                     setError(errorMessage);
+                    handlers?.updateState({
+                        error: errorMessage,
+                    });
                     handlers?.onError(errorMessage);
                 }
             }
         }
-        process(service);
+        void process(service);
         return () => {
             mounted = false;
         };

package/dist/ui/Command.js

@@ -1,12 +1,12 @@
 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 { formatErrorMessage } from '../services/messages.js';
 import { useInput } from '../services/keyboard.js';
+import { formatErrorMessage } from '../services/messages.js';
 import { handleRefinement } from '../services/refinement.js';
 import { routeTasksWithConfirm } from '../services/router.js';
 import { ensureMinimumTime } from '../services/timing.js';
@@ -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();
@@ -64,6 +59,9 @@ export function Command({ command, state, status, service, handlers, onAborted,
                     });
                     // Check if tasks contain DEFINE type (variant selection needed)
                     const hasDefineTask = result.tasks.some((task) => task.type === TaskType.Define);
+                    if (!handlers) {
+                        return;
+                    }
                     // Create Schedule definition
                     const scheduleDefinition = createScheduleDefinition(result.message, result.tasks, hasDefineTask
                         ? async (selectedTasks) => {
@@ -73,12 +71,12 @@ export function Command({ command, state, status, service, handlers, onAborted,
                         : undefined);
                     if (hasDefineTask) {
                         // DEFINE tasks: Move Command to timeline, add Schedule to queue
-                        handlers?.completeActive();
-                        handlers?.addToQueue(scheduleDefinition);
+                        handlers.completeActive();
+                        handlers.addToQueue(scheduleDefinition);
                     }
                     else {
                         // No DEFINE tasks: Complete Command, then route to Confirm flow
-                        handlers?.completeActive();
+                        handlers.completeActive();
                         routeTasksWithConfirm(result.tasks, result.message, svc, command, handlers, false);
                     }
                 }
@@ -88,11 +86,14 @@ export function Command({ command, state, status, service, handlers, onAborted,
                 if (mounted) {
                     const errorMessage = formatErrorMessage(err);
                     setError(errorMessage);
+                    handlers?.updateState({
+                        error: errorMessage,
+                    });
                     handlers?.onError(errorMessage);
                 }
             }
         }
-        process(service);
+        void process(service);
         return () => {
             mounted = false;
         };

package/dist/ui/Component.js

@@ -3,16 +3,16 @@ import { memo } from 'react';
 import { ComponentName } from '../types/types.js';
 import { Answer } from './Answer.js';
 import { Command } from './Command.js';
-import { Confirm } from './Confirm.js';
 import { Config } from './Config.js';
+import { Confirm } from './Confirm.js';
 import { Debug } from './Debug.js';
 import { Execute } from './Execute.js';
 import { Feedback } from './Feedback.js';
 import { Introspect } from './Introspect.js';
 import { Message } from './Message.js';
-import { Schedule } from './Schedule.js';
 import { Refinement } from './Refinement.js';
 import { Report } from './Report.js';
+import { Schedule } from './Schedule.js';
 import { Validate } from './Validate.js';
 import { Welcome } from './Welcome.js';
 export const Component = memo(function Component({ def, debug, }) {

package/dist/ui/Config.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState } from 'react';
+import { useEffect, useState } from 'react';
 import { Box, Text, useFocus } from 'ink';
 import TextInput from 'ink-text-input';
 import { ComponentStatus } from '../types/components.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";
@@ -17,6 +30,10 @@ function TextStep({ value, placeholder, validate, onChange, onSubmit, }) {
     const [inputValue, setInputValue] = useState(value);
     const [validationFailed, setValidationFailed] = useState(false);
     const { isFocused } = useFocus({ autoFocus: true });
+    // Sync internal state with prop changes
+    useEffect(() => {
+        setInputValue(value);
+    }, [value]);
     const handleChange = (newValue) => {
         setInputValue(newValue);
         onChange(newValue);
@@ -85,15 +102,27 @@ 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');
                 }
             }
         });
         return initial;
     });
-    const [inputValue, setInputValue] = useState('');
+    const [inputValue, setInputValue] = useState(() => {
+        // Initialize with the current step's value if available
+        if (isActive && step < steps.length) {
+            const stepConfig = steps[step];
+            const configKey = stepConfig.path || stepConfig.key;
+            return values[configKey] || '';
+        }
+        return '';
+    });
     const [selectedIndex, setSelectedIndex] = useState(() => {
+        // If not active, use saved state
+        if (!isActive && state?.selectedIndex !== undefined) {
+            return state.selectedIndex;
+        }
         // Initialize selectedIndex based on current step's defaultIndex
         if (isActive &&
             step < steps.length &&
@@ -108,35 +137,43 @@ export function Config({ steps, state, status, debug = DebugLevel.None, handlers
         }
         return value.replace(/\n/g, '').trim();
     };
+    // Update inputValue when step changes
+    useEffect(() => {
+        if (isActive && step < steps.length) {
+            const stepConfig = steps[step];
+            const configKey = stepConfig.path || stepConfig.key;
+            const value = values[configKey] || '';
+            setInputValue(value);
+        }
+    }, [step, isActive, steps]);
     useInput((_, key) => {
         if (!isActive || step >= steps.length)
             return;
         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({
                 values,
                 completedStep: step,
+                selectedIndex,
             });
             if (onAborted) {
                 onAborted('configuration');
@@ -177,8 +214,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
@@ -197,6 +234,7 @@ export function Config({ steps, state, status, debug = DebugLevel.None, handlers
             const stateUpdate = {
                 values: newValues,
                 completedStep: steps.length,
+                selectedIndex,
             };
             handlers?.updateState(stateUpdate);
             // Call onFinished callback and handle result
@@ -219,6 +257,7 @@ export function Config({ steps, state, status, debug = DebugLevel.None, handlers
             const stateUpdate = {
                 values: newValues,
                 completedStep: step + 1,
+                selectedIndex,
             };
             handlers?.updateState(stateUpdate);
             const nextStep = step + 1;
@@ -249,8 +288,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');
             }
         }
     };
@@ -262,6 +301,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

@@ -1,8 +1,8 @@
 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 { ComponentStatus } from '../types/components.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, }) {
@@ -15,7 +15,7 @@ export function Confirm({ message, state, status, handlers, onConfirmed, onCance
             // Escape: highlight "No" and cancel
             setSelectedIndex(1);
             handlers?.updateState({ selectedIndex: 1 });
-            onCancelled?.();
+            onCancelled();
         }
         else if (key.tab) {
             // Toggle between Yes (0) and No (1)
@@ -27,10 +27,10 @@ export function Confirm({ message, state, status, handlers, onConfirmed, onCance
             // Confirm selection
             handlers?.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));
                         }) })] })] }));