prompt-language-shell 0.8.8 → 0.9.2

package/dist/ui/Output.js

@@ -0,0 +1,54 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { Palette } from '../services/colors.js';
+import { ExecutionStatus } from '../services/shell.js';
+const MAX_LINES = 8;
+const MAX_WIDTH = 75;
+const SHORT_OUTPUT_THRESHOLD = 4;
+const MINIMAL_INFO_THRESHOLD = 2;
+/**
+ * Get the last N lines from text, filtering out empty/whitespace-only lines
+ */
+export function getLastLines(text, maxLines = MAX_LINES) {
+    const lines = text
+        .trim()
+        .split(/\r?\n/)
+        .filter((line) => line.trim().length > 0);
+    return lines.length <= maxLines ? lines : lines.slice(-maxLines);
+}
+/**
+ * Compute display configuration for output rendering.
+ * Encapsulates the logic for what to show and how to style it.
+ */
+export function computeDisplayConfig(stdout, stderr, status, isFinished) {
+    const hasStdout = stdout.trim().length > 0;
+    const hasStderr = stderr.trim().length > 0;
+    if (!hasStdout && !hasStderr)
+        return null;
+    const stdoutLines = hasStdout ? getLastLines(stdout) : [];
+    const stderrLines = hasStderr ? getLastLines(stderr) : [];
+    // Show stdout if no stderr, or if stderr is minimal (provides context)
+    const showStdout = hasStdout && (!hasStderr || stderrLines.length <= MINIMAL_INFO_THRESHOLD);
+    // Use word wrapping for short outputs to show more detail
+    const totalLines = stdoutLines.length + stderrLines.length;
+    const wrapMode = totalLines <= SHORT_OUTPUT_THRESHOLD ? 'wrap' : 'truncate-end';
+    // Darker colors for finished tasks
+    const baseColor = isFinished ? Palette.DarkGray : Palette.Gray;
+    const stderrColor = status === ExecutionStatus.Failed ? Palette.Yellow : baseColor;
+    return {
+        stdoutLines,
+        stderrLines,
+        showStdout,
+        wrapMode,
+        stdoutColor: baseColor,
+        stderrColor,
+    };
+}
+export function Output({ stdout, stderr, status, isFinished }) {
+    const config = computeDisplayConfig(stdout, stderr, status, isFinished ?? false);
+    if (!config)
+        return null;
+    const { stdoutLines, stderrLines, showStdout, wrapMode, stdoutColor, stderrColor, } = config;
+    return (_jsxs(Box, { marginTop: 1, marginLeft: 5, flexDirection: "column", width: MAX_WIDTH, children: [showStdout &&
+                stdoutLines.map((line, index) => (_jsx(Text, { color: stdoutColor, wrap: wrapMode, children: line }, `out-${index}`))), stderrLines.map((line, index) => (_jsx(Text, { color: stderrColor, wrap: wrapMode, children: line }, `err-${index}`)))] }));
+}

package/dist/ui/Schedule.js

@@ -79,6 +79,8 @@ export function taskToListItem(task, highlightedChildIndex = null, isDefineTaskW
 export const ScheduleView = ({ message, tasks, state, status, debug = DebugLevel.None, }) => {
     const isActive = status === ComponentStatus.Active;
     const { highlightedIndex, currentDefineGroupIndex, completedSelections } = state;
+    // Use compact mode when all tasks are Config type
+    const isCompact = tasks.every((task) => task.type === TaskType.Config);
     // Find all Define tasks
     const defineTaskIndices = tasks
         .map((t, idx) => (t.type === TaskType.Define ? idx : -1))
@@ -114,7 +116,7 @@ export const ScheduleView = ({ message, tasks, state, status, debug = DebugLevel
             isActive;
         return taskToListItem(task, childIndex, isDefineWithoutSelection, status, debug);
     });
-    return (_jsxs(Box, { flexDirection: "column", children: [message && (_jsx(Box, { marginBottom: 1, marginLeft: 1, children: _jsx(Label, { description: message, taskType: TaskType.Schedule, showType: debug !== DebugLevel.None, status: status, debug: debug }) })), _jsx(Box, { marginLeft: 1, children: _jsx(List, { items: listItems, highlightedIndex: currentDefineTaskIndex >= 0 ? highlightedIndex : null, highlightedParentIndex: currentDefineTaskIndex, showType: debug !== DebugLevel.None }) })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [message && (_jsx(Box, { marginBottom: 1, marginLeft: 1, children: _jsx(Label, { description: message, taskType: TaskType.Schedule, showType: debug !== DebugLevel.None, status: status, debug: debug }) })), _jsx(Box, { marginLeft: 1, children: _jsx(List, { items: listItems, highlightedIndex: currentDefineTaskIndex >= 0 ? highlightedIndex : null, highlightedParentIndex: currentDefineTaskIndex, showType: debug !== DebugLevel.None, compact: isCompact }) })] }));
 };
 /**
  * Schedule controller: Manages task selection and navigation

package/dist/ui/Subtask.js

@@ -4,7 +4,11 @@ import { getStatusColors, Palette, STATUS_ICONS } from '../services/colors.js';
 import { ExecutionStatus } from '../services/shell.js';
 import { formatDuration } from '../services/utils.js';
 import { Spinner } from './Spinner.js';
-export function Subtask({ label, command, status, isActive: _isActive, startTime, endTime, elapsed, }) {
+/**
+ * Pure display component for a single subtask.
+ * Shows label, command, status icon, and elapsed time.
+ */
+export function SubtaskView({ label, command, status, elapsed, }) {
     const colors = getStatusColors(status);
     const isCancelled = status === ExecutionStatus.Cancelled;
     const isAborted = status === ExecutionStatus.Aborted;
@@ -12,11 +16,10 @@ export function Subtask({ label, command, status, isActive: _isActive, startTime
     const isFinished = status === ExecutionStatus.Success ||
         status === ExecutionStatus.Failed ||
         status === ExecutionStatus.Aborted;
-    const elapsedTime = elapsed ?? (startTime && endTime ? endTime - startTime : undefined);
     // Apply strikethrough for cancelled and aborted tasks
     const formatText = (text) => shouldStrikethrough ? text.split('').join('\u0336') + '\u0336' : text;
     return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { paddingLeft: 2, gap: 1, children: [_jsx(Text, { color: colors.icon, children: STATUS_ICONS[status] }), _jsx(Text, { color: colors.description, children: shouldStrikethrough
                             ? formatText(label || command.description)
                             : label || command.description }), (isFinished || status === ExecutionStatus.Running) &&
-                        elapsedTime !== undefined && (_jsxs(Text, { color: Palette.DarkGray, children: ["(", formatDuration(elapsedTime), ")"] }))] }), _jsxs(Box, { paddingLeft: 5, flexDirection: "row", children: [_jsx(Box, { children: _jsx(Text, { color: colors.symbol, children: "\u221F " }) }), _jsxs(Box, { gap: 1, children: [_jsx(Text, { color: colors.command, children: command.command }), status === ExecutionStatus.Running && _jsx(Spinner, {})] })] })] }));
+                        elapsed !== undefined && (_jsxs(Text, { color: Palette.DarkGray, children: ["(", formatDuration(elapsed), ")"] }))] }), _jsxs(Box, { paddingLeft: 5, flexDirection: "row", children: [_jsx(Box, { children: _jsx(Text, { color: colors.symbol, children: "\u221F " }) }), _jsxs(Box, { gap: 1, children: [_jsx(Text, { color: colors.command, children: command.command }), status === ExecutionStatus.Running && _jsx(Spinner, {})] })] })] }));
 }

package/dist/ui/Task.js

@@ -1,86 +1,11 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { useEffect, useState } from 'react';
-import { ExecutionResult, ExecutionStatus, executeCommand, } from '../services/shell.js';
-import { calculateElapsed } from '../services/utils.js';
-import { Subtask } from './Subtask.js';
-export function Task({ label, command, isActive, index, initialStatus, initialElapsed, 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);
-    // 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);
-            try {
-                const output = await executeCommand(command, undefined, index);
-                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) {
-                    onComplete?.(index, output, taskDuration);
-                }
-                else {
-                    onError?.(index, output.errors || 'Command failed', taskDuration);
-                }
-            }
-            catch (err) {
-                if (!mounted)
-                    return;
-                const end = Date.now();
-                setEndTime(end);
-                const errorDuration = calculateElapsed(start);
-                setElapsed(errorDuration);
-                setStatus(ExecutionStatus.Failed);
-                onError?.(index, err instanceof Error ? err.message : 'Unknown error', errorDuration);
-            }
-        }
-        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);
-            onAbort?.(index);
-        }
-    }, [isActive, status, startTime, index, onAbort]);
-    return (_jsx(Subtask, { label: label, command: command, status: status, isActive: isActive, startTime: startTime, endTime: endTime, elapsed: status === ExecutionStatus.Running ? currentElapsed : elapsed }));
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box } from 'ink';
+import { Output } from './Output.js';
+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.8.8",
+  "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;
-}