prompt-language-shell 0.4.0 → 0.4.4

package/dist/ui/Main.js

@@ -1,12 +1,18 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import React from 'react';
 import { useInput } from 'ink';
-import { ComponentName, FeedbackType, TaskType, } from '../types/types.js';
+import { FeedbackType } from '../types/types.js';
 import { createAnthropicService, } from '../services/anthropic.js';
-import { getConfigurationRequiredMessage, hasValidAnthropicKey, loadConfig, loadDebugSetting, saveAnthropicConfig, saveDebugSetting, } from '../services/config.js';
-import { FeedbackMessages, getCancellationMessage, getRefiningMessage, } from '../services/messages.js';
-import { createCommandDefinition, createConfirmDefinition, createConfigDefinition, createFeedback, createMessage, createRefinement, createPlanDefinition, createWelcomeDefinition, isStateless, markAsDone, } from '../services/components.js';
+import { getConfigurationRequiredMessage, hasValidAnthropicKey, loadConfig, loadDebugSetting, saveDebugSetting, } from '../services/configuration.js';
+import { getCancellationMessage } from '../services/messages.js';
+import { createCommandDefinition, createConfigDefinition, createFeedback, createMessage, createWelcomeDefinition, isStateless, markAsDone, } from '../services/components.js';
 import { exitApp } from '../services/process.js';
+import { createAnswerAbortedHandler, createAnswerCompleteHandler, createAnswerErrorHandler, } from '../handlers/answer.js';
+import { createCommandAbortedHandler, createCommandCompleteHandler, createCommandErrorHandler, } from '../handlers/command.js';
+import { createConfigAbortedHandler, createConfigFinishedHandler, } from '../handlers/config.js';
+import { createExecutionCancelledHandler, createExecutionConfirmedHandler, } from '../handlers/execution.js';
+import { createIntrospectAbortedHandler, createIntrospectCompleteHandler, createIntrospectErrorHandler, } from '../handlers/introspect.js';
+import { createPlanAbortedHandler, createPlanAbortHandlerFactory, createPlanSelectionConfirmedHandler, } from '../handlers/plan.js';
 import { Column } from './Column.js';
 export const Main = ({ app, command }) => {
     // Initialize service from existing config if available
@@ -52,18 +58,7 @@ export const Main = ({ app, command }) => {
             return currentQueue;
         });
     }, [addToTimeline]);
-    const handleCommandError = React.useCallback((error) => {
-        setQueue((currentQueue) => {
-            if (currentQueue.length === 0)
-                return currentQueue;
-            const [first] = currentQueue;
-            if (first.name === ComponentName.Command) {
-                addToTimeline(markAsDone(first), createFeedback(FeedbackType.Failed, FeedbackMessages.UnexpectedError, error));
-            }
-            exitApp(1);
-            return [];
-        });
-    }, [addToTimeline]);
+    const handleCommandError = React.useCallback((error) => setQueue(createCommandErrorHandler(addToTimeline)(error)), [addToTimeline]);
     const handleAborted = React.useCallback((operationName) => {
         setQueue((currentQueue) => {
             if (currentQueue.length === 0)
@@ -76,117 +71,31 @@ export const Main = ({ app, command }) => {
             return [];
         });
     }, [addToTimeline]);
-    const handleConfigAborted = React.useCallback(() => {
-        handleAborted('Configuration');
-    }, [handleAborted]);
-    const handlePlanAborted = React.useCallback(() => {
-        handleAborted('Task selection');
-    }, [handleAborted]);
-    const createPlanAbortHandler = React.useCallback((tasks) => {
-        const allIntrospect = tasks.every((task) => task.type === TaskType.Introspect);
-        if (allIntrospect) {
-            return () => handleAborted('Introspection');
-        }
-        return handlePlanAborted;
-    }, [handleAborted, handlePlanAborted]);
-    const handleCommandAborted = React.useCallback(() => {
-        handleAborted('Request');
-    }, [handleAborted]);
+    const handleConfigAborted = React.useCallback(createConfigAbortedHandler(handleAborted), [handleAborted]);
+    const handlePlanAborted = React.useCallback(createPlanAbortedHandler(handleAborted), [handleAborted]);
+    const createPlanAbortHandler = React.useCallback(createPlanAbortHandlerFactory(handleAborted, handlePlanAborted), [handleAborted, handlePlanAborted]);
+    const handleCommandAborted = React.useCallback(createCommandAbortedHandler(handleAborted), [handleAborted]);
     const handleRefinementAborted = React.useCallback(() => {
         handleAborted('Plan refinement');
     }, [handleAborted]);
-    const handleExecutionConfirmed = React.useCallback(() => {
-        setQueue((currentQueue) => {
-            if (currentQueue.length === 0)
-                return currentQueue;
-            const [first] = currentQueue;
-            if (first.name === ComponentName.Confirm) {
-                addToTimeline(markAsDone(first));
-            }
-            exitApp(0);
-            return [];
-        });
-    }, [addToTimeline]);
-    const handleExecutionCancelled = React.useCallback(() => {
-        setQueue((currentQueue) => {
-            if (currentQueue.length === 0)
-                return currentQueue;
-            const [first] = currentQueue;
-            if (first.name === ComponentName.Confirm) {
-                // Find the most recent Plan in timeline to check task types
-                const currentTimeline = timelineRef.current;
-                const lastPlanIndex = [...currentTimeline]
-                    .reverse()
-                    .findIndex((item) => item.name === ComponentName.Plan);
-                const lastPlan = lastPlanIndex >= 0
-                    ? currentTimeline[currentTimeline.length - 1 - lastPlanIndex]
-                    : null;
-                const allIntrospect = lastPlan &&
-                    lastPlan.name === ComponentName.Plan &&
-                    'props' in lastPlan &&
-                    lastPlan.props &&
-                    'tasks' in lastPlan.props &&
-                    Array.isArray(lastPlan.props.tasks) &&
-                    lastPlan.props.tasks.every((task) => task.type === TaskType.Introspect);
-                const operation = allIntrospect ? 'introspection' : 'execution';
-                addToTimeline(markAsDone(first), createFeedback(FeedbackType.Aborted, getCancellationMessage(operation)));
-            }
-            exitApp(0);
-            return [];
-        });
-    }, [addToTimeline]);
-    const handlePlanSelectionConfirmed = React.useCallback(async (selectedTasks) => {
-        // Mark current plan as done and add refinement to queue
-        let refinementDef = null;
-        refinementDef = createRefinement(getRefiningMessage(), handleRefinementAborted);
-        setQueue((currentQueue) => {
-            if (currentQueue.length === 0)
-                return currentQueue;
-            const [first] = currentQueue;
-            if (first.name === ComponentName.Plan) {
-                addToTimeline(markAsDone(first));
-            }
-            // Add refinement to queue so it becomes the active component
-            return [refinementDef];
-        });
-        // Process refined command in background
-        try {
-            const refinedCommand = selectedTasks
-                .map((task) => {
-                const action = task.action.toLowerCase().replace(/,/g, ' -');
-                const type = task.type || 'execute';
-                return `${action} (type: ${type})`;
-            })
-                .join(', ');
-            const result = await service.processWithTool(refinedCommand, 'plan');
-            // Mark refinement as done and move to timeline
-            setQueue((currentQueue) => {
-                if (currentQueue.length > 0 &&
-                    currentQueue[0].id === refinementDef.id) {
-                    addToTimeline(markAsDone(currentQueue[0]));
-                }
-                return [];
-            });
-            // Show final execution plan with confirmation
-            const planDefinition = createPlanDefinition(result.message, result.tasks, createPlanAbortHandler(result.tasks), undefined);
-            const confirmDefinition = createConfirmDefinition(handleExecutionConfirmed, handleExecutionCancelled);
-            addToTimeline(planDefinition);
-            setQueue([confirmDefinition]);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            // Mark refinement as done and move to timeline before showing error
-            setQueue((currentQueue) => {
-                if (currentQueue.length > 0 &&
-                    currentQueue[0].id === refinementDef.id) {
-                    addToTimeline(markAsDone(currentQueue[0]));
-                }
-                return [];
-            });
-            addToTimeline(createFeedback(FeedbackType.Failed, FeedbackMessages.UnexpectedError, errorMessage));
-            exitApp(1);
-        }
-    }, [
+    const handleIntrospectAborted = React.useCallback(createIntrospectAbortedHandler(handleAborted), [handleAborted]);
+    const handleIntrospectError = React.useCallback((error) => setQueue(createIntrospectErrorHandler(addToTimeline)(error)), [addToTimeline]);
+    const handleIntrospectComplete = React.useCallback((message, capabilities) => setQueue(createIntrospectCompleteHandler(addToTimeline)(message, capabilities)), [addToTimeline]);
+    const handleAnswerAborted = React.useCallback(createAnswerAbortedHandler(handleAborted), [handleAborted]);
+    const handleAnswerError = React.useCallback((error) => setQueue(createAnswerErrorHandler(addToTimeline)(error)), [addToTimeline]);
+    const handleAnswerComplete = React.useCallback((answer) => setQueue(createAnswerCompleteHandler(addToTimeline)(answer)), [addToTimeline]);
+    const handleExecutionConfirmed = React.useCallback(() => setQueue(createExecutionConfirmedHandler(timelineRef, addToTimeline, service, handleIntrospectError, handleIntrospectComplete, handleIntrospectAborted, handleAnswerError, handleAnswerComplete, handleAnswerAborted)()), [
+        addToTimeline,
+        service,
+        handleIntrospectError,
+        handleIntrospectComplete,
+        handleIntrospectAborted,
+        handleAnswerError,
+        handleAnswerComplete,
+        handleAnswerAborted,
+    ]);
+    const handleExecutionCancelled = React.useCallback(() => setQueue(createExecutionCancelledHandler(timelineRef, addToTimeline)()), [addToTimeline]);
+    const handlePlanSelectionConfirmed = React.useCallback(createPlanSelectionConfirmedHandler(addToTimeline, service, handleRefinementAborted, createPlanAbortHandler, handleExecutionConfirmed, handleExecutionCancelled, setQueue), [
         addToTimeline,
         service,
         handleRefinementAborted,
@@ -194,62 +103,20 @@ export const Main = ({ app, command }) => {
         handleExecutionConfirmed,
         handleExecutionCancelled,
     ]);
-    const handleCommandComplete = React.useCallback((message, tasks) => {
-        setQueue((currentQueue) => {
-            if (currentQueue.length === 0)
-                return currentQueue;
-            const [first] = currentQueue;
-            // Check if tasks contain a Define task that requires user interaction
-            const hasDefineTask = tasks.some((task) => task.type === TaskType.Define);
-            if (first.name === ComponentName.Command) {
-                const planDefinition = createPlanDefinition(message, tasks, createPlanAbortHandler(tasks), hasDefineTask ? handlePlanSelectionConfirmed : undefined);
-                if (hasDefineTask) {
-                    // Don't exit - keep the plan in the queue for interaction
-                    addToTimeline(markAsDone(first));
-                    return [planDefinition];
-                }
-                else {
-                    // No define task - show plan and confirmation
-                    const confirmDefinition = createConfirmDefinition(handleExecutionConfirmed, handleExecutionCancelled);
-                    addToTimeline(markAsDone(first), planDefinition);
-                    return [confirmDefinition];
-                }
-            }
-            exitApp(0);
-            return [];
-        });
-    }, [
+    const handleCommandComplete = React.useCallback((message, tasks) => setQueue(createCommandCompleteHandler(addToTimeline, createPlanAbortHandler, handlePlanSelectionConfirmed, handleExecutionConfirmed, handleExecutionCancelled)(message, tasks)), [
         addToTimeline,
         createPlanAbortHandler,
         handlePlanSelectionConfirmed,
         handleExecutionConfirmed,
         handleExecutionCancelled,
     ]);
-    const handleConfigFinished = React.useCallback((config) => {
-        const anthropicConfig = config;
-        saveAnthropicConfig(anthropicConfig);
-        const newService = createAnthropicService(anthropicConfig);
-        setService(newService);
-        // Complete config component and add command if present
-        setQueue((currentQueue) => {
-            if (currentQueue.length === 0)
-                return currentQueue;
-            const [first, ...rest] = currentQueue;
-            if (first.name === ComponentName.Config) {
-                addToTimeline(markAsDone(first), createFeedback(FeedbackType.Succeeded, FeedbackMessages.ConfigurationComplete));
-            }
-            // Add command to queue if we have one
-            if (command) {
-                return [
-                    ...rest,
-                    createCommandDefinition(command, newService, handleCommandError, handleCommandComplete, handleCommandAborted),
-                ];
-            }
-            // No command - exit after showing completion message
-            exitApp(0);
-            return rest;
-        });
-    }, [addToTimeline, command, handleCommandError, handleCommandComplete]);
+    const handleConfigFinished = React.useCallback((config) => setQueue(createConfigFinishedHandler(addToTimeline, command, handleCommandError, handleCommandComplete, handleCommandAborted, setService)(config)), [
+        addToTimeline,
+        command,
+        handleCommandError,
+        handleCommandComplete,
+        handleCommandAborted,
+    ]);
     // Initialize queue on mount
     React.useEffect(() => {
         const hasConfig = !!service;

package/dist/ui/Plan.js

@@ -1,23 +1,24 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
 import { Box, useInput } from 'ink';
-import { TaskColors } from '../types/colors.js';
 import { TaskType } from '../types/types.js';
+import { getTaskColors } from '../services/colors.js';
 import { Label } from './Label.js';
 import { List } from './List.js';
-function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutSelection = false) {
+function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutSelection = false, isCurrent = false) {
+    const taskColors = getTaskColors(task.type, isCurrent);
     const item = {
         description: {
             text: task.action,
-            color: TaskColors[task.type].description,
+            color: taskColors.description,
         },
-        type: { text: task.type, color: TaskColors[task.type].type },
+        type: { text: task.type, color: taskColors.type },
         children: [],
     };
     // Mark define tasks with right arrow when no selection has been made
     if (isDefineTaskWithoutSelection) {
         item.marker = '  → ';
-        item.markerColor = TaskColors[TaskType.Plan].type;
+        item.markerColor = getTaskColors(TaskType.Plan, isCurrent).type;
     }
     // Add children for Define tasks with options
     if (task.type === TaskType.Define && Array.isArray(task.params?.options)) {
@@ -29,17 +30,18 @@ function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutS
                 childType =
                     index === highlightedChildIndex ? TaskType.Execute : TaskType.Discard;
             }
-            const colors = TaskColors[childType];
+            const colors = getTaskColors(childType, isCurrent);
+            const planColors = getTaskColors(TaskType.Plan, isCurrent);
             return {
                 description: {
                     text: String(option),
                     color: colors.description,
-                    highlightedColor: TaskColors[TaskType.Plan].description,
+                    highlightedColor: planColors.description,
                 },
                 type: {
                     text: childType,
                     color: colors.type,
-                    highlightedColor: TaskColors[TaskType.Plan].type,
+                    highlightedColor: planColors.type,
                 },
             };
         });
@@ -143,6 +145,7 @@ export function Plan({ message, tasks, state, debug = false, onSelectionConfirme
         isDone,
         state,
     ]);
+    const isCurrent = isDone === false;
     const listItems = tasks.map((task, idx) => {
         // Find which define group this task belongs to (if any)
         const defineGroupIndex = defineTaskIndices.indexOf(idx);
@@ -170,7 +173,7 @@ export function Plan({ message, tasks, state, debug = false, onSelectionConfirme
             defineGroupIndex === currentDefineGroupIndex &&
             highlightedIndex === null &&
             !isDone;
-        return taskToListItem(task, childIndex, isDefineWithoutSelection);
+        return taskToListItem(task, childIndex, isDefineWithoutSelection, isCurrent);
     });
-    return (_jsxs(Box, { flexDirection: "column", children: [message && (_jsx(Box, { marginBottom: 1, children: _jsx(Label, { description: message, descriptionColor: TaskColors[TaskType.Plan].description, type: TaskType.Plan, typeColor: TaskColors[TaskType.Plan].type, showType: debug }) })), _jsx(List, { items: listItems, highlightedIndex: currentDefineTaskIndex >= 0 ? highlightedIndex : null, highlightedParentIndex: currentDefineTaskIndex, showType: debug })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [message && (_jsx(Box, { marginBottom: 1, children: _jsx(Label, { description: message, taskType: TaskType.Plan, showType: debug, isCurrent: isCurrent }) })), _jsx(List, { items: listItems, highlightedIndex: currentDefineTaskIndex >= 0 ? highlightedIndex : null, highlightedParentIndex: currentDefineTaskIndex, showType: debug })] }));
 }

package/dist/ui/Report.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+const COLORS = {
+    BuiltIn: '#5c9ccc', // blue - for built-in capabilities
+    UserDefined: '#5aaa8a', // green - for user-defined skills
+};
+function CapabilityItem({ name, description, isBuiltIn }) {
+    const color = isBuiltIn ? COLORS.BuiltIn : COLORS.UserDefined;
+    return (_jsxs(Box, { children: [_jsx(Text, { children: "- " }), _jsx(Text, { color: color, children: name }), _jsxs(Text, { children: [" - ", description] })] }));
+}
+export function Report({ message, capabilities }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: message }), _jsx(Box, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: capabilities.map((capability, index) => (_jsx(CapabilityItem, { name: capability.name, description: capability.description, isBuiltIn: capability.isBuiltIn }, index))) })] }));
+}

package/dist/ui/Separator.js

@@ -1,6 +1,6 @@
 import { jsxs as _jsxs } from "react/jsx-runtime";
 import { Text } from 'ink';
-import { Colors } from '../types/colors.js';
+import { Colors } from '../services/colors.js';
 export const Separator = ({ color = Colors.Label.Discarded, spaces = 1, }) => {
     const spacing = ' '.repeat(spaces);
     return (_jsxs(Text, { color: color, children: [spacing, "\u203A", spacing] }));

package/package.json

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