prompt-language-shell 0.2.2 → 0.2.6

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
@@ -84,6 +190,10 @@ derived from available skills:
    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
+   instead. For example:
+   - CORRECT: "Build project Alpha, the legacy version"
+   - WRONG: "Build project Alpha (the legacy version)"
 
 Example:
 - Available skills: "Build Product" (variant A, variant B), "Deploy
@@ -128,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:**
 
@@ -252,6 +366,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:
 
@@ -440,7 +569,8 @@ 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"] }
+  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"
@@ -451,11 +581,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

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import { jsx as _jsx } from "react/jsx-runtime";
-import { readFileSync, existsSync } from 'fs';
-import { fileURLToPath } from 'url';
+import { existsSync, readFileSync } from 'fs';
 import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
 import { render, Text } from 'ink';
-import { loadConfig, ConfigError, configExists, saveConfig, } from './services/config.js';
+import { ConfigError, configExists, loadConfig, saveConfig, } from './services/config.js';
 import { createAnthropicService } from './services/anthropic.js';
 import { Main } from './ui/Main.js';
 const __filename = fileURLToPath(import.meta.url);

package/dist/services/anthropic.js

@@ -1,5 +1,5 @@
 import Anthropic from '@anthropic-ai/sdk';
-import { loadSkills, formatSkillsForPrompt } from './skills.js';
+import { formatSkillsForPrompt, loadSkills } from './skills.js';
 import { toolRegistry } from './tool-registry.js';
 export class AnthropicService {
     client;
@@ -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/skills.js

@@ -1,6 +1,6 @@
-import { readFileSync, readdirSync, existsSync } from 'fs';
-import { join } from 'path';
+import { existsSync, readdirSync, readFileSync } from 'fs';
 import { homedir } from 'os';
+import { join } from 'path';
 /**
  * Get the path to the skills directory
  */
@@ -46,6 +46,11 @@ export function formatSkillsForPrompt(skills) {
 The following skills define domain-specific workflows. When the user's
 query matches a skill, incorporate the skill's steps into your plan.
 
+**IMPORTANT**: When creating options from skill descriptions, do NOT use
+brackets for additional information. Use commas instead. For example:
+- CORRECT: "Build project Alpha, the legacy version"
+- WRONG: "Build project Alpha (the legacy version)"
+
 `;
     const skillsContent = skills.join('\n\n');
     return header + skillsContent;

package/dist/services/skills.test.js

@@ -0,0 +1,115 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, writeFileSync, rmSync, existsSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { getSkillsDirectory, loadSkills, formatSkillsForPrompt, } from './skills.js';
+describe('skills service', () => {
+    let originalHome;
+    let tempHome;
+    beforeEach(() => {
+        // Mock HOME to point to temp directory
+        originalHome = process.env.HOME;
+        tempHome = join(tmpdir(), `pls-home-test-${Date.now()}`);
+        mkdirSync(tempHome, { recursive: true });
+        process.env.HOME = tempHome;
+        // Create .pls/skills directory structure
+        const plsDir = join(tempHome, '.pls');
+        mkdirSync(plsDir, { recursive: true });
+        mkdirSync(join(plsDir, 'skills'), { recursive: true });
+    });
+    afterEach(() => {
+        // Restore original HOME first
+        if (originalHome !== undefined) {
+            process.env.HOME = originalHome;
+        }
+        // Clean up temp directory
+        if (existsSync(tempHome)) {
+            rmSync(tempHome, { recursive: true, force: true });
+        }
+    });
+    describe('getSkillsDirectory', () => {
+        it('returns path to .pls/skills in home directory', () => {
+            const skillsDir = getSkillsDirectory();
+            expect(skillsDir).toContain('.pls');
+            expect(skillsDir).toContain('skills');
+        });
+    });
+    describe('loadSkills', () => {
+        it('returns empty array when skills directory does not exist', () => {
+            // Remove the skills directory
+            const skillsDir = getSkillsDirectory();
+            if (existsSync(skillsDir)) {
+                rmSync(skillsDir, { recursive: true, force: true });
+            }
+            const skills = loadSkills();
+            expect(skills).toEqual([]);
+        });
+        it('returns empty array when skills directory is empty', () => {
+            const skills = loadSkills();
+            expect(skills).toEqual([]);
+        });
+        it('loads single skill file', () => {
+            const skillsDir = getSkillsDirectory();
+            const skillContent = `### Name
+Build Opera
+
+### Description
+Run Opera Desktop browser build
+
+### Steps
+Navigate to the project directory, run the project generation script, run the compilation`;
+            writeFileSync(join(skillsDir, 'opera.md'), skillContent, 'utf-8');
+            const skills = loadSkills();
+            expect(skills).toHaveLength(1);
+            expect(skills[0]).toBe(skillContent);
+        });
+        it('loads multiple skill files', () => {
+            const skillsDir = getSkillsDirectory();
+            const skill1 = 'Skill 1 content';
+            const skill2 = 'Skill 2 content';
+            writeFileSync(join(skillsDir, 'skill1.md'), skill1, 'utf-8');
+            writeFileSync(join(skillsDir, 'skill2.md'), skill2, 'utf-8');
+            const skills = loadSkills();
+            expect(skills).toHaveLength(2);
+            expect(skills).toContain(skill1);
+            expect(skills).toContain(skill2);
+        });
+        it('ignores non-markdown files', () => {
+            const skillsDir = getSkillsDirectory();
+            writeFileSync(join(skillsDir, 'skill.md'), 'Skill content', 'utf-8');
+            writeFileSync(join(skillsDir, 'readme.txt'), 'Not a skill', 'utf-8');
+            writeFileSync(join(skillsDir, 'data.json'), '{}', 'utf-8');
+            const skills = loadSkills();
+            expect(skills).toHaveLength(1);
+            expect(skills[0]).toBe('Skill content');
+        });
+        it('handles both .md and .MD extensions', () => {
+            const skillsDir = getSkillsDirectory();
+            writeFileSync(join(skillsDir, 'skill1.md'), 'Lowercase', 'utf-8');
+            writeFileSync(join(skillsDir, 'skill2.MD'), 'Uppercase', 'utf-8');
+            const skills = loadSkills();
+            expect(skills).toHaveLength(2);
+        });
+    });
+    describe('formatSkillsForPrompt', () => {
+        it('returns empty string when no skills', () => {
+            const formatted = formatSkillsForPrompt([]);
+            expect(formatted).toBe('');
+        });
+        it('formats single skill with header', () => {
+            const skills = ['Skill 1 content'];
+            const formatted = formatSkillsForPrompt(skills);
+            expect(formatted).toContain('## Available Skills');
+            expect(formatted).toContain('The following skills define domain-specific workflows');
+            expect(formatted).toContain('Skill 1 content');
+        });
+        it('formats multiple skills separated by blank lines', () => {
+            const skills = ['Skill 1', 'Skill 2', 'Skill 3'];
+            const formatted = formatSkillsForPrompt(skills);
+            expect(formatted).toContain('Skill 1');
+            expect(formatted).toContain('Skill 2');
+            expect(formatted).toContain('Skill 3');
+            expect(formatted).toContain('\n\n');
+        });
+    });
+});

package/dist/services/tool-registry.js

@@ -1,7 +1,6 @@
 import { readFileSync } from 'fs';
-import { resolve } from 'path';
+import { dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
-import { dirname } from 'path';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 class ToolRegistry {

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

@@ -7,4 +7,5 @@ export var TaskType;
     TaskType["Report"] = "report";
     TaskType["Define"] = "define";
     TaskType["Ignore"] = "ignore";
+    TaskType["Select"] = "select";
 })(TaskType || (TaskType = {}));

package/dist/ui/Column.js

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

package/dist/ui/Command.js

@@ -2,27 +2,79 @@ import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-run
 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
-function getTaskActionColor(taskType) {
-    return taskType === TaskType.Ignore ? 'yellow' : 'white';
+// Color palette
+const ColorPalette = {
+    [TaskType.Config]: {
+        description: '#ffffff', // white
+        type: '#5c9ccc', // cyan
+    },
+    [TaskType.Plan]: {
+        description: '#ffffff', // white
+        type: '#cc5c9c', // magenta
+    },
+    [TaskType.Execute]: {
+        description: '#ffffff', // white
+        type: '#4a9a7a', // green
+    },
+    [TaskType.Answer]: {
+        description: '#ffffff', // white
+        type: '#9c5ccc', // purple
+    },
+    [TaskType.Report]: {
+        description: '#ffffff', // white
+        type: '#cc9c5c', // orange
+    },
+    [TaskType.Define]: {
+        description: '#ffffff', // white
+        type: '#cc9c5c', // amber
+    },
+    [TaskType.Ignore]: {
+        description: '#cccc5c', // yellow
+        type: '#cc7a5c', // orange
+    },
+    [TaskType.Select]: {
+        description: '#888888', // grey
+        type: '#5c8cbc', // steel blue
+    },
+};
+function taskToListItem(task) {
+    const colors = ColorPalette[task.type];
+    const item = {
+        description: {
+            text: task.action,
+            color: colors.description,
+        },
+        type: {
+            text: task.type,
+            color: colors.type,
+        },
+    };
+    // 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,
+            },
+        }));
+    }
+    return item;
 }
-function getTaskTypeColor(taskType) {
-    if (taskType === TaskType.Ignore)
-        return 'red';
-    if (taskType === TaskType.Define)
-        return 'blue';
-    return 'greenBright';
-}
-function shouldDimTaskType(taskType) {
-    return taskType !== TaskType.Define;
-}
-export function Command({ command, state, service, tasks, error: errorProp, systemPrompt: systemPromptProp, }) {
+export function Command({ command, state, service, error: errorProp, children, }) {
     const done = state?.done ?? false;
-    const [processedTasks, setProcessedTasks] = useState(tasks || []);
-    const [systemPrompt, setSystemPrompt] = useState(systemPromptProp);
     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)
         if (done) {
@@ -43,8 +95,8 @@ export function Command({ command, state, service, tasks, error: errorProp, syst
                 const remainingTime = Math.max(0, MIN_PROCESSING_TIME - elapsed);
                 await new Promise((resolve) => setTimeout(resolve, remainingTime));
                 if (mounted) {
-                    setProcessedTasks(result.tasks);
-                    setSystemPrompt(result.systemPrompt);
+                    setMessage(result.message);
+                    setTasks(result.tasks);
                     setIsLoading(false);
                 }
             }
@@ -63,7 +115,5 @@ export function Command({ command, state, service, tasks, error: errorProp, syst
             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] }) })), processedTasks.length > 0 && (_jsx(Box, { flexDirection: "column", children: processedTasks.map((task, index) => (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "whiteBright", children: '  - ' }), _jsx(Text, { color: getTaskActionColor(task.type), children: task.action }), _jsxs(Text, { color: getTaskTypeColor(task.type), dimColor: shouldDimTaskType(task.type), children: [' ', "(", task.type, ")"] })] }), (task.type === TaskType.Define &&
-                            task.params?.options &&
-                            Array.isArray(task.params.options) && (_jsx(Box, { flexDirection: "column", marginLeft: 4, children: task.params.options.map((option, optIndex) => (_jsx(Box, { children: _jsxs(Text, { color: "whiteBright", dimColor: true, children: ["- ", String(option)] }) }, optIndex))) })))] }, index))) }))] }));
+    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 && (_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

@@ -0,0 +1,20 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Command } from './Command.js';
+import { Config } from './Config.js';
+import { Welcome } from './Welcome.js';
+export function Component({ def }) {
+    switch (def.name) {
+        case 'welcome':
+            return _jsx(Welcome, { ...def.props });
+        case 'config': {
+            const props = def.props;
+            const state = def.state;
+            return _jsx(Config, { ...props, state: state });
+        }
+        case 'command': {
+            const props = def.props;
+            const state = def.state;
+            return _jsx(Command, { ...props, state: state });
+        }
+    }
+}

package/dist/ui/Config.js

@@ -0,0 +1,44 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text } from 'ink';
+import TextInput from 'ink-text-input';
+export function Config({ steps, state, onFinished }) {
+    const done = state?.done ?? false;
+    const [step, setStep] = React.useState(done ? steps.length : 0);
+    const [values, setValues] = React.useState(() => {
+        const initial = {};
+        steps.forEach((step) => {
+            if (step.value !== null) {
+                initial[step.key] = step.value;
+            }
+        });
+        return initial;
+    });
+    const [inputValue, setInputValue] = React.useState('');
+    const handleSubmit = (value) => {
+        const currentStepConfig = steps[step];
+        const finalValue = value.trim() || currentStepConfig.value || '';
+        const newValues = { ...values, [currentStepConfig.key]: finalValue };
+        setValues(newValues);
+        setInputValue('');
+        if (step === steps.length - 1) {
+            // Last step completed
+            if (onFinished) {
+                onFinished(newValues);
+            }
+            setStep(steps.length);
+        }
+        else {
+            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" }) }))] }));
+}