prompt-language-shell 0.4.0 → 0.4.4

package/dist/services/components.js

@@ -1,6 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { ComponentName } from '../types/types.js';
-import { AnthropicModel, isValidAnthropicApiKey, isValidAnthropicModel, } from './config.js';
+import { AnthropicModel, isValidAnthropicApiKey, isValidAnthropicModel, } from './configuration.js';
 import { getConfirmationMessage } from './messages.js';
 import { StepType } from '../ui/Config.js';
 export function markAsDone(component) {
@@ -125,6 +125,59 @@ export function createConfirmDefinition(onConfirmed, onCancelled) {
         },
     };
 }
+export function createIntrospectDefinition(tasks, service, onError, onComplete, onAborted) {
+    return {
+        id: randomUUID(),
+        name: ComponentName.Introspect,
+        state: {
+            done: false,
+            isLoading: true,
+        },
+        props: {
+            tasks,
+            service,
+            onError,
+            onComplete,
+            onAborted,
+        },
+    };
+}
+export function createReportDefinition(message, capabilities) {
+    return {
+        id: randomUUID(),
+        name: ComponentName.Report,
+        props: {
+            message,
+            capabilities,
+        },
+    };
+}
+export function createAnswerDefinition(question, service, onError, onComplete, onAborted) {
+    return {
+        id: randomUUID(),
+        name: ComponentName.Answer,
+        state: {
+            done: false,
+            isLoading: true,
+        },
+        props: {
+            question,
+            service,
+            onError,
+            onComplete,
+            onAborted,
+        },
+    };
+}
+export function createAnswerDisplayDefinition(answer) {
+    return {
+        id: randomUUID(),
+        name: ComponentName.AnswerDisplay,
+        props: {
+            answer,
+        },
+    };
+}
 export function isStateless(component) {
     return !('state' in component);
 }

package/dist/services/queue.js

@@ -0,0 +1,52 @@
+import { FeedbackType } from '../types/types.js';
+import { createFeedback, markAsDone } from './components.js';
+import { FeedbackMessages } from './messages.js';
+import { exitApp } from './process.js';
+/**
+ * Higher-order function that wraps queue handler logic with common patterns:
+ * - Check if queue is empty
+ * - Extract first element
+ * - Optionally check component name
+ * - Execute callback with first element
+ * - Return new queue state
+ */
+export function withQueueHandler(componentName, callback, shouldExit = false, exitCode = 0) {
+    return (currentQueue) => {
+        if (currentQueue.length === 0)
+            return currentQueue;
+        const [first, ...rest] = currentQueue;
+        // If componentName is specified, check if it matches
+        if (componentName && first.name !== componentName) {
+            if (shouldExit) {
+                exitApp(exitCode);
+            }
+            return [];
+        }
+        // Execute callback with first and rest
+        const result = callback(first, rest);
+        // Exit if specified
+        if (shouldExit) {
+            exitApp(exitCode);
+        }
+        // Return result or empty queue
+        return result || [];
+    };
+}
+/**
+ * Creates a generic error handler for a component
+ */
+export function createErrorHandler(componentName, addToTimeline) {
+    return (error) => withQueueHandler(componentName, (first) => {
+        addToTimeline(markAsDone(first), createFeedback(FeedbackType.Failed, FeedbackMessages.UnexpectedError, error));
+        return undefined;
+    }, true, 1);
+}
+/**
+ * Creates a generic completion handler for a component
+ */
+export function createCompletionHandler(componentName, addToTimeline, onComplete) {
+    return withQueueHandler(componentName, (first) => {
+        onComplete(first);
+        return undefined;
+    }, true, 0);
+}

package/dist/services/tool-registry.js

@@ -33,6 +33,7 @@ class ToolRegistry {
 // Create singleton instance
 export const toolRegistry = new ToolRegistry();
 // Register built-in tools
+import { answerTool } from '../tools/answer.tool.js';
 import { introspectTool } from '../tools/introspect.tool.js';
 import { planTool } from '../tools/plan.tool.js';
 toolRegistry.register('plan', {
@@ -43,3 +44,7 @@ toolRegistry.register('introspect', {
     schema: introspectTool,
     instructionsPath: 'config/INTROSPECT.md',
 });
+toolRegistry.register('answer', {
+    schema: answerTool,
+    instructionsPath: 'config/ANSWER.md',
+});

package/dist/tools/answer.tool.js

@@ -0,0 +1,18 @@
+export const answerTool = {
+    name: 'answer',
+    description: 'Answer questions and provide up-to-date information using web search. Called after PLAN has identified an answer request and user has confirmed. Searches the web for current data and provides concise, helpful responses formatted for terminal display.',
+    input_schema: {
+        type: 'object',
+        properties: {
+            question: {
+                type: 'string',
+                description: 'The question or information request from the user. Should be a clear, complete question.',
+            },
+            answer: {
+                type: 'string',
+                description: 'The answer to the question. Must be concise and well-formatted. Maximum 4 lines of text, each line maximum 80 characters. Use natural line breaks for readability.',
+            },
+        },
+        required: ['question', 'answer'],
+    },
+};

package/dist/types/types.js

@@ -8,6 +8,10 @@ export var ComponentName;
     ComponentName["Refinement"] = "refinement";
     ComponentName["Feedback"] = "feedback";
     ComponentName["Confirm"] = "confirm";
+    ComponentName["Introspect"] = "introspect";
+    ComponentName["Report"] = "report";
+    ComponentName["Answer"] = "answer";
+    ComponentName["AnswerDisplay"] = "answerDisplay";
 })(ComponentName || (ComponentName = {}));
 export var TaskType;
 (function (TaskType) {

package/dist/ui/Answer.js

@@ -0,0 +1,71 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { getTextColor } from '../services/colors.js';
+import { Spinner } from './Spinner.js';
+const MIN_PROCESSING_TIME = 1000;
+export function Answer({ question, state, service, onError, onComplete, onAborted, }) {
+    const done = state?.done ?? false;
+    const isCurrent = done === false;
+    const [error, setError] = useState(null);
+    const [isLoading, setIsLoading] = useState(state?.isLoading ?? !done);
+    useInput((input, key) => {
+        if (key.escape && isLoading && !done) {
+            setIsLoading(false);
+            onAborted();
+        }
+    }, { isActive: isLoading && !done });
+    useEffect(() => {
+        // Skip processing if done
+        if (done) {
+            return;
+        }
+        // Skip processing if no service available
+        if (!service) {
+            setError('No service available');
+            setIsLoading(false);
+            return;
+        }
+        let mounted = true;
+        async function process(svc) {
+            const startTime = Date.now();
+            try {
+                // Call answer tool
+                const result = await svc.processWithTool(question, 'answer');
+                const elapsed = Date.now() - startTime;
+                const remainingTime = Math.max(0, MIN_PROCESSING_TIME - elapsed);
+                await new Promise((resolve) => setTimeout(resolve, remainingTime));
+                if (mounted) {
+                    // Extract answer from result
+                    const answer = result.answer || '';
+                    setIsLoading(false);
+                    onComplete?.(answer);
+                }
+            }
+            catch (err) {
+                const elapsed = Date.now() - startTime;
+                const remainingTime = Math.max(0, MIN_PROCESSING_TIME - elapsed);
+                await new Promise((resolve) => setTimeout(resolve, remainingTime));
+                if (mounted) {
+                    const errorMessage = err instanceof Error ? err.message : 'Unknown error occurred';
+                    setIsLoading(false);
+                    if (onError) {
+                        onError(errorMessage);
+                    }
+                    else {
+                        setError(errorMessage);
+                    }
+                }
+            }
+        }
+        process(service);
+        return () => {
+            mounted = false;
+        };
+    }, [question, done, service, onComplete, onError]);
+    // Return null when done (like Introspect)
+    if (done || (!isLoading && !error)) {
+        return null;
+    }
+    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isLoading && (_jsxs(Box, { children: [_jsx(Text, { color: getTextColor(isCurrent), children: "Finding answer. " }), _jsx(Spinner, {})] })), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "red", children: ["Error: ", error] }) }))] }));
+}

package/dist/ui/AnswerDisplay.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { Colors } from '../services/colors.js';
+export function AnswerDisplay({ answer }) {
+    // Split answer into lines and display with indentation
+    const lines = answer.split('\n');
+    return (_jsx(Box, { flexDirection: "column", paddingLeft: 2, children: lines.map((line, index) => (_jsx(Text, { color: Colors.Text.Active, children: line }, index))) }));
+}

package/dist/ui/Command.js

@@ -1,6 +1,7 @@
 import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
 import { Box, Text, useInput } from 'ink';
+import { getTextColor } from '../services/colors.js';
 import { Spinner } from './Spinner.js';
 const MIN_PROCESSING_TIME = 1000; // purely for visual effect
 export function Command({ command, state, service, children, onError, onComplete, onAborted, }) {
@@ -58,5 +59,6 @@ export function Command({ command, state, service, children, onError, onComplete
             mounted = false;
         };
     }, [command, done, service]);
-    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [_jsxs(Box, { children: [_jsxs(Text, { color: "gray", children: ["> pls ", command] }), isLoading && (_jsxs(_Fragment, { children: [_jsx(Text, { children: " " }), _jsx(Spinner, {})] }))] }), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "red", children: ["Error: ", error] }) })), children] }));
+    const isCurrent = done === false;
+    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [_jsxs(Box, { children: [_jsxs(Text, { color: getTextColor(isCurrent), children: ["> pls ", command] }), isLoading && (_jsxs(_Fragment, { children: [_jsx(Text, { children: " " }), _jsx(Spinner, {})] }))] }), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "red", children: ["Error: ", error] }) })), children] }));
 }

package/dist/ui/Component.js

@@ -1,13 +1,17 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import React from 'react';
 import { ComponentName } from '../types/types.js';
+import { Answer } from './Answer.js';
+import { AnswerDisplay } from './AnswerDisplay.js';
 import { Command } from './Command.js';
 import { Confirm } from './Confirm.js';
 import { Config } from './Config.js';
 import { Feedback } from './Feedback.js';
+import { Introspect } from './Introspect.js';
 import { Message } from './Message.js';
 import { Plan } from './Plan.js';
 import { Refinement } from './Refinement.js';
+import { Report } from './Report.js';
 import { Welcome } from './Welcome.js';
 export const Component = React.memo(function Component({ def, debug, }) {
     switch (def.name) {
@@ -23,8 +27,11 @@ export const Component = React.memo(function Component({ def, debug, }) {
             const state = def.state;
             return _jsx(Command, { ...props, state: state });
         }
-        case ComponentName.Plan:
-            return _jsx(Plan, { ...def.props, debug: debug });
+        case ComponentName.Plan: {
+            const props = def.props;
+            const state = def.state;
+            return _jsx(Plan, { ...props, state: state, debug: debug });
+        }
         case ComponentName.Feedback:
             return _jsx(Feedback, { ...def.props });
         case ComponentName.Message:
@@ -39,5 +46,19 @@ export const Component = React.memo(function Component({ def, debug, }) {
             const state = def.state;
             return _jsx(Confirm, { ...props, state: state });
         }
+        case ComponentName.Introspect: {
+            const props = def.props;
+            const state = def.state;
+            return _jsx(Introspect, { ...props, state: state });
+        }
+        case ComponentName.Report:
+            return _jsx(Report, { ...def.props });
+        case ComponentName.Answer: {
+            const props = def.props;
+            const state = def.state;
+            return _jsx(Answer, { ...props, state: state });
+        }
+        case ComponentName.AnswerDisplay:
+            return _jsx(AnswerDisplay, { ...def.props });
     }
 });

package/dist/ui/Config.js

@@ -2,7 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React from 'react';
 import { Box, Text, useFocus, useInput } from 'ink';
 import TextInput from 'ink-text-input';
-import { Colors } from '../types/colors.js';
+import { Colors } from '../services/colors.js';
 export var StepType;
 (function (StepType) {
     StepType["Text"] = "text";

package/dist/ui/Confirm.js

@@ -1,9 +1,10 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React from 'react';
 import { Box, Text, useInput } from 'ink';
-import { Colors } from '../types/colors.js';
+import { Colors } from '../services/colors.js';
 export function Confirm({ message, state, onConfirmed, onCancelled, }) {
     const done = state?.done ?? false;
+    const isCurrent = done === false;
     const [selectedIndex, setSelectedIndex] = React.useState(0); // 0 = Yes, 1 = No
     useInput((input, key) => {
         if (done)
@@ -33,9 +34,9 @@ export function Confirm({ message, state, onConfirmed, onCancelled, }) {
     ];
     if (done) {
         // When done, show both the message and user's choice in timeline
-        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: message }) }), _jsx(Box, { children: _jsxs(Text, { color: "gray", children: ["> ", options[selectedIndex].label] }) })] }));
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: undefined, children: message }) }), _jsx(Box, { children: _jsxs(Text, { color: Colors.Text.Inactive, children: ["> ", options[selectedIndex].label] }) })] }));
     }
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: message }) }), _jsxs(Box, { 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, children: _jsx(Text, { color: isCurrent ? Colors.Text.Active : Colors.Text.Inactive, children: message }) }), _jsxs(Box, { 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, bold: isSelected, children: option.label }) }, option.value));
                         }) })] })] }));

package/dist/ui/Feedback.js

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

package/dist/ui/Introspect.js

@@ -0,0 +1,100 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { getTextColor } from '../services/colors.js';
+import { Spinner } from './Spinner.js';
+const MIN_PROCESSING_TIME = 1000;
+const BUILT_IN_CAPABILITIES = new Set([
+    'CONFIG',
+    'PLAN',
+    'INTROSPECT',
+    'ANSWER',
+    'EXECUTE',
+    'REPORT',
+]);
+function parseCapabilityFromTask(task) {
+    // Parse "NAME: Description" format from task.action
+    const colonIndex = task.action.indexOf(':');
+    if (colonIndex === -1) {
+        return {
+            name: task.action,
+            description: '',
+            isBuiltIn: BUILT_IN_CAPABILITIES.has(task.action.toUpperCase()),
+        };
+    }
+    const name = task.action.substring(0, colonIndex).trim();
+    const description = task.action.substring(colonIndex + 1).trim();
+    const isBuiltIn = BUILT_IN_CAPABILITIES.has(name.toUpperCase());
+    return {
+        name,
+        description,
+        isBuiltIn,
+    };
+}
+export function Introspect({ tasks, state, service, children, onError, onComplete, onAborted, }) {
+    const done = state?.done ?? false;
+    const isCurrent = done === false;
+    const [error, setError] = useState(null);
+    const [isLoading, setIsLoading] = useState(state?.isLoading ?? !done);
+    useInput((input, key) => {
+        if (key.escape && isLoading && !done) {
+            setIsLoading(false);
+            onAborted();
+        }
+    }, { isActive: isLoading && !done });
+    useEffect(() => {
+        // Skip processing if done
+        if (done) {
+            return;
+        }
+        // Skip processing if no service available
+        if (!service) {
+            setError('No service available');
+            setIsLoading(false);
+            return;
+        }
+        let mounted = true;
+        async function process(svc) {
+            const startTime = Date.now();
+            try {
+                // Get the introspect task action (first task should have the intro message)
+                const introspectAction = tasks[0]?.action || 'list capabilities';
+                // Call introspect tool
+                const result = await svc.processWithTool(introspectAction, 'introspect');
+                const elapsed = Date.now() - startTime;
+                const remainingTime = Math.max(0, MIN_PROCESSING_TIME - elapsed);
+                await new Promise((resolve) => setTimeout(resolve, remainingTime));
+                if (mounted) {
+                    // Parse capabilities from returned tasks
+                    const capabilities = result.tasks.map(parseCapabilityFromTask);
+                    setIsLoading(false);
+                    onComplete?.(result.message, capabilities);
+                }
+            }
+            catch (err) {
+                const elapsed = Date.now() - startTime;
+                const remainingTime = Math.max(0, MIN_PROCESSING_TIME - elapsed);
+                await new Promise((resolve) => setTimeout(resolve, remainingTime));
+                if (mounted) {
+                    const errorMessage = err instanceof Error ? err.message : 'Unknown error occurred';
+                    setIsLoading(false);
+                    if (onError) {
+                        onError(errorMessage);
+                    }
+                    else {
+                        setError(errorMessage);
+                    }
+                }
+            }
+        }
+        process(service);
+        return () => {
+            mounted = false;
+        };
+    }, [tasks, done, service]);
+    // Don't render wrapper when done and nothing to show
+    if (!isLoading && !error && !children) {
+        return null;
+    }
+    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isLoading && (_jsxs(Box, { children: [_jsx(Text, { color: getTextColor(isCurrent), children: "Listing capabilities. " }), _jsx(Spinner, {})] })), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "red", children: ["Error: ", error] }) })), children] }));
+}

package/dist/ui/Label.js

@@ -1,6 +1,8 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
+import { getTaskColors } from '../services/colors.js';
 import { Separator } from './Separator.js';
-export function Label({ description, descriptionColor, type, typeColor, showType = false, }) {
-    return (_jsxs(Box, { children: [_jsx(Text, { color: descriptionColor, children: description }), showType && (_jsxs(_Fragment, { children: [_jsx(Separator, {}), _jsx(Text, { color: typeColor, children: type })] }))] }));
+export function Label({ description, taskType, showType = false, isCurrent = false, }) {
+    const colors = getTaskColors(taskType, isCurrent);
+    return (_jsxs(Box, { children: [_jsx(Text, { color: colors.description, children: description }), showType && (_jsxs(_Fragment, { children: [_jsx(Separator, {}), _jsx(Text, { color: colors.type, children: taskType })] }))] }));
 }

package/dist/ui/List.js

@@ -1,6 +1,6 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
-import { Label } from './Label.js';
+import { Separator } from './Separator.js';
 export const List = ({ items, level = 0, highlightedIndex = null, highlightedParentIndex = null, showType = false, }) => {
     const marginLeft = level > 0 ? 4 : 0;
     return (_jsx(Box, { flexDirection: "column", marginLeft: marginLeft, children: items.map((item, index) => {
@@ -21,6 +21,6 @@ export const List = ({ items, level = 0, highlightedIndex = null, highlightedPar
                 (isHighlighted && item.type.highlightedColor
                     ? item.type.highlightedColor
                     : 'whiteBright');
-            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: markerColor, children: marker }), _jsx(Label, { description: item.description.text, descriptionColor: descriptionColor, type: item.type.text, typeColor: typeColor, showType: showType })] }), 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(List, { items: item.children, level: level + 1, highlightedIndex: shouldHighlightChildren ? highlightedIndex : null, showType: showType }))] }, index));
         }) }));
 };