prompt-language-shell 0.2.4 → 0.2.8

package/dist/config/PLAN.md

@@ -25,31 +25,115 @@ 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.
 
-## Skills Integration
+## Response Format
+
+Every response MUST include an introductory message before the task list.
+This message should introduce the PLAN, not the execution itself.
 
-If skills are provided in the "Available Skills" section below, you MUST
-use them when the user's query matches a skill's domain.
+**Critical rules:**
+- The message is MANDATORY - every single response must include one
+- NEVER repeat the same message - each response should use different wording
+- Must be a SINGLE sentence, maximum 64 characters (including the colon)
+- The message introduces the plan/steps that follow, NOT the action itself
+- ALWAYS end the message with a colon (:)
+- Match the tone to the request (professional, helpful, reassuring)
+- Avoid formulaic patterns - vary your phrasing naturally
+
+**Correct examples (introducing the plan):**
+- "Here is my plan:"
+- "Here's what I'll do:"
+- "Let me break this down:"
+- "I've planned the following steps:"
+- "Here's how I'll approach this:"
+- "Here are the steps I'll take:"
+- "This is my plan:"
+- "Let me outline the approach:"
+- "Here's the plan:"
+
+**DO NOT:**
+- Use the exact same phrase repeatedly
+- Create overly long or verbose introductions
+- Include unnecessary pleasantries or apologies
+- Use the same sentence structure every time
+- Phrase it as if you're executing (use "plan" language, not "doing" language)
+- Forget the colon at the end
+
+Remember: You are presenting a PLAN, not performing the action. The message
+should naturally lead into a list of planned steps. Always end with a colon.
 
-When a query matches a skill:
-1. Recognize the semantic match between the user's request and the skill
-   description
-2. Check if the skill has parameters (e.g. {PROJECT}) or describes
-   multiple variants in its description
-3. If skill requires parameters and user didn't specify which variant:
-   - Create a "define" type task with options listing all variants from the
+## Skills Integration
+
+Skills define the ONLY operations you can execute. If skills are provided in
+the "Available Skills" section below, you MUST use ONLY those skills for
+executable operations.
+
+**Skills are EXHAUSTIVE and EXCLUSIVE**
+- The list of available skills is COMPLETE
+- If an action verb does NOT have a matching skill, it CANNOT be executed
+- You MUST create an "ignore" type task for ANY verb without a matching skill
+- There are NO implicit or assumed operations
+- **DO NOT infer follow-up actions based on context**
+- **DO NOT assume operations even if they seem logically related to a matched skill**
+- Example: If only a "backup" skill exists, and user says "backup and restore",
+  you create tasks from backup skill + one "ignore" task for "restore"
+
+**STRICT SKILL MATCHING RULES:**
+
+1. **Identify skill match:** For each action verb in the user's request,
+   check if a corresponding skill exists
+   - If a skill exists → use that skill
+   - If NO skill exists → create "ignore" type task
+   - **NEVER create execute tasks for unmatched verbs under ANY circumstances**
+   - This includes common verbs like "analyze", "validate", "initialize",
+     "configure", "setup" if no corresponding skill exists
+   - Do NOT infer or assume operations - only use explicitly defined skills
+
+2. **Check for Execution section (CRITICAL):**
+   - If the skill has an "Execution" section, you MUST use it as the
+     authoritative source for task commands
+   - Each line in the Execution section corresponds to one task
+   - Extract the exact command or operation from each Execution line
+   - Replace parameter placeholders (e.g., {TARGET}, {ENV}) with specified values
+   - The action field must reference the specific command from Execution
+   - **IMPORTANT**: Once you determine the execution steps from the skill,
+     you MUST verify that each step matches a command present in the
+     Execution section. If a step does NOT have a corresponding command in
+     the Execution section, it should NOT be included in the task list.
+   - If no Execution section exists, fall back to the Steps section
+
+3. **Handle skill parameters:**
+   - Check if the skill has parameters (e.g., {PROJECT}) or describes multiple
+     variants in its description
+   - If skill requires parameters and user didn't specify which variant:
+     Create a "define" type task with options listing all variants from the
      skill description
-   - Extract variants from the skill's description section
-4. If user specified the variant or skill has no parameters:
-   - Extract the individual steps from the skill's "Steps" section
-   - Replace parameter placeholders (e.g., {BROWSER}) with the specified value
+   - If user specified the variant or skill has no parameters:
+     Extract the individual steps from the skill's "Execution" or "Steps"
+     section (prefer Execution if available)
+   - Replace ALL parameter placeholders with the specified value
+
+4. **Handle partial execution:**
+   - Keywords indicating partial execution: "only", "just", specific verbs
+     that match individual step names
+   - 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
+   - Only extract steps that align with the user's specific request
+
+5. **Create task definitions:**
    - Create a task definition for each step with:
      - action: clear, professional description starting with a capital letter
-     - type: category of operation (if the skill specifies it or you
-       can infer it)
+     - type: category of operation (if the skill specifies it or you can infer it)
      - params: any specific parameters mentioned in the step
-5. If the user's query includes additional requirements beyond the skill,
-   append those as additional task definitions
-6. NEVER replace the skill's detailed steps with a generic restatement
+   - NEVER replace the skill's detailed steps with a generic restatement
+
+6. **Handle additional requirements beyond the skill:**
+   - If the user's query includes additional requirements beyond the skill,
+     check if those requirements match OTHER available skills
+   - If they match a skill → append tasks from that skill
+   - If they do NOT match any skill → append "ignore" type task
+   - NEVER create generic execute tasks for unmatched requirements
 
 Example 1 - Skill with parameter, variant specified:
 - Skill has {PROJECT} parameter with variants: Alpha, Beta, Gamma
@@ -73,6 +157,28 @@ Example 3 - Skill without parameters:
 - Correct: Four tasks (the three from skill + one for report generation)
 - WRONG: Two tasks ("run tests", "generate a report")
 
+Example 4 - NEGATIVE: Unmatched verb after matched skill:
+- ONLY skill available: "backup" (with steps: connect, export, save)
+- User: "backup data and archive it"
+- CORRECT: Three tasks from backup skill + one "ignore" type task with
+  action "Ignore unknown 'archive' request"
+- WRONG: Three tasks from backup skill + one execute task "Archive the
+  backed up data"
+
+Example 5 - NEGATIVE: Multiple unmatched verbs:
+- ONLY skill available: "sync" (with steps: connect, transfer, verify)
+- User: "sync files and encrypt them, then notify me"
+- CORRECT: Three tasks from sync skill + one "ignore" for "encrypt" +
+  one "ignore" for "notify"
+- WRONG: Creating execute tasks for "encrypt" or "notify"
+
+Example 6 - NEGATIVE: Context inference prohibition:
+- ONLY skill available: "process" (with steps: load, transform, output)
+- User: "process dataset and validate results"
+- CORRECT: Three tasks from process skill + one "ignore" type task for
+  "validate"
+- WRONG: Adding an execute task like "Validate the processed dataset results"
+
 ### Skills and Unclear Requests
 
 When a request is vague and could match multiple skills or multiple operations
@@ -132,12 +238,16 @@ Examples that should be aborted as offensive:
    - Extract steps from the matching skill and create tasks for each step
 
 3. **Logical consequences** - Infer natural workflow steps:
-   - "build" and "deploy" skills exist, user says "build and release" →
-     Most likely means "build and deploy" since "release" often means
-     "deploy" after building
+   - "backup" and "sync" skills exist, user says "backup and upload" →
+     Most likely means "backup and sync" since "upload" often means
+     "sync" after backup
    - Use context and available skills to infer the logical interpretation
    - IMPORTANT: Only infer if matching skills exist. If no matching skill
      exists, use "ignore" type
+   - **Strict skill matching:** For action verbs representing executable
+     operations, you MUST have a matching skill. If a user requests an action
+     that has no corresponding skill, create an "ignore" type task. Do NOT
+     create generic "execute" type tasks for commands without matching skills.
 
 **For requests with unclear subject:**
 
@@ -223,6 +333,7 @@ When creating task definitions, focus on:
   with precise, contextually appropriate alternatives. Use professional, clear
   terminology suitable for technical documentation. Maintain natural, fluent
   English phrasing while preserving the original intent.
+  **Keep action descriptions concise, at most 64 characters.**
 
 - **Type**: Categorize the operation using one of these supported types:
   - `config` - Configuration changes, settings updates
@@ -256,6 +367,21 @@ steps to answer:
 1. Identify each individual task or step
 2. Break complex questions into separate, simpler task definitions
 3. Create a task definition for each distinct operation
+4. **For each operation, independently check if it matches a skill:**
+   - If operation matches a skill → extract skill steps
+   - If operation does NOT match a skill → create "ignore" type task
+   - **CRITICAL: Do NOT infer context or create generic execute tasks for
+     unmatched operations**
+   - Even if an unmatched operation appears after a matched skill, treat it
+     independently
+   - Do NOT create tasks like "Verify the processed X" or "Check X results"
+     for unmatched operations
+   - The ONLY valid types for unmatched operations are "ignore" or "answer"
+     (for information requests)
+   - Example: "process files and validate" where only "process" has a skill
+     → Create tasks from process skill + create "ignore" type for "validate"
+   - Example: "deploy service and monitor" where only "deploy" has a skill
+     → Create tasks from deploy skill + create "ignore" type for "monitor"
 
 When breaking down complex questions:
 
@@ -456,11 +582,13 @@ Examples showing proper use of skills and disambiguation:
   environment", "Deploy to canary environment"] }
 - "deploy all" with deploy skill (staging, production) → Two tasks: one for
   staging deployment, one for production deployment
-- "build and run" with build and run skills → Create tasks from build skill
-  + run skill
-- "build Beta and lint" with build skill (has {PROJECT} parameter) but NO
-  lint skill → Four tasks: three from build skill (with {PROJECT}=Beta) +
-  one "ignore" type for unknown "lint"
+- "backup and restore" with backup and restore skills → Create tasks from
+  backup skill + restore skill
+- "backup photos and verify" with backup skill (has {TYPE} parameter) but NO
+  verify skill → Two tasks from backup skill (with {TYPE}=photos) + one
+  "ignore" type for unknown "verify"
+- "analyze data and generate report" with analyze skill but NO generate skill →
+  Tasks from analyze skill + one "ignore" type for unknown "generate"
 
 ### Correct Examples: Requests Without Matching Skills
 

package/dist/index.js

@@ -3,8 +3,8 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { existsSync, readFileSync } from 'fs';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
-import { render, Text } from 'ink';
-import { ConfigError, configExists, loadConfig, saveConfig, } from './services/config.js';
+import { render } from 'ink';
+import { hasValidConfig, loadConfig, saveAnthropicConfig, } from './services/config.js';
 import { createAnthropicService } from './services/anthropic.js';
 import { Main } from './ui/Main.js';
 const __filename = fileURLToPath(import.meta.url);
@@ -27,29 +27,25 @@ const app = {
 const args = process.argv.slice(2);
 const command = args.join(' ').trim() || null;
 async function runApp() {
-    // First-time setup: config doesn't exist
-    if (!configExists()) {
-        const { waitUntilExit } = render(_jsx(Main, { app: app, command: command, isReady: false, onConfigured: (config) => {
-                saveConfig('anthropic', config);
-                // Create service once for the session
-                return command ? createAnthropicService(config) : undefined;
-            } }));
-        await waitUntilExit();
-        return;
-    }
-    // Try to load and validate config
-    try {
+    // Happy path: valid config exists
+    if (hasValidConfig()) {
         const config = loadConfig();
-        // Create service once at app initialization
         const service = createAnthropicService(config.anthropic);
         render(_jsx(Main, { app: app, command: command, service: service, isReady: true }));
+        return;
     }
-    catch (error) {
-        if (error instanceof ConfigError) {
-            render(_jsx(Text, { color: "red", children: error.message }));
-            process.exit(1);
-        }
-        throw error;
-    }
+    // Setup: config doesn't exist or is invalid
+    const { waitUntilExit, unmount } = render(_jsx(Main, { app: app, command: command, isReady: false, onConfigured: (config) => {
+            saveAnthropicConfig(config);
+            if (command) {
+                return createAnthropicService(config);
+            }
+            else {
+                // No command - exit after showing completion message
+                setTimeout(() => unmount(), 100);
+                return undefined;
+            }
+        } }));
+    await waitUntilExit();
 }
 runApp();

package/dist/services/anthropic.js

@@ -40,8 +40,11 @@ export class AnthropicService {
             throw new Error('Expected tool_use response from Claude API');
         }
         const content = response.content[0];
-        // Extract and validate tasks array
+        // Extract and validate message and tasks
         const input = content.input;
+        if (!input.message || typeof input.message !== 'string') {
+            throw new Error('Invalid tool response: missing or invalid message field');
+        }
         if (!input.tasks || !Array.isArray(input.tasks)) {
             throw new Error('Invalid tool response: missing or invalid tasks array');
         }
@@ -53,6 +56,7 @@ export class AnthropicService {
         });
         const isDebug = process.env.DEBUG === 'true';
         return {
+            message: input.message,
             tasks: input.tasks,
             systemPrompt: isDebug ? systemPrompt : undefined,
         };

package/dist/services/config.js

@@ -3,9 +3,11 @@ import { homedir } from 'os';
 import { join } from 'path';
 import YAML from 'yaml';
 export class ConfigError extends Error {
-    constructor(message) {
+    origin;
+    constructor(message, origin) {
         super(message);
         this.name = 'ConfigError';
+        this.origin = origin;
     }
 }
 const CONFIG_FILE = join(homedir(), '.plsrc');
@@ -14,30 +16,21 @@ function parseYamlConfig(content) {
         return YAML.parse(content);
     }
     catch (error) {
-        throw new ConfigError(`\nFailed to parse YAML configuration file at ${CONFIG_FILE}\n` +
-            `Error: ${error instanceof Error ? error.message : String(error)}`);
+        throw new ConfigError('Failed to parse configuration file', error instanceof Error ? error : undefined);
     }
 }
 function validateConfig(parsed) {
     if (!parsed || typeof parsed !== 'object') {
-        throw new ConfigError(`\nInvalid configuration format in ${CONFIG_FILE}\n` +
-            'Expected a YAML object with configuration settings.');
+        throw new ConfigError('Invalid configuration format');
     }
     const config = parsed;
     // Validate anthropic section
     if (!config.anthropic || typeof config.anthropic !== 'object') {
-        throw new ConfigError(`\nMissing or invalid 'anthropic' section in ${CONFIG_FILE}\n` +
-            'Please add:\n' +
-            'anthropic:\n' +
-            '  key: sk-ant-...');
+        throw new ConfigError('Missing or invalid anthropic configuration');
     }
-    const anthropic = config.anthropic;
-    const key = anthropic['key'];
+    const { key, model } = config.anthropic;
     if (!key || typeof key !== 'string') {
-        throw new ConfigError(`\nMissing or invalid 'anthropic.key' in ${CONFIG_FILE}\n` +
-            'Please add your Anthropic API key:\n' +
-            'anthropic:\n' +
-            '  key: sk-ant-...');
+        throw new ConfigError('Missing or invalid API key');
     }
     const validatedConfig = {
         anthropic: {
@@ -45,19 +38,14 @@ function validateConfig(parsed) {
         },
     };
     // Optional model
-    if (anthropic.model && typeof anthropic.model === 'string') {
-        validatedConfig.anthropic.model = anthropic.model;
+    if (model && typeof model === 'string') {
+        validatedConfig.anthropic.model = model;
     }
     return validatedConfig;
 }
 export function loadConfig() {
     if (!existsSync(CONFIG_FILE)) {
-        throw new ConfigError(`\nConfiguration file not found at ${CONFIG_FILE}\n\n` +
-            'Please create it with your Anthropic API key.\n' +
-            'Example:\n\n' +
-            'anthropic:\n' +
-            '  key: sk-ant-...\n' +
-            '  model: claude-haiku-4-5-20251001\n');
+        throw new ConfigError('Configuration not found');
     }
     const content = readFileSync(CONFIG_FILE, 'utf-8');
     const parsed = parseYamlConfig(content);
@@ -69,6 +57,15 @@ export function getConfigPath() {
 export function configExists() {
     return existsSync(CONFIG_FILE);
 }
+export function hasValidConfig() {
+    try {
+        const config = loadConfig();
+        return !!config.anthropic.key;
+    }
+    catch {
+        return false;
+    }
+}
 export function mergeConfig(existingContent, sectionName, newValues) {
     const parsed = existingContent.trim()
         ? YAML.parse(existingContent)
@@ -95,3 +92,6 @@ export function saveConfig(section, config) {
     const newContent = mergeConfig(existingContent, section, config);
     writeFileSync(CONFIG_FILE, newContent, 'utf-8');
 }
+export function saveAnthropicConfig(config) {
+    saveConfig('anthropic', config);
+}

package/dist/tools/plan.tool.js

@@ -4,6 +4,10 @@ export const planTool = {
     input_schema: {
         type: 'object',
         properties: {
+            message: {
+                type: 'string',
+                description: 'Introductory reply to display before the task list. Must be a single sentence, maximum 64 characters (including the colon at the end). Vary this naturally - try to use a different phrase each time.',
+            },
             tasks: {
                 type: 'array',
                 description: 'Array of planned tasks to execute',
@@ -27,6 +31,6 @@ export const planTool = {
                 },
             },
         },
-        required: ['tasks'],
+        required: ['message', 'tasks'],
     },
 };

package/dist/types/components.js

@@ -9,3 +9,9 @@ export var TaskType;
     TaskType["Ignore"] = "ignore";
     TaskType["Select"] = "select";
 })(TaskType || (TaskType = {}));
+export var FeedbackType;
+(function (FeedbackType) {
+    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, flexDirection: "column", gap: 1, children: items.map((item, index) => (_jsx(Box, { children: _jsx(Component, { def: item }) }, index))) }));
+    return (_jsx(Box, { marginTop: 1, marginBottom: 1, flexDirection: "column", gap: 1, children: items.map((item, index) => (_jsx(Box, { children: _jsx(Component, { def: item }) }, index))) }));
 };

package/dist/ui/Command.js

@@ -3,6 +3,7 @@ import { useEffect, useState } from 'react';
 import { Box, Text } from 'ink';
 import { TaskType } from '../types/components.js';
 import { List } from './List.js';
+import { Separator } from './Separator.js';
 import { Spinner } from './Spinner.js';
 const MIN_PROCESSING_TIME = 1000; // purely for visual effect
 // Color palette
@@ -68,10 +69,11 @@ function taskToListItem(task) {
     }
     return item;
 }
-export function Command({ command, state, service, error: errorProp, children, }) {
+export function Command({ command, state, service, error: errorProp, children, onError, onComplete, }) {
     const done = state?.done ?? false;
     const [error, setError] = useState(state?.error || errorProp || null);
     const [isLoading, setIsLoading] = useState(state?.isLoading ?? !done);
+    const [message, setMessage] = useState('');
     const [tasks, setTasks] = useState([]);
     useEffect(() => {
         // Skip processing if done (showing historical/final state)
@@ -93,8 +95,10 @@ export function Command({ command, state, service, error: errorProp, children, }
                 const remainingTime = Math.max(0, MIN_PROCESSING_TIME - elapsed);
                 await new Promise((resolve) => setTimeout(resolve, remainingTime));
                 if (mounted) {
+                    setMessage(result.message);
                     setTasks(result.tasks);
                     setIsLoading(false);
+                    onComplete?.();
                 }
             }
             catch (err) {
@@ -102,8 +106,14 @@ export function Command({ command, state, service, error: errorProp, children, }
                 const remainingTime = Math.max(0, MIN_PROCESSING_TIME - elapsed);
                 await new Promise((resolve) => setTimeout(resolve, remainingTime));
                 if (mounted) {
-                    setError(err instanceof Error ? err.message : 'Unknown error occurred');
+                    const errorMessage = err instanceof Error ? err.message : 'Unknown error occurred';
                     setIsLoading(false);
+                    if (onError) {
+                        onError(errorMessage);
+                    }
+                    else {
+                        setError(errorMessage);
+                    }
                 }
             }
         }
@@ -112,5 +122,5 @@ export function Command({ command, state, service, error: errorProp, children, }
             mounted = false;
         };
     }, [command, done, service]);
-    return (_jsxs(Box, { alignSelf: "flex-start", marginBottom: 1, flexDirection: "column", children: [_jsxs(Box, { children: [_jsxs(Text, { color: "gray", children: ["> pls ", command] }), isLoading && (_jsxs(_Fragment, { children: [_jsx(Text, { children: " " }), _jsx(Spinner, {})] }))] }), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "red", children: ["Error: ", error] }) })), !isLoading && tasks.length > 0 && (_jsx(Box, { marginTop: 1, children: _jsx(List, { items: tasks.map(taskToListItem) }) })), children] }));
+    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", marginLeft: 1, children: [_jsxs(Box, { children: [_jsxs(Text, { color: "gray", children: ["> pls ", command] }), isLoading && (_jsxs(_Fragment, { children: [_jsx(Text, { children: " " }), _jsx(Spinner, {})] }))] }), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "red", children: ["Error: ", error] }) })), !isLoading && tasks.length > 0 && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [message && (_jsxs(Box, { marginBottom: 1, children: [_jsxs(Text, { children: [" ", message] }), _jsx(Separator, { color: "#9c5ccc" }), _jsx(Text, { color: "#9c5ccc", children: "plan" })] })), _jsx(List, { items: tasks.map(taskToListItem) })] })), children] }));
 }

package/dist/ui/Component.js

@@ -1,6 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Command } from './Command.js';
 import { Config } from './Config.js';
+import { Feedback } from './Feedback.js';
 import { Welcome } from './Welcome.js';
 export function Component({ def }) {
     switch (def.name) {
@@ -11,6 +12,8 @@ export function Component({ def }) {
             const state = def.state;
             return _jsx(Config, { ...props, state: state });
         }
+        case 'feedback':
+            return _jsx(Feedback, { ...def.props });
         case 'command': {
             const props = def.props;
             const state = def.state;

package/dist/ui/Config.js

@@ -1,8 +1,8 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import React from 'react';
-import { Box, Text } from 'ink';
+import { Box, Text, useInput } from 'ink';
 import TextInput from 'ink-text-input';
-export function Config({ steps, state, onFinished }) {
+export function Config({ steps, state, onFinished, onAborted }) {
     const done = state?.done ?? false;
     const [step, setStep] = React.useState(done ? steps.length : 0);
     const [values, setValues] = React.useState(() => {
@@ -15,9 +15,26 @@ export function Config({ steps, state, onFinished }) {
         return initial;
     });
     const [inputValue, setInputValue] = React.useState('');
+    const normalizeValue = (value) => {
+        if (value === null || value === undefined) {
+            return '';
+        }
+        return value.replace(/\n/g, '').trim();
+    };
+    useInput((input, key) => {
+        if (key.escape && !done && step < steps.length) {
+            if (onAborted) {
+                onAborted();
+            }
+        }
+    });
     const handleSubmit = (value) => {
         const currentStepConfig = steps[step];
-        const finalValue = value.trim() || currentStepConfig.value || '';
+        const finalValue = normalizeValue(value) || normalizeValue(currentStepConfig.value);
+        // Don't allow empty value if step has no default (mandatory field)
+        if (!finalValue && !currentStepConfig.value) {
+            return;
+        }
         const newValues = { ...values, [currentStepConfig.key]: finalValue };
         setValues(newValues);
         setInputValue('');
@@ -32,13 +49,14 @@ export function Config({ steps, state, onFinished }) {
             setStep(step + 1);
         }
     };
-    return (_jsxs(Box, { flexDirection: "column", marginLeft: 1, children: [steps.map((stepConfig, index) => {
-                const isCurrentStep = index === step && !done;
-                const isCompleted = index < step || done;
-                const shouldShow = isCompleted || isCurrentStep;
-                if (!shouldShow) {
-                    return null;
-                }
-                return (_jsxs(Box, { flexDirection: "column", marginTop: index === 0 ? 0 : 1, children: [_jsx(Box, { children: _jsxs(Text, { children: [stepConfig.description, ":"] }) }), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: "> " }), isCurrentStep ? (_jsx(TextInput, { value: inputValue, onChange: setInputValue, onSubmit: handleSubmit })) : (_jsx(Text, { dimColor: true, children: values[stepConfig.key] || '' }))] })] }, stepConfig.key));
-            }), step === steps.length && !done && (_jsx(Box, { marginY: 1, children: _jsx(Text, { color: "green", children: "\u2713 Configuration complete" }) }))] }));
+    return (_jsx(Box, { flexDirection: "column", marginLeft: 1, children: steps.map((stepConfig, index) => {
+            const isCurrentStep = index === step && !done;
+            const isCompleted = index < step;
+            const wasAborted = index === step && done;
+            const shouldShow = isCompleted || isCurrentStep || wasAborted;
+            if (!shouldShow) {
+                return null;
+            }
+            return (_jsxs(Box, { flexDirection: "column", marginTop: index === 0 ? 0 : 1, children: [_jsx(Box, { children: _jsxs(Text, { children: [stepConfig.description, ":"] }) }), _jsxs(Box, { children: [_jsx(Text, { children: " " }), _jsx(Text, { color: "#5c8cbc", dimColor: !isCurrentStep, children: ">" }), _jsx(Text, { children: " " }), isCurrentStep ? (_jsx(TextInput, { value: inputValue, onChange: setInputValue, onSubmit: handleSubmit, placeholder: stepConfig.value || undefined })) : (_jsx(Text, { dimColor: true, children: values[stepConfig.key] || '' }))] })] }, stepConfig.key));
+        }) }));
 }

package/dist/ui/Feedback.js

@@ -0,0 +1,22 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { FeedbackType } from '../types/components.js';
+function getSymbol(type) {
+    return {
+        [FeedbackType.Succeeded]: '✓',
+        [FeedbackType.Aborted]: '⊘',
+        [FeedbackType.Failed]: '✗',
+    }[type];
+}
+function getColor(type) {
+    return {
+        [FeedbackType.Succeeded]: '#00aa00', // green
+        [FeedbackType.Aborted]: '#cc9c5c', // orange
+        [FeedbackType.Failed]: '#aa0000', // red
+    }[type];
+}
+export function Feedback({ type, message }) {
+    const color = getColor(type);
+    const symbol = getSymbol(type);
+    return (_jsx(Box, { marginLeft: 1, children: _jsxs(Text, { color: color, children: [symbol, " ", message] }) }));
+}