prompt-language-shell 0.5.2 → 0.6.0

package/dist/ui/Plan.js

@@ -49,11 +49,11 @@ function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutS
     }
     return item;
 }
-export function Plan({ message, tasks, state, debug = false, onSelectionConfirmed, onAborted, }) {
+export function Plan({ message, tasks, state, isActive = true, debug = false, handlers, onSelectionConfirmed, }) {
+    // isActive passed as prop
     const [highlightedIndex, setHighlightedIndex] = useState(state?.highlightedIndex ?? null);
     const [currentDefineGroupIndex, setCurrentDefineGroupIndex] = useState(state?.currentDefineGroupIndex ?? 0);
     const [completedSelections, setCompletedSelections] = useState(state?.completedSelections ?? []);
-    const [isDone, setIsDone] = useState(state?.done ?? false);
     // Find all Define tasks
     const defineTaskIndices = tasks
         .map((t, idx) => (t.type === TaskType.Define ? idx : -1))
@@ -65,13 +65,29 @@ export function Plan({ message, tasks, state, debug = false, onSelectionConfirme
         ? defineTask.params.options.length
         : 0;
     const hasMoreGroups = currentDefineGroupIndex < defineTaskIndices.length - 1;
+    // If no DEFINE tasks, immediately confirm with all tasks
+    useEffect(() => {
+        if (isActive && defineTaskIndices.length === 0 && onSelectionConfirmed) {
+            // No selection needed - all tasks are concrete
+            const concreteTasks = tasks.filter((task) => task.type !== TaskType.Ignore && task.type !== TaskType.Discard);
+            onSelectionConfirmed(concreteTasks);
+            // Signal Plan completion after adding Confirm to queue
+            handlers?.onComplete();
+        }
+    }, [
+        isActive,
+        defineTaskIndices.length,
+        tasks,
+        onSelectionConfirmed,
+        handlers,
+    ]);
     useInput((input, key) => {
-        // Don't handle input if already done or no define task
-        if (isDone || !defineTask) {
+        // Don't handle input if not active or no define task
+        if (!isActive || !defineTask) {
             return;
         }
         if (key.escape) {
-            onAborted();
+            handlers?.onAborted('task selection');
             return;
         }
         if (key.downArrow) {
@@ -97,16 +113,13 @@ export function Plan({ message, tasks, state, debug = false, onSelectionConfirme
             setCompletedSelections(newCompletedSelections);
             if (hasMoreGroups) {
                 // Advance to next group
-                setCurrentDefineGroupIndex(currentDefineGroupIndex + 1);
+                const newGroupIndex = currentDefineGroupIndex + 1;
+                setCurrentDefineGroupIndex(newGroupIndex);
                 setHighlightedIndex(null);
             }
             else {
-                // Last group - mark as done to show the selection
-                setIsDone(true);
-                setHighlightedIndex(null); // Clear highlight to show Execute color
-                if (state) {
-                    state.done = true;
-                }
+                // Clear highlight to show Execute color
+                setHighlightedIndex(null);
                 // Build refined task list with only selected options (no discarded or ignored ones)
                 const refinedTasks = [];
                 tasks.forEach((task, idx) => {
@@ -116,8 +129,10 @@ export function Plan({ message, tasks, state, debug = false, onSelectionConfirme
                         // This is a Define task - only include the selected option
                         const options = task.params.options;
                         const selectedIndex = newCompletedSelections[defineGroupIndex];
+                        const selectedOption = String(options[selectedIndex]);
+                        // Use Execute as default - LLM will properly classify during refinement
                         refinedTasks.push({
-                            action: String(options[selectedIndex]),
+                            action: selectedOption,
                             type: TaskType.Execute,
                         });
                     }
@@ -127,26 +142,33 @@ export function Plan({ message, tasks, state, debug = false, onSelectionConfirme
                         refinedTasks.push(task);
                     }
                 });
-                onSelectionConfirmed?.(refinedTasks);
+                if (onSelectionConfirmed) {
+                    // Callback will handle the entire flow (Refinement, refined Plan, Confirm)
+                    // So we need to complete the Plan first
+                    handlers?.onComplete();
+                    onSelectionConfirmed(refinedTasks);
+                }
+                else {
+                    // No selection callback, just complete normally
+                    handlers?.onComplete();
+                }
             }
         }
-    }, { isActive: !isDone && defineTask !== null });
-    // Sync state back to state object
+    }, { isActive: isActive && defineTask !== null });
+    // Sync state back to component definition
+    // This ensures timeline can render historical state and tests can validate behavior
     useEffect(() => {
-        if (state) {
-            state.highlightedIndex = highlightedIndex;
-            state.currentDefineGroupIndex = currentDefineGroupIndex;
-            state.completedSelections = completedSelections;
-            state.done = isDone;
-        }
+        handlers?.updateState({
+            highlightedIndex,
+            currentDefineGroupIndex,
+            completedSelections,
+        });
     }, [
         highlightedIndex,
         currentDefineGroupIndex,
         completedSelections,
-        isDone,
-        state,
+        handlers,
     ]);
-    const isCurrent = isDone === false;
     const listItems = tasks.map((task, idx) => {
         // Find which define group this task belongs to (if any)
         const defineGroupIndex = defineTaskIndices.indexOf(idx);
@@ -159,9 +181,9 @@ export function Plan({ message, tasks, state, debug = false, onSelectionConfirme
                 childIndex = completedSelections[defineGroupIndex] ?? null;
             }
             else if (defineGroupIndex === currentDefineGroupIndex) {
-                // Current active group - show live navigation unless done
-                if (isDone) {
-                    // If done, show the completed selection for this group too
+                // Current active group - show live navigation unless not active
+                if (!isActive) {
+                    // If not active, show the completed selection for this group too
                     childIndex = completedSelections[defineGroupIndex] ?? null;
                 }
                 else {
@@ -169,12 +191,12 @@ export function Plan({ message, tasks, state, debug = false, onSelectionConfirme
                 }
             }
         }
-        // Show arrow on current active define task when no child is highlighted and not done
+        // Show arrow on current active define task when no child is highlighted and is active
         const isDefineWithoutSelection = isDefineTask &&
             defineGroupIndex === currentDefineGroupIndex &&
             highlightedIndex === null &&
-            !isDone;
-        return taskToListItem(task, childIndex, isDefineWithoutSelection, isCurrent);
+            isActive;
+        return taskToListItem(task, childIndex, isDefineWithoutSelection, isActive);
     });
-    return (_jsxs(Box, { flexDirection: "column", children: [message && (_jsx(Box, { marginBottom: 1, children: _jsx(Label, { description: message, taskType: TaskType.Plan, showType: debug, isCurrent: isCurrent }) })), _jsx(List, { items: listItems, highlightedIndex: currentDefineTaskIndex >= 0 ? highlightedIndex : null, highlightedParentIndex: currentDefineTaskIndex, showType: debug })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [message && (_jsx(Box, { marginBottom: 1, marginLeft: 1, children: _jsx(Label, { description: message, taskType: TaskType.Plan, showType: debug, isCurrent: isActive }) })), _jsx(Box, { marginLeft: 1, children: _jsx(List, { items: listItems, highlightedIndex: currentDefineTaskIndex >= 0 ? highlightedIndex : null, highlightedParentIndex: currentDefineTaskIndex, showType: debug }) })] }));
 }

package/dist/ui/Refinement.js

@@ -3,13 +3,12 @@ import { Box } from 'ink';
 import { useInput } from '../services/keyboard.js';
 import { Message } from './Message.js';
 import { Spinner } from './Spinner.js';
-export const Refinement = ({ text, state, onAborted }) => {
-    const isDone = state?.done ?? false;
-    useInput((input, key) => {
-        if (key.escape && !isDone) {
-            onAborted();
+export const Refinement = ({ text, isActive = true, onAborted, }) => {
+    useInput((_, key) => {
+        if (key.escape && isActive) {
+            onAborted('plan refinement');
             return;
         }
-    }, { isActive: !isDone });
-    return (_jsxs(Box, { gap: 1, children: [_jsx(Message, { text: text }), !isDone && _jsx(Spinner, {})] }));
+    }, { isActive });
+    return (_jsxs(Box, { gap: 1, children: [_jsx(Message, { text: text }), isActive && _jsx(Spinner, {})] }));
 };

package/dist/ui/Report.js

@@ -10,5 +10,5 @@ function CapabilityItem({ name, description, isBuiltIn, isIndirect, }) {
     return (_jsxs(Box, { children: [_jsx(Text, { children: "- " }), _jsx(Text, { color: color, children: name }), _jsxs(Text, { children: [" - ", description] })] }));
 }
 export function Report({ message, capabilities }) {
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: message }), _jsx(Box, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: capabilities.map((capability, index) => (_jsx(CapabilityItem, { name: capability.name, description: capability.description, isBuiltIn: capability.isBuiltIn, isIndirect: capability.isIndirect }, index))) })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginLeft: 1, children: _jsx(Text, { children: message }) }), _jsx(Box, { flexDirection: "column", marginLeft: 3, marginTop: 1, children: capabilities.map((capability, index) => (_jsx(CapabilityItem, { name: capability.name, description: capability.description, isBuiltIn: capability.isBuiltIn, isIndirect: capability.isIndirect }, index))) })] }));
 }

package/dist/ui/UserQuery.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { Colors } from '../services/colors.js';
+export function UserQuery({ children }) {
+    return (_jsx(Box, { paddingX: 1, alignSelf: "flex-start", backgroundColor: Colors.Background.UserQuery, children: _jsx(Text, { color: Colors.Text.UserQuery, children: children }) }));
+}

package/dist/ui/Validate.js

@@ -6,29 +6,29 @@ 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 { saveConfig, unflattenConfig } from '../services/configuration.js';
+import { Config, StepType } from './Config.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;
+export function Validate({ missingConfig, userRequest, state, isActive = true, service, children, debug, onError, onComplete, onAborted, handlers, }) {
+    // isActive passed as prop
     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();
+    const [configRequirements, setConfigRequirements] = useState(null);
+    const [showConfig, setShowConfig] = useState(false);
+    useInput((_, key) => {
+        if (key.escape && isActive && !showConfig) {
+            onAborted('validation');
         }
-    }, { isActive: isLoading && !done });
+    }, { isActive: isActive && !showConfig });
     useEffect(() => {
-        // Skip processing if done
-        if (done) {
+        // Skip processing if not active
+        if (!isActive) {
             return;
         }
         // Skip processing if no service available
         if (!service) {
             setError('No service available');
-            setIsLoading(false);
             return;
         }
         let mounted = true;
@@ -67,15 +67,22 @@ export function Validate({ missingConfig, userRequest, state, service, children,
                     ];
                     const message = messages[Math.floor(Math.random() * messages.length)];
                     setCompletionMessage(message);
-                    setIsLoading(false);
-                    onComplete?.(withDescriptions);
+                    setConfigRequirements(withDescriptions);
+                    // Save state after validation completes
+                    handlers?.updateState({
+                        configRequirements: withDescriptions,
+                        validated: true,
+                    });
                 }
             }
             catch (err) {
                 await ensureMinimumTime(startTime, MIN_PROCESSING_TIME);
                 if (mounted) {
                     const errorMessage = formatErrorMessage(err);
-                    setIsLoading(false);
+                    // Save error state
+                    handlers?.updateState({
+                        error: errorMessage,
+                    });
                     if (onError) {
                         onError(errorMessage);
                     }
@@ -92,17 +99,40 @@ export function Validate({ missingConfig, userRequest, state, service, children,
     }, [
         missingConfig,
         userRequest,
-        done,
+        isActive,
         service,
         onComplete,
         onError,
         onAborted,
     ]);
-    // Don't render when done and nothing to show
-    if (done && !completionMessage && !error && !children) {
+    // Don't render when not active and nothing to show
+    if (!isActive && !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] }));
+    // Create ConfigSteps from requirements
+    const configSteps = configRequirements
+        ? configRequirements.map((req) => ({
+            description: req.description || req.path,
+            key: req.path,
+            path: req.path,
+            type: StepType.Text,
+            value: null,
+            validate: () => true,
+        }))
+        : null;
+    const handleConfigFinished = (config) => {
+        // Convert flat dotted keys to nested structure grouped by section
+        const configBySection = unflattenConfig(config);
+        // Save each section
+        for (const [section, sectionConfig] of Object.entries(configBySection)) {
+            saveConfig(section, sectionConfig);
+        }
+        onComplete?.(configRequirements);
+    };
+    const handleConfigAborted = (operation) => {
+        onAborted(operation);
+    };
+    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 && !error && (_jsx(Box, { marginTop: 1, children: _jsx(Config, { steps: configSteps, isActive: isActive, debug: debug, onFinished: handleConfigFinished, onAborted: handleConfigAborted, handlers: handlers }) })), children] }));
 }
 /**
  * Build prompt for VALIDATE tool

package/dist/ui/Welcome.js

@@ -21,7 +21,7 @@ function Description({ description }) {
 function Usage() {
     return (_jsxs(Box, { flexDirection: "column", marginTop: 1, gap: 1, children: [_jsx(Section, { title: "Get started:", children: _jsx(Example, { children: "list skills" }) }), _jsx(Section, { title: "Usage:", children: _jsx(Example, { children: "[describe your request]" }) })] }));
 }
-function Section({ title, children, }) {
+function Section({ title, children }) {
     return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: Palette.White, children: title }), children] }));
 }
 function Example({ children }) {

package/dist/ui/Workflow.js

@@ -0,0 +1,119 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, 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);
+    // Function to move active component to timeline
+    const moveActiveToTimeline = useCallback(() => {
+        setActive((curr) => {
+            if (!curr)
+                return null;
+            const doneComponent = markAsDone(curr);
+            setTimeline((prev) => [...prev, doneComponent]);
+            return null;
+        });
+    }, []);
+    // Global handlers for all stateful components
+    const handlers = useMemo(() => ({
+        onComplete: () => {
+            moveActiveToTimeline();
+        },
+        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: () => {
+            moveActiveToTimeline();
+        },
+        updateState: (newState) => {
+            setActive((curr) => {
+                if (!curr || !('state' in curr))
+                    return curr;
+                const stateful = curr;
+                return {
+                    ...stateful,
+                    state: {
+                        ...stateful.state,
+                        ...newState,
+                    },
+                };
+            });
+        },
+    }), [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.0",
   "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 };
-}