prompt-language-shell 0.9.0 → 0.9.2

package/dist/ui/Task.js

@@ -1,175 +1,11 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useEffect, useRef, useState } from 'react';
 import { Box } from 'ink';
-import { ExecutionResult, ExecutionStatus, executeCommand, setOutputCallback, } from '../services/shell.js';
-import { calculateElapsed } from '../services/utils.js';
 import { Output } from './Output.js';
-import { Subtask } from './Subtask.js';
-export function Task({ label, command, isActive, isFinished, index, initialStatus, initialElapsed, initialOutput, onOutputChange, onComplete, onAbort, onError, }) {
-    const [status, setStatus] = useState(initialStatus ?? ExecutionStatus.Pending);
-    const [startTime, setStartTime] = useState();
-    const [endTime, setEndTime] = useState();
-    const [elapsed, setElapsed] = useState(initialElapsed);
-    const [currentElapsed, setCurrentElapsed] = useState(0);
-    const [stdout, setStdout] = useState(initialOutput?.stdout ?? '');
-    const [stderr, setStderr] = useState(initialOutput?.stderr ?? '');
-    const [error, setError] = useState(initialOutput?.error ?? '');
-    // Refs to track current output for callbacks (avoid stale closure)
-    const stdoutRef = useRef(stdout);
-    const stderrRef = useRef(stderr);
-    const errorRef = useRef(error);
-    stdoutRef.current = stdout;
-    stderrRef.current = stderr;
-    errorRef.current = error;
-    // Refs for callbacks to avoid stale closures in async effects
-    const onOutputChangeRef = useRef(onOutputChange);
-    const onCompleteRef = useRef(onComplete);
-    const onErrorRef = useRef(onError);
-    const onAbortRef = useRef(onAbort);
-    onOutputChangeRef.current = onOutputChange;
-    onCompleteRef.current = onComplete;
-    onErrorRef.current = onError;
-    onAbortRef.current = onAbort;
-    // Update elapsed time while running
-    useEffect(() => {
-        if (status !== ExecutionStatus.Running || !startTime)
-            return;
-        const interval = setInterval(() => {
-            setCurrentElapsed((prev) => {
-                const next = Date.now() - startTime;
-                return next !== prev ? next : prev;
-            });
-        }, 1000);
-        return () => {
-            clearInterval(interval);
-        };
-    }, [status, startTime]);
-    // Execute command when becoming active
-    useEffect(() => {
-        // Don't execute if task is cancelled or if not active
-        if (!isActive ||
-            status === ExecutionStatus.Cancelled ||
-            status !== ExecutionStatus.Pending) {
-            return;
-        }
-        let mounted = true;
-        async function execute() {
-            const start = Date.now();
-            setStatus(ExecutionStatus.Running);
-            setStartTime(start);
-            setCurrentElapsed(0);
-            setStdout('');
-            setStderr('');
-            setError('');
-            // Set up output callback to capture real-time output
-            setOutputCallback((data, stream) => {
-                if (!mounted)
-                    return;
-                if (stream === 'stdout') {
-                    setStdout((prev) => {
-                        const newStdout = prev + data;
-                        stdoutRef.current = newStdout;
-                        // Report output change to parent using refs for current values
-                        onOutputChangeRef.current?.(index, {
-                            stdout: newStdout,
-                            stderr: stderrRef.current,
-                            error: errorRef.current,
-                        });
-                        return newStdout;
-                    });
-                }
-                else {
-                    setStderr((prev) => {
-                        const newStderr = prev + data;
-                        stderrRef.current = newStderr;
-                        // Report output change to parent using refs for current values
-                        onOutputChangeRef.current?.(index, {
-                            stdout: stdoutRef.current,
-                            stderr: newStderr,
-                            error: errorRef.current,
-                        });
-                        return newStderr;
-                    });
-                }
-            });
-            try {
-                const output = await executeCommand(command, undefined, index);
-                setOutputCallback(undefined); // Clear callback
-                if (!mounted)
-                    return;
-                const end = Date.now();
-                setEndTime(end);
-                const taskDuration = calculateElapsed(start);
-                setElapsed(taskDuration);
-                setStatus(output.result === ExecutionResult.Success
-                    ? ExecutionStatus.Success
-                    : ExecutionStatus.Failed);
-                if (output.result === ExecutionResult.Success) {
-                    const taskOutput = {
-                        stdout: output.output,
-                        stderr: output.errors,
-                        error: '',
-                        workdir: output.workdir,
-                    };
-                    onCompleteRef.current?.(index, taskDuration, taskOutput);
-                }
-                else {
-                    const errorMsg = output.errors || output.error || 'Command failed';
-                    setError(errorMsg);
-                    const taskOutput = {
-                        stdout: output.output,
-                        stderr: output.errors,
-                        error: errorMsg,
-                        workdir: output.workdir,
-                    };
-                    onErrorRef.current?.(index, errorMsg, taskDuration, taskOutput);
-                }
-            }
-            catch (err) {
-                setOutputCallback(undefined); // Clear callback
-                if (!mounted)
-                    return;
-                const end = Date.now();
-                setEndTime(end);
-                const errorDuration = calculateElapsed(start);
-                setElapsed(errorDuration);
-                setStatus(ExecutionStatus.Failed);
-                const errorMsg = err instanceof Error ? err.message : 'Unknown error';
-                setError(errorMsg);
-                const taskOutput = {
-                    stdout: stdoutRef.current,
-                    stderr: stderrRef.current,
-                    error: errorMsg,
-                };
-                // Use try/catch to prevent callback errors from propagating
-                try {
-                    onErrorRef.current?.(index, errorMsg, errorDuration, taskOutput);
-                }
-                catch {
-                    // Callback error - already set error state above
-                }
-            }
-        }
-        void execute();
-        return () => {
-            mounted = false;
-        };
-    }, [isActive]);
-    // Handle abort when task becomes inactive while running
-    useEffect(() => {
-        if (!isActive && status === ExecutionStatus.Running && startTime) {
-            // Task was aborted mid-execution
-            const end = Date.now();
-            setEndTime(end);
-            setElapsed(calculateElapsed(startTime));
-            setStatus(ExecutionStatus.Aborted);
-            const taskOutput = {
-                stdout: stdoutRef.current,
-                stderr: stderrRef.current,
-                error: errorRef.current,
-            };
-            onAbortRef.current?.(index, taskOutput);
-        }
-    }, [isActive, status, startTime, index]);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Subtask, { label: label, command: command, status: status, isActive: isActive, startTime: startTime, endTime: endTime, elapsed: status === ExecutionStatus.Running ? currentElapsed : elapsed }), _jsx(Output, { stdout: stdout, stderr: stderr, isFinished: isFinished, status: status }, `${stdout.length}-${stderr.length}`)] }));
+import { SubtaskView } from './Subtask.js';
+/**
+ * Pure display component for a task.
+ * Combines SubtaskView (label/command/status) with Output (stdout/stderr).
+ */
+export function TaskView({ label, command, status, elapsed, stdout, stderr, isFinished, }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(SubtaskView, { label: label, command: command, status: status, elapsed: elapsed }), _jsx(Output, { stdout: stdout, stderr: stderr, isFinished: isFinished, status: status }, `${stdout.length}-${stderr.length}`)] }));
 }

package/dist/ui/Validate.js

@@ -4,10 +4,11 @@ import { Box, Text } from 'ink';
 import { ComponentStatus, } from '../types/components.js';
 import { TaskType } from '../types/types.js';
 import { saveConfig } from '../configuration/io.js';
+import { createConfigStepsFromSchema } from '../configuration/steps.js';
 import { unflattenConfig } from '../configuration/transformation.js';
 import { Colors, getTextColor } from '../services/colors.js';
-import { createConfigDefinitionWithKeys, createMessage, } from '../services/components.js';
-import { saveConfigLabels } from '../services/config-labels.js';
+import { createConfig, createMessage } from '../services/components.js';
+import { saveConfigLabels } from '../configuration/labels.js';
 import { useInput } from '../services/keyboard.js';
 import { formatErrorMessage, getUnresolvedPlaceholdersMessage, } from '../services/messages.js';
 import { ensureMinimumTime } from '../services/timing.js';
@@ -73,28 +74,32 @@ export function Validate({ missingConfig, userRequest, status, service, onError,
                     setCompletionMessage(message);
                     setConfigRequirements(withDescriptions);
                     // Add validation message to timeline before Config component
-                    workflowHandlers.addToTimeline(createMessage(message));
+                    workflowHandlers.addToTimeline(createMessage({ text: 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;
+                    const configDef = createConfig({
+                        steps: createConfigStepsFromSchema(keys),
+                        onFinished: (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);
+                            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);
+                        },
+                        onAborted: (operation) => {
+                            onAborted(operation);
+                        },
                     });
                     // Override descriptions with LLM-generated ones
                     if ('props' in configDef && 'steps' in configDef.props) {

package/dist/ui/Workflow.js

@@ -3,11 +3,19 @@ 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, isSimple, markAsDone, } from '../services/components.js';
+import { createFeedback } from '../services/components.js';
 import { getWarnings } from '../services/logger.js';
 import { getCancellationMessage } from '../services/messages.js';
 import { exitApp } from '../services/process.js';
 import { SimpleComponent, ControllerComponent, TimelineComponent, } from './Component.js';
+/**
+ * Mark a component as done. Returns the component to be added to timeline.
+ * Components use handlers.updateState to save their state before completion,
+ * so this function sets the status to Done and returns the updated component.
+ */
+function markAsDone(component) {
+    return { ...component, status: ComponentStatus.Done };
+}
 export const Workflow = ({ initialQueue, debug }) => {
     const [timeline, setTimeline] = useState([]);
     const [current, setCurrent] = useState({ active: null, pending: null });
@@ -42,14 +50,14 @@ export const Workflow = ({ initialQueue, debug }) => {
             // Add feedback to queue
             setQueue((queue) => [
                 ...queue,
-                createFeedback(FeedbackType.Failed, error),
+                createFeedback({ type: FeedbackType.Failed, message: 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)]);
+            setQueue([createFeedback({ type: FeedbackType.Aborted, message })]);
         },
         // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
         onCompleted: (finalState) => {
@@ -144,7 +152,7 @@ export const Workflow = ({ initialQueue, debug }) => {
     useEffect(() => {
         const warningMessages = getWarnings();
         if (warningMessages.length > 0) {
-            const warningComponents = warningMessages.map((msg) => markAsDone(createFeedback(FeedbackType.Warning, msg)));
+            const warningComponents = warningMessages.map((msg) => createFeedback({ type: FeedbackType.Warning, message: msg }, ComponentStatus.Done));
             setTimeline((prev) => [...prev, ...warningComponents]);
         }
     }, [timeline, current]);
@@ -187,3 +195,12 @@ export const Workflow = ({ initialQueue, debug }) => {
     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 })] }));
 };
+/**
+ * Check if a component is stateless (simple).
+ * Stateless components are display-only and complete immediately without
+ * tracking internal state. Stateful components manage user interaction
+ * and maintain state across their lifecycle.
+ */
+export function isSimple(component) {
+    return !('state' in component);
+}

package/package.json

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

package/dist/parser.js

@@ -1,13 +0,0 @@
-/**
- * Parses a comma-separated list of tasks from command-line prompt
- * Strips exclamation marks and periods from each task
- *
- * @param prompt - Raw command-line input string
- * @returns Array of parsed task strings
- */
-export function parseCommands(prompt) {
-    return prompt
-        .split(',')
-        .map((task) => task.trim().replace(/[!.]/g, '').trim())
-        .filter((task) => task.length > 0);
-}

package/dist/services/config-utils.js

@@ -1,20 +0,0 @@
-/**
- * Utility functions for config manipulation
- */
-/**
- * Flatten nested config object to dot notation
- * Example: { a: { b: 1 } } => { 'a.b': 1 }
- */
-export function flattenConfig(obj, prefix = '') {
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-        const fullKey = prefix ? `${prefix}.${key}` : key;
-        if (value && typeof value === 'object' && !Array.isArray(value)) {
-            Object.assign(result, flattenConfig(value, fullKey));
-        }
-        else {
-            result[fullKey] = value;
-        }
-    }
-    return result;
-}