prompt-language-shell 0.3.2 → 0.3.6

package/dist/config/PLAN.md

@@ -18,9 +18,8 @@ Your task is to create structured task definitions that:
 Each task should be precise and unambiguous, ready to be executed by the
 appropriate handler.
 
-**IMPORTANT**: While the primary use case involves building specific
-software products, all instructions and examples in this document are
-intentionally generic. This ensures the planning algorithm is not biased
+**IMPORTANT**: All instructions and examples in this document are
+intentionally generic to ensure the planning algorithm is not biased
 toward any particular domain and can be validated to work correctly across
 all scenarios. Do NOT assume or infer domain-specific context unless
 explicitly provided in skills or user requests.
@@ -118,7 +117,7 @@ executable operations.
    - Consult the skill's Description section for guidance on which steps are
      optional or conditional
    - Example: If description says "initialization only required for clean
-     builds" and user says "rebuild cache", skip initialization steps
+     operations" and user says "regenerate cache", skip initialization steps
    - Only extract steps that align with the user's specific request
 
 5. **Create task definitions:**
@@ -136,26 +135,27 @@ executable operations.
    - NEVER create generic execute tasks for unmatched requirements
 
 Example 1 - Skill with parameter, variant specified:
-- Skill has {PROJECT} parameter with variants: Alpha, Beta, Gamma
-- Skill steps: "- Navigate to the {PROJECT} root directory. - Execute the
-  {PROJECT} generation script. - Compile the {PROJECT}'s source code"
-- User: "build Alpha"
+- Skill has {TARGET} parameter with variants: Alpha, Beta, Gamma
+- Skill steps: "- Navigate to the {TARGET} root directory. - Execute the
+  {TARGET} generation script. - Run the {TARGET} processing pipeline"
+- User: "process Alpha"
 - Correct: Three tasks with actions following the skill's steps, with
-  {PROJECT} replaced by "Alpha"
-- WRONG: One task with action "Build Alpha"
+  {TARGET} replaced by "Alpha"
+- WRONG: One task with action "Process Alpha"
 
 Example 2 - Skill with parameter, variant NOT specified:
 - Same skill as Example 1
-- User: "build"
-- Correct: One task with type "define", action "Clarify which project to
-  build", params { options: ["Build Alpha", "Build Beta", "Build Gamma"] }
-- WRONG: Three tasks with {PROJECT} unreplaced or defaulted
+- User: "process"
+- Correct: One task with type "define", action "Clarify which target to
+  process", params { options: ["Process Alpha", "Process Beta", "Process
+  Gamma"] }
+- WRONG: Three tasks with {TARGET} unreplaced or defaulted
 
 Example 3 - Skill without parameters:
-- Skill steps: "- Check prerequisites. - Run compilation. - Execute tests"
-- User: "run tests and generate a report"
+- Skill steps: "- Check prerequisites. - Run processing. - Execute validation"
+- User: "run validation and generate a report"
 - Correct: Four tasks (the three from skill + one for report generation)
-- WRONG: Two tasks ("run tests", "generate a report")
+- WRONG: Two tasks ("run validation", "generate a report")
 
 Example 4 - NEGATIVE: Unmatched verb after matched skill:
 - ONLY skill available: "backup" (with steps: connect, export, save)
@@ -189,22 +189,29 @@ derived from available skills:
 2. For each applicable skill, extract specific, executable commands with their
    parameters
 3. Present these as concrete options, NOT generic categories
-4. Each option should be something the user can directly select and execute
-5. Format options WITHOUT brackets. Use commas to separate extra information
+4. Each option should represent a SINGLE atomic choice (e.g., which variant,
+   which environment, which product), NOT a complete sequence of steps
+5. **CRITICAL: Options must be ATOMIC choices, not sequences.** Each option
+   should select ONE thing (variant, environment, target), and once selected,
+   that choice will be expanded into individual sequential steps
+6. Format options WITHOUT brackets. Use commas to separate extra information
    instead. For example:
-   - CORRECT: "Build project Alpha, the legacy version"
-   - WRONG: "Build project Alpha (the legacy version)"
+   - CORRECT: "Process target Alpha, the legacy version"
+   - WRONG: "Process target Alpha (the legacy version)"
 
 Example:
-- Available skills: "Build Product" (variant A, variant B), "Deploy
+- Available skills: "Process Product" (variant A, variant B), "Deploy
   Product" (staging, production), "Verify Product" (quick check, full
   validation)
 - User: "do something with the product"
-- Correct: Create "define" task with options: ["Build product variant A",
-  "Build product variant B", "Deploy product to staging", "Deploy product
+- Correct: Create "define" task with options: ["Process product variant A",
+  "Process product variant B", "Deploy product to staging", "Deploy product
   to production", "Run quick verification", "Run full validation"]
-- WRONG: Generic options like ["Build", "Deploy", "Verify"] - these
+- WRONG: Generic options like ["Process", "Deploy", "Verify"] - these
   require further clarification
+- WRONG: Options like ["Process A, run checks, deploy to staging", "Process
+  B, skip checks, deploy to production"] - these are sequences, not atomic
+  choices
 
 ## Evaluation of Requests
 
@@ -233,7 +240,7 @@ Examples that should be aborted as offensive:
      - "what is the current directory" → type: "answer"
 
 2. **Skill-based requests** - Use skills when verb matches a defined skill:
-   - If "build" skill exists and user says "build" → Use the build skill
+   - If "process" skill exists and user says "process" → Use the process skill
    - If "deploy" skill exists and user says "deploy" → Use the deploy skill
    - Extract steps from the matching skill and create tasks for each step
 
@@ -262,32 +269,43 @@ type ONLY if there are concrete skill-based options:
 **For skill-based disambiguation:**
 
 When a skill exists but requires parameters or has multiple variants,
-use "define" type:
+use "define" type to select ONE variant. The options should be ATOMIC choices,
+not sequences of steps:
 
 1. **Skill requires parameters** - Ask which variant:
-   - "build" + build skill with {PRODUCT} parameter (Alpha, Beta, Gamma,
-     Delta) → Create "define" type with params { options: ["Build Alpha",
-     "Build Beta", "Build Gamma", "Build Delta"] }
+   - "process" + process skill with {TARGET} parameter (Alpha, Beta, Gamma,
+     Delta) → Create "define" type with params { options: ["Process Alpha",
+     "Process Beta", "Process Gamma", "Process Delta"] }
+   - Each option is ONE variant choice
+   - Once selected, that variant will expand into its individual steps
    - User must specify which variant to execute the skill with
+   - **WRONG**: Options like ["Process Alpha and deploy", "Process Beta and
+     validate"] - these are sequences, not atomic variant choices
 
 2. **Skill has multiple distinct operations** - Ask which one:
    - "deploy" + deploy skill defining staging, production, canary
      environments → Create "define" type with params { options: ["Deploy to
      staging environment", "Deploy to production environment", "Deploy to
      canary environment"] }
+   - Each option selects ONE environment
+   - **WRONG**: Options like ["Deploy to staging, then production", "Deploy
+     to production only"] - these mix sequences with choices
 
 3. **Skill has single variant or user specifies variant** - Execute directly:
-   - "build Alpha" + build skill with {PRODUCT} parameter → Replace
-     {PRODUCT} with "Alpha" and execute skill steps
+   - "process Alpha" + process skill with {TARGET} parameter → Replace
+     {TARGET} with "Alpha" and execute skill steps as SEPARATE sequential
+     tasks
    - "deploy staging" + deploy skill with {ENV} parameter → Replace {ENV}
-     with "staging" and execute that command
-   - No disambiguation needed
+     with "staging" and execute each step as a SEPARATE task
+   - No disambiguation needed - proceed directly to breaking down into steps
 
 4. **User specifies "all"** - Spread into multiple tasks:
    - "deploy all" + deploy skill defining staging and production → Create
-     two tasks: one for staging deployment, one for production deployment
-   - "build all" + build skill with multiple product variants → Create four
-     tasks: one for Alpha, one for Beta, one for Gamma, one for Delta
+     separate task sequences: first all staging steps, then all production
+     steps (as individual sequential tasks, not bundled)
+   - "process all" + process skill with multiple target variants → Create
+     separate task sequences for each variant (each variant's steps as
+     individual sequential tasks)
 
 **For requests with no matching skills:**
 
@@ -305,8 +323,8 @@ Use "ignore" type:
 
 **Critical rules:**
 
-- NEVER create "define" type with generic categories like "Run tests",
-  "Build project" unless these map to actual skill commands
+- NEVER create "define" type with generic categories like "Run validation",
+  "Process target" unless these map to actual skill commands
 - NEVER create "define" type without a matching skill. The "define" type
   is ONLY for disambiguating between multiple variants/operations within
   an existing skill
@@ -338,14 +356,18 @@ When creating task definitions, focus on:
 - **Type**: Categorize the operation using one of these supported types:
   - `config` - Configuration changes, settings updates
   - `plan` - Planning or breaking down tasks
-  - `execute` - Shell commands, running programs, scripts, compiling,
-    building
+  - `execute` - Shell commands, running programs, scripts, processing
+    operations
   - `answer` - Answering questions, explaining concepts, providing
     information
   - `report` - Generating summaries, creating reports, displaying
     results
   - `define` - Presenting skill-based options when request matches
-    multiple skill variants
+    multiple skill variants. **CRITICAL: Options must be ATOMIC choices
+    (selecting ONE variant, ONE environment, ONE target), NOT sequences of
+    steps. Each option represents a single selection that will later be
+    expanded into individual sequential steps. NEVER bundle multiple steps
+    into a single option like "Process X, run validation, deploy Y".**
   - `ignore` - Request is too vague and cannot be mapped to skills or
     inferred from context
 
@@ -541,7 +563,7 @@ Only split when tasks are truly distinct operations:
   dependencies" (type: execute) and "Run tests" (type: execute)
 - "create file; add content" → Two tasks with actions "Create a file" (type:
   execute) and "Add content" (type: execute)
-- "build project and deploy" → Two tasks with actions "Build the project"
+- "process data and deploy" → Two tasks with actions "Process the data"
   (type: execute) and "Deploy" (type: execute)
 
 ### Correct Examples: Complex Questions
@@ -567,15 +589,15 @@ Split only when multiple distinct queries or operations are needed:
 
 Examples showing proper use of skills and disambiguation:
 
-- "build" with build skill requiring {PROJECT} parameter (Alpha, Beta, Gamma,
-  Delta) → One task: type "define", action "Clarify which project to build",
-  params { options: ["Build Alpha", "Build Beta", "Build Gamma", "Build
-  Delta"] }. NOTE: If variants have descriptions, format as "Build Alpha, the
-  legacy version" NOT "Build Alpha (the legacy version)"
-- "build Alpha" with same build skill → Three tasks extracted from skill
-  steps: "Navigate to the Alpha project's root directory", "Execute the Alpha
-  project generation script", "Compile the Alpha source code"
-- "build all" with same build skill → Twelve tasks (3 steps × 4 projects)
+- "process" with process skill requiring {TARGET} parameter (Alpha, Beta, Gamma,
+  Delta) → One task: type "define", action "Clarify which target to process",
+  params { options: ["Process Alpha", "Process Beta", "Process Gamma", "Process
+  Delta"] }. NOTE: If variants have descriptions, format as "Process Alpha, the
+  legacy version" NOT "Process Alpha (the legacy version)"
+- "process Alpha" with same process skill → Three tasks extracted from skill
+  steps: "Navigate to the Alpha target's root directory", "Execute the Alpha
+  target generation script", "Run the Alpha processing pipeline"
+- "process all" with same process skill → Twelve tasks (3 steps × 4 targets)
 - "deploy" with deploy skill (staging, production, canary) → One task: type
   "define", action "Clarify which environment to deploy to", params
   { options: ["Deploy to staging environment", "Deploy to production
@@ -590,13 +612,40 @@ Examples showing proper use of skills and disambiguation:
 - "analyze data and generate report" with analyze skill but NO generate skill →
   Tasks from analyze skill + one "ignore" type for unknown "generate"
 
+### INCORRECT Examples: Sequence-Based Define Options
+
+These examples show the WRONG way to use "define" type - bundling sequences
+instead of atomic choices:
+
+- "process alpha, verify, process beta" with process skill for targets Alpha
+  and Beta →
+  - WRONG: One task type "define" with options ["Process Alpha, run
+    verification, process Beta", "Process Alpha, skip verification, process
+    Beta"]
+  - CORRECT: Multiple sequential tasks: "Process Alpha", "Run verification",
+    "Process Beta" (no define needed - these are distinct sequential
+    operations)
+
+- "deploy" with deploy skill (staging, production) →
+  - WRONG: One task type "define" with options ["Deploy to staging then
+    production", "Deploy to production only"]
+  - CORRECT: One task type "define" with options ["Deploy to staging", "Deploy
+    to production"] (atomic environment choices)
+
+- "process and validate" with process skill ({TARGET} parameter: Alpha, Beta) →
+  - WRONG: One task type "define" with options ["Process Alpha and run
+    validation", "Process Beta and run validation"]
+  - CORRECT: One task type "define" to choose target ["Process Alpha",
+    "Process Beta"], then once selected, expand into separate sequential tasks
+    for process steps + validation step
+
 ### Correct Examples: Requests Without Matching Skills
 
 - "lint" with NO lint skill → One task: type "ignore", action "Ignore
   unknown 'lint' request"
 - "format" with NO format skill → One task: type "ignore", action "Ignore
   unknown 'format' request"
-- "build" with NO build skill → One task: type "ignore", action "Ignore
-  unknown 'build' request"
+- "process" with NO process skill → One task: type "ignore", action "Ignore
+  unknown 'process' request"
 - "do stuff" with NO skills → One task: type "ignore", action "Ignore
   unknown 'do stuff' request"

package/dist/services/components.js

@@ -1,11 +1,24 @@
-import { ComponentName, } from '../types/components.js';
-import { StepType } from '../ui/Config.js';
+import { randomUUID } from 'node:crypto';
+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(),
         name: ComponentName.Welcome,
         props: { app },
     };
@@ -35,6 +48,7 @@ export function createConfigSteps() {
 }
 export function createConfigDefinition(onFinished, onAborted) {
     return {
+        id: randomUUID(),
         name: ComponentName.Config,
         state: { done: false },
         props: {
@@ -44,8 +58,9 @@ 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,
         state: {
             done: false,
@@ -56,20 +71,31 @@ export function createCommandDefinition(command, service, onError, onComplete) {
             service,
             onError,
             onComplete,
+            onAborted,
         },
     };
 }
-export function createPlanDefinition(message, tasks) {
+export function createPlanDefinition(message, tasks, onAborted, onSelectionConfirmed) {
     return {
+        id: randomUUID(),
         name: ComponentName.Plan,
+        state: {
+            done: false,
+            highlightedIndex: null,
+            currentDefineGroupIndex: 0,
+            completedSelections: [],
+        },
         props: {
             message,
             tasks,
+            onSelectionConfirmed,
+            onAborted,
         },
     };
 }
 export function createFeedback(type, ...messages) {
     return {
+        id: randomUUID(),
         name: ComponentName.Feedback,
         props: {
             type,
@@ -79,12 +105,24 @@ export function createFeedback(type, ...messages) {
 }
 export function createMessage(text) {
     return {
+        id: randomUUID(),
         name: ComponentName.Message,
         props: {
             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,27 +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 || (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/Column.js

@@ -2,5 +2,5 @@ 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, index) => (_jsx(Box, { children: _jsx(Component, { def: item }) }, index))) }));
+    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))) }));
 };

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

@@ -1,7 +1,21 @@
 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 }) => {
+export const List = ({ items, level = 0, highlightedIndex = null, highlightedParentIndex = null, }) => {
     const marginLeft = level > 0 ? 4 : 0;
-    return (_jsx(Box, { flexDirection: "column", marginLeft: marginLeft, children: items.map((item, index) => (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "whiteBright", children: '  - ' }), _jsx(Label, { description: item.description.text, descriptionColor: item.description.color, type: item.type.text, typeColor: item.type.color })] }), item.children && item.children.length > 0 && (_jsx(List, { items: item.children, level: level + 1 }))] }, index))) }));
+    return (_jsx(Box, { flexDirection: "column", marginLeft: marginLeft, children: items.map((item, index) => {
+            // At level 0, track which parent is active for child highlighting
+            // At level > 0, only highlight if this parent is the active one
+            const shouldHighlightChildren = level === 0 ? highlightedParentIndex === index : false;
+            const isHighlighted = item.highlighted || (level > 0 && index === highlightedIndex);
+            const marker = item.marker || (isHighlighted ? '  → ' : '  - ');
+            // Use highlighted colors if available and item is highlighted
+            const descriptionColor = isHighlighted && item.description.highlightedColor
+                ? item.description.highlightedColor
+                : item.description.color;
+            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));
+        }) }));
 };

package/dist/ui/Main.js

@@ -1,10 +1,9 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import React from 'react';
-import { ComponentName, } 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,18 +45,106 @@ export const Main = ({ app, command }) => {
             return [];
         });
     }, [addToTimeline]);
+    const handleAborted = React.useCallback((operationName) => {
+        setQueue((currentQueue) => {
+            if (currentQueue.length === 0)
+                return currentQueue;
+            const [first] = currentQueue;
+            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 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)
                 return currentQueue;
             const [first] = currentQueue;
+            // 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) {
-                addToTimeline(markAsDone(first), createPlanDefinition(message, tasks));
+                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
+                    addToTimeline(markAsDone(first), planDefinition);
+                    exitApp(0);
+                    return [];
+                }
             }
             exitApp(0);
             return [];
         });
-    }, [addToTimeline]);
+    }, [addToTimeline, handlePlanSelectionConfirmed]);
     const handleConfigFinished = React.useCallback((config) => {
         const anthropicConfig = config;
         saveAnthropicConfig(anthropicConfig);
@@ -75,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
@@ -83,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,6 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box } from 'ink';
-import { TaskType } from '../types/components.js';
+import { useEffect, useState } from 'react';
+import { Box, useInput } from 'ink';
+import { TaskType } from '../types/types.js';
 import { Label } from './Label.js';
 import { List } from './List.js';
 const ColorPalette = {
@@ -36,8 +37,12 @@ const ColorPalette = {
         description: '#888888', // grey
         type: '#5c8cbc', // steel blue
     },
+    [TaskType.Discard]: {
+        description: '#666666', // dark grey
+        type: '#a85c3f', // dark orange
+    },
 };
-function taskToListItem(task) {
+function taskToListItem(task, highlightedChildIndex = null, isDefineTaskWithoutSelection = false) {
     const item = {
         description: {
             text: task.action,
@@ -46,22 +51,162 @@ function taskToListItem(task) {
         type: { text: task.type, color: ColorPalette[task.type].type },
         children: [],
     };
+    // Mark define tasks with right arrow when no selection has been made
+    if (isDefineTaskWithoutSelection) {
+        item.marker = '  → ';
+    }
     // Add children for Define tasks with options
     if (task.type === TaskType.Define && Array.isArray(task.params?.options)) {
-        const selectColors = ColorPalette[TaskType.Select];
-        item.children = task.params.options.map((option) => ({
-            description: {
-                text: String(option),
-                color: selectColors.description,
-            },
-            type: {
-                text: TaskType.Select,
-                color: selectColors.type,
-            },
-        }));
+        item.children = task.params.options.map((option, index) => {
+            // Determine the type based on selection state
+            let childType = TaskType.Select;
+            if (highlightedChildIndex !== null) {
+                // A selection was made - mark others as discarded
+                childType =
+                    index === highlightedChildIndex ? TaskType.Execute : TaskType.Discard;
+            }
+            const colors = ColorPalette[childType];
+            return {
+                description: {
+                    text: String(option),
+                    color: colors.description,
+                    highlightedColor: ColorPalette[TaskType.Plan].description,
+                },
+                type: {
+                    text: childType,
+                    color: colors.type,
+                    highlightedColor: ColorPalette[TaskType.Plan].type,
+                },
+            };
+        });
     }
     return item;
 }
-export function Plan({ message, tasks }) {
-    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: tasks.map(taskToListItem) })] }));
+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 ?? []);
+    const [isDone, setIsDone] = useState(state?.done ?? false);
+    // Find all Define tasks
+    const defineTaskIndices = tasks
+        .map((t, idx) => (t.type === TaskType.Define ? idx : -1))
+        .filter((idx) => idx !== -1);
+    // Get the current active define task
+    const currentDefineTaskIndex = defineTaskIndices[currentDefineGroupIndex] ?? -1;
+    const defineTask = currentDefineTaskIndex >= 0 ? tasks[currentDefineTaskIndex] : null;
+    const optionsCount = Array.isArray(defineTask?.params?.options)
+        ? defineTask.params.options.length
+        : 0;
+    const hasMoreGroups = currentDefineGroupIndex < defineTaskIndices.length - 1;
+    useInput((input, key) => {
+        // Don't handle input if already done or no define task
+        if (isDone || !defineTask) {
+            return;
+        }
+        if (key.escape) {
+            onAborted();
+            return;
+        }
+        if (key.downArrow) {
+            setHighlightedIndex((prev) => {
+                if (prev === null) {
+                    return 0; // Select first
+                }
+                return (prev + 1) % optionsCount; // Wrap around
+            });
+        }
+        else if (key.upArrow) {
+            setHighlightedIndex((prev) => {
+                if (prev === null) {
+                    return optionsCount - 1; // Select last
+                }
+                return (prev - 1 + optionsCount) % optionsCount; // Wrap around
+            });
+        }
+        else if (key.return && highlightedIndex !== null) {
+            // Record the selection for this group
+            const newCompletedSelections = [...completedSelections];
+            newCompletedSelections[currentDefineGroupIndex] = highlightedIndex;
+            setCompletedSelections(newCompletedSelections);
+            if (hasMoreGroups) {
+                // Advance to next group
+                setCurrentDefineGroupIndex(currentDefineGroupIndex + 1);
+                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;
+                }
+                // 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);
+                    }
+                });
+                onSelectionConfirmed?.(refinedTasks);
+            }
+        }
+    }, { isActive: !isDone && defineTask !== null });
+    // Sync state back to state object
+    useEffect(() => {
+        if (state) {
+            state.highlightedIndex = highlightedIndex;
+            state.currentDefineGroupIndex = currentDefineGroupIndex;
+            state.completedSelections = completedSelections;
+            state.done = isDone;
+        }
+    }, [
+        highlightedIndex,
+        currentDefineGroupIndex,
+        completedSelections,
+        isDone,
+        state,
+    ]);
+    const listItems = tasks.map((task, idx) => {
+        // Find which define group this task belongs to (if any)
+        const defineGroupIndex = defineTaskIndices.indexOf(idx);
+        const isDefineTask = defineGroupIndex !== -1;
+        // Determine child selection state
+        let childIndex = null;
+        if (isDefineTask) {
+            if (defineGroupIndex < currentDefineGroupIndex) {
+                // Previously completed group - show the selection
+                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
+                    childIndex = completedSelections[defineGroupIndex] ?? null;
+                }
+                else {
+                    childIndex = null;
+                }
+            }
+        }
+        // Show arrow on current active define task when no child is highlighted and not done
+        const isDefineWithoutSelection = isDefineTask &&
+            defineGroupIndex === currentDefineGroupIndex &&
+            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.2",
+  "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",