prompt-language-shell 0.8.2 → 0.8.6

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

@@ -38,6 +38,7 @@ export var 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

@@ -1,21 +1,29 @@
 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 { ComponentStatus } from '../types/components.js';
+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 const AnswerView = ({ question, state, status }) => {
+    const isActive = status === ComponentStatus.Active;
+    const { error, answer } = state;
+    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] }) }))] }));
+};
+/**
+ * Answer controller: Fetches answer from LLM
+ */
+export function Answer({ question, status, service, requestHandlers, lifecycleHandlers, workflowHandlers, }) {
     const isActive = status === ComponentStatus.Active;
     const [error, setError] = useState(null);
-    const [answer, setAnswer] = useState(state?.answer ?? null);
+    const [answer, setAnswer] = useState(null);
     useInput((input, key) => {
         if (key.escape && isActive) {
-            handlers?.onAborted('answer');
+            requestHandlers.onAborted('answer');
         }
     }, { isActive });
     useEffect(() => {
@@ -30,26 +38,33 @@ 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({
+                    // Expose final state
+                    const finalState = {
                         answer: answerText,
-                    });
+                        error: null,
+                    };
+                    requestHandlers.onCompleted(finalState);
                     // Signal completion
-                    handlers?.completeActive();
+                    lifecycleHandlers.completeActive();
                 }
             }
             catch (err) {
                 if (mounted) {
                     const errorMessage = formatErrorMessage(err);
                     setError(errorMessage);
-                    handlers?.updateState({
+                    // Expose final state with error
+                    const finalState = {
                         error: errorMessage,
-                    });
-                    handlers?.onError(errorMessage);
+                        answer: null,
+                    };
+                    requestHandlers.onCompleted(finalState);
+                    requestHandlers.onError(errorMessage);
                 }
             }
         }
@@ -57,7 +72,14 @@ export function Answer({ question, state, status, service, handlers, }) {
         return () => {
             mounted = false;
         };
-    }, [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] }) }))] }));
+    }, [
+        question,
+        isActive,
+        service,
+        requestHandlers,
+        lifecycleHandlers,
+        workflowHandlers,
+    ]);
+    const state = { error, answer };
+    return _jsx(AnswerView, { question: question, state: state, status: status });
 }

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,22 @@ 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 const CommandView = ({ command, state, status }) => {
     const isActive = status === ComponentStatus.Active;
-    const [error, setError] = useState(state?.error ?? null);
+    const { error } = state;
+    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] }) }))] }));
+};
+/**
+ * Command controller: Processes and routes command
+ */
+export function Command({ command, status, service, requestHandlers, lifecycleHandlers, workflowHandlers, onAborted, }) {
+    const isActive = status === ComponentStatus.Active;
+    const [error, setError] = useState(null);
+    const [message, setMessage] = useState(null);
+    const [tasks, setTasks] = useState([]);
     useInput((_, key) => {
         if (key.escape && isActive) {
-            handlers?.onAborted('request');
+            requestHandlers.onAborted('request');
             onAborted?.('request');
         }
     }, { isActive });
@@ -51,33 +61,37 @@ export function Command({ command, state, status, service, handlers, onAborted,
                     const debugComponents = allConfig
                         ? [...scheduleDebug, ...(result.debug || [])]
                         : scheduleDebug;
-                    addDebugToTimeline(debugComponents, handlers);
-                    // Save result to state for timeline display
-                    handlers?.updateState({
+                    if (debugComponents.length > 0) {
+                        workflowHandlers.addToTimeline(...debugComponents);
+                    }
+                    // Update local state
+                    setMessage(result.message);
+                    setTasks(result.tasks);
+                    // Expose final state
+                    const finalState = {
+                        error: null,
                         message: result.message,
                         tasks: result.tasks,
-                    });
+                    };
+                    requestHandlers.onCompleted(finalState);
                     // 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) => {
                             // Refinement flow for DEFINE tasks
-                            await handleRefinement(selectedTasks, svc, command, handlers);
+                            await handleRefinement(selectedTasks, svc, command, lifecycleHandlers, workflowHandlers, requestHandlers);
                         }
                         : undefined);
                     if (hasDefineTask) {
                         // DEFINE tasks: Move Command to timeline, add Schedule to queue
-                        handlers.completeActive();
-                        handlers.addToQueue(scheduleDefinition);
+                        lifecycleHandlers.completeActive();
+                        workflowHandlers.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, lifecycleHandlers, workflowHandlers, requestHandlers, false);
                     }
                 }
             }
@@ -86,10 +100,14 @@ export function Command({ command, state, status, service, handlers, onAborted,
                 if (mounted) {
                     const errorMessage = formatErrorMessage(err);
                     setError(errorMessage);
-                    handlers?.updateState({
+                    // Expose final state with error
+                    const finalState = {
                         error: errorMessage,
-                    });
-                    handlers?.onError(errorMessage);
+                        message: null,
+                        tasks: [],
+                    };
+                    requestHandlers.onCompleted(finalState);
+                    requestHandlers.onError(errorMessage);
                 }
             }
         }
@@ -97,6 +115,14 @@ export function Command({ command, state, status, service, handlers, onAborted,
         return () => {
             mounted = false;
         };
-    }, [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] }) }))] }));
+    }, [
+        command,
+        isActive,
+        service,
+        requestHandlers,
+        lifecycleHandlers,
+        workflowHandlers,
+    ]);
+    const state = { error, message, tasks };
+    return _jsx(CommandView, { command: command, state: state, status: status });
 }

package/dist/ui/Component.js

@@ -1,49 +1,163 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { memo } from 'react';
 import { ComponentName } from '../types/types.js';
-import { Answer } from './Answer.js';
-import { Command } from './Command.js';
-import { Config } from './Config.js';
-import { Confirm } from './Confirm.js';
+import { Answer, AnswerView } from './Answer.js';
+import { Command, CommandView } from './Command.js';
+import { Config, ConfigView } from './Config.js';
+import { Confirm, ConfirmView } from './Confirm.js';
 import { Debug } from './Debug.js';
-import { Execute } from './Execute.js';
+import { Execute, ExecuteView } from './Execute.js';
 import { Feedback } from './Feedback.js';
-import { Introspect } from './Introspect.js';
+import { Introspect, IntrospectView } from './Introspect.js';
 import { Message } from './Message.js';
-import { Refinement } from './Refinement.js';
+import { Refinement, RefinementView } from './Refinement.js';
 import { Report } from './Report.js';
-import { Schedule } from './Schedule.js';
-import { Validate } from './Validate.js';
+import { Schedule, ScheduleView } from './Schedule.js';
+import { Validate, ValidateView } from './Validate.js';
 import { Welcome } from './Welcome.js';
-export const Component = memo(function Component({ def, debug, }) {
+/**
+ * Render a simple component (no lifecycle management)
+ */
+export const SimpleComponent = memo(function SimpleComponent({ def, }) {
     switch (def.name) {
+        case ComponentName.Welcome: {
+            const { props, status } = def;
+            return _jsx(Welcome, { ...props, status: status });
+        }
+        case ComponentName.Feedback: {
+            const { props, status } = def;
+            return _jsx(Feedback, { ...props, status: status });
+        }
+        case ComponentName.Message: {
+            const { props, status } = def;
+            return _jsx(Message, { ...props, status: status });
+        }
+        case ComponentName.Debug: {
+            const { props, status } = def;
+            return _jsx(Debug, { ...props, status: status });
+        }
+        case ComponentName.Report: {
+            const { props, status } = def;
+            return _jsx(Report, { ...props, status: status });
+        }
+        default:
+            throw new Error(`Unknown simple component: ${def.name}`);
+    }
+});
+/**
+ * Render a managed component (controller with lifecycle management)
+ */
+export const ControllerComponent = memo(function ControllerComponent({ def, debug, requestHandlers, lifecycleHandlers, workflowHandlers, }) {
+    switch (def.name) {
+        case ComponentName.Config: {
+            const { props: { steps, onFinished, onAborted }, status, } = def;
+            return (_jsx(Config, { steps: steps, onFinished: onFinished, onAborted: onAborted, requestHandlers: requestHandlers, lifecycleHandlers: lifecycleHandlers, status: status, debug: debug }));
+        }
+        case ComponentName.Command: {
+            const { props: { command, service, onAborted }, status, } = def;
+            return (_jsx(Command, { command: command, service: service, onAborted: onAborted, requestHandlers: requestHandlers, lifecycleHandlers: lifecycleHandlers, workflowHandlers: workflowHandlers, status: status }));
+        }
+        case ComponentName.Schedule: {
+            const { props: { message, tasks, onSelectionConfirmed }, status, } = def;
+            return (_jsx(Schedule, { message: message, tasks: tasks, onSelectionConfirmed: onSelectionConfirmed, requestHandlers: requestHandlers, lifecycleHandlers: lifecycleHandlers, status: status, debug: debug }));
+        }
+        case ComponentName.Refinement: {
+            const { props: { text, onAborted }, status, } = def;
+            return (_jsx(Refinement, { text: text, onAborted: onAborted, requestHandlers: requestHandlers, status: status }));
+        }
+        case ComponentName.Confirm: {
+            const { props: { message, onConfirmed, onCancelled }, status, } = def;
+            return (_jsx(Confirm, { message: message, onConfirmed: onConfirmed, onCancelled: onCancelled, requestHandlers: requestHandlers, status: status }));
+        }
+        case ComponentName.Introspect: {
+            const { props: { tasks, service, children }, status, } = def;
+            return (_jsx(Introspect, { tasks: tasks, service: service, children: children, requestHandlers: requestHandlers, lifecycleHandlers: lifecycleHandlers, workflowHandlers: workflowHandlers, status: status, debug: debug }));
+        }
+        case ComponentName.Answer: {
+            const { props: { question, service }, status, } = def;
+            return (_jsx(Answer, { question: question, service: service, requestHandlers: requestHandlers, lifecycleHandlers: lifecycleHandlers, workflowHandlers: workflowHandlers, status: status }));
+        }
+        case ComponentName.Validate: {
+            const { props: { missingConfig, userRequest, service, onError, onValidationComplete, onAborted, }, status, } = def;
+            return (_jsx(Validate, { missingConfig: missingConfig, userRequest: userRequest, service: service, onError: onError, onValidationComplete: onValidationComplete, onAborted: onAborted, requestHandlers: requestHandlers, lifecycleHandlers: lifecycleHandlers, workflowHandlers: workflowHandlers, status: status }));
+        }
+        case ComponentName.Execute: {
+            const { props: { tasks, service }, status, } = def;
+            return (_jsx(Execute, { tasks: tasks, service: service, requestHandlers: requestHandlers, lifecycleHandlers: lifecycleHandlers, workflowHandlers: workflowHandlers, status: status }));
+        }
+        default:
+            throw new Error(`Unknown managed component: ${def.name}`);
+    }
+});
+/**
+ * Render a managed component as View only (no Controller logic)
+ */
+export const ViewComponent = memo(function ViewComponent({ def, }) {
+    switch (def.name) {
+        case ComponentName.Confirm: {
+            const { props: { message }, state, status, } = def;
+            return _jsx(ConfirmView, { message: message, state: state, status: status });
+        }
+        case ComponentName.Config: {
+            const { props: { steps }, state, status, } = def;
+            return _jsx(ConfigView, { steps: steps, state: state, status: status });
+        }
+        case ComponentName.Schedule: {
+            const { props: { message, tasks }, state, status, } = def;
+            return (_jsx(ScheduleView, { message: message, tasks: tasks, state: state, status: status }));
+        }
+        case ComponentName.Execute: {
+            const { props: { tasks }, state, status, } = def;
+            return _jsx(ExecuteView, { tasks: tasks, state: state, status: status });
+        }
+        case ComponentName.Answer: {
+            const { props: { question }, state, status, } = def;
+            return _jsx(AnswerView, { question: question, state: state, status: status });
+        }
+        case ComponentName.Command: {
+            const { props: { command }, state, status, } = def;
+            return _jsx(CommandView, { command: command, state: state, status: status });
+        }
+        case ComponentName.Introspect: {
+            const { props: { children }, state, status, } = def;
+            return (_jsx(IntrospectView, { state: state, status: status, children: children }));
+        }
+        case ComponentName.Validate: {
+            const { state, status } = def;
+            return _jsx(ValidateView, { state: state, status: status });
+        }
+        case ComponentName.Refinement: {
+            const { props: { text }, status, } = def;
+            return _jsx(RefinementView, { text: text, status: status });
+        }
+        default:
+            throw new Error(`Unknown managed component: ${def.name}`);
+    }
+});
+/**
+ * Render a component in the timeline (Views only for managed, as-is for simple)
+ */
+export const TimelineComponent = ({ def, }) => {
+    switch (def.name) {
+        // Simple components render as-is
         case ComponentName.Welcome:
-            return _jsx(Welcome, { ...def.props, status: def.status });
-        case ComponentName.Config:
-            return (_jsx(Config, { ...def.props, state: def.state, status: def.status, debug: debug }));
-        case ComponentName.Command:
-            return _jsx(Command, { ...def.props, state: def.state, status: def.status });
-        case ComponentName.Schedule:
-            return (_jsx(Schedule, { ...def.props, state: def.state, status: def.status, debug: debug }));
         case ComponentName.Feedback:
-            return _jsx(Feedback, { ...def.props, status: def.status });
         case ComponentName.Message:
-            return _jsx(Message, { ...def.props, status: def.status });
         case ComponentName.Debug:
-            return _jsx(Debug, { ...def.props, status: def.status });
-        case ComponentName.Refinement:
-            return (_jsx(Refinement, { ...def.props, state: def.state, status: def.status }));
-        case ComponentName.Confirm:
-            return _jsx(Confirm, { ...def.props, state: def.state, status: def.status });
-        case ComponentName.Introspect:
-            return (_jsx(Introspect, { ...def.props, state: def.state, status: def.status, debug: debug }));
         case ComponentName.Report:
-            return _jsx(Report, { ...def.props, status: def.status });
-        case ComponentName.Answer:
-            return _jsx(Answer, { ...def.props, state: def.state, status: def.status });
-        case ComponentName.Execute:
-            return _jsx(Execute, { ...def.props, state: def.state, status: def.status });
+            return _jsx(SimpleComponent, { def: def });
+        // Managed components render as Views
+        case ComponentName.Config:
+        case ComponentName.Command:
+        case ComponentName.Confirm:
+        case ComponentName.Schedule:
+        case ComponentName.Refinement:
         case ComponentName.Validate:
-            return (_jsx(Validate, { ...def.props, state: def.state, status: def.status, debug: debug }));
+        case ComponentName.Execute:
+        case ComponentName.Answer:
+        case ComponentName.Introspect:
+            return _jsx(ViewComponent, { def: def });
+        default:
+            throw new Error('Unknown component type');
     }
-});
+};