prompt-language-shell 0.5.2 → 0.6.2

package/dist/ui/Workflow.js

@@ -0,0 +1,132 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { Box, Static } from 'ink';
+import { ComponentName, FeedbackType } from '../types/types.js';
+import { createFeedback, isStateless, markAsDone, } from '../services/components.js';
+import { exitApp } from '../services/process.js';
+import { getCancellationMessage } from '../services/messages.js';
+import { Component } from './Component.js';
+export const Workflow = ({ initialQueue, debug }) => {
+    const [timeline, setTimeline] = useState([]);
+    const [active, setActive] = useState(null);
+    const [queue, setQueue] = useState(initialQueue);
+    // Ref to track active component for synchronous access
+    const activeRef = useRef(null);
+    // Keep ref in sync with active state
+    useEffect(() => {
+        activeRef.current = active;
+    }, [active]);
+    // Function to move active component to timeline with optional additional items
+    const moveActiveToTimeline = useCallback((...items) => {
+        const curr = activeRef.current;
+        if (!curr) {
+            // No active component, just add items if provided
+            if (items.length > 0) {
+                setTimeline((prev) => [...prev, ...items]);
+            }
+            return;
+        }
+        const doneComponent = markAsDone(curr);
+        // Atomic update: add active component and any additional items
+        setTimeline((prev) => items.length > 0
+            ? [...prev, doneComponent, ...items]
+            : [...prev, doneComponent]);
+        setActive(null);
+    }, []);
+    // Global handlers for all stateful components
+    const handlers = useMemo(() => ({
+        onAborted: (operation) => {
+            moveActiveToTimeline();
+            // Add feedback to queue and exit
+            const message = getCancellationMessage(operation);
+            setQueue((queue) => [
+                ...queue,
+                createFeedback(FeedbackType.Aborted, message),
+            ]);
+        },
+        onError: (error) => {
+            moveActiveToTimeline();
+            // Add feedback to queue and exit with error code
+            setQueue((queue) => [
+                ...queue,
+                createFeedback(FeedbackType.Failed, error),
+            ]);
+        },
+        addToQueue: (...items) => {
+            setQueue((queue) => [...queue, ...items]);
+        },
+        addToTimeline: (...items) => {
+            setTimeline((prev) => [...prev, ...items]);
+        },
+        completeActive: (...items) => {
+            moveActiveToTimeline(...items);
+        },
+        updateState: (newState) => {
+            setActive((curr) => {
+                if (!curr || !('state' in curr))
+                    return curr;
+                const stateful = curr;
+                const updated = {
+                    ...stateful,
+                    state: {
+                        ...stateful.state,
+                        ...newState,
+                    },
+                };
+                // Update ref synchronously so moveActiveToTimeline sees the latest state
+                activeRef.current = updated;
+                return updated;
+            });
+        },
+    }), [moveActiveToTimeline]);
+    // Global Esc handler removed - components handle their own Esc individually
+    // Move next item from queue to active
+    useEffect(() => {
+        if (queue.length > 0 && active === null) {
+            const [first, ...rest] = queue;
+            setQueue(rest);
+            setActive(first);
+        }
+    }, [queue, active]);
+    // Process active component - stateless components auto-move to timeline
+    useEffect(() => {
+        if (!active)
+            return;
+        if (isStateless(active)) {
+            const doneComponent = markAsDone(active);
+            setTimeline((prev) => [...prev, doneComponent]);
+            setActive(null);
+        }
+        // Stateful components stay in active until handlers move them to timeline
+    }, [active]);
+    // Exit when all done
+    useEffect(() => {
+        if (active === null && queue.length === 0 && timeline.length > 0) {
+            // Check if last item in timeline is a failed feedback
+            const lastItem = timeline[timeline.length - 1];
+            const isFailed = lastItem.name === ComponentName.Feedback &&
+                lastItem.props.type === FeedbackType.Failed;
+            exitApp(isFailed ? 1 : 0);
+        }
+    }, [active, queue, timeline]);
+    // Inject global handlers into active component
+    const activeComponent = useMemo(() => {
+        if (!active)
+            return null;
+        // For stateless components, render as-is with isActive=true
+        if (isStateless(active)) {
+            return (_jsx(Component, { def: active, isActive: true, debug: debug }, active.id));
+        }
+        // For stateful components, inject global handlers
+        const statefulActive = active;
+        const wrappedDef = {
+            ...statefulActive,
+            props: {
+                ...statefulActive.props,
+                handlers,
+            },
+        };
+        return (_jsx(Component, { def: wrappedDef, isActive: true, debug: debug }, active.id));
+    }, [active, debug, handlers]);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: timeline, children: (item) => (_jsx(Box, { marginTop: 1, children: _jsx(Component, { def: item, isActive: false, debug: debug }) }, item.id)) }, "timeline"), _jsx(Box, { marginTop: 1, children: activeComponent })] }));
+};

package/package.json

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

package/dist/handlers/answer.js

@@ -1,21 +0,0 @@
-import { ComponentName } from '../types/types.js';
-import { createAnswerDisplayDefinition } from '../services/components.js';
-import { createErrorHandler, withQueueHandler } from '../services/queue.js';
-/**
- * Creates all answer handlers
- */
-export function createAnswerHandlers(ops, handleAborted) {
-    const onError = (error) => {
-        ops.setQueue(createErrorHandler(ComponentName.Answer, ops.addToTimeline)(error));
-    };
-    const onComplete = (answer) => {
-        ops.setQueue(withQueueHandler(ComponentName.Answer, () => {
-            ops.addToTimeline(createAnswerDisplayDefinition(answer));
-            return undefined;
-        }, true, 0));
-    };
-    const onAborted = () => {
-        handleAborted('Answer');
-    };
-    return { onError, onComplete, onAborted };
-}

package/dist/handlers/command.js

@@ -1,34 +0,0 @@
-import { ComponentName, TaskType } from '../types/types.js';
-import { createConfirmDefinition, createPlanDefinition, markAsDone, } from '../services/components.js';
-import { createErrorHandler, withQueueHandler } from '../services/queue.js';
-/**
- * Creates all command handlers
- */
-export function createCommandHandlers(ops, handleAborted, planHandlers, executionHandlers) {
-    const onError = (error) => {
-        ops.setQueue(createErrorHandler(ComponentName.Command, ops.addToTimeline)(error));
-    };
-    const onComplete = (message, tasks) => {
-        ops.setQueue(withQueueHandler(ComponentName.Command, (first) => {
-            const hasDefineTask = tasks.some((task) => task.type === TaskType.Define);
-            const planDefinition = createPlanDefinition(message, tasks, planHandlers.createAbortHandler(tasks), hasDefineTask ? planHandlers.onSelectionConfirmed : undefined);
-            if (hasDefineTask) {
-                ops.addToTimeline(markAsDone(first));
-                return [planDefinition];
-            }
-            else {
-                const confirmDefinition = createConfirmDefinition(() => {
-                    executionHandlers.onConfirmed(tasks);
-                }, () => {
-                    executionHandlers.onCancelled(tasks);
-                });
-                ops.addToTimeline(markAsDone(first), planDefinition);
-                return [confirmDefinition];
-            }
-        }, false, 0));
-    };
-    const onAborted = () => {
-        handleAborted('Request');
-    };
-    return { onError, onComplete, onAborted };
-}

package/dist/handlers/config.js

@@ -1,88 +0,0 @@
-import { ComponentName, FeedbackType } from '../types/types.js';
-import { createAnthropicService, } from '../services/anthropic.js';
-import { createCommandDefinition, createExecuteDefinition, createFeedback, markAsDone, } from '../services/components.js';
-import { saveAnthropicConfig, saveConfig } from '../services/configuration.js';
-import { FeedbackMessages } from '../services/messages.js';
-import { exitApp } from '../services/process.js';
-import { withQueueHandler } from '../services/queue.js';
-/**
- * Creates all config handlers
- */
-export function createConfigHandlers(ops, handleAborted, command, commandHandlers, setService) {
-    const onFinished = (config) => {
-        const anthropicConfig = config;
-        saveAnthropicConfig(anthropicConfig);
-        const newService = createAnthropicService(anthropicConfig);
-        setService(newService);
-        ops.setQueue(withQueueHandler(ComponentName.Config, (first, rest) => {
-            ops.addToTimeline(markAsDone(first), createFeedback(FeedbackType.Succeeded, FeedbackMessages.ConfigurationComplete));
-            if (command) {
-                return [
-                    ...rest,
-                    createCommandDefinition(command, newService, commandHandlers.onError, commandHandlers.onComplete, commandHandlers.onAborted),
-                ];
-            }
-            exitApp(0);
-            return rest;
-        }, false, 0));
-    };
-    const onAborted = () => {
-        handleAborted('Configuration');
-    };
-    return { onFinished, onAborted };
-}
-/**
- * Creates config execution finished handler for CONFIG skill
- * Saves arbitrary config keys and optionally continues with execution
- */
-export function createConfigExecutionFinishedHandler(addToTimeline, keys, tasks, service, executeHandlers) {
-    return (config) => {
-        // Group by top-level section
-        const sections = {};
-        for (const fullKey of keys) {
-            const parts = fullKey.split('.');
-            const shortKey = parts[parts.length - 1];
-            const topSection = parts[0];
-            // Initialize section if needed
-            sections[topSection] = sections[topSection] ?? {};
-            if (shortKey in config) {
-                const value = config[shortKey];
-                // Build nested structure recursively
-                let current = sections[topSection];
-                for (let i = 1; i < parts.length - 1; i++) {
-                    current[parts[i]] = current[parts[i]] ?? {};
-                    current = current[parts[i]];
-                }
-                current[parts[parts.length - 1]] = value;
-            }
-        }
-        for (const [section, sectionConfig] of Object.entries(sections)) {
-            saveConfig(section, sectionConfig);
-        }
-        return withQueueHandler(ComponentName.Config, (first, rest) => {
-            addToTimeline(markAsDone(first), createFeedback(FeedbackType.Succeeded, FeedbackMessages.ConfigurationComplete));
-            // If tasks are provided, continue with execution
-            if (tasks && service && executeHandlers) {
-                return [
-                    ...rest,
-                    createExecuteDefinition(tasks, service, executeHandlers.onError, executeHandlers.onComplete, executeHandlers.onAborted),
-                ];
-            }
-            // Otherwise, exit (legacy behavior for initial setup)
-            exitApp(0);
-            return rest;
-        }, false, 0);
-    };
-}
-/**
- * Creates config execution aborted handler for CONFIG skill
- */
-export function createConfigExecutionAbortedHandler(addToTimeline) {
-    return () => {
-        return withQueueHandler(ComponentName.Config, (first, rest) => {
-            addToTimeline(markAsDone(first), createFeedback(FeedbackType.Aborted, 'Configuration cancelled.'));
-            exitApp(0);
-            return rest;
-        }, false, 0);
-    };
-}

package/dist/handlers/execute.js

@@ -1,46 +0,0 @@
-import { ComponentName, FeedbackType } from '../types/types.js';
-import { createFeedback, createMessage, markAsDone, } from '../services/components.js';
-import { formatDuration } from '../services/messages.js';
-import { exitApp } from '../services/process.js';
-import { ExecutionResult } from '../services/shell.js';
-import { withQueueHandler } from '../services/queue.js';
-/**
- * Creates all execute handlers
- */
-export function createExecuteHandlers(ops, handleAborted) {
-    void handleAborted;
-    const onError = (error) => {
-        ops.setQueue(withQueueHandler(ComponentName.Execute, (first) => {
-            ops.addToTimeline(markAsDone(first), createFeedback(FeedbackType.Failed, error));
-            exitApp(1);
-            return [];
-        }));
-    };
-    const onComplete = (outputs, totalElapsed) => {
-        ops.setQueue(withQueueHandler(ComponentName.Execute, (first) => {
-            const failed = outputs.find((out) => out.result !== ExecutionResult.Success);
-            if (failed) {
-                const errorMessage = failed.error
-                    ? `${failed.description}: ${failed.error}`
-                    : `${failed.description} failed`;
-                ops.addToTimeline(markAsDone(first), createFeedback(FeedbackType.Failed, errorMessage));
-                exitApp(1);
-                return [];
-            }
-            ops.addToTimeline(markAsDone(first), createMessage(`Execution completed in ${formatDuration(totalElapsed)}.`));
-            exitApp(0);
-            return [];
-        }));
-    };
-    const onAborted = (elapsedTime) => {
-        ops.setQueue(withQueueHandler(ComponentName.Execute, (first) => {
-            const message = elapsedTime > 0
-                ? `The execution was cancelled after ${formatDuration(elapsedTime)}.`
-                : 'The execution was cancelled.';
-            ops.addToTimeline(markAsDone(first), createFeedback(FeedbackType.Aborted, message));
-            exitApp(0);
-            return [];
-        }));
-    };
-    return { onError, onComplete, onAborted };
-}

package/dist/handlers/execution.js

@@ -1,140 +0,0 @@
-import { ComponentName, FeedbackType, TaskType } from '../types/types.js';
-import { createAnswerDefinition, createConfigDefinitionWithKeys, createExecuteDefinition, createFeedback, createIntrospectDefinition, createValidateDefinition, markAsDone, } from '../services/components.js';
-import { StepType } from '../ui/Config.js';
-import { getCancellationMessage } from '../services/messages.js';
-import { exitApp } from '../services/process.js';
-import { withQueueHandler } from '../services/queue.js';
-import { createConfigExecutionAbortedHandler, createConfigExecutionFinishedHandler, } from './config.js';
-import { validateExecuteTasks } from '../services/execution-validator.js';
-/**
- * Creates all execution handlers
- */
-export function createExecutionHandlers(ops, taskHandlers) {
-    const onConfirmed = (tasks) => {
-        ops.setQueue(withQueueHandler(ComponentName.Confirm, (first) => {
-            const allIntrospect = tasks.every((task) => task.type === TaskType.Introspect);
-            const allAnswer = tasks.every((task) => task.type === TaskType.Answer);
-            const allConfig = tasks.every((task) => task.type === TaskType.Config);
-            const allExecute = tasks.every((task) => task.type === TaskType.Execute);
-            const service = ops.service;
-            if (!service) {
-                ops.addToTimeline(markAsDone(first), createFeedback(FeedbackType.Failed, 'Service not available'));
-                exitApp(1);
-                return [];
-            }
-            if (allIntrospect && tasks.length > 0) {
-                ops.addToTimeline(markAsDone(first));
-                return [
-                    createIntrospectDefinition(tasks, service, taskHandlers.introspect.onError, taskHandlers.introspect.onComplete, taskHandlers.introspect.onAborted),
-                ];
-            }
-            else if (allAnswer && tasks.length > 0) {
-                const question = tasks[0].action;
-                ops.addToTimeline(markAsDone(first));
-                return [
-                    createAnswerDefinition(question, service, taskHandlers.answer.onError, taskHandlers.answer.onComplete, taskHandlers.answer.onAborted),
-                ];
-            }
-            else if (allConfig && tasks.length > 0) {
-                const keys = tasks
-                    .map((task) => task.params?.key)
-                    .filter((key) => typeof key === 'string');
-                ops.addToTimeline(markAsDone(first));
-                const handleConfigFinished = (config) => {
-                    ops.setQueue(createConfigExecutionFinishedHandler(ops.addToTimeline, keys)(config));
-                };
-                const handleConfigAborted = () => {
-                    ops.setQueue(createConfigExecutionAbortedHandler(ops.addToTimeline)());
-                };
-                return [
-                    createConfigDefinitionWithKeys(keys, handleConfigFinished, handleConfigAborted),
-                ];
-            }
-            else if (allExecute && tasks.length > 0) {
-                // Validate config requirements before execution
-                const missingConfig = validateExecuteTasks(tasks);
-                if (missingConfig.length > 0) {
-                    // Config is missing - call VALIDATE tool to get contextual descriptions
-                    const keys = missingConfig.map((req) => req.path);
-                    const userRequest = tasks.map((t) => t.action).join(', ');
-                    ops.addToTimeline(markAsDone(first));
-                    // Create handlers for Validate completion
-                    const handleValidateComplete = (configWithDescriptions) => {
-                        ops.setQueue(withQueueHandler(ComponentName.Validate, (first) => {
-                            // Create CONFIG component with descriptions from VALIDATE
-                            const handleConfigFinished = (config) => {
-                                ops.setQueue(createConfigExecutionFinishedHandler(ops.addToTimeline, keys, tasks, service, taskHandlers.execute)(config));
-                            };
-                            const handleConfigAborted = () => {
-                                ops.setQueue(createConfigExecutionAbortedHandler(ops.addToTimeline)());
-                            };
-                            // Create config steps from validated descriptions
-                            const steps = configWithDescriptions.map((req) => {
-                                const keyParts = req.path.split('.');
-                                const shortKey = keyParts[keyParts.length - 1];
-                                // Extract description without the {path} suffix
-                                // Format from VALIDATE: "Description {path}"
-                                let description = req.description || req.path;
-                                const pathPattern = /\s*\{[^}]+\}\s*$/;
-                                description = description.replace(pathPattern, '').trim();
-                                const step = {
-                                    description,
-                                    key: shortKey,
-                                    path: req.path,
-                                    type: StepType.Text,
-                                    value: null,
-                                    validate: () => true,
-                                };
-                                return step;
-                            });
-                            // Mark Validate as done and move to timeline
-                            ops.addToTimeline(markAsDone(first));
-                            return [
-                                {
-                                    id: crypto.randomUUID(),
-                                    name: ComponentName.Config,
-                                    state: { done: false },
-                                    props: {
-                                        steps,
-                                        onFinished: handleConfigFinished,
-                                        onAborted: handleConfigAborted,
-                                    },
-                                },
-                            ];
-                        }));
-                    };
-                    const handleValidateError = (error) => {
-                        ops.addToTimeline(createFeedback(FeedbackType.Failed, error));
-                        exitApp(1);
-                    };
-                    const handleValidateAborted = () => {
-                        ops.addToTimeline(createFeedback(FeedbackType.Aborted, 'Configuration validation cancelled'));
-                        exitApp(0);
-                    };
-                    return [
-                        createValidateDefinition(missingConfig, userRequest, service, handleValidateError, handleValidateComplete, handleValidateAborted),
-                    ];
-                }
-                // No missing config - execute directly
-                ops.addToTimeline(markAsDone(first));
-                return [
-                    createExecuteDefinition(tasks, service, taskHandlers.execute.onError, taskHandlers.execute.onComplete, taskHandlers.execute.onAborted),
-                ];
-            }
-            else {
-                ops.addToTimeline(markAsDone(first), createFeedback(FeedbackType.Failed, 'I can only process one type of task at a time for now.'));
-                exitApp(0);
-                return [];
-            }
-        }));
-    };
-    const onCancelled = (tasks) => {
-        ops.setQueue(withQueueHandler(ComponentName.Confirm, (first) => {
-            const allIntrospect = tasks.every((task) => task.type === TaskType.Introspect);
-            const operation = allIntrospect ? 'introspection' : 'execution';
-            ops.addToTimeline(markAsDone(first), createFeedback(FeedbackType.Aborted, getCancellationMessage(operation)));
-            return undefined;
-        }, true, 0));
-    };
-    return { onConfirmed, onCancelled };
-}

package/dist/handlers/introspect.js

@@ -1,21 +0,0 @@
-import { ComponentName } from '../types/types.js';
-import { createReportDefinition } from '../services/components.js';
-import { createErrorHandler, withQueueHandler } from '../services/queue.js';
-/**
- * Creates all introspect handlers
- */
-export function createIntrospectHandlers(ops, handleAborted) {
-    const onError = (error) => {
-        ops.setQueue(createErrorHandler(ComponentName.Introspect, ops.addToTimeline)(error));
-    };
-    const onComplete = (message, capabilities) => {
-        ops.setQueue(withQueueHandler(ComponentName.Introspect, () => {
-            ops.addToTimeline(createReportDefinition(message, capabilities));
-            return undefined;
-        }, true, 0));
-    };
-    const onAborted = () => {
-        handleAborted('Introspection');
-    };
-    return { onError, onComplete, onAborted };
-}

package/dist/handlers/plan.js

@@ -1,79 +0,0 @@
-import { ComponentName, FeedbackType, TaskType } from '../types/types.js';
-import { createConfirmDefinition, createFeedback, createPlanDefinition, markAsDone, createRefinement, } from '../services/components.js';
-import { FeedbackMessages, formatErrorMessage, getRefiningMessage, } from '../services/messages.js';
-import { exitApp } from '../services/process.js';
-/**
- * Creates all plan handlers
- */
-export function createPlanHandlers(ops, handleAborted, executionHandlers) {
-    const onAborted = () => {
-        handleAborted('Task selection');
-    };
-    const createAbortHandler = (tasks) => {
-        const allIntrospect = tasks.every((task) => task.type === TaskType.Introspect);
-        if (allIntrospect) {
-            return () => {
-                handleAborted('Introspection');
-            };
-        }
-        return onAborted;
-    };
-    const onSelectionConfirmed = async (selectedTasks) => {
-        const refinementDef = createRefinement(getRefiningMessage(), () => {
-            handleAborted('Plan refinement');
-        });
-        ops.setQueue((currentQueue) => {
-            if (currentQueue.length === 0)
-                return currentQueue;
-            const [first] = currentQueue;
-            if (first.name === ComponentName.Plan) {
-                ops.addToTimeline(markAsDone(first));
-            }
-            return [refinementDef];
-        });
-        try {
-            const service = ops.service;
-            if (!service) {
-                ops.addToTimeline(createFeedback(FeedbackType.Failed, FeedbackMessages.UnexpectedError, 'Service not available'));
-                exitApp(1);
-                return;
-            }
-            const refinedCommand = selectedTasks
-                .map((task) => {
-                const action = task.action.toLowerCase().replace(/,/g, ' -');
-                const type = task.type;
-                return `${action} (type: ${type})`;
-            })
-                .join(', ');
-            const result = await service.processWithTool(refinedCommand, 'plan');
-            ops.setQueue((currentQueue) => {
-                if (currentQueue.length > 0 &&
-                    currentQueue[0].id === refinementDef.id) {
-                    ops.addToTimeline(markAsDone(currentQueue[0]));
-                }
-                return [];
-            });
-            const planDefinition = createPlanDefinition(result.message, result.tasks, createAbortHandler(result.tasks), undefined);
-            const confirmDefinition = createConfirmDefinition(() => {
-                executionHandlers.onConfirmed(result.tasks);
-            }, () => {
-                executionHandlers.onCancelled(result.tasks);
-            });
-            ops.addToTimeline(planDefinition);
-            ops.setQueue([confirmDefinition]);
-        }
-        catch (error) {
-            const errorMessage = formatErrorMessage(error);
-            ops.setQueue((currentQueue) => {
-                if (currentQueue.length > 0 &&
-                    currentQueue[0].id === refinementDef.id) {
-                    ops.addToTimeline(markAsDone(currentQueue[0]));
-                }
-                return [];
-            });
-            ops.addToTimeline(createFeedback(FeedbackType.Failed, FeedbackMessages.UnexpectedError, errorMessage));
-            exitApp(1);
-        }
-    };
-    return { onAborted, createAbortHandler, onSelectionConfirmed };
-}

package/dist/types/handlers.js

@@ -1 +0,0 @@
-export {};

package/dist/ui/AnswerDisplay.js

@@ -1,8 +0,0 @@
-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/Column.js

@@ -1,7 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import React from 'react';
-import { Box } from 'ink';
-import { Component } from './Component.js';
-export const Column = React.memo(({ items, debug }) => {
-    return (_jsx(Box, { marginTop: 1, marginBottom: 1, marginLeft: 1, flexDirection: "column", gap: 1, children: items.map((item) => (_jsx(Box, { children: _jsx(Component, { def: item, debug: debug }) }, item.id))) }));
-});