prompt-language-shell 0.8.4 → 0.8.8

package/dist/ui/Validate.js

@@ -1,23 +1,35 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
 import { Box, Text } from 'ink';
-import { ComponentStatus } from '../types/components.js';
+import { ComponentStatus, } from '../types/components.js';
 import { TaskType } from '../types/types.js';
+import { saveConfig } from '../configuration/io.js';
+import { unflattenConfig } from '../configuration/transformation.js';
 import { Colors, getTextColor } from '../services/colors.js';
-import { createConfigStepsFromSchema } from '../services/components.js';
-import { DebugLevel, saveConfig, unflattenConfig, } from '../services/configuration.js';
+import { createConfigDefinitionWithKeys, createMessage, } from '../services/components.js';
 import { saveConfigLabels } from '../services/config-labels.js';
 import { useInput } from '../services/keyboard.js';
-import { formatErrorMessage } from '../services/messages.js';
+import { formatErrorMessage, getUnresolvedPlaceholdersMessage, } from '../services/messages.js';
 import { ensureMinimumTime } from '../services/timing.js';
-import { Config } from './Config.js';
 import { Spinner } from './Spinner.js';
 const MIN_PROCESSING_TIME = 1000;
-export function Validate({ missingConfig, userRequest, state, status, service, children, debug = DebugLevel.None, onError, onComplete, onAborted, stateHandlers, lifecycleHandlers, workflowHandlers, }) {
+export const ValidateView = ({ state, status }) => {
     const isActive = status === ComponentStatus.Active;
-    const [error, setError] = useState(state?.error ?? null);
-    const [completionMessage, setCompletionMessage] = useState(state?.completionMessage ?? null);
-    const [configRequirements, setConfigRequirements] = useState(state?.configRequirements ?? null);
+    const { error, completionMessage } = state;
+    // Don't render when not active and nothing to show
+    if (!isActive && !completionMessage && !error) {
+        return null;
+    }
+    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isActive && !completionMessage && !error && (_jsxs(Box, { marginLeft: 1, children: [_jsxs(Text, { color: getTextColor(isActive), children: ["Validating configuration requirements.", ' '] }), _jsx(Spinner, {})] })), completionMessage && (_jsx(Box, { marginLeft: 1, children: _jsx(Text, { color: getTextColor(isActive), children: completionMessage }) })), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) }))] }));
+};
+/**
+ * Validate controller: Validates missing config
+ */
+export function Validate({ missingConfig, userRequest, status, service, onError, requestHandlers, onValidationComplete, onAborted, lifecycleHandlers, workflowHandlers, }) {
+    const isActive = status === ComponentStatus.Active;
+    const [error, setError] = useState(null);
+    const [completionMessage, setCompletionMessage] = useState(null);
+    const [configRequirements, setConfigRequirements] = useState([]);
     useInput((_, key) => {
         if (key.escape && isActive) {
             onAborted('validation');
@@ -40,7 +52,7 @@ export function Validate({ missingConfig, userRequest, state, status, service, c
                 if (mounted) {
                     // Add debug components to timeline if present
                     if (result.debug?.length) {
-                        workflowHandlers?.addToTimeline(...result.debug);
+                        workflowHandlers.addToTimeline(...result.debug);
                     }
                     // Extract CONFIG tasks with descriptions from result
                     const configTasks = result.tasks.filter((task) => task.type === TaskType.Config);
@@ -57,25 +69,50 @@ export function Validate({ missingConfig, userRequest, state, status, service, c
                         };
                     });
                     // 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)];
+                    const message = getUnresolvedPlaceholdersMessage(withDescriptions.length);
                     setCompletionMessage(message);
                     setConfigRequirements(withDescriptions);
-                    // Save state after validation completes
-                    stateHandlers?.updateState({
+                    // Add validation message to timeline before Config component
+                    workflowHandlers.addToTimeline(createMessage(message));
+                    // Create Config component and add to queue
+                    const keys = withDescriptions.map((req) => req.path);
+                    const configDef = createConfigDefinitionWithKeys(keys, (config) => {
+                        // Convert flat dotted keys to nested structure grouped by section
+                        const configBySection = unflattenConfig(config);
+                        // Extract and save labels to cache
+                        const labels = {};
+                        for (const req of withDescriptions) {
+                            if (req.description) {
+                                labels[req.path] = req.description;
+                            }
+                        }
+                        saveConfigLabels(labels);
+                        // Save each section
+                        for (const [section, sectionConfig] of Object.entries(configBySection)) {
+                            saveConfig(section, sectionConfig);
+                        }
+                        // After config is saved, invoke callback to add Execute component to queue
+                        onValidationComplete(withDescriptions);
+                    }, (operation) => {
+                        onAborted(operation);
+                    });
+                    // Override descriptions with LLM-generated ones
+                    if ('props' in configDef && 'steps' in configDef.props) {
+                        configDef.props.steps = configDef.props.steps.map((step, index) => ({
+                            ...step,
+                            description: withDescriptions[index].description ||
+                                withDescriptions[index].path,
+                        }));
+                    }
+                    workflowHandlers.addToQueue(configDef);
+                    lifecycleHandlers.completeActive();
+                    const finalState = {
+                        error: null,
                         completionMessage: message,
                         configRequirements: withDescriptions,
                         validated: true,
-                        error: null,
-                    });
+                    };
+                    requestHandlers.onCompleted(finalState);
                 }
             }
             catch (err) {
@@ -83,13 +120,13 @@ export function Validate({ missingConfig, userRequest, state, status, service, c
                 if (mounted) {
                     const errorMessage = formatErrorMessage(err);
                     setError(errorMessage);
-                    // Save error state
-                    stateHandlers?.updateState({
+                    const finalState = {
                         error: errorMessage,
                         completionMessage: null,
-                        configRequirements: null,
+                        configRequirements: [],
                         validated: false,
-                    });
+                    };
+                    requestHandlers.onCompleted(finalState);
                     onError(errorMessage);
                 }
             }
@@ -103,59 +140,20 @@ export function Validate({ missingConfig, userRequest, state, status, service, c
         userRequest,
         isActive,
         service,
-        onComplete,
+        requestHandlers,
         onError,
         onAborted,
+        onValidationComplete,
+        lifecycleHandlers,
+        workflowHandlers,
     ]);
-    // Don't render when not active and nothing to show
-    if (!isActive && !completionMessage && !error && !children) {
-        return null;
-    }
-    // Create ConfigSteps from requirements using createConfigStepsFromSchema
-    // to load current values from config file, then override descriptions
-    const configSteps = configRequirements
-        ? (() => {
-            const keys = configRequirements.map((req) => req.path);
-            const steps = createConfigStepsFromSchema(keys);
-            // Override descriptions with LLM-generated ones
-            return steps.map((step, index) => ({
-                ...step,
-                description: configRequirements[index].description ||
-                    configRequirements[index].path,
-            }));
-        })()
-        : null;
-    const handleConfigFinished = (config) => {
-        // Convert flat dotted keys to nested structure grouped by section
-        const configBySection = unflattenConfig(config);
-        // Extract and save labels to cache
-        if (configRequirements) {
-            const labels = {};
-            for (const req of configRequirements) {
-                if (req.description) {
-                    labels[req.path] = req.description;
-                }
-            }
-            saveConfigLabels(labels);
-        }
-        // Save each section
-        for (const [section, sectionConfig] of Object.entries(configBySection)) {
-            saveConfig(section, sectionConfig);
-        }
-        // Mark validation component as complete before invoking callback
-        // This allows the workflow to proceed to execution
-        lifecycleHandlers?.completeActive();
-        // Invoke callback which will queue the Execute component
-        if (configRequirements) {
-            onComplete(configRequirements);
-        }
-    };
-    const handleConfigAborted = (operation) => {
-        // Mark validation component as complete when aborted
-        lifecycleHandlers?.completeActive();
-        onAborted(operation);
+    const state = {
+        error,
+        completionMessage,
+        configRequirements,
+        validated: error === null && completionMessage !== null,
     };
-    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isActive && !completionMessage && !error && (_jsxs(Box, { marginLeft: 1, children: [_jsxs(Text, { color: getTextColor(isActive), children: ["Validating configuration requirements.", ' '] }), _jsx(Spinner, {})] })), completionMessage && (_jsx(Box, { marginLeft: 1, children: _jsx(Text, { color: getTextColor(isActive), children: completionMessage }) })), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) })), configSteps && configSteps.length > 0 && !error && (_jsx(Box, { marginTop: 1, children: _jsx(Config, { steps: configSteps, status: status, debug: debug, onFinished: handleConfigFinished, onAborted: handleConfigAborted }) })), configSteps && configSteps.length === 0 && !error && (_jsx(Box, { marginTop: 1, marginLeft: 1, children: _jsx(Text, { color: Colors.Status.Error, children: "Error: No configuration steps generated. Please try again." }) })), children] }));
+    return _jsx(ValidateView, { state: state, status: status });
 }
 /**
  * Build prompt for VALIDATE tool

package/dist/ui/Workflow.js

@@ -3,12 +3,11 @@ import { useCallback, useEffect, useMemo, useState } from 'react';
 import { Box, Static } from 'ink';
 import { ComponentStatus, } from '../types/components.js';
 import { ComponentName, FeedbackType } from '../types/types.js';
-import { createFeedback, isStateless, markAsDone, } from '../services/components.js';
-import { DebugLevel } from '../services/configuration.js';
+import { createFeedback, isSimple, markAsDone, } from '../services/components.js';
 import { getWarnings } from '../services/logger.js';
 import { getCancellationMessage } from '../services/messages.js';
 import { exitApp } from '../services/process.js';
-import { Component } from './Component.js';
+import { SimpleComponent, ControllerComponent, TimelineComponent, } from './Component.js';
 export const Workflow = ({ initialQueue, debug }) => {
     const [timeline, setTimeline] = useState([]);
     const [current, setCurrent] = useState({ active: null, pending: null });
@@ -36,25 +35,39 @@ export const Workflow = ({ initialQueue, debug }) => {
             return { active: null, pending };
         });
     }, []);
-    // Focused handler instances - segregated by responsibility
-    const stateHandlers = useMemo(() => ({
-        updateState: (newState) => {
+    // Request handlers - manages errors, aborts, and completions
+    const requestHandlers = useMemo(() => ({
+        onError: (error) => {
+            moveActiveToTimeline();
+            // Add feedback to queue
+            setQueue((queue) => [
+                ...queue,
+                createFeedback(FeedbackType.Failed, error),
+            ]);
+        },
+        onAborted: (operation) => {
+            moveActiveToTimeline();
+            // Clear queue and add only feedback to prevent subsequent components from executing
+            const message = getCancellationMessage(operation);
+            setQueue([createFeedback(FeedbackType.Aborted, message)]);
+        },
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+        onCompleted: (finalState) => {
             setCurrent((curr) => {
                 const { active, pending } = curr;
                 if (!active || !('state' in active))
                     return curr;
-                const stateful = active;
+                // Save final state to definition
+                const managed = active;
                 const updated = {
-                    ...stateful,
-                    state: {
-                        ...stateful.state,
-                        ...newState,
-                    },
+                    ...managed,
+                    state: finalState,
                 };
                 return { active: updated, pending };
             });
         },
-    }), []);
+    }), [moveActiveToTimeline]);
+    // Lifecycle handlers - for components with active/pending states
     const lifecycleHandlers = useMemo(() => ({
         completeActive: (...items) => {
             moveActiveToPending();
@@ -62,33 +75,6 @@ export const Workflow = ({ initialQueue, debug }) => {
                 setQueue((queue) => [...items, ...queue]);
             }
         },
-    }), [moveActiveToPending]);
-    const queueHandlers = useMemo(() => ({
-        addToQueue: (...items) => {
-            setQueue((queue) => [...queue, ...items]);
-        },
-    }), []);
-    const errorHandlers = useMemo(() => ({
-        onAborted: (operation) => {
-            moveActiveToTimeline();
-            // Add feedback to queue
-            const message = getCancellationMessage(operation);
-            setQueue((queue) => [
-                ...queue,
-                createFeedback(FeedbackType.Aborted, message),
-            ]);
-        },
-        onError: (error) => {
-            moveActiveToTimeline();
-            // Add feedback to queue
-            setQueue((queue) => [
-                ...queue,
-                createFeedback(FeedbackType.Failed, error),
-            ]);
-        },
-    }), [moveActiveToTimeline]);
-    // Workflow handlers - used for timeline/queue management
-    const workflowHandlers = useMemo(() => ({
         completeActiveAndPending: (...items) => {
             setCurrent((curr) => {
                 const { active, pending } = curr;
@@ -107,6 +93,12 @@ export const Workflow = ({ initialQueue, debug }) => {
                 setQueue((queue) => [...items, ...queue]);
             }
         },
+    }), [moveActiveToPending]);
+    // Workflow handlers - manages queue and timeline
+    const workflowHandlers = useMemo(() => ({
+        addToQueue: (...items) => {
+            setQueue((queue) => [...queue, ...items]);
+        },
         addToTimeline: (...items) => {
             setTimeline((prev) => [...prev, ...items]);
         },
@@ -140,13 +132,13 @@ export const Workflow = ({ initialQueue, debug }) => {
         const { active, pending } = current;
         if (!active)
             return;
-        if (isStateless(active)) {
-            // Stateless components move directly to timeline
+        if (isSimple(active)) {
+            // Simple components move directly to timeline
             const doneComponent = markAsDone(active);
             setTimeline((prev) => [...prev, doneComponent]);
             setCurrent({ active: null, pending });
         }
-        // Stateful components stay in active until handlers move them to pending
+        // Managed components stay in active until handlers move them to pending
     }, [current]);
     // Check for accumulated warnings and add them to timeline
     useEffect(() => {
@@ -180,86 +172,18 @@ export const Workflow = ({ initialQueue, debug }) => {
             lastItem.props.type === FeedbackType.Failed;
         exitApp(isFailed ? 1 : 0);
     }, [current, queue, timeline]);
-    // Render active and pending components
-    const activeComponent = useMemo(() => {
-        const { active } = current;
-        if (!active)
-            return null;
-        // For stateless components, render as-is
-        if (isStateless(active)) {
-            return _jsx(Component, { def: active, debug: debug }, active.id);
-        }
-        // For stateful components, inject focused handlers
-        const statefulActive = active;
-        const wrappedDef = {
-            ...statefulActive,
-            props: {
-                ...statefulActive.props,
-                stateHandlers,
-                lifecycleHandlers,
-                queueHandlers,
-                errorHandlers,
-                workflowHandlers,
-            },
-        };
-        return _jsx(Component, { def: wrappedDef, debug: debug }, active.id);
-    }, [
-        current,
-        debug,
-        stateHandlers,
-        lifecycleHandlers,
-        queueHandlers,
-        errorHandlers,
-        workflowHandlers,
-    ]);
-    const pendingComponent = useMemo(() => {
-        const { pending } = current;
-        if (!pending)
+    // Render component with handlers (used for both active and pending)
+    const renderComponent = useCallback((def, status) => {
+        if (!def)
             return null;
-        // For stateless components, render as-is
-        if (isStateless(pending)) {
-            return _jsx(Component, { def: pending, debug: debug }, pending.id);
+        // For simple components, render as-is
+        if (isSimple(def)) {
+            return _jsx(SimpleComponent, { def: def }, def.id);
         }
-        // For stateful components, inject focused handlers (they may have useEffect hooks)
-        const statefulPending = pending;
-        const wrappedDef = {
-            ...statefulPending,
-            props: {
-                ...statefulPending.props,
-                stateHandlers,
-                lifecycleHandlers,
-                queueHandlers,
-                errorHandlers,
-                workflowHandlers,
-            },
-        };
-        return _jsx(Component, { def: wrappedDef, debug: debug }, pending.id);
-    }, [
-        current,
-        debug,
-        stateHandlers,
-        lifecycleHandlers,
-        queueHandlers,
-        errorHandlers,
-        workflowHandlers,
-    ]);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: timeline, children: (item) => {
-                    // For stateful timeline components, inject handlers (useEffect hooks may still run)
-                    let def = item;
-                    if (!isStateless(item)) {
-                        const statefulItem = item;
-                        def = {
-                            ...statefulItem,
-                            props: {
-                                ...statefulItem.props,
-                                stateHandlers,
-                                lifecycleHandlers,
-                                queueHandlers,
-                                errorHandlers,
-                                workflowHandlers,
-                            },
-                        };
-                    }
-                    return (_jsx(Box, { marginTop: 1, children: _jsx(Component, { def: def, debug: DebugLevel.None }) }, item.id));
-                } }, "timeline"), pendingComponent && _jsx(Box, { marginTop: 1, children: pendingComponent }), activeComponent && _jsx(Box, { marginTop: 1, children: activeComponent })] }));
+        // For managed components, inject handlers via ControllerComponent
+        return (_jsx(ControllerComponent, { def: { ...def, status }, debug: debug, requestHandlers: requestHandlers, lifecycleHandlers: lifecycleHandlers, workflowHandlers: workflowHandlers }, def.id));
+    }, [debug, requestHandlers, lifecycleHandlers, workflowHandlers]);
+    const activeComponent = useMemo(() => renderComponent(current.active, ComponentStatus.Active), [current.active, renderComponent]);
+    const pendingComponent = useMemo(() => renderComponent(current.pending, ComponentStatus.Pending), [current.pending, renderComponent]);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: timeline, children: (item) => (_jsx(Box, { marginTop: 1, children: _jsx(TimelineComponent, { def: item }) }, item.id)) }, "timeline"), pendingComponent && _jsx(Box, { marginTop: 1, children: pendingComponent }), activeComponent && _jsx(Box, { marginTop: 1, children: activeComponent })] }));
 };

package/package.json

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