prompt-language-shell 0.8.4 → 0.8.8

package/dist/ui/Feedback.js

@@ -1,5 +1,6 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
+import { ComponentStatus } from '../types/components.js';
 import { FeedbackType } from '../types/types.js';
 import { getFeedbackColor } from '../services/colors.js';
 function getSymbol(type) {
@@ -12,7 +13,7 @@ function getSymbol(type) {
     }[type];
 }
 export function Feedback({ type, message }) {
-    const color = getFeedbackColor(type, false);
+    const color = getFeedbackColor(type, ComponentStatus.Done);
     const symbol = getSymbol(type);
     return (_jsx(Box, { marginLeft: 1, children: _jsxs(Text, { color: color, children: [symbol, " ", message] }) }));
 }

package/dist/ui/Introspect.js

@@ -1,22 +1,35 @@
 import { jsx as _jsx, jsxs as _jsxs } 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 { createReportDefinition } from '../services/components.js';
-import { DebugLevel } from '../services/configuration.js';
+import { DebugLevel } from '../configuration/types.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 Introspect({ tasks, state: _state, status, service, children, debug = DebugLevel.None, stateHandlers, lifecycleHandlers, queueHandlers, errorHandlers, workflowHandlers, }) {
+export const IntrospectView = ({ state, status, children, }) => {
+    const isActive = status === ComponentStatus.Active;
+    const { error } = state;
+    // Don't render wrapper when done and nothing to show
+    if (!isActive && !error && !children) {
+        return null;
+    }
+    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isActive && (_jsxs(Box, { marginLeft: 1, children: [_jsx(Text, { color: getTextColor(isActive), children: "Listing capabilities. " }), _jsx(Spinner, {})] })), error && (_jsx(Box, { marginTop: 1, marginLeft: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) })), children] }));
+};
+/**
+ * Introspect controller: Lists capabilities via LLM
+ */
+export function Introspect({ tasks, status, service, children, debug = DebugLevel.None, requestHandlers, lifecycleHandlers, workflowHandlers, }) {
     const isActive = status === ComponentStatus.Active;
-    // isActive passed as prop
     const [error, setError] = useState(null);
+    const [capabilities, setCapabilities] = useState(null);
+    const [message, setMessage] = useState(null);
     useInput((input, key) => {
         if (key.escape && isActive) {
-            errorHandlers?.onAborted('introspection');
+            requestHandlers.onAborted('introspection');
         }
     }, { isActive });
     useEffect(() => {
@@ -36,25 +49,28 @@ export function Introspect({ tasks, state: _state, status, service, children, de
                 if (mounted) {
                     // Add debug components to timeline if present
                     if (result.debug?.length) {
-                        workflowHandlers?.addToTimeline(...result.debug);
+                        workflowHandlers.addToTimeline(...result.debug);
                     }
                     // Capabilities come directly from result - no parsing needed
-                    let capabilities = result.capabilities;
+                    let caps = result.capabilities;
                     // Filter out internal capabilities when not in debug mode
                     if (debug === DebugLevel.None) {
-                        capabilities = capabilities.filter((cap) => cap.name.toUpperCase() !== 'SCHEDULE' &&
+                        caps = caps.filter((cap) => cap.name.toUpperCase() !== 'SCHEDULE' &&
                             cap.name.toUpperCase() !== 'VALIDATE' &&
                             cap.name.toUpperCase() !== 'REPORT');
                     }
-                    // Save state before completing
-                    stateHandlers?.updateState({
-                        capabilities,
+                    setCapabilities(caps);
+                    setMessage(result.message);
+                    const finalState = {
+                        error: null,
+                        capabilities: caps,
                         message: result.message,
-                    });
+                    };
+                    requestHandlers.onCompleted(finalState);
                     // Add Report component to queue
-                    queueHandlers?.addToQueue(createReportDefinition(result.message, capabilities));
+                    workflowHandlers.addToQueue(createReportDefinition(result.message, caps));
                     // Signal completion
-                    lifecycleHandlers?.completeActive();
+                    lifecycleHandlers.completeActive();
                 }
             }
             catch (err) {
@@ -62,11 +78,13 @@ export function Introspect({ tasks, state: _state, status, service, children, de
                 if (mounted) {
                     const errorMessage = formatErrorMessage(err);
                     setError(errorMessage);
-                    // Save error state
-                    stateHandlers?.updateState({
+                    const finalState = {
                         error: errorMessage,
-                    });
-                    errorHandlers?.onError(errorMessage);
+                        capabilities: [],
+                        message: null,
+                    };
+                    requestHandlers.onCompleted(finalState);
+                    requestHandlers.onError(errorMessage);
                 }
             }
         }
@@ -74,10 +92,19 @@ export function Introspect({ tasks, state: _state, status, service, children, de
         return () => {
             mounted = false;
         };
-    }, [tasks, isActive, service, debug]);
-    // Don't render wrapper when done and nothing to show
-    if (!isActive && !error && !children) {
-        return null;
-    }
-    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isActive && (_jsxs(Box, { marginLeft: 1, children: [_jsx(Text, { color: getTextColor(isActive), children: "Listing capabilities. " }), _jsx(Spinner, {})] })), error && (_jsx(Box, { marginTop: 1, marginLeft: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) })), children] }));
+    }, [
+        tasks,
+        isActive,
+        service,
+        debug,
+        requestHandlers,
+        lifecycleHandlers,
+        workflowHandlers,
+    ]);
+    const state = {
+        error,
+        capabilities: capabilities || [],
+        message,
+    };
+    return (_jsx(IntrospectView, { state: state, status: status, children: children }));
 }

package/dist/ui/Label.js

@@ -1,9 +1,10 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import { getTaskColors, getTaskTypeLabel } from '../services/colors.js';
-import { DebugLevel } from '../services/configuration.js';
+import { DebugLevel } from '../configuration/types.js';
 import { Separator } from './Separator.js';
-export function Label({ description, taskType, showType = false, isCurrent = false, debug = DebugLevel.None, }) {
-    const colors = getTaskColors(taskType, isCurrent);
+import { ComponentStatus } from '../types/components.js';
+export function Label({ description, taskType, showType = false, status = ComponentStatus.Done, debug = DebugLevel.None, }) {
+    const colors = getTaskColors(taskType, status);
     return (_jsxs(Box, { children: [_jsx(Text, { color: colors.description, children: description }), showType && (_jsxs(_Fragment, { children: [_jsx(Separator, {}), _jsx(Text, { color: colors.type, children: getTaskTypeLabel(taskType, debug) })] }))] }));
 }

package/dist/ui/List.js

@@ -4,7 +4,8 @@ import { Palette } from '../services/colors.js';
 import { Separator } from './Separator.js';
 export const List = ({ items, level = 0, highlightedIndex = null, highlightedParentIndex = null, showType = false, }) => {
     const marginLeft = level > 0 ? 2 : 0;
-    return (_jsx(Box, { flexDirection: "column", marginLeft: marginLeft, children: items.map((item, index) => {
+    const gap = level === 0 ? 1 : 0;
+    return (_jsx(Box, { flexDirection: "column", marginLeft: marginLeft, gap: gap, children: items.map((item, index) => {
             // At level 0, track which parent is active for child highlighting
             // At level > 0, only highlight if this parent is the active one
             const shouldHighlightChildren = level === 0 ? highlightedParentIndex === index : false;
@@ -23,6 +24,6 @@ export const List = ({ items, level = 0, highlightedIndex = null, highlightedPar
                 (isHighlighted && item.type.highlightedColor
                     ? item.type.highlightedColor
                     : Palette.White);
-            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: markerColor, children: marker }), _jsx(Text, { color: descriptionColor, children: item.description.text }), showType && (_jsxs(_Fragment, { children: [_jsx(Separator, {}), _jsx(Text, { color: typeColor, children: item.type.text })] }))] }), item.children && item.children.length > 0 && (_jsx(List, { items: item.children, level: level + 1, highlightedIndex: shouldHighlightChildren ? highlightedIndex : null, showType: showType }))] }, index));
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: markerColor, children: marker }), _jsx(Text, { color: descriptionColor, children: item.description.text }), showType && (_jsxs(_Fragment, { children: [_jsx(Separator, {}), _jsx(Text, { color: typeColor, children: item.type.text })] }))] }), item.children && item.children.length > 0 && (_jsx(Box, { marginTop: 1, children: _jsx(List, { items: item.children, level: level + 1, highlightedIndex: shouldHighlightChildren ? highlightedIndex : null, showType: showType }) }))] }, index));
         }) }));
 };

package/dist/ui/Main.js

@@ -1,9 +1,13 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
+import { DebugLevel } from '../configuration/types.js';
 import { FeedbackType } from '../types/types.js';
+import { loadConfig, loadDebugSetting, saveConfig, saveDebugSetting, } from '../configuration/io.js';
+import { getConfigurationRequiredMessage } from '../configuration/messages.js';
+import { getMissingConfigKeys } from '../configuration/schema.js';
+import { unflattenConfig } from '../configuration/transformation.js';
 import { createAnthropicService } from '../services/anthropic.js';
 import { createCommandDefinition, createConfigDefinitionWithKeys, createFeedback, createMessage, createWelcomeDefinition, } from '../services/components.js';
-import { DebugLevel, getConfigurationRequiredMessage, getMissingConfigKeys, loadConfig, loadDebugSetting, saveConfig, saveDebugSetting, unflattenConfig, } from '../services/configuration.js';
 import { registerGlobalShortcut } from '../services/keyboard.js';
 import { initializeLogger, setDebugLevel } from '../services/logger.js';
 import { Workflow } from './Workflow.js';

package/dist/ui/Refinement.js

@@ -4,6 +4,13 @@ import { ComponentStatus } from '../types/components.js';
 import { useInput } from '../services/keyboard.js';
 import { Message } from './Message.js';
 import { Spinner } from './Spinner.js';
+export const RefinementView = ({ text, status }) => {
+    const isActive = status === ComponentStatus.Active;
+    return (_jsxs(Box, { gap: 1, children: [_jsx(Message, { text: text, status: status }), isActive && _jsx(Spinner, {})] }));
+};
+/**
+ * Refinement controller: Handles abort input
+ */
 export const Refinement = ({ text, status, onAborted }) => {
     const isActive = status === ComponentStatus.Active;
     useInput((_, key) => {
@@ -12,5 +19,5 @@ export const Refinement = ({ text, status, onAborted }) => {
             return;
         }
     }, { isActive });
-    return (_jsxs(Box, { gap: 1, children: [_jsx(Message, { text: text }), isActive && _jsx(Spinner, {})] }));
+    return _jsx(RefinementView, { text: text, status: status });
 };

package/dist/ui/Schedule.js

@@ -1,19 +1,24 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
 import { Box } from 'ink';
-import { ComponentStatus } from '../types/components.js';
+import { ComponentStatus, } from '../types/components.js';
 import { TaskType } from '../types/types.js';
-import { getTaskColors, getTaskTypeLabel } from '../services/colors.js';
-import { DebugLevel } from '../services/configuration.js';
+import { getTaskColors, getTaskTypeLabel, Palette, } from '../services/colors.js';
+import { DebugLevel } from '../configuration/types.js';
 import { useInput } from '../services/keyboard.js';
 import { Label } from './Label.js';
 import { List } from './List.js';
-function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutSelection = false, isCurrent = false, debug = DebugLevel.None) {
-    const taskColors = getTaskColors(task.type, isCurrent);
+export function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutSelection = false, status = ComponentStatus.Done, debug = DebugLevel.None) {
+    const taskColors = getTaskColors(task.type, status);
+    // Determine description color based on status
+    let descriptionColor = taskColors.description;
+    if (status === ComponentStatus.Pending) {
+        descriptionColor = Palette.SoftWhite;
+    }
     const item = {
         description: {
             text: task.action,
-            color: taskColors.description,
+            color: descriptionColor,
         },
         type: { text: getTaskTypeLabel(task.type, debug), color: taskColors.type },
         children: [],
@@ -21,7 +26,7 @@ function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutS
     // Mark define tasks with right arrow when no selection has been made
     if (isDefineTaskWithoutSelection) {
         item.marker = '  → ';
-        item.markerColor = getTaskColors(TaskType.Schedule, isCurrent).type;
+        item.markerColor = getTaskColors(TaskType.Schedule, status).type;
     }
     // Add children for Define tasks with options
     if (task.type === TaskType.Define && Array.isArray(task.params?.options)) {
@@ -33,8 +38,8 @@ function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutS
                 childType =
                     index === highlightedChildIndex ? TaskType.Execute : TaskType.Discard;
             }
-            const colors = getTaskColors(childType, isCurrent);
-            const planColors = getTaskColors(TaskType.Schedule, isCurrent);
+            const colors = getTaskColors(childType, status);
+            const planColors = getTaskColors(TaskType.Schedule, status);
             return {
                 description: {
                     text: option,
@@ -56,11 +61,11 @@ function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutS
         Array.isArray(scheduledTask.subtasks) &&
         scheduledTask.subtasks.length > 0) {
         item.children = scheduledTask.subtasks.map((subtask) => {
-            const subtaskColors = getTaskColors(subtask.type, isCurrent);
+            const subtaskColors = getTaskColors(subtask.type, status);
             return {
                 description: {
                     text: subtask.action,
-                    color: subtaskColors.description,
+                    color: Palette.AshGray,
                 },
                 type: {
                     text: getTaskTypeLabel(subtask.type, debug),
@@ -71,12 +76,54 @@ function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutS
     }
     return item;
 }
-export function Schedule({ message, tasks, state, status, debug = DebugLevel.None, stateHandlers, lifecycleHandlers, errorHandlers, onSelectionConfirmed, }) {
+export const ScheduleView = ({ message, tasks, state, status, debug = DebugLevel.None, }) => {
     const isActive = status === ComponentStatus.Active;
-    // isActive passed as prop
-    const [highlightedIndex, setHighlightedIndex] = useState(state?.highlightedIndex ?? null);
-    const [currentDefineGroupIndex, setCurrentDefineGroupIndex] = useState(state?.currentDefineGroupIndex ?? 0);
-    const [completedSelections, setCompletedSelections] = useState(state?.completedSelections ?? []);
+    const { highlightedIndex, currentDefineGroupIndex, completedSelections } = state;
+    // Find all Define tasks
+    const defineTaskIndices = tasks
+        .map((t, idx) => (t.type === TaskType.Define ? idx : -1))
+        .filter((idx) => idx !== -1);
+    // Get the current active define task
+    const currentDefineTaskIndex = defineTaskIndices[currentDefineGroupIndex] ?? -1;
+    const listItems = tasks.map((task, idx) => {
+        // Find which define group this task belongs to (if any)
+        const defineGroupIndex = defineTaskIndices.indexOf(idx);
+        const isDefineTask = defineGroupIndex !== -1;
+        // Determine child selection state
+        let childIndex = null;
+        if (isDefineTask) {
+            if (defineGroupIndex < currentDefineGroupIndex) {
+                // Previously completed group - show the selection
+                childIndex = completedSelections[defineGroupIndex] ?? null;
+            }
+            else if (defineGroupIndex === currentDefineGroupIndex) {
+                // Current active group - show live navigation unless not active
+                if (!isActive) {
+                    // If not active, show the completed selection for this group too
+                    childIndex = completedSelections[defineGroupIndex] ?? null;
+                }
+                else {
+                    childIndex = null;
+                }
+            }
+        }
+        // Show arrow on current active define task when no child is highlighted and is active
+        const isDefineWithoutSelection = isDefineTask &&
+            defineGroupIndex === currentDefineGroupIndex &&
+            highlightedIndex === null &&
+            isActive;
+        return taskToListItem(task, childIndex, isDefineWithoutSelection, status, debug);
+    });
+    return (_jsxs(Box, { flexDirection: "column", children: [message && (_jsx(Box, { marginBottom: 1, marginLeft: 1, children: _jsx(Label, { description: message, taskType: TaskType.Schedule, showType: debug !== DebugLevel.None, status: status, debug: debug }) })), _jsx(Box, { marginLeft: 1, children: _jsx(List, { items: listItems, highlightedIndex: currentDefineTaskIndex >= 0 ? highlightedIndex : null, highlightedParentIndex: currentDefineTaskIndex, showType: debug !== DebugLevel.None }) })] }));
+};
+/**
+ * Schedule controller: Manages task selection and navigation
+ */
+export function Schedule({ message, tasks, status, debug = DebugLevel.None, requestHandlers, lifecycleHandlers, onSelectionConfirmed, }) {
+    const isActive = status === ComponentStatus.Active;
+    const [highlightedIndex, setHighlightedIndex] = useState(null);
+    const [currentDefineGroupIndex, setCurrentDefineGroupIndex] = useState(0);
+    const [completedSelections, setCompletedSelections] = useState([]);
     // Find all Define tasks
     const defineTaskIndices = tasks
         .map((t, idx) => (t.type === TaskType.Define ? idx : -1))
@@ -93,9 +140,16 @@ export function Schedule({ message, tasks, state, status, debug = DebugLevel.Non
         if (isActive && defineTaskIndices.length === 0 && onSelectionConfirmed) {
             // No selection needed - all tasks are concrete
             const concreteTasks = tasks.filter((task) => task.type !== TaskType.Ignore && task.type !== TaskType.Discard);
+            // Expose final state
+            const finalState = {
+                highlightedIndex,
+                currentDefineGroupIndex,
+                completedSelections,
+            };
+            requestHandlers.onCompleted(finalState);
             // Complete the selection phase - it goes to timeline
             // Callback will create a new Plan showing refined tasks (pending) + Confirm (active)
-            lifecycleHandlers?.completeActive();
+            lifecycleHandlers.completeActive();
             void onSelectionConfirmed(concreteTasks);
         }
     }, [
@@ -104,6 +158,10 @@ export function Schedule({ message, tasks, state, status, debug = DebugLevel.Non
         tasks,
         onSelectionConfirmed,
         lifecycleHandlers,
+        highlightedIndex,
+        currentDefineGroupIndex,
+        completedSelections,
+        requestHandlers,
     ]);
     useInput((input, key) => {
         // Don't handle input if not active or no define task
@@ -111,7 +169,7 @@ export function Schedule({ message, tasks, state, status, debug = DebugLevel.Non
             return;
         }
         if (key.escape) {
-            errorHandlers?.onAborted('task selection');
+            requestHandlers.onAborted('task selection');
             return;
         }
         if (key.downArrow) {
@@ -167,61 +225,31 @@ export function Schedule({ message, tasks, state, status, debug = DebugLevel.Non
                         refinedTasks.push(task);
                     }
                 });
+                // Expose final state
+                const finalState = {
+                    highlightedIndex: null,
+                    currentDefineGroupIndex,
+                    completedSelections: newCompletedSelections,
+                };
+                requestHandlers.onCompleted(finalState);
                 if (onSelectionConfirmed) {
                     // Complete the selection phase - it goes to timeline
                     // Callback will create a new Plan showing refined tasks (pending) + Confirm (active)
-                    lifecycleHandlers?.completeActive();
+                    lifecycleHandlers.completeActive();
                     void onSelectionConfirmed(refinedTasks);
                 }
                 else {
                     // No selection callback, just complete normally
-                    lifecycleHandlers?.completeActive();
+                    lifecycleHandlers.completeActive();
                 }
             }
         }
     }, { isActive: isActive && defineTask !== null });
-    // Sync state back to component definition
-    // This ensures timeline can render historical state and tests can validate behavior
-    useEffect(() => {
-        stateHandlers?.updateState({
-            highlightedIndex,
-            currentDefineGroupIndex,
-            completedSelections,
-        });
-    }, [
+    // Controller always renders View, passing current state
+    const state = {
         highlightedIndex,
         currentDefineGroupIndex,
         completedSelections,
-        stateHandlers,
-    ]);
-    const listItems = tasks.map((task, idx) => {
-        // Find which define group this task belongs to (if any)
-        const defineGroupIndex = defineTaskIndices.indexOf(idx);
-        const isDefineTask = defineGroupIndex !== -1;
-        // Determine child selection state
-        let childIndex = null;
-        if (isDefineTask) {
-            if (defineGroupIndex < currentDefineGroupIndex) {
-                // Previously completed group - show the selection
-                childIndex = completedSelections[defineGroupIndex] ?? null;
-            }
-            else if (defineGroupIndex === currentDefineGroupIndex) {
-                // Current active group - show live navigation unless not active
-                if (!isActive) {
-                    // If not active, show the completed selection for this group too
-                    childIndex = completedSelections[defineGroupIndex] ?? null;
-                }
-                else {
-                    childIndex = null;
-                }
-            }
-        }
-        // Show arrow on current active define task when no child is highlighted and is active
-        const isDefineWithoutSelection = isDefineTask &&
-            defineGroupIndex === currentDefineGroupIndex &&
-            highlightedIndex === null &&
-            isActive;
-        return taskToListItem(task, childIndex, isDefineWithoutSelection, isActive, debug);
-    });
-    return (_jsxs(Box, { flexDirection: "column", children: [message && (_jsx(Box, { marginBottom: 1, marginLeft: 1, children: _jsx(Label, { description: message, taskType: TaskType.Schedule, showType: debug !== DebugLevel.None, isCurrent: isActive, debug: debug }) })), _jsx(Box, { marginLeft: 1, children: _jsx(List, { items: listItems, highlightedIndex: currentDefineTaskIndex >= 0 ? highlightedIndex : null, highlightedParentIndex: currentDefineTaskIndex, showType: debug !== DebugLevel.None }) })] }));
+    };
+    return (_jsx(ScheduleView, { message: message, tasks: tasks, state: state, status: status, debug: debug }));
 }