prompt-language-shell 0.3.4 → 0.3.8

package/README.md

@@ -45,6 +45,12 @@ Your configuration is stored in `~/.plsrc` as a YAML file. Supported settings:
 - `anthropic.key` - Your API key
 - `anthropic.model` - The model to use
 
+## Skills
+
+You can extend `pls` with custom workflows by creating markdown files in `~/.pls/skills/`. Skills define domain-specific operations, parameters, and steps that guide both planning and execution of tasks.
+
+Your skills are referenced when planning requests, enabling `pls` to understand specific workflows, create and execute structured plans tailored to your environment.
+
 ## Development
 
 See [CLAUDE.md](./CLAUDE.md) for development guidelines and architecture.

package/dist/index.js

@@ -20,6 +20,7 @@ const app = {
     version: packageJson.version,
     description: packageJson.description,
     isDev,
+    isDebug: false,
 };
 // Get command from command-line arguments
 const args = process.argv.slice(2);

package/dist/services/components.js

@@ -1,10 +1,22 @@
 import { randomUUID } from 'node:crypto';
-import { ComponentName, } from '../types/components.js';
-import { StepType } from '../ui/Config.js';
+import { ComponentName } from '../types/types.js';
 import { AnthropicModel, isValidAnthropicApiKey, isValidAnthropicModel, } from './config.js';
+import { getConfirmationMessage } from './messages.js';
+import { StepType } from '../ui/Config.js';
 export function markAsDone(component) {
     return { ...component, state: { ...component.state, done: true } };
 }
+export function getRefiningMessage() {
+    const messages = [
+        'Let me work out the specifics for you.',
+        "I'll figure out the concrete steps.",
+        'Let me break this down into tasks.',
+        "I'll plan out the details.",
+        'Let me arrange the steps.',
+        "I'll prepare everything you need.",
+    ];
+    return messages[Math.floor(Math.random() * messages.length)];
+}
 export function createWelcomeDefinition(app) {
     return {
         id: randomUUID(),
@@ -47,7 +59,7 @@ export function createConfigDefinition(onFinished, onAborted) {
         },
     };
 }
-export function createCommandDefinition(command, service, onError, onComplete) {
+export function createCommandDefinition(command, service, onError, onComplete, onAborted) {
     return {
         id: randomUUID(),
         name: ComponentName.Command,
@@ -60,10 +72,11 @@ export function createCommandDefinition(command, service, onError, onComplete) {
             service,
             onError,
             onComplete,
+            onAborted,
         },
     };
 }
-export function createPlanDefinition(message, tasks, onSelectionConfirmed) {
+export function createPlanDefinition(message, tasks, onAborted, onSelectionConfirmed) {
     return {
         id: randomUUID(),
         name: ComponentName.Plan,
@@ -77,6 +90,7 @@ export function createPlanDefinition(message, tasks, onSelectionConfirmed) {
             message,
             tasks,
             onSelectionConfirmed,
+            onAborted,
         },
     };
 }
@@ -99,6 +113,29 @@ export function createMessage(text) {
         },
     };
 }
+export function createRefinement(text, onAborted) {
+    return {
+        id: randomUUID(),
+        name: ComponentName.Refinement,
+        state: { done: false },
+        props: {
+            text,
+            onAborted,
+        },
+    };
+}
+export function createConfirmDefinition(onConfirmed, onCancelled) {
+    return {
+        id: randomUUID(),
+        name: ComponentName.Confirm,
+        state: { done: false },
+        props: {
+            message: getConfirmationMessage(),
+            onConfirmed,
+            onCancelled,
+        },
+    };
+}
 export function isStateless(component) {
     return !('state' in component);
 }

package/dist/services/config.js

@@ -50,6 +50,14 @@ function validateConfig(parsed) {
     if (model && typeof model === 'string' && isValidAnthropicModel(model)) {
         validatedConfig.anthropic.model = model;
     }
+    // Optional settings section
+    if (config.settings && typeof config.settings === 'object') {
+        const settings = config.settings;
+        validatedConfig.settings = {};
+        if ('debug' in settings && typeof settings.debug === 'boolean') {
+            validatedConfig.settings.debug = settings.debug;
+        }
+    }
     return validatedConfig;
 }
 export function loadConfig() {
@@ -116,6 +124,18 @@ export function saveConfig(section, config) {
 export function saveAnthropicConfig(config) {
     saveConfig('anthropic', config);
 }
+export function saveDebugSetting(debug) {
+    saveConfig('settings', { debug });
+}
+export function loadDebugSetting() {
+    try {
+        const config = loadConfig();
+        return config.settings?.debug ?? false;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Returns a message requesting initial setup.
  * Provides natural language variations that sound like a professional concierge

package/dist/services/messages.js

@@ -0,0 +1,15 @@
+/**
+ * Returns a natural language confirmation message for plan execution.
+ * Randomly selects from variations to sound less robotic.
+ */
+export function getConfirmationMessage() {
+    const messages = [
+        'Should I execute this plan?',
+        'Do you want me to proceed with these tasks?',
+        'Ready to execute?',
+        'Shall I execute this plan?',
+        'Would you like me to run these tasks?',
+        'Execute this plan?',
+    ];
+    return messages[Math.floor(Math.random() * messages.length)];
+}

package/dist/tools/plan.tool.js

@@ -1,6 +1,6 @@
 export const planTool = {
     name: 'plan',
-    description: 'Plan and structure tasks from a user command. Break down the request into clear, actionable steps with type information and parameters.',
+    description: 'Plan and structure tasks from a user command. Break down the request into clear, actionable steps with type information and parameters. When refining previously selected tasks, the input will be formatted as lowercase actions with types in brackets, e.g., "install the python development environment (type: execute), explain how virtual environments work (type: answer)".',
     input_schema: {
         type: 'object',
         properties: {

package/dist/types/components.js

@@ -1,28 +1 @@
-export var ComponentName;
-(function (ComponentName) {
-    ComponentName["Welcome"] = "welcome";
-    ComponentName["Config"] = "config";
-    ComponentName["Feedback"] = "feedback";
-    ComponentName["Message"] = "message";
-    ComponentName["Plan"] = "plan";
-    ComponentName["Command"] = "command";
-})(ComponentName || (ComponentName = {}));
-export var TaskType;
-(function (TaskType) {
-    TaskType["Config"] = "config";
-    TaskType["Plan"] = "plan";
-    TaskType["Execute"] = "execute";
-    TaskType["Answer"] = "answer";
-    TaskType["Report"] = "report";
-    TaskType["Define"] = "define";
-    TaskType["Ignore"] = "ignore";
-    TaskType["Select"] = "select";
-    TaskType["Discard"] = "discard";
-})(TaskType || (TaskType = {}));
-export var FeedbackType;
-(function (FeedbackType) {
-    FeedbackType["Info"] = "info";
-    FeedbackType["Succeeded"] = "succeeded";
-    FeedbackType["Aborted"] = "aborted";
-    FeedbackType["Failed"] = "failed";
-})(FeedbackType || (FeedbackType = {}));
+export {};

package/dist/types/types.js

@@ -0,0 +1,30 @@
+export var ComponentName;
+(function (ComponentName) {
+    ComponentName["Welcome"] = "welcome";
+    ComponentName["Config"] = "config";
+    ComponentName["Message"] = "message";
+    ComponentName["Command"] = "command";
+    ComponentName["Plan"] = "plan";
+    ComponentName["Refinement"] = "refinement";
+    ComponentName["Feedback"] = "feedback";
+    ComponentName["Confirm"] = "confirm";
+})(ComponentName || (ComponentName = {}));
+export var TaskType;
+(function (TaskType) {
+    TaskType["Config"] = "config";
+    TaskType["Plan"] = "plan";
+    TaskType["Execute"] = "execute";
+    TaskType["Answer"] = "answer";
+    TaskType["Report"] = "report";
+    TaskType["Define"] = "define";
+    TaskType["Ignore"] = "ignore";
+    TaskType["Select"] = "select";
+    TaskType["Discard"] = "discard";
+})(TaskType || (TaskType = {}));
+export var FeedbackType;
+(function (FeedbackType) {
+    FeedbackType["Info"] = "info";
+    FeedbackType["Succeeded"] = "succeeded";
+    FeedbackType["Aborted"] = "aborted";
+    FeedbackType["Failed"] = "failed";
+})(FeedbackType || (FeedbackType = {}));

package/dist/ui/Column.js

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

package/dist/ui/Command.js

@@ -1,12 +1,18 @@
 import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
-import { Box, Text } from 'ink';
+import { Box, Text, useInput } from 'ink';
 import { Spinner } from './Spinner.js';
 const MIN_PROCESSING_TIME = 1000; // purely for visual effect
-export function Command({ command, state, service, children, onError, onComplete, }) {
+export function Command({ command, state, service, children, onError, onComplete, onAborted, }) {
     const done = state?.done ?? false;
     const [error, setError] = useState(null);
     const [isLoading, setIsLoading] = useState(state?.isLoading ?? !done);
+    useInput((input, key) => {
+        if (key.escape && isLoading && !done) {
+            setIsLoading(false);
+            onAborted();
+        }
+    }, { isActive: isLoading && !done });
     useEffect(() => {
         // Skip processing if done (showing historical/final state)
         if (done) {

package/dist/ui/Component.js

@@ -1,12 +1,14 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { ComponentName } from '../types/components.js';
+import { ComponentName } from '../types/types.js';
 import { Command } from './Command.js';
+import { Confirm } from './Confirm.js';
 import { Config } from './Config.js';
 import { Feedback } from './Feedback.js';
 import { Message } from './Message.js';
 import { Plan } from './Plan.js';
+import { Refinement } from './Refinement.js';
 import { Welcome } from './Welcome.js';
-export function Component({ def }) {
+export function Component({ def, debug }) {
     switch (def.name) {
         case ComponentName.Welcome:
             return _jsx(Welcome, { ...def.props });
@@ -21,10 +23,20 @@ export function Component({ def }) {
             return _jsx(Command, { ...props, state: state });
         }
         case ComponentName.Plan:
-            return _jsx(Plan, { ...def.props });
+            return _jsx(Plan, { ...def.props, debug: debug });
         case ComponentName.Feedback:
             return _jsx(Feedback, { ...def.props });
         case ComponentName.Message:
             return _jsx(Message, { ...def.props });
+        case ComponentName.Refinement: {
+            const props = def.props;
+            const state = def.state;
+            return _jsx(Refinement, { ...props, state: state });
+        }
+        case ComponentName.Confirm: {
+            const props = def.props;
+            const state = def.state;
+            return _jsx(Confirm, { ...props, state: state });
+        }
     }
 }

package/dist/ui/Config.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React from 'react';
-import { Box, Text, useInput, useFocus } from 'ink';
+import { Box, Text, useFocus, useInput } from 'ink';
 import TextInput from 'ink-text-input';
 export var StepType;
 (function (StepType) {

package/dist/ui/Confirm.js

@@ -0,0 +1,41 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text, useInput } from 'ink';
+export function Confirm({ message, state, onConfirmed, onCancelled, }) {
+    const done = state?.done ?? false;
+    const [selectedIndex, setSelectedIndex] = React.useState(0); // 0 = Yes, 1 = No
+    useInput((input, key) => {
+        if (done)
+            return;
+        if (key.escape) {
+            // Escape: highlight "No" and cancel
+            setSelectedIndex(1);
+            onCancelled?.();
+        }
+        else if (key.tab) {
+            // Toggle between Yes (0) and No (1)
+            setSelectedIndex((prev) => (prev === 0 ? 1 : 0));
+        }
+        else if (key.return) {
+            // Confirm selection
+            if (selectedIndex === 0) {
+                onConfirmed?.();
+            }
+            else {
+                onCancelled?.();
+            }
+        }
+    }, { isActive: !done });
+    const options = [
+        { label: 'Yes', value: 'yes', color: '#4a9a7a' }, // green (execute)
+        { label: 'No', value: 'no', color: '#a85c3f' }, // dark orange (discard)
+    ];
+    if (done) {
+        // When done, show both the message and user's choice in timeline
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: message }) }), _jsx(Box, { children: _jsxs(Text, { color: "gray", children: ["> ", options[selectedIndex].label] }) })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: message }) }), _jsxs(Box, { children: [_jsx(Text, { color: "#5c8cbc", children: ">" }), _jsx(Text, { children: " " }), _jsx(Box, { children: options.map((option, index) => {
+                            const isSelected = index === selectedIndex;
+                            return (_jsx(Box, { marginRight: 2, children: _jsx(Text, { color: isSelected ? option.color : undefined, dimColor: !isSelected, bold: isSelected, children: option.label }) }, option.value));
+                        }) })] })] }));
+}

package/dist/ui/Feedback.js

@@ -1,6 +1,6 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
-import { FeedbackType } from '../types/components.js';
+import { FeedbackType } from '../types/types.js';
 function getSymbol(type) {
     return {
         [FeedbackType.Info]: 'ℹ',

package/dist/ui/Label.js

@@ -1,6 +1,6 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import { Separator } from './Separator.js';
-export function Label({ description, descriptionColor, type, typeColor, }) {
-    return (_jsxs(Box, { children: [_jsx(Text, { color: descriptionColor, children: description }), _jsx(Separator, {}), _jsx(Text, { color: typeColor, children: type })] }));
+export function Label({ description, descriptionColor, type, typeColor, showType = false, }) {
+    return (_jsxs(Box, { children: [_jsx(Text, { color: descriptionColor, children: description }), showType && (_jsxs(_Fragment, { children: [_jsx(Separator, {}), _jsx(Text, { color: typeColor, children: type })] }))] }));
 }

package/dist/ui/List.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import { Label } from './Label.js';
-export const List = ({ items, level = 0, highlightedIndex = null, highlightedParentIndex = null, }) => {
+export const List = ({ items, level = 0, highlightedIndex = null, highlightedParentIndex = null, showType = false, }) => {
     const marginLeft = level > 0 ? 4 : 0;
     return (_jsx(Box, { flexDirection: "column", marginLeft: marginLeft, children: items.map((item, index) => {
             // At level 0, track which parent is active for child highlighting
@@ -16,6 +16,11 @@ export const List = ({ items, level = 0, highlightedIndex = null, highlightedPar
             const typeColor = isHighlighted && item.type.highlightedColor
                 ? item.type.highlightedColor
                 : item.type.color;
-            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "whiteBright", children: marker }), _jsx(Label, { description: item.description.text, descriptionColor: descriptionColor, type: item.type.text, typeColor: typeColor })] }), item.children && item.children.length > 0 && (_jsx(List, { items: item.children, level: level + 1, highlightedIndex: shouldHighlightChildren ? highlightedIndex : null }))] }, index));
+            // Use highlighted type color for arrow markers when highlighted
+            const markerColor = item.markerColor ||
+                (isHighlighted && item.type.highlightedColor
+                    ? item.type.highlightedColor
+                    : 'whiteBright');
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: markerColor, children: marker }), _jsx(Label, { description: item.description.text, descriptionColor: descriptionColor, type: item.type.text, typeColor: typeColor, showType: showType })] }), item.children && item.children.length > 0 && (_jsx(List, { items: item.children, level: level + 1, highlightedIndex: shouldHighlightChildren ? highlightedIndex : null, showType: showType }))] }, index));
         }) }));
 };

package/dist/ui/Main.js

@@ -1,10 +1,10 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import React from 'react';
-import { ComponentName, TaskType, } from '../types/components.js';
+import { useInput } from 'ink';
+import { ComponentName, FeedbackType, TaskType, } from '../types/types.js';
 import { createAnthropicService, } from '../services/anthropic.js';
-import { FeedbackType } from '../types/components.js';
-import { getConfigurationRequiredMessage, hasValidAnthropicKey, loadConfig, saveAnthropicConfig, } from '../services/config.js';
-import { createCommandDefinition, createConfigDefinition, createFeedback, createMessage, createPlanDefinition, createWelcomeDefinition, isStateless, markAsDone, } from '../services/components.js';
+import { getConfigurationRequiredMessage, hasValidAnthropicKey, loadConfig, loadDebugSetting, saveAnthropicConfig, saveDebugSetting, } from '../services/config.js';
+import { createCommandDefinition, createConfirmDefinition, createConfigDefinition, createFeedback, createMessage, createRefinement, createPlanDefinition, createWelcomeDefinition, getRefiningMessage, isStateless, markAsDone, } from '../services/components.js';
 import { exitApp } from '../services/process.js';
 import { Column } from './Column.js';
 export const Main = ({ app, command }) => {
@@ -18,6 +18,18 @@ export const Main = ({ app, command }) => {
     });
     const [timeline, setTimeline] = React.useState([]);
     const [queue, setQueue] = React.useState([]);
+    const [isDebug, setIsDebug] = React.useState(() => loadDebugSetting());
+    // Top-level Shift+Tab handler for debug mode toggle
+    // Child components must ignore Shift+Tab to prevent conflicts
+    useInput((input, key) => {
+        if (key.shift && key.tab) {
+            setIsDebug((prev) => {
+                const newValue = !prev;
+                saveDebugSetting(newValue);
+                return newValue;
+            });
+        }
+    }, { isActive: true });
     const addToTimeline = React.useCallback((...items) => {
         setTimeline((timeline) => [...timeline, ...items]);
     }, []);
@@ -46,20 +58,106 @@ export const Main = ({ app, command }) => {
             return [];
         });
     }, [addToTimeline]);
-    const handlePlanSelectionConfirmed = React.useCallback((selectedIndex, updatedTasks) => {
+    const handleAborted = React.useCallback((operationName) => {
         setQueue((currentQueue) => {
             if (currentQueue.length === 0)
                 return currentQueue;
             const [first] = currentQueue;
-            if (first.name === ComponentName.Plan) {
-                // Mark plan as done and add it to timeline
+            if (!isStateless(first)) {
+                addToTimeline(markAsDone(first), createFeedback(FeedbackType.Aborted, `${operationName} was aborted by user`));
+            }
+            exitApp(0);
+            return [];
+        });
+    }, [addToTimeline]);
+    const handleConfigAborted = React.useCallback(() => {
+        handleAborted('Configuration');
+    }, [handleAborted]);
+    const handlePlanAborted = React.useCallback(() => {
+        handleAborted('Task selection');
+    }, [handleAborted]);
+    const handleCommandAborted = React.useCallback(() => {
+        handleAborted('Request');
+    }, [handleAborted]);
+    const handleRefinementAborted = React.useCallback(() => {
+        handleAborted('Plan refinement');
+    }, [handleAborted]);
+    const handleExecutionConfirmed = React.useCallback(() => {
+        setQueue((currentQueue) => {
+            if (currentQueue.length === 0)
+                return currentQueue;
+            const [first] = currentQueue;
+            if (first.name === ComponentName.Confirm) {
                 addToTimeline(markAsDone(first));
             }
-            // Exit after selection is confirmed
             exitApp(0);
             return [];
         });
     }, [addToTimeline]);
+    const handleExecutionCancelled = React.useCallback(() => {
+        setQueue((currentQueue) => {
+            if (currentQueue.length === 0)
+                return currentQueue;
+            const [first] = currentQueue;
+            if (first.name === ComponentName.Confirm) {
+                addToTimeline(markAsDone(first), createFeedback(FeedbackType.Aborted, 'Execution cancelled'));
+            }
+            exitApp(0);
+            return [];
+        });
+    }, [addToTimeline]);
+    const handlePlanSelectionConfirmed = React.useCallback(async (selectedTasks) => {
+        // Mark current plan as done and add refinement to queue
+        let refinementDef = null;
+        refinementDef = createRefinement(getRefiningMessage(), handleRefinementAborted);
+        setQueue((currentQueue) => {
+            if (currentQueue.length === 0)
+                return currentQueue;
+            const [first] = currentQueue;
+            if (first.name === ComponentName.Plan) {
+                addToTimeline(markAsDone(first));
+            }
+            // Add refinement to queue so it becomes the active component
+            return [refinementDef];
+        });
+        // Process refined command in background
+        try {
+            const refinedCommand = selectedTasks
+                .map((task) => {
+                const action = task.action.toLowerCase().replace(/,/g, ' -');
+                const type = task.type || 'execute';
+                return `${action} (type: ${type})`;
+            })
+                .join(', ');
+            const result = await service.processWithTool(refinedCommand, 'plan');
+            // Mark refinement as done and move to timeline
+            setQueue((currentQueue) => {
+                if (currentQueue.length > 0 &&
+                    currentQueue[0].id === refinementDef.id) {
+                    addToTimeline(markAsDone(currentQueue[0]));
+                }
+                return [];
+            });
+            // Show final execution plan with confirmation
+            const planDefinition = createPlanDefinition(result.message, result.tasks, handlePlanAborted, undefined);
+            const confirmDefinition = createConfirmDefinition(handleExecutionConfirmed, handleExecutionCancelled);
+            addToTimeline(planDefinition);
+            setQueue([confirmDefinition]);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            // Mark refinement as done and move to timeline before showing error
+            setQueue((currentQueue) => {
+                if (currentQueue.length > 0 &&
+                    currentQueue[0].id === refinementDef.id) {
+                    addToTimeline(markAsDone(currentQueue[0]));
+                }
+                return [];
+            });
+            addToTimeline(createFeedback(FeedbackType.Failed, 'Unexpected error occurred:', errorMessage));
+            exitApp(1);
+        }
+    }, [addToTimeline, service, handleRefinementAborted]);
     const handleCommandComplete = React.useCallback((message, tasks) => {
         setQueue((currentQueue) => {
             if (currentQueue.length === 0)
@@ -68,23 +166,28 @@ export const Main = ({ app, command }) => {
             // Check if tasks contain a Define task that requires user interaction
             const hasDefineTask = tasks.some((task) => task.type === TaskType.Define);
             if (first.name === ComponentName.Command) {
-                const planDefinition = createPlanDefinition(message, tasks, hasDefineTask ? handlePlanSelectionConfirmed : undefined);
+                const planDefinition = createPlanDefinition(message, tasks, handlePlanAborted, hasDefineTask ? handlePlanSelectionConfirmed : undefined);
                 if (hasDefineTask) {
                     // Don't exit - keep the plan in the queue for interaction
                     addToTimeline(markAsDone(first));
                     return [planDefinition];
                 }
                 else {
-                    // No define task - add plan to timeline and exit
+                    // No define task - show plan and confirmation
+                    const confirmDefinition = createConfirmDefinition(handleExecutionConfirmed, handleExecutionCancelled);
                     addToTimeline(markAsDone(first), planDefinition);
-                    exitApp(0);
-                    return [];
+                    return [confirmDefinition];
                 }
             }
             exitApp(0);
             return [];
         });
-    }, [addToTimeline, handlePlanSelectionConfirmed]);
+    }, [
+        addToTimeline,
+        handlePlanSelectionConfirmed,
+        handleExecutionConfirmed,
+        handleExecutionCancelled,
+    ]);
     const handleConfigFinished = React.useCallback((config) => {
         const anthropicConfig = config;
         saveAnthropicConfig(anthropicConfig);
@@ -102,7 +205,7 @@ export const Main = ({ app, command }) => {
             if (command) {
                 return [
                     ...rest,
-                    createCommandDefinition(command, newService, handleCommandError, handleCommandComplete),
+                    createCommandDefinition(command, newService, handleCommandError, handleCommandComplete, handleCommandAborted),
                 ];
             }
             // No command - exit after showing completion message
@@ -110,25 +213,13 @@ export const Main = ({ app, command }) => {
             return rest;
         });
     }, [addToTimeline, command, handleCommandError, handleCommandComplete]);
-    const handleConfigAborted = React.useCallback(() => {
-        setQueue((currentQueue) => {
-            if (currentQueue.length === 0)
-                return currentQueue;
-            const [first] = currentQueue;
-            if (first.name === ComponentName.Config) {
-                addToTimeline(markAsDone(first), createFeedback(FeedbackType.Aborted, 'Configuration aborted by user'));
-            }
-            exitApp(0);
-            return [];
-        });
-    }, [addToTimeline]);
     // Initialize queue on mount
     React.useEffect(() => {
         const hasConfig = !!service;
         if (command && hasConfig) {
             // With command + valid config: [Command]
             setQueue([
-                createCommandDefinition(command, service, handleCommandError, handleCommandComplete),
+                createCommandDefinition(command, service, handleCommandError, handleCommandComplete, handleCommandAborted),
             ]);
         }
         else if (command && !hasConfig) {
@@ -155,7 +246,13 @@ export const Main = ({ app, command }) => {
     React.useEffect(() => {
         processNextInQueue();
     }, [queue, processNextInQueue]);
+    // Exit when queue is empty and timeline has content (all stateless components done)
+    React.useEffect(() => {
+        if (queue.length === 0 && timeline.length > 0) {
+            exitApp(0);
+        }
+    }, [queue, timeline]);
     const current = queue.length > 0 ? queue[0] : null;
     const items = [...timeline, ...(current ? [current] : [])];
-    return _jsx(Column, { items: items });
+    return _jsx(Column, { items: items, debug: isDebug });
 };

package/dist/ui/Message.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { Text } from 'ink';
+import { Box, Text } from 'ink';
 export const Message = ({ text }) => {
-    return _jsx(Text, { children: text });
+    return (_jsx(Box, { children: _jsx(Text, { children: text }) }));
 };

package/dist/ui/Plan.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
 import { Box, useInput } from 'ink';
-import { TaskType } from '../types/components.js';
+import { TaskType } from '../types/types.js';
 import { Label } from './Label.js';
 import { List } from './List.js';
 const ColorPalette = {
@@ -54,6 +54,7 @@ function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutS
     // Mark define tasks with right arrow when no selection has been made
     if (isDefineTaskWithoutSelection) {
         item.marker = '  → ';
+        item.markerColor = ColorPalette[TaskType.Plan].type;
     }
     // Add children for Define tasks with options
     if (task.type === TaskType.Define && Array.isArray(task.params?.options)) {
@@ -82,7 +83,7 @@ function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutS
     }
     return item;
 }
-export function Plan({ message, tasks, state, onSelectionConfirmed, }) {
+export function Plan({ message, tasks, state, debug = false, onSelectionConfirmed, onAborted, }) {
     const [highlightedIndex, setHighlightedIndex] = useState(state?.highlightedIndex ?? null);
     const [currentDefineGroupIndex, setCurrentDefineGroupIndex] = useState(state?.currentDefineGroupIndex ?? 0);
     const [completedSelections, setCompletedSelections] = useState(state?.completedSelections ?? []);
@@ -103,6 +104,10 @@ export function Plan({ message, tasks, state, onSelectionConfirmed, }) {
         if (isDone || !defineTask) {
             return;
         }
+        if (key.escape) {
+            onAborted();
+            return;
+        }
         if (key.downArrow) {
             setHighlightedIndex((prev) => {
                 if (prev === null) {
@@ -136,14 +141,27 @@ export function Plan({ message, tasks, state, onSelectionConfirmed, }) {
                 if (state) {
                     state.done = true;
                 }
-                // Update all tasks and notify parent
-                const updatedTasks = tasks.map((task, idx) => {
-                    if (defineTaskIndices.includes(idx)) {
-                        return { ...task, type: TaskType.Execute };
+                // Build refined task list with only selected options (no discarded or ignored ones)
+                const refinedTasks = [];
+                tasks.forEach((task, idx) => {
+                    const defineGroupIndex = defineTaskIndices.indexOf(idx);
+                    if (defineGroupIndex !== -1 &&
+                        Array.isArray(task.params?.options)) {
+                        // This is a Define task - only include the selected option
+                        const options = task.params.options;
+                        const selectedIndex = newCompletedSelections[defineGroupIndex];
+                        refinedTasks.push({
+                            action: String(options[selectedIndex]),
+                            type: TaskType.Execute,
+                        });
+                    }
+                    else if (task.type !== TaskType.Ignore &&
+                        task.type !== TaskType.Discard) {
+                        // Regular task - keep as is, but skip Ignore and Discard tasks
+                        refinedTasks.push(task);
                     }
-                    return task;
                 });
-                onSelectionConfirmed?.(highlightedIndex, updatedTasks);
+                onSelectionConfirmed?.(refinedTasks);
             }
         }
     }, { isActive: !isDone && defineTask !== null });
@@ -184,11 +202,12 @@ export function Plan({ message, tasks, state, onSelectionConfirmed, }) {
                 }
             }
         }
-        // Show arrow on current active define task when no child is highlighted
+        // Show arrow on current active define task when no child is highlighted and not done
         const isDefineWithoutSelection = isDefineTask &&
             defineGroupIndex === currentDefineGroupIndex &&
-            highlightedIndex === null;
+            highlightedIndex === null &&
+            !isDone;
         return taskToListItem(task, childIndex, isDefineWithoutSelection);
     });
-    return (_jsxs(Box, { flexDirection: "column", children: [message && (_jsx(Box, { marginBottom: 1, children: _jsx(Label, { description: message, descriptionColor: ColorPalette[TaskType.Plan].description, type: TaskType.Plan, typeColor: ColorPalette[TaskType.Plan].type }) })), _jsx(List, { items: listItems, highlightedIndex: currentDefineTaskIndex >= 0 ? highlightedIndex : null, highlightedParentIndex: currentDefineTaskIndex })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [message && (_jsx(Box, { marginBottom: 1, children: _jsx(Label, { description: message, descriptionColor: ColorPalette[TaskType.Plan].description, type: TaskType.Plan, typeColor: ColorPalette[TaskType.Plan].type, showType: debug }) })), _jsx(List, { items: listItems, highlightedIndex: currentDefineTaskIndex >= 0 ? highlightedIndex : null, highlightedParentIndex: currentDefineTaskIndex, showType: debug })] }));
 }

package/dist/ui/Refinement.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, useInput } from 'ink';
+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();
+            return;
+        }
+    }, { isActive: !isDone });
+    return (_jsxs(Box, { gap: 1, children: [_jsx(Message, { text: text }), !isDone && _jsx(Spinner, {})] }));
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prompt-language-shell",
-  "version": "0.3.4",
+  "version": "0.3.8",
   "description": "Your personal command-line concierge. Ask politely, and it gets things done.",
   "type": "module",
   "main": "dist/index.js",
@@ -12,7 +12,8 @@
   ],
   "scripts": {
     "clean": "rm -rf dist",
-    "build": "npm run clean && tsc && chmod +x dist/index.js && mkdir -p dist/config && cp src/config/*.md dist/config/",
+    "typecheck": "tsc --project tsconfig.eslint.json",
+    "build": "npm run typecheck && npm run clean && tsc && chmod +x dist/index.js && mkdir -p dist/config && cp src/config/*.md dist/config/",
     "dev": "npm run build && tsc --watch",
     "prepare": "husky",
     "prepublishOnly": "npm run check",