prompt-language-shell 0.4.9 → 0.5.0

package/dist/ui/Execute.js

@@ -6,6 +6,9 @@ import { useInput } from '../services/keyboard.js';
 import { formatErrorMessage } from '../services/messages.js';
 import { formatDuration } from '../services/utils.js';
 import { ExecutionStatus, executeCommands, } from '../services/shell.js';
+import { replacePlaceholders } from '../services/placeholder-resolver.js';
+import { loadUserConfig } from '../services/config-loader.js';
+import { ensureMinimumTime } from '../services/timing.js';
 import { Spinner } from './Spinner.js';
 const MINIMUM_PROCESSING_TIME = 400;
 const STATUS_ICONS = {
@@ -13,7 +16,22 @@ const STATUS_ICONS = {
     [ExecutionStatus.Running]: '• ',
     [ExecutionStatus.Success]: '✓ ',
     [ExecutionStatus.Failed]: '✗ ',
+    [ExecutionStatus.Aborted]: '⊘ ',
 };
+function calculateTotalElapsed(commandStatuses) {
+    return commandStatuses.reduce((sum, cmd) => {
+        if (cmd.elapsed !== undefined) {
+            return sum + cmd.elapsed;
+        }
+        if (cmd.startTime) {
+            const elapsed = cmd.endTime
+                ? cmd.endTime - cmd.startTime
+                : Date.now() - cmd.startTime;
+            return sum + elapsed;
+        }
+        return sum;
+    }, 0);
+}
 function getStatusColors(status) {
     switch (status) {
         case ExecutionStatus.Pending:
@@ -44,6 +62,13 @@ function getStatusColors(status) {
                 command: Colors.Status.Error,
                 symbol: Palette.Gray,
             };
+        case ExecutionStatus.Aborted:
+            return {
+                icon: Palette.DarkOrange,
+                description: getTextColor(true),
+                command: Palette.DarkOrange,
+                symbol: Palette.Gray,
+            };
     }
 }
 function CommandStatusDisplay({ item, elapsed }) {
@@ -75,7 +100,24 @@ export function Execute({ tasks, state, service, onError, onComplete, onAborted,
         if (key.escape && (isLoading || isExecuting) && !done) {
             setIsLoading(false);
             setIsExecuting(false);
-            onAborted();
+            setRunningIndex(null);
+            // Mark any running command as aborted when cancelled
+            const now = Date.now();
+            setCommandStatuses((prev) => prev.map((item) => {
+                if (item.status === ExecutionStatus.Running) {
+                    const elapsed = item.startTime
+                        ? Math.floor((now - item.startTime) / 1000) * 1000
+                        : undefined;
+                    return {
+                        ...item,
+                        status: ExecutionStatus.Aborted,
+                        endTime: now,
+                        elapsed,
+                    };
+                }
+                return item;
+            }));
+            onAborted(calculateTotalElapsed(commandStatuses));
         }
     }, { isActive: (isLoading || isExecuting) && !done });
     // Update elapsed time for running command
@@ -97,9 +139,7 @@ export function Execute({ tasks, state, service, onError, onComplete, onAborted,
     useEffect(() => {
         if (isExecuting || commandStatuses.length === 0 || !outputs.length)
             return;
-        // Sum up elapsed times from all commands
-        const totalElapsed = commandStatuses.reduce((sum, cmd) => sum + (cmd.elapsed ?? 0), 0);
-        onComplete?.(outputs, totalElapsed);
+        onComplete?.(outputs, calculateTotalElapsed(commandStatuses));
     }, [isExecuting, commandStatuses, outputs, onComplete]);
     useEffect(() => {
         if (done) {
@@ -114,20 +154,22 @@ export function Execute({ tasks, state, service, onError, onComplete, onAborted,
         async function process(svc) {
             const startTime = Date.now();
             try {
-                // Format tasks for the execute tool
+                // Load user config for placeholder resolution
+                const userConfig = loadUserConfig();
+                // Format tasks for the execute tool and resolve placeholders
                 const taskDescriptions = tasks
                     .map((task) => {
+                    // Resolve placeholders in task action
+                    const resolvedAction = replacePlaceholders(task.action, userConfig);
                     const params = task.params
                         ? ` (params: ${JSON.stringify(task.params)})`
                         : '';
-                    return `- ${task.action}${params}`;
+                    return `- ${resolvedAction}${params}`;
                 })
                     .join('\n');
                 // Call execute tool to get commands
                 const result = await svc.processWithTool(taskDescriptions, 'execute');
-                const elapsed = Date.now() - startTime;
-                const remainingTime = Math.max(0, MINIMUM_PROCESSING_TIME - elapsed);
-                await new Promise((resolve) => setTimeout(resolve, remainingTime));
+                await ensureMinimumTime(startTime, MINIMUM_PROCESSING_TIME);
                 if (!mounted)
                     return;
                 if (!result.commands || result.commands.length === 0) {
@@ -136,9 +178,14 @@ export function Execute({ tasks, state, service, onError, onComplete, onAborted,
                     onComplete?.([], 0);
                     return;
                 }
+                // Resolve placeholders in command strings before execution
+                const resolvedCommands = result.commands.map((cmd) => ({
+                    ...cmd,
+                    command: replacePlaceholders(cmd.command, userConfig),
+                }));
                 // Set message and initialize command statuses
                 setMessage(result.message);
-                setCommandStatuses(result.commands.map((cmd, index) => ({
+                setCommandStatuses(resolvedCommands.map((cmd, index) => ({
                     command: cmd,
                     status: ExecutionStatus.Pending,
                     label: tasks[index]?.action,
@@ -146,7 +193,7 @@ export function Execute({ tasks, state, service, onError, onComplete, onAborted,
                 setIsLoading(false);
                 setIsExecuting(true);
                 // Execute commands sequentially
-                const outputs = await executeCommands(result.commands, (progress) => {
+                const outputs = await executeCommands(resolvedCommands, (progress) => {
                     if (!mounted)
                         return;
                     const now = Date.now();
@@ -186,9 +233,7 @@ export function Execute({ tasks, state, service, onError, onComplete, onAborted,
                 }
             }
             catch (err) {
-                const elapsed = Date.now() - startTime;
-                const remainingTime = Math.max(0, MINIMUM_PROCESSING_TIME - elapsed);
-                await new Promise((resolve) => setTimeout(resolve, remainingTime));
+                await ensureMinimumTime(startTime, MINIMUM_PROCESSING_TIME);
                 if (mounted) {
                     const errorMessage = formatErrorMessage(err);
                     setIsLoading(false);

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/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.9",
+  "version": "0.5.0",
   "description": "Your personal command-line concierge. Ask politely, and it gets things done.",
   "type": "module",
   "main": "dist/index.js",