prompt-language-shell 0.3.4 → 0.3.6

package/dist/services/components.js

@@ -1,10 +1,21 @@
 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 { 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 +58,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 +71,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 +89,7 @@ export function createPlanDefinition(message, tasks, onSelectionConfirmed) {
             message,
             tasks,
             onSelectionConfirmed,
+            onAborted,
         },
     };
 }
@@ -99,6 +112,17 @@ export function createMessage(text) {
         },
     };
 }
+export function createRefinement(text, onAborted) {
+    return {
+        id: randomUUID(),
+        name: ComponentName.Refinement,
+        state: { done: false },
+        props: {
+            text,
+            onAborted,
+        },
+    };
+}
 export function isStateless(component) {
     return !('state' in component);
 }

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,29 @@
+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 || (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/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,10 +1,11 @@
 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 { 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 }) {
     switch (def.name) {
@@ -26,5 +27,10 @@ export function Component({ def }) {
             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 });
+        }
     }
 }

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/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/Main.js

@@ -1,10 +1,9 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import React from 'react';
-import { ComponentName, TaskType, } from '../types/components.js';
+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 { createCommandDefinition, 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 }) => {
@@ -46,20 +45,81 @@ 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
-                addToTimeline(markAsDone(first));
+            if (!isStateless(first)) {
+                addToTimeline(markAsDone(first), createFeedback(FeedbackType.Aborted, `${operationName} was aborted by user`));
             }
-            // Exit after selection is confirmed
             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 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
+            const planDefinition = createPlanDefinition(result.message, result.tasks, handlePlanAborted, undefined);
+            addToTimeline(planDefinition);
+            exitApp(0);
+        }
+        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,7 +128,7 @@ 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));
@@ -102,7 +162,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 +170,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) {

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 = {
@@ -82,7 +82,7 @@ function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutS
     }
     return item;
 }
-export function Plan({ message, tasks, state, onSelectionConfirmed, }) {
+export function Plan({ message, tasks, state, onSelectionConfirmed, onAborted, }) {
     const [highlightedIndex, setHighlightedIndex] = useState(state?.highlightedIndex ?? null);
     const [currentDefineGroupIndex, setCurrentDefineGroupIndex] = useState(state?.currentDefineGroupIndex ?? 0);
     const [completedSelections, setCompletedSelections] = useState(state?.completedSelections ?? []);
@@ -103,6 +103,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 +140,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,10 +201,11 @@ 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 })] }));

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.6",
   "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",