prompt-language-shell 0.1.2 → 0.1.6

package/README.md

@@ -10,61 +10,40 @@ npm install -g prompt-language-shell
 
 ## Setup
 
-Before using `pls`, you need to configure your Claude API key:
-
-1. Get your API key from [Anthropic Console](https://console.anthropic.com/)
-2. Create the configuration directory and file:
-
-```bash
-mkdir -p ~/.pls
-echo "CLAUDE_API_KEY=sk-ant-your-api-key-here" > ~/.pls/.env
-```
-
-Replace `sk-ant-your-api-key-here` with your actual API key.
+On first run, `pls` walks you through a quick setup. Your settings will be saved to `~/.plsrc`.
 
 ## Usage
 
-Simply type `pls` followed by your request in natural language:
+Type `pls` followed by your request in natural language:
 
 ```bash
 pls change dir to ~
 ```
 
-The tool will:
-
-- Display your original command
-- Process it to grammatically correct and clarify it
-- Show the interpreted task
-
-Example output:
+Your command will be interpreted and organized into a list of tasks:
 
 ```
 > pls change dir to ~
-  - change directory to the home folder
-```
-
-You can provide multiple tasks separated by commas (`,`), semicolons (`;`), or the word "and":
-
-```bash
-pls install deps, run tests and deploy
+  - Change directory to the home folder
 ```
 
-Example output:
+You can provide multiple requests at once:
 
 ```
 > pls install deps, run tests and deploy
-  - install dependencies
-  - run tests
-  - deploy to server
+  - Install dependencies
+  - Run tests
+  - Deploy to server
 ```
 
 Run `pls` without arguments to see the welcome screen.
 
 ## Configuration
 
-Configuration is stored in `~/.pls/.env`. Currently supported:
+Your configuration is stored in `~/.plsrc` as a YAML file. Supported settings:
 
-- `CLAUDE_API_KEY` - Your Anthropic API key (required)
+- `anthropic.api-key` - Your Anthropic API key
+- `anthropic.model` - The Claude model to use for task planning
 
 ## Development
 

package/dist/config/PLAN.md

@@ -15,6 +15,38 @@ preserving the original intent. Apply minimal necessary changes to achieve
 optimal clarity. The refined output will be used to plan and execute real
 operations, so precision and unambiguous language are essential.
 
+## Skills Integration
+
+If skills are provided in the "Available Skills" section below, you MUST
+use them when the user's query matches a skill's domain.
+
+When a query matches a skill:
+1. Recognize the semantic match between the user's request and the skill
+   description
+2. Extract the individual steps from the skill's "Steps" section
+3. Refine each step into clear, professional task descriptions that start
+   with a capital letter like a sentence
+4. Return each step as a separate task in a JSON array
+5. If the user's query includes additional requirements beyond the skill,
+   append those as additional tasks
+6. NEVER replace the skill's detailed steps with a generic restatement of
+   the user's request
+
+Example 1:
+- Skill has steps: "- Navigate to the project directory. - Run the build
+  script - Execute the test suite"
+- User asks: "test the application"
+- Correct output: ["Navigate to the project directory", "Run the build
+  script", "Execute the test suite"]
+- WRONG output: ["test the application"]
+
+Example 2:
+- Skill has steps: "- Navigate to the project directory. - Run the build
+  script - Execute the test suite"
+- User asks: "test the application and generate a report"
+- Correct output: ["Navigate to the project directory", "Run the build
+  script", "Execute the test suite", "Generate a report"]
+
 ## Evaluation of Requests
 
 Before processing any request, evaluate its nature and respond appropriately:
@@ -35,18 +67,41 @@ If the request is too vague or unclear to understand what action should be
 taken, return the exact phrase "abort unclear request".
 
 Before marking a request as unclear, try to infer meaning from:
+- **Available skills**: If a skill is provided that narrows down a domain,
+  use that context to interpret the request. Skills define the scope of what
+  generic terms mean in a specific context. When a user says "all X" or
+  "the Y", check if an available skill defines what X or Y means. For example,
+  if a skill defines specific deployment environments for a project, then
+  "deploy to all environments" should be interpreted within that skill's
+  context, not as a generic unclear request.
 - Common abbreviations and acronyms in technical contexts
 - Well-known product names, tools, or technologies
 - Context clues within the request itself
 - Standard industry terminology
 
-For example:
-- "test GX" → "GX" possibly means Opera GX browser
+For example using skills context:
+- "build all applications" + build skill defining mobile, desktop, and web
+  applications → interpret as those three specific applications
+- "deploy to all environments" + deployment skill defining staging, production,
+  and canary → interpret as those three specific environments
+- "run all test suites" + testing skill listing unit and integration tests →
+  interpret as those two specific test types
+- "build the package" + monorepo skill defining a single backend package →
+  interpret as that one specific package
+- "check all services" + microservices skill listing auth, api, and database
+  services → interpret as those three specific services
+- "run both compilers" + build skill defining TypeScript and Sass compilers →
+  interpret as those two specific compilers
+- "start the server" + infrastructure skill defining a single Node.js server →
+  interpret as that one specific server
+
+For example using common context:
 - "run TS compiler" → "TS" stands for TypeScript
 - "open VSC" → "VSC" likely means Visual Studio Code
+- "run unit tests" → standard development terminology for testing
 
 Only mark as unclear if the request is truly unintelligible or lacks any
-discernible intent.
+discernible intent, even after considering available skills and context.
 
 Examples that are too vague:
 - "do stuff"
@@ -168,7 +223,9 @@ Split into multiple tasks when:
 - Single task: Return ONLY the corrected command text
 - Multiple tasks: Return ONLY a JSON array of strings
 
-Do not include explanations, commentary, or any other text.
+Do not include explanations, commentary, markdown formatting, code blocks, or
+any other text. For JSON arrays, return the raw JSON without ```json``` or
+any other wrapping.
 
 ## Final Validation Before Response
 

package/dist/index.js

@@ -6,8 +6,7 @@ import { dirname, join } from 'path';
 import { render, Text } from 'ink';
 import { loadConfig, ConfigError, configExists, saveConfig, } from './services/config.js';
 import { createAnthropicService } from './services/anthropic.js';
-import { Please } from './ui/Please.js';
-import { ConfigThenCommand } from './ui/ConfigThenCommand.js';
+import { Main } from './ui/Main.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // Get package info
@@ -18,7 +17,7 @@ const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
 // In production, we're in node_modules and src/ doesn't exist alongside
 const srcPath = join(__dirname, '../src');
 const isDev = existsSync(srcPath);
-const appInfo = {
+const app = {
     name: packageJson.name,
     version: packageJson.version,
     description: packageJson.description,
@@ -26,36 +25,24 @@ const appInfo = {
 };
 // Get command from command-line arguments
 const args = process.argv.slice(2);
-const rawCommand = args.join(' ').trim();
+const command = args.join(' ').trim() || null;
 async function runApp() {
-    // Check if config exists, if not run setup
+    // First-time setup: config doesn't exist
     if (!configExists()) {
-        if (!rawCommand) {
-            // "pls" for the first time: show welcome box and ask about config below
-            const { waitUntilExit } = render(_jsx(Please, { app: appInfo, showConfigSetup: true, onConfigComplete: ({ apiKey, model }) => {
-                    saveConfig(apiKey, model);
-                } }));
-            await waitUntilExit();
-            return;
-        }
-        else {
-            // "pls do stuff" for the first time: ask about config, then continue
-            render(_jsx(ConfigThenCommand, { command: rawCommand, onConfigSave: saveConfig }));
-            return;
-        }
+        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 {
         const config = loadConfig();
-        if (!rawCommand) {
-            // "pls" when config present: show welcome box
-            render(_jsx(Please, { app: appInfo }));
-        }
-        else {
-            // "pls do stuff": fetch and show the plan
-            const claudeService = createAnthropicService(config.anthropic.apiKey, config.anthropic.model);
-            render(_jsx(Please, { app: appInfo, command: rawCommand, claudeService: claudeService }));
-        }
+        // Create service once at app initialization
+        const service = createAnthropicService(config.anthropic);
+        render(_jsx(Main, { app: app, command: command, service: service, isReady: true }));
     }
     catch (error) {
         if (error instanceof ConfigError) {

package/dist/services/anthropic.js

@@ -2,25 +2,30 @@ import { readFileSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import Anthropic from '@anthropic-ai/sdk';
+import { loadSkills, formatSkillsForPrompt } from './skills.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const PLAN_PROMPT = readFileSync(join(__dirname, '../config/PLAN.md'), 'utf-8');
 export class AnthropicService {
     client;
     model;
-    constructor(apiKey, model = 'claude-haiku-4-5-20251001') {
-        this.client = new Anthropic({ apiKey });
+    constructor(key, model = 'claude-haiku-4-5-20251001') {
+        this.client = new Anthropic({ apiKey: key });
         this.model = model;
     }
-    async processCommand(rawCommand) {
+    async processCommand(command) {
+        // Load skills and augment the planning prompt
+        const skills = loadSkills();
+        const skillsSection = formatSkillsForPrompt(skills);
+        const systemPrompt = PLAN_PROMPT + skillsSection;
         const response = await this.client.messages.create({
             model: this.model,
-            max_tokens: 200,
-            system: PLAN_PROMPT,
+            max_tokens: 512,
+            system: systemPrompt,
             messages: [
                 {
                     role: 'user',
-                    content: rawCommand,
+                    content: command,
                 },
             ],
         });
@@ -29,26 +34,41 @@ export class AnthropicService {
             throw new Error('Unexpected response type from Claude API');
         }
         const text = content.text.trim();
+        let tasks;
         // Try to parse as JSON array
         if (text.startsWith('[') && text.endsWith(']')) {
             try {
                 const parsed = JSON.parse(text);
-                if (Array.isArray(parsed) && parsed.length > 0) {
+                if (Array.isArray(parsed)) {
                     // Validate all items are strings
                     const allStrings = parsed.every((item) => typeof item === 'string');
                     if (allStrings) {
-                        return parsed.filter((item) => typeof item === 'string');
+                        tasks = parsed.filter((item) => typeof item === 'string');
                     }
+                    else {
+                        tasks = [text];
+                    }
+                }
+                else {
+                    tasks = [text];
                 }
             }
             catch {
                 // If JSON parsing fails, treat as single task
+                tasks = [text];
             }
         }
-        // Single task
-        return [text];
+        else {
+            // Single task
+            tasks = [text];
+        }
+        const isDebug = process.env.DEBUG === 'true';
+        return {
+            tasks,
+            systemPrompt: isDebug ? systemPrompt : undefined,
+        };
     }
 }
-export function createAnthropicService(apiKey, model) {
-    return new AnthropicService(apiKey, model);
+export function createAnthropicService(config) {
+    return new AnthropicService(config.key, config.model);
 }

package/dist/services/config.js

@@ -1,10 +1,7 @@
 import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { homedir } from 'os';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
+import { join } from 'path';
 import YAML from 'yaml';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
 export class ConfigError extends Error {
     constructor(message) {
         super(message);
@@ -32,37 +29,25 @@ function validateConfig(parsed) {
         throw new ConfigError(`\nMissing or invalid 'anthropic' section in ${CONFIG_FILE}\n` +
             'Please add:\n' +
             'anthropic:\n' +
-            '  api-key: sk-ant-...');
+            '  key: sk-ant-...');
     }
     const anthropic = config.anthropic;
-    // Support both 'api-key' (kebab-case) and 'apiKey' (camelCase)
-    const apiKey = anthropic['api-key'] || anthropic.apiKey;
-    if (!apiKey || typeof apiKey !== 'string') {
-        throw new ConfigError(`\nMissing or invalid 'anthropic.api-key' in ${CONFIG_FILE}\n` +
+    const key = anthropic['key'];
+    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' +
-            '  api-key: sk-ant-...');
+            '  key: sk-ant-...');
     }
     const validatedConfig = {
         anthropic: {
-            apiKey: apiKey,
+            key,
         },
     };
     // Optional model
     if (anthropic.model && typeof anthropic.model === 'string') {
         validatedConfig.anthropic.model = anthropic.model;
     }
-    // Optional UI config
-    if (config.ui && typeof config.ui === 'object') {
-        const ui = config.ui;
-        validatedConfig.ui = {};
-        if (ui.theme && typeof ui.theme === 'string') {
-            validatedConfig.ui.theme = ui.theme;
-        }
-        if (typeof ui.verbose === 'boolean') {
-            validatedConfig.ui.verbose = ui.verbose;
-        }
-    }
     return validatedConfig;
 }
 export function loadConfig() {
@@ -71,7 +56,7 @@ export function loadConfig() {
             'Please create it with your Anthropic API key.\n' +
             'Example:\n\n' +
             'anthropic:\n' +
-            '  api-key: sk-ant-...\n' +
+            '  key: sk-ant-...\n' +
             '  model: claude-haiku-4-5-20251001\n');
     }
     const content = readFileSync(CONFIG_FILE, 'utf-8');
@@ -86,10 +71,10 @@ export function configExists() {
 }
 export function mergeConfig(existingContent, sectionName, newValues) {
     const parsed = existingContent.trim()
-        ? YAML.parse(existingContent) || {}
+        ? YAML.parse(existingContent)
         : {};
     // Update or add section
-    const section = parsed[sectionName] || {};
+    const section = parsed[sectionName] ?? {};
     for (const [key, value] of Object.entries(newValues)) {
         section[key] = value;
     }
@@ -103,13 +88,10 @@ export function mergeConfig(existingContent, sectionName, newValues) {
     // Convert back to YAML
     return YAML.stringify(sortedConfig);
 }
-export function saveConfig(apiKey, model) {
+export function saveConfig(section, config) {
     const existingContent = existsSync(CONFIG_FILE)
         ? readFileSync(CONFIG_FILE, 'utf-8')
         : '';
-    const newContent = mergeConfig(existingContent, 'anthropic', {
-        'api-key': apiKey,
-        model: model,
-    });
+    const newContent = mergeConfig(existingContent, section, config);
     writeFileSync(CONFIG_FILE, newContent, 'utf-8');
 }

package/dist/services/skills.js

@@ -0,0 +1,52 @@
+import { readFileSync, readdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+/**
+ * Get the path to the skills directory
+ */
+export function getSkillsDirectory() {
+    return join(homedir(), '.pls', 'skills');
+}
+/**
+ * Load all skill markdown files from the skills directory
+ * Returns an array of skill file contents
+ */
+export function loadSkills() {
+    const skillsDir = getSkillsDirectory();
+    // Return empty array if directory doesn't exist
+    if (!existsSync(skillsDir)) {
+        return [];
+    }
+    try {
+        const files = readdirSync(skillsDir);
+        // Filter for markdown files
+        const skillFiles = files.filter((file) => file.endsWith('.md') || file.endsWith('.MD'));
+        // Read and return contents of each skill file
+        return skillFiles.map((file) => {
+            const filePath = join(skillsDir, file);
+            return readFileSync(filePath, 'utf-8');
+        });
+    }
+    catch {
+        // Return empty array if there's any error reading the directory
+        return [];
+    }
+}
+/**
+ * Format skills for inclusion in the planning prompt
+ */
+export function formatSkillsForPrompt(skills) {
+    if (skills.length === 0) {
+        return '';
+    }
+    const header = `
+
+## Available Skills
+
+The following skills define domain-specific workflows. When the user's
+query matches a skill, incorporate the skill's steps into your plan.
+
+`;
+    const skillsContent = skills.join('\n\n');
+    return header + skillsContent;
+}

package/dist/types/components.js

@@ -0,0 +1 @@
+export {};

package/dist/ui/Command.js

@@ -2,22 +2,35 @@ 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 { Spinner } from './Spinner.js';
-const MIN_PROCESSING_TIME = 2000; // purelly for visual effect
-export function Command({ rawCommand, claudeService }) {
-    const [processedTasks, setProcessedTasks] = useState([]);
-    const [error, setError] = useState(null);
-    const [isLoading, setIsLoading] = useState(true);
+const MIN_PROCESSING_TIME = 2000; // purely for visual effect
+export function Command({ command, state, service, tasks, error: errorProp, systemPrompt: systemPromptProp, }) {
+    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);
     useEffect(() => {
+        // Skip processing if done (showing historical/final state)
+        if (done) {
+            return;
+        }
+        // Skip processing if no service available
+        if (!service) {
+            setError('No service available');
+            setIsLoading(false);
+            return;
+        }
         let mounted = true;
-        async function process() {
+        async function process(svc) {
             const startTime = Date.now();
             try {
-                const result = await claudeService.processCommand(rawCommand);
+                const result = await svc.processCommand(command);
                 const elapsed = Date.now() - startTime;
                 const remainingTime = Math.max(0, MIN_PROCESSING_TIME - elapsed);
                 await new Promise((resolve) => setTimeout(resolve, remainingTime));
                 if (mounted) {
-                    setProcessedTasks(result);
+                    setProcessedTasks(result.tasks);
+                    setSystemPrompt(result.systemPrompt);
                     setIsLoading(false);
                 }
             }
@@ -31,10 +44,10 @@ export function Command({ rawCommand, claudeService }) {
                 }
             }
         }
-        process();
+        process(service);
         return () => {
             mounted = false;
         };
-    }, [rawCommand, claudeService]);
-    return (_jsxs(Box, { alignSelf: "flex-start", marginBottom: 1, flexDirection: "column", children: [_jsxs(Box, { children: [_jsxs(Text, { color: "gray", children: ["> pls ", rawCommand] }), 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, { children: [_jsx(Text, { color: "whiteBright", children: '  - ' }), _jsx(Text, { color: "white", children: task })] }, index))) }))] }));
+    }, [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, { children: [_jsx(Text, { color: "whiteBright", children: '  - ' }), _jsx(Text, { color: "white", children: task })] }, index))) }))] }));
 }

package/dist/ui/Configure.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text } from 'ink';
+import TextInput from 'ink-text-input';
+export function Configure({ state, key: keyProp, model: modelProp, onComplete, }) {
+    const done = state?.done ?? false;
+    const [step, setStep] = React.useState(state?.step ?? (done ? 'done' : 'key'));
+    const [key, setKey] = React.useState(keyProp || '');
+    const [model, setModel] = React.useState(modelProp || 'claude-haiku-4-5-20251001');
+    const handleKeySubmit = (value) => {
+        setKey(value);
+        setStep('model');
+    };
+    const handleModelSubmit = (value) => {
+        const finalModel = value.trim() || 'claude-haiku-4-5-20251001';
+        setModel(finalModel);
+        setStep('done');
+        if (onComplete) {
+            onComplete({ key, model: finalModel });
+        }
+    };
+    return (_jsxs(Box, { flexDirection: "column", marginLeft: 1, children: [!done && _jsx(Text, { children: "Configuration required." }), !done && (_jsx(Box, { children: _jsxs(Text, { color: "whiteBright", dimColor: true, children: ['==>', " Get your API key from: https://platform.claude.com/"] }) })), _jsx(Box, { marginTop: done ? 0 : 1, children: _jsx(Text, { children: "Anthropic API key:" }) }), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: "> " }), step === 'key' && !done ? (_jsx(TextInput, { value: key, onChange: setKey, onSubmit: handleKeySubmit, mask: "*" })) : (_jsx(Text, { dimColor: true, children: '*'.repeat(12) }))] }), (step === 'model' || step === 'done') && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Box, { children: _jsxs(Text, { children: ["Model", ' ', !done && (_jsx(Text, { dimColor: true, children: "(default: claude-haiku-4-5-20251001)" })), ":"] }) }), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: "> " }), step === 'model' && !done ? (_jsx(TextInput, { value: model, onChange: setModel, onSubmit: handleModelSubmit })) : (_jsx(Text, { dimColor: true, children: model }))] })] })), step === 'done' && !done && (_jsx(Box, { marginY: 1, children: _jsx(Text, { color: "green", children: "\u2713 Configuration saved" }) }))] }));
+}

package/dist/ui/History.js

@@ -1,8 +1,9 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Box } from 'ink';
+import { renderComponent } from './renderComponent.js';
 export function History({ items }) {
     if (items.length === 0) {
         return null;
     }
-    return (_jsx(Box, { flexDirection: "column", gap: 1, children: items.map((item, index) => (_jsx(Box, { children: item }, index))) }));
+    return (_jsx(Box, { flexDirection: "column", gap: 1, children: items.map((item, index) => (_jsx(Box, { children: renderComponent(item) }, `${item.name}-${index}`))) }));
 }

package/dist/ui/Main.js

@@ -0,0 +1,55 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box } from 'ink';
+import { History } from './History.js';
+import { renderComponent } from './renderComponent.js';
+export const Main = ({ app, command, service, isReady, onConfigured, }) => {
+    const [history, setHistory] = React.useState([]);
+    const [current, setCurrent] = React.useState(null);
+    React.useEffect(() => {
+        // Initialize history and current component based on props
+        if (!isReady) {
+            // Not configured - show welcome in history, configure as current
+            setHistory([
+                {
+                    name: 'welcome',
+                    props: {
+                        app,
+                    },
+                },
+            ]);
+            setCurrent({
+                name: 'configure',
+                state: {
+                    done: false,
+                    step: 'key',
+                },
+                props: {
+                    onComplete: onConfigured,
+                },
+            });
+        }
+        else if (command && service) {
+            setCurrent({
+                name: 'command',
+                state: {
+                    done: false,
+                    isLoading: true,
+                },
+                props: {
+                    command,
+                    service,
+                },
+            });
+        }
+        else {
+            setCurrent({
+                name: 'welcome',
+                props: {
+                    app,
+                },
+            });
+        }
+    }, [isReady, command, service, app, onConfigured]);
+    return (_jsxs(Box, { marginTop: 1, flexDirection: "column", gap: 1, children: [_jsx(History, { items: history }), current && renderComponent(current)] }));
+};

package/dist/ui/Please.js

@@ -5,12 +5,21 @@ import { Command } from './Command.js';
 import { Welcome } from './Welcome.js';
 import { ConfigSetup } from './ConfigSetup.js';
 import { History } from './History.js';
-export const Please = ({ app: info, command, claudeService, showConfigSetup, onConfigComplete, }) => {
+export const PLS = ({ app: info, command, claudeService, showConfigSetup, onConfigComplete, }) => {
     const [history, setHistory] = React.useState([]);
-    // Simple command execution
-    if (command && claudeService) {
-        return (_jsxs(Box, { marginTop: 1, flexDirection: "column", gap: 1, children: [_jsx(History, { items: history }), _jsx(Command, { rawCommand: command, claudeService: claudeService })] }));
+    const [service, setService] = React.useState(claudeService);
+    const handleConfigComplete = (config) => {
+        if (onConfigComplete) {
+            const result = onConfigComplete(config);
+            if (result) {
+                setService(result);
+            }
+        }
+    };
+    // Command execution (with service from props or after config)
+    if (command && service) {
+        return (_jsxs(Box, { marginTop: 1, flexDirection: "column", gap: 1, children: [_jsx(History, { items: history }), _jsx(Command, { rawCommand: command, claudeService: service })] }));
     }
     // Welcome screen with optional config setup
-    return (_jsxs(Box, { flexDirection: "column", marginY: 1, gap: 1, children: [_jsx(History, { items: history }), _jsx(Welcome, { info: info }), showConfigSetup && onConfigComplete && (_jsx(ConfigSetup, { onComplete: onConfigComplete }))] }));
+    return (_jsxs(Box, { flexDirection: "column", marginY: 1, gap: 1, children: [_jsx(History, { items: history }), !showConfigSetup && _jsx(Welcome, { info: info }), showConfigSetup && _jsx(ConfigSetup, { onComplete: handleConfigComplete })] }));
 };

package/dist/ui/Welcome.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Text, Box } from 'ink';
-export function Welcome({ info: app }) {
+export function Welcome({ app: app }) {
     const descriptionLines = app.description
         .split('. ')
         .map((line) => line.replace(/\.$/, ''))
@@ -9,5 +9,5 @@ export function Welcome({ info: app }) {
     const words = app.name
         .split('-')
         .map((word) => word.charAt(0).toUpperCase() + word.slice(1));
-    return (_jsx(Box, { alignSelf: "flex-start", children: _jsxs(Box, { borderStyle: "round", borderColor: "green", paddingX: 3, paddingY: 1, flexDirection: "column", children: [_jsxs(Box, { marginBottom: 1, gap: 1, children: [words.map((word, index) => (_jsx(Text, { color: "greenBright", bold: true, children: word }, index))), _jsxs(Text, { color: "whiteBright", dimColor: true, children: ["v", app.version] }), app.isDev && _jsx(Text, { color: "yellowBright", children: "dev" })] }), descriptionLines.map((line, index) => (_jsx(Box, { children: _jsxs(Text, { color: "white", children: [line, "."] }) }, index))), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: "brightWhite", bold: true, children: "Usage:" }), _jsxs(Box, { gap: 1, children: [_jsx(Text, { color: "whiteBright", dimColor: true, children: ">" }), _jsxs(Box, { gap: 1, children: [_jsx(Text, { color: "greenBright", bold: true, children: "pls" }), _jsx(Text, { color: "yellow", bold: true, children: "[describe your request]" })] })] })] })] }) }));
+    return (_jsx(Box, { alignSelf: "flex-start", marginBottom: 1, children: _jsxs(Box, { borderStyle: "round", borderColor: "green", paddingX: 3, paddingY: 1, flexDirection: "column", children: [_jsxs(Box, { marginBottom: 1, gap: 1, children: [words.map((word, index) => (_jsx(Text, { color: "greenBright", bold: true, children: word }, index))), _jsxs(Text, { color: "whiteBright", dimColor: true, children: ["v", app.version] }), app.isDev && _jsx(Text, { color: "yellowBright", children: "dev" })] }), descriptionLines.map((line, index) => (_jsx(Box, { children: _jsxs(Text, { color: "white", children: [line, "."] }) }, index))), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: "brightWhite", bold: true, children: "Usage:" }), _jsxs(Box, { gap: 1, children: [_jsx(Text, { color: "whiteBright", dimColor: true, children: ">" }), _jsxs(Box, { gap: 1, children: [_jsx(Text, { color: "greenBright", bold: true, children: "pls" }), _jsx(Text, { color: "yellow", bold: true, children: "[describe your request]" })] })] })] })] }) }));
 }

package/dist/ui/renderComponent.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Welcome } from './Welcome.js';
+import { Configure } from './Configure.js';
+import { Command } from './Command.js';
+export function renderComponent(def) {
+    switch (def.name) {
+        case 'welcome':
+            return _jsx(Welcome, { ...def.props });
+        case 'configure':
+            return (_jsx(Configure, { ...def.props, state: 'state' in def ? def.state : undefined }));
+        case 'command':
+            return (_jsx(Command, { ...def.props, state: 'state' in def ? def.state : undefined }));
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prompt-language-shell",
-  "version": "0.1.2",
+  "version": "0.1.6",
   "description": "Your personal command-line concierge. Ask politely, and it gets things done.",
   "type": "module",
   "main": "dist/index.js",
@@ -16,8 +16,8 @@
     "prepare": "npm run build",
     "test": "vitest run",
     "test:watch": "vitest",
-    "format": "prettier --write .",
-    "format:check": "prettier --check .",
+    "format": "prettier --write '**/*.{ts,tsx}'",
+    "format:check": "prettier --check '**/*.{ts,tsx}'",
     "lint": "eslint .",
     "lint:fix": "eslint --fix ."
   },