prompt-language-shell 0.4.8 → 0.5.0

package/dist/ui/Introspect.js

@@ -4,6 +4,7 @@ import { Box, Text } from 'ink';
 import { Colors, getTextColor } from '../services/colors.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;
 const BUILT_IN_CAPABILITIES = new Set([
@@ -12,9 +13,10 @@ const BUILT_IN_CAPABILITIES = new Set([
     'INTROSPECT',
     'ANSWER',
     'EXECUTE',
+    'VALIDATE',
     'REPORT',
 ]);
-const INDIRECT_CAPABILITIES = new Set(['PLAN', 'REPORT']);
+const INDIRECT_CAPABILITIES = new Set(['PLAN', 'VALIDATE', 'REPORT']);
 function parseCapabilityFromTask(task) {
     // Parse "NAME: Description" format from task.action
     const colonIndex = task.action.indexOf(':');
@@ -69,9 +71,7 @@ export function Introspect({ tasks, state, service, children, debug = false, onE
                 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));
+                await ensureMinimumTime(startTime, MIN_PROCESSING_TIME);
                 if (mounted) {
                     // Parse capabilities from returned tasks
                     let capabilities = result.tasks.map(parseCapabilityFromTask);
@@ -85,9 +85,7 @@ export function Introspect({ tasks, state, service, children, debug = false, onE
                 }
             }
             catch (err) {
-                const elapsed = Date.now() - startTime;
-                const remainingTime = Math.max(0, MIN_PROCESSING_TIME - elapsed);
-                await new Promise((resolve) => setTimeout(resolve, remainingTime));
+                await ensureMinimumTime(startTime, MIN_PROCESSING_TIME);
                 if (mounted) {
                     const errorMessage = formatErrorMessage(err);
                     setIsLoading(false);

package/dist/ui/Main.js

@@ -2,20 +2,20 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import React from 'react';
 import { FeedbackType } from '../types/types.js';
 import { createAnthropicService, } from '../services/anthropic.js';
+import { createCommandDefinition, createConfigDefinition, createFeedback, createMessage, createWelcomeDefinition, isStateless, markAsDone, } from '../services/components.js';
 import { getConfigurationRequiredMessage, hasValidAnthropicKey, loadConfig, loadDebugSetting, saveDebugSetting, } from '../services/configuration.js';
 import { registerGlobalShortcut } from '../services/keyboard.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 { createAnswerHandlers } from '../handlers/answer.js';
+import { createCommandHandlers } from '../handlers/command.js';
+import { createConfigHandlers } from '../handlers/config.js';
+import { createExecuteHandlers } from '../handlers/execute.js';
+import { createExecutionHandlers } from '../handlers/execution.js';
+import { createIntrospectHandlers } from '../handlers/introspect.js';
+import { createPlanHandlers } from '../handlers/plan.js';
 import { Column } from './Column.js';
 export const Main = ({ app, command }) => {
-    // Initialize service from existing config if available
     const [service, setService] = React.useState(() => {
         if (hasValidAnthropicKey()) {
             const config = loadConfig();
@@ -26,14 +26,8 @@ export const Main = ({ app, command }) => {
     const [timeline, setTimeline] = React.useState([]);
     const [queue, setQueue] = React.useState([]);
     const [isDebug, setIsDebug] = React.useState(() => loadDebugSetting());
-    // Use ref to track latest timeline for callbacks
-    const timelineRef = React.useRef(timeline);
-    React.useEffect(() => {
-        timelineRef.current = timeline;
-    }, [timeline]);
     // Register global keyboard shortcuts
     React.useEffect(() => {
-        // Shift+Tab: Toggle debug mode
         registerGlobalShortcut('shift+tab', () => {
             setIsDebug((prev) => {
                 const newValue = !prev;
@@ -50,7 +44,6 @@ export const Main = ({ app, command }) => {
             if (currentQueue.length === 0)
                 return currentQueue;
             const [first, ...rest] = currentQueue;
-            // Stateless components auto-complete immediately
             if (isStateless(first)) {
                 addToTimeline(first);
                 return rest;
@@ -58,7 +51,7 @@ export const Main = ({ app, command }) => {
             return currentQueue;
         });
     }, [addToTimeline]);
-    const handleCommandError = React.useCallback((error) => setQueue(createCommandErrorHandler(addToTimeline)(error)), [addToTimeline]);
+    // Core abort handler
     const handleAborted = React.useCallback((operationName) => {
         setQueue((currentQueue) => {
             if (currentQueue.length === 0)
@@ -71,86 +64,54 @@ export const Main = ({ app, command }) => {
             return [];
         });
     }, [addToTimeline]);
-    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 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, setQueue)()), [
-        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), [
+    // Create operations object
+    const ops = React.useMemo(() => ({
         addToTimeline,
+        setQueue,
         service,
-        handleRefinementAborted,
-        createPlanAbortHandler,
-        handleExecutionConfirmed,
-        handleExecutionCancelled,
-    ]);
-    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) => setQueue(createConfigFinishedHandler(addToTimeline, command, handleCommandError, handleCommandComplete, handleCommandAborted, setService)(config)), [
-        addToTimeline,
-        command,
-        handleCommandError,
-        handleCommandComplete,
-        handleCommandAborted,
-    ]);
+    }), [addToTimeline, service]);
+    // Create handlers in dependency order
+    const introspectHandlers = React.useMemo(() => createIntrospectHandlers(ops, handleAborted), [ops, handleAborted]);
+    const answerHandlers = React.useMemo(() => createAnswerHandlers(ops, handleAborted), [ops, handleAborted]);
+    const executeHandlers = React.useMemo(() => createExecuteHandlers(ops, handleAborted), [ops, handleAborted]);
+    const executionHandlers = React.useMemo(() => createExecutionHandlers(ops, {
+        introspect: introspectHandlers,
+        answer: answerHandlers,
+        execute: executeHandlers,
+    }), [ops, introspectHandlers, answerHandlers, executeHandlers]);
+    const planHandlers = React.useMemo(() => createPlanHandlers(ops, handleAborted, executionHandlers), [ops, handleAborted, executionHandlers]);
+    const commandHandlers = React.useMemo(() => createCommandHandlers(ops, handleAborted, planHandlers, executionHandlers), [ops, handleAborted, planHandlers, executionHandlers]);
+    const configHandlers = React.useMemo(() => createConfigHandlers(ops, handleAborted, command, commandHandlers, setService), [ops, handleAborted, command, commandHandlers]);
     // Initialize queue on mount
     React.useEffect(() => {
         const hasConfig = !!service;
         if (command && hasConfig) {
-            // With command + valid config: [Command]
             setQueue([
-                createCommandDefinition(command, service, handleCommandError, handleCommandComplete, handleCommandAborted),
+                createCommandDefinition(command, service, commandHandlers.onError, commandHandlers.onComplete, commandHandlers.onAborted),
             ]);
         }
         else if (command && !hasConfig) {
-            // With command + no config: [Message, Config] (Command added after config)
             setQueue([
                 createMessage(getConfigurationRequiredMessage()),
-                createConfigDefinition(handleConfigFinished, handleConfigAborted),
+                createConfigDefinition(configHandlers.onFinished, configHandlers.onAborted),
             ]);
         }
         else if (!command && hasConfig) {
-            // No command + valid config: [Welcome]
             setQueue([createWelcomeDefinition(app)]);
         }
         else {
-            // No command + no config: [Welcome, Message, Config]
             setQueue([
                 createWelcomeDefinition(app),
                 createMessage(getConfigurationRequiredMessage(true)),
-                createConfigDefinition(handleConfigFinished, handleConfigAborted),
+                createConfigDefinition(configHandlers.onFinished, configHandlers.onAborted),
             ]);
         }
-    }, []); // Only run on mount
+    }, []);
     // Process queue whenever it changes
     React.useEffect(() => {
         processNextInQueue();
     }, [queue, processNextInQueue]);
-    // Exit when queue is empty and timeline has content (all stateless components done)
+    // Exit when queue is empty and timeline has content
     React.useEffect(() => {
         if (queue.length === 0 && timeline.length > 0) {
             exitApp(0);

package/dist/ui/Spinner.js

@@ -3,15 +3,20 @@ import { useEffect, useState } from 'react';
 import { Text } from 'ink';
 const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 const INTERVAL = 80;
+const CYCLE = FRAMES.length * INTERVAL;
+function getFrame() {
+    return Math.floor((Date.now() % CYCLE) / INTERVAL);
+}
 export function Spinner() {
-    const [frame, setFrame] = useState(0);
+    const [frame, setFrame] = useState(getFrame);
     useEffect(() => {
         const timer = setInterval(() => {
-            setFrame((prev) => (prev + 1) % FRAMES.length);
+            setFrame((prev) => {
+                const next = getFrame();
+                return next !== prev ? next : prev;
+            });
         }, INTERVAL);
-        return () => {
-            clearInterval(timer);
-        };
+        return () => clearInterval(timer);
     }, []);
     return _jsx(Text, { color: "blueBright", children: FRAMES[frame] });
 }

package/dist/ui/Validate.js

@@ -0,0 +1,120 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { Box, Text } from 'ink';
+import { TaskType } from '../types/types.js';
+import { Colors, getTextColor } from '../services/colors.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 Validate({ missingConfig, userRequest, 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);
+    const [completionMessage, setCompletionMessage] = useState(null);
+    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 {
+                // Build prompt for VALIDATE tool
+                const prompt = buildValidatePrompt(missingConfig, userRequest);
+                // Call validate tool
+                const result = await svc.processWithTool(prompt, 'validate');
+                await ensureMinimumTime(startTime, MIN_PROCESSING_TIME);
+                if (mounted) {
+                    // Extract CONFIG tasks with descriptions from result
+                    const configTasks = result.tasks.filter((task) => task.type === TaskType.Config);
+                    // Build ConfigRequirements with descriptions
+                    const withDescriptions = configTasks.map((task) => {
+                        const key = typeof task.params?.key === 'string'
+                            ? task.params.key
+                            : 'unknown';
+                        const original = missingConfig.find((req) => req.path === key);
+                        return {
+                            path: key,
+                            type: original?.type || 'string',
+                            description: task.action,
+                        };
+                    });
+                    // Build completion message showing which config properties are needed
+                    const count = withDescriptions.length;
+                    const propertyWord = count === 1 ? 'property' : 'properties';
+                    // Shuffle between different message variations
+                    const messages = [
+                        `Additional configuration ${propertyWord} required.`,
+                        `Configuration ${propertyWord} needed.`,
+                        `Missing configuration ${propertyWord} detected.`,
+                        `Setup requires configuration ${propertyWord}.`,
+                    ];
+                    const message = messages[Math.floor(Math.random() * messages.length)];
+                    setCompletionMessage(message);
+                    setIsLoading(false);
+                    onComplete?.(withDescriptions);
+                }
+            }
+            catch (err) {
+                await ensureMinimumTime(startTime, MIN_PROCESSING_TIME);
+                if (mounted) {
+                    const errorMessage = formatErrorMessage(err);
+                    setIsLoading(false);
+                    if (onError) {
+                        onError(errorMessage);
+                    }
+                    else {
+                        setError(errorMessage);
+                    }
+                }
+            }
+        }
+        process(service);
+        return () => {
+            mounted = false;
+        };
+    }, [
+        missingConfig,
+        userRequest,
+        done,
+        service,
+        onComplete,
+        onError,
+        onAborted,
+    ]);
+    // Don't render when done and nothing to show
+    if (done && !completionMessage && !error && !children) {
+        return null;
+    }
+    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isLoading && (_jsxs(Box, { children: [_jsxs(Text, { color: getTextColor(isCurrent), children: ["Validating configuration requirements.", ' '] }), _jsx(Spinner, {})] })), completionMessage && !isLoading && (_jsx(Box, { children: _jsx(Text, { color: getTextColor(isCurrent), children: completionMessage }) })), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) })), children] }));
+}
+/**
+ * Build prompt for VALIDATE tool
+ */
+function buildValidatePrompt(missingConfig, userRequest) {
+    const configList = missingConfig
+        .map((req) => `- Config path: ${req.path}\n  Type: ${req.type}`)
+        .join('\n');
+    return `User requested: "${userRequest}"
+
+Missing configuration values:
+${configList}
+
+Generate natural language descriptions for these configuration values based on the skill context.`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prompt-language-shell",
-  "version": "0.4.8",
+  "version": "0.5.0",
   "description": "Your personal command-line concierge. Ask politely, and it gets things done.",
   "type": "module",
   "main": "dist/index.js",
@@ -46,22 +46,22 @@
   },
   "homepage": "https://github.com/aswitalski/pls#readme",
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.69.0",
-    "ink": "^6.5.0",
+    "@anthropic-ai/sdk": "^0.70.1",
+    "ink": "^6.5.1",
     "ink-text-input": "^6.0.0",
     "react": "^19.2.0",
     "yaml": "^2.8.1"
   },
   "devDependencies": {
     "@types/node": "^24.10.1",
-    "@types/react": "^19.2.5",
-    "@vitest/coverage-v8": "^4.0.9",
+    "@types/react": "^19.2.6",
+    "@vitest/coverage-v8": "^4.0.12",
     "eslint": "^9.39.1",
     "husky": "^9.1.7",
     "ink-testing-library": "^4.0.0",
     "prettier": "^3.6.2",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.46.4",
-    "vitest": "^4.0.9"
+    "typescript-eslint": "^8.47.0",
+    "vitest": "^4.0.12"
   }
 }