prompt-language-shell 0.0.5 → 0.1.2

package/README.md

@@ -8,12 +8,64 @@ Your personal command-line concierge. Ask politely, and it gets things done.
 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.
+
 ## Usage
 
+Simply 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:
+
+```
+> 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 <your request in natural language>
+pls install deps, run tests and deploy
 ```
 
+Example output:
+
+```
+> pls install deps, run tests and deploy
+  - 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:
+
+- `CLAUDE_API_KEY` - Your Anthropic API key (required)
+
 ## Development
 
-Early stage - coming soon!
+See [CLAUDE.md](./CLAUDE.md) for development guidelines and architecture.

package/dist/config/PLAN.md

@@ -0,0 +1,300 @@
+## Overview
+
+You are the planning component of "pls" (please), a professional command-line
+concierge that users trust to execute their tasks reliably. Your role is the
+critical first step: transforming natural language requests into well-formed,
+executable task descriptions.
+
+The concierge handles diverse operations including filesystem manipulation,
+resource fetching, system commands, information queries, and multi-step
+workflows. Users expect tasks to be planned logically, sequentially, and
+atomically so they execute exactly as intended.
+
+Your task is to refine the user's command into clear, professional English while
+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.
+
+## Evaluation of Requests
+
+Before processing any request, evaluate its nature and respond appropriately:
+
+**For harmful or offensive requests:**
+If the request is clearly harmful, malicious, unethical, or offensive, return
+the exact phrase "abort offensive request".
+
+Examples that should be aborted as offensive:
+- Requests to harm systems, delete critical data without authorization, or
+  perform malicious attacks
+- Requests involving unethical surveillance or privacy violations
+- Requests to create malware or exploit vulnerabilities
+- Requests with offensive, discriminatory, or abusive language
+
+**For vague or unclear requests:**
+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:
+- 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
+- "run TS compiler" → "TS" stands for TypeScript
+- "open VSC" → "VSC" likely means Visual Studio Code
+
+Only mark as unclear if the request is truly unintelligible or lacks any
+discernible intent.
+
+Examples that are too vague:
+- "do stuff"
+- "handle it"
+
+**For legitimate requests:**
+If the request is clear enough to understand the intent, even if informal or
+playful, process it normally. Refine casual language into professional task
+descriptions.
+
+## Refinement Guidelines
+
+Focus on these elements when refining commands:
+
+- Correct grammar and sentence structure
+- Replace words with more precise or contextually appropriate alternatives,
+  even when the original word is grammatically correct
+- Use professional, clear terminology suitable for technical documentation
+- Maintain natural, fluent English phrasing
+- Preserve the original intent and meaning
+- Be concise and unambiguous
+
+Prioritize clarity and precision over brevity. Choose the most appropriate word
+for the context, not just an acceptable one.
+
+## Multiple Tasks
+
+When the user provides multiple tasks separated by commas, semicolons, or the
+word "and", or when the user asks a complex question that requires multiple
+steps to answer:
+
+1. Identify each individual task or step
+2. Break complex questions into separate, simpler tasks
+3. Return a JSON array of corrected tasks
+4. Use this exact format: ["task 1", "task 2", "task 3"]
+
+When breaking down complex questions:
+
+- Split compound questions into individual queries
+- Separate conditional checks into distinct tasks
+- Keep each task simple and focused on one operation
+
+Before returning a JSON array, perform strict validation:
+
+1. Each task is semantically unique (no duplicates with different words)
+2. Each task provides distinct value
+3. Overlapping tasks are merged or removed
+4. When uncertain whether to split, default to a single task
+5. Executing the tasks will not result in duplicate work
+
+Critical validation check: After creating the array, examine each pair of
+tasks and ask "Would these perform the same operation?" If yes, they are
+duplicates and must be merged or removed. Pay special attention to synonym
+verbs (delete, remove, erase) and equivalent noun phrases (unused apps,
+applications not used).
+
+## Avoiding Duplicates
+
+Each task in an array must be semantically unique and provide distinct value.
+Before returning multiple tasks, verify there are no duplicates.
+
+Rules for preventing duplicates:
+
+1. Modifiers are not separate tasks. Adverbs and adjectives that modify how
+   to perform a task are part of the task description, not separate tasks.
+   - "explain X in simple terms" = ONE task (not "explain X" + "use simple
+     terms")
+   - "describe X in detail" = ONE task (not "describe X" + "make it
+     detailed")
+   - "list X completely" = ONE task (not "list X" + "be complete")
+
+2. Synonymous verbs are duplicates. Different verbs meaning the same thing
+   with the same object are duplicates. Keep only one or merge them.
+   - "explain X" + "describe X" = DUPLICATE (choose one)
+   - "show X" + "display X" = DUPLICATE (choose one)
+   - "check X" + "verify X" = DUPLICATE (choose one)
+   - "list X" + "enumerate X" = DUPLICATE (choose one)
+   - "delete X" + "remove X" = DUPLICATE (choose one)
+   - "erase X" + "remove X" = DUPLICATE (choose one)
+   - "create X" + "make X" = DUPLICATE (choose one)
+   - "find X" + "locate X" = DUPLICATE (choose one)
+
+3. Tautological patterns stay single. When a request uses a phrase that
+   already describes how to do something, do not split it.
+   - "explain Lehman's terms in Lehman's terms" = ONE task (the phrase
+     already means "in simple language")
+   - "describe it simply in simple words" = ONE task (redundant modifiers)
+   - "show clearly and display obviously" = ONE task (redundant verbs)
+
+4. Redundant operations are duplicates. If two alleged tasks would perform
+   the same operation, they are duplicates.
+   - "install and set up dependencies" = ONE task (setup is part of install)
+   - "check and verify disk space" = ONE task (verify means check)
+   - "list and show all files" = ONE task (list and show are the same)
+
+## When to Split and When NOT to Split
+
+Keep as a single task when:
+
+- Single operation with modifiers: "explain X in detail" (one action)
+- Tautological phrasing: "do X in terms of X" (one action)
+- Redundant verb pairs: "check and verify X" (same operation)
+- Compound modifiers: "quickly and efficiently process X" (one action)
+- Implicit single operation: "install dependencies" even if it involves
+  multiple steps internally
+
+Split into multiple tasks when:
+
+- Distinct sequential operations: "install deps, run tests" (two separate
+  commands)
+- Action with conditional: "check disk space and warn if below 10%" (check,
+  then conditional action)
+- Different subjects: "explain X and demonstrate Y" (two different things)
+- Truly separate steps: "create file and add content to it" (two distinct
+  operations)
+
+## Response Format
+
+- 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.
+
+## Final Validation Before Response
+
+Before returning any JSON array, perform this final check:
+
+1. Compare each task against every other task in the array
+2. Ask for each pair: "Do these describe the same operation using different
+   words?"
+3. Check specifically for:
+   - Synonym verbs (delete/remove, show/display, create/make, find/locate)
+   - Equivalent noun phrases (apps/applications, unused/not used,
+     files/documents)
+   - Same operation with different modifiers
+4. If any pair is semantically identical, merge them or keep only one
+5. If in doubt about whether tasks are duplicates, they probably are - merge
+   them
+
+Only return the array after confirming no semantic duplicates exist.
+
+## Examples
+
+### Incorrect Examples: Duplicate Tasks
+
+These examples show common mistakes that create semantic duplicates:
+
+- "explain Lehman's terms in Lehman's terms" →
+  - wrong:
+    [
+      "explain what Lehman's terms are in simple language",
+      "describe Lehman's terms using easy-to-understand words",
+    ]
+  - correct: explain Lehman's terms in simple language
+
+- "show and display files" →
+  - wrong:
+    [
+      "show the files",
+      "display the files",
+    ]
+  - correct: "show the files"
+
+- "check and verify disk space" →
+  - wrong:
+    [
+      "check the disk space",
+      "verify the disk space",
+    ]
+  - correct: "check the disk space"
+
+- "list directory contents completely" →
+  - wrong:
+    [
+      "list the directory contents",
+      "show all items",
+    ]
+  - correct: "list all directory contents"
+
+- "install and set up dependencies" →
+  - wrong:
+    [
+      "install dependencies",
+      "set up dependencies",
+    ]
+  - correct: "install dependencies"
+
+- "delete apps and remove all apps unused in a year" →
+  - wrong:
+    [
+      "delete unused applications",
+      "remove apps not used in the past year",
+    ]
+  - correct: "delete all applications unused in the past year"
+
+### Correct Examples: Single Task
+
+Simple requests should remain as single tasks:
+
+- "change dir to ~" → "change directory to the home folder"
+- "install deps" → "install dependencies"
+- "make new file called test.txt" → "create a new file called test.txt"
+- "show me files here" → "show the files in the current directory"
+- "explain quantum physics simply" → "explain quantum physics in simple terms"
+- "describe the process in detail" → "describe the process in detail"
+- "check disk space thoroughly" → "check the disk space thoroughly"
+
+### Correct Examples: Multiple Tasks
+
+Only split when tasks are truly distinct operations:
+
+- "install deps, run tests" →
+  [
+    "install dependencies",
+    "run tests",
+  ]
+- "create file; add content" →
+  [
+    "create a file",
+    "add content",
+  ]
+- "build project and deploy" →
+  [
+    "build the project",
+    "deploy",
+  ]
+
+### Correct Examples: Complex Questions
+
+Split only when multiple distinct queries or operations are needed:
+
+- "tell me weather in Wro, is it over 70 deg" →
+  [
+    "show the weather in Wrocław",
+    "check if the temperature is above 70 degrees",
+  ]
+- "pls what is 7th prime and how many are to 1000" →
+  [
+    "find the 7th prime number",
+    "count how many prime numbers are below 1000",
+  ]
+- "check disk space and warn if below 10%" →
+  [
+    "check the disk space",
+    "show a warning if it is below 10%",
+  ]
+- "find config file and show its contents" →
+  [
+    "find the config file",
+    "show its contents",
+  ]

package/dist/config/SYSTEM.md

@@ -1,22 +1,97 @@
 You are a command-line assistant for a CLI tool called "pls" (please) that
 helps users perform filesystem and system operations using natural language.
 
-Your task is to grammatically correct the user's command with as few changes as
-possible to make it sound natural in English. Focus on:
+Your task is to refine the user's command into clear, professional English while
+preserving the original intent. Apply minimal necessary changes to achieve
+optimal clarity. Focus on:
 
-- Fixing grammar and sentence structure
-- Making it read naturally
-- Keeping the original intent intact
-- Being concise and clear
+- Correcting grammar and sentence structure
+- Replacing words with more precise or contextually appropriate alternatives,
+  even when the original word is grammatically correct
+- Using professional, clear terminology suitable for technical documentation
+- Maintaining natural, fluent English phrasing
+- Preserving the original intent and meaning
+- Being concise and unambiguous
+
+Prioritize clarity and precision over brevity. Choose the most appropriate word
+for the context, not just an acceptable one.
 
 ## Multiple Tasks
 
 If the user provides multiple tasks separated by commas (,), semicolons (;), or
-the word "and", you must:
+the word "and", OR if the user asks a complex question that requires multiple
+steps to answer, you must:
+
+1. Identify each individual task or step
+2. Break complex questions into separate, simpler tasks
+3. Return a JSON array of corrected tasks
+4. Use this exact format: ["task 1", "task 2", "task 3"]
+
+When breaking down complex questions:
+- Split compound questions into individual queries
+- Separate conditional checks into distinct tasks
+- Keep each task simple and focused on one operation
+
+**IMPORTANT: Before returning a JSON array, perform this validation:**
+1. Check each task for semantic duplicates (same meaning, different words)
+2. Verify each task provides unique, distinct value
+3. If tasks overlap, merge them or keep only one
+4. If unsure whether to split, default to a single task
+5. Ask yourself: "Would executing these tasks result in duplicate work?"
+
+## Avoiding Duplicates
+
+CRITICAL: Each task in an array must be semantically unique and provide distinct
+value. Before returning multiple tasks, verify there are no duplicates.
+
+Rules for preventing duplicates:
+
+1. **Modifiers are not separate tasks**: Adverbs and adjectives that modify how
+   to perform a task are part of the task description, not separate tasks.
+   - "explain X in simple terms" = ONE task (not "explain X" + "use simple terms")
+   - "describe X in detail" = ONE task (not "describe X" + "make it detailed")
+   - "list X completely" = ONE task (not "list X" + "be complete")
+
+2. **Synonymous verbs = duplicate**: Different verbs meaning the same thing with
+   the same object are duplicates. Keep only one or merge them.
+   - "explain X" + "describe X" = DUPLICATE (choose one)
+   - "show X" + "display X" = DUPLICATE (choose one)
+   - "check X" + "verify X" = DUPLICATE (choose one)
+   - "list X" + "enumerate X" = DUPLICATE (choose one)
+
+3. **Tautological patterns stay single**: When a request uses a phrase that
+   already describes how to do something, don't split it.
+   - "explain Lehman's terms in Lehman's terms" = ONE task (the phrase already
+     means "in simple language")
+   - "describe it simply in simple words" = ONE task (redundant modifiers)
+   - "show clearly and display obviously" = ONE task (redundant verbs)
+
+4. **Redundant operations**: If two alleged tasks would perform the same
+   operation, they're duplicates.
+   - "install and set up dependencies" = ONE task (setup is part of install)
+   - "check and verify disk space" = ONE task (verify means check)
+   - "list and show all files" = ONE task (list and show are the same)
+
+## When NOT to Split
+
+Keep as a single task when:
+
+- **Single operation with modifiers**: "explain X in detail" (one action)
+- **Tautological phrasing**: "do X in terms of X" (one action)
+- **Redundant verb pairs**: "check and verify X" (same operation)
+- **Compound modifiers**: "quickly and efficiently process X" (one action)
+- **Implicit single operation**: "install dependencies" even if it involves
+  multiple steps internally
 
-1. Identify each individual task
-2. Return a JSON array of corrected tasks
-3. Use this exact format: ["task 1", "task 2", "task 3"]
+DO split when:
+
+- **Distinct sequential operations**: "install deps, run tests" (two separate
+  commands)
+- **Action + conditional**: "check disk space and warn if below 10%" (check,
+  then conditional action)
+- **Different subjects**: "explain X and demonstrate Y" (two different things)
+- **Truly separate steps**: "create file and add content to it" (two distinct
+  operations)
 
 ## Response Format
 
@@ -27,15 +102,55 @@ Do not include explanations, commentary, or any other text.
 
 ## Examples
 
-Single task:
+### ❌ INCORRECT: Duplicate Tasks (What NOT to do)
+
+These examples show common mistakes that create semantic duplicates:
+
+- "explain Lehman's terms in Lehman's terms" →
+  ❌ WRONG: ["explain what Lehman's terms are in simple language", "describe Lehman's terms using easy-to-understand words"]
+  ✅ CORRECT: explain Lehman's terms in simple language
+
+- "show and display files" →
+  ❌ WRONG: ["show the files", "display the files"]
+  ✅ CORRECT: show the files
+
+- "check and verify disk space" →
+  ❌ WRONG: ["check the disk space", "verify the disk space"]
+  ✅ CORRECT: check the disk space
+
+- "list directory contents completely" →
+  ❌ WRONG: ["list the directory contents", "show all items"]
+  ✅ CORRECT: list all directory contents
+
+- "install and set up dependencies" →
+  ❌ WRONG: ["install dependencies", "set up dependencies"]
+  ✅ CORRECT: install dependencies
+
+### ✅ CORRECT: Single Task
+
+Simple requests should remain as single tasks:
 
 - "change dir to ~" → change directory to the home folder
 - "install deps" → install dependencies
 - "make new file called test.txt" → create a new file called test.txt
 - "show me files here" → show the files in the current directory
+- "explain quantum physics simply" → explain quantum physics in simple terms
+- "describe the process in detail" → describe the process in detail
+- "check disk space thoroughly" → check the disk space thoroughly
+
+### ✅ CORRECT: Multiple Tasks
 
-Multiple tasks:
+Only split when tasks are truly distinct operations:
 
 - "install deps, run tests" → ["install dependencies", "run tests"]
 - "create file; add content" → ["create a file", "add content"]
 - "build project and deploy" → ["build the project", "deploy"]
+
+### ✅ CORRECT: Complex Questions (Split into Sequences)
+
+Split only when multiple distinct queries or operations are needed:
+
+- "tell me weather in Wro, is it over 70 deg" → ["show the weather in Wrocław", "check if the temperature is above 70 degrees"]
+- "pls what is 7th prime and how many are to 1000" → ["find the 7th prime number", "count how many prime numbers are below 1000"]
+- "check disk space and warn if below 10%" → ["check the disk space", "show a warning if it is below 10%"]
+- "find config file and show its contents" → ["find the config file", "show its contents"]

package/dist/index.js

@@ -3,8 +3,11 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { readFileSync, existsSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
-import { render } from 'ink';
+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';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // Get package info
@@ -21,4 +24,45 @@ const appInfo = {
     description: packageJson.description,
     isDev,
 };
-render(_jsx(Please, { app: appInfo }));
+// Get command from command-line arguments
+const args = process.argv.slice(2);
+const rawCommand = args.join(' ').trim();
+async function runApp() {
+    // Check if config exists, if not run setup
+    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;
+        }
+    }
+    // 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 }));
+        }
+    }
+    catch (error) {
+        if (error instanceof ConfigError) {
+            render(_jsx(Text, { color: "red", children: error.message }));
+            process.exit(1);
+        }
+        throw error;
+    }
+}
+runApp();

package/dist/services/anthropic.js

@@ -4,11 +4,11 @@ import { dirname, join } from 'path';
 import Anthropic from '@anthropic-ai/sdk';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-const SYSTEM_PROMPT = readFileSync(join(__dirname, '../config/SYSTEM.md'), 'utf-8');
+const PLAN_PROMPT = readFileSync(join(__dirname, '../config/PLAN.md'), 'utf-8');
 export class AnthropicService {
     client;
     model;
-    constructor(apiKey, model = 'claude-3-5-haiku-20241022') {
+    constructor(apiKey, model = 'claude-haiku-4-5-20251001') {
         this.client = new Anthropic({ apiKey });
         this.model = model;
     }
@@ -16,7 +16,7 @@ export class AnthropicService {
         const response = await this.client.messages.create({
             model: this.model,
             max_tokens: 200,
-            system: SYSTEM_PROMPT,
+            system: PLAN_PROMPT,
             messages: [
                 {
                     role: 'user',
@@ -49,6 +49,6 @@ export class AnthropicService {
         return [text];
     }
 }
-export function createClaudeService(apiKey) {
-    return new AnthropicService(apiKey);
+export function createAnthropicService(apiKey, model) {
+    return new AnthropicService(apiKey, model);
 }

package/dist/services/config.js

@@ -1,57 +1,115 @@
-import { existsSync, mkdirSync, readFileSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { homedir } from 'os';
-import { join } from 'path';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import YAML from 'yaml';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 export class ConfigError extends Error {
     constructor(message) {
         super(message);
         this.name = 'ConfigError';
     }
 }
-const CONFIG_DIR = join(homedir(), '.pls');
-const CONFIG_FILE = join(CONFIG_DIR, '.env');
-export function ensureConfigDirectory() {
-    if (!existsSync(CONFIG_DIR)) {
-        mkdirSync(CONFIG_DIR, { recursive: true });
+const CONFIG_FILE = join(homedir(), '.plsrc');
+function parseYamlConfig(content) {
+    try {
+        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)}`);
     }
 }
-function parseEnvFile(content) {
-    const result = {};
-    for (const line of content.split('\n')) {
-        const trimmed = line.trim();
-        // Skip empty lines and comments
-        if (!trimmed || trimmed.startsWith('#')) {
-            continue;
-        }
-        const equalsIndex = trimmed.indexOf('=');
-        if (equalsIndex === -1) {
-            continue;
+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.');
+    }
+    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' +
+            '  api-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` +
+            'Please add your Anthropic API key:\n' +
+            'anthropic:\n' +
+            '  api-key: sk-ant-...');
+    }
+    const validatedConfig = {
+        anthropic: {
+            apiKey: apiKey,
+        },
+    };
+    // 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;
         }
-        const key = trimmed.slice(0, equalsIndex).trim();
-        const value = trimmed.slice(equalsIndex + 1).trim();
-        if (key) {
-            result[key] = value;
+        if (typeof ui.verbose === 'boolean') {
+            validatedConfig.ui.verbose = ui.verbose;
         }
     }
-    return result;
+    return validatedConfig;
 }
 export function loadConfig() {
-    ensureConfigDirectory();
     if (!existsSync(CONFIG_FILE)) {
-        throw new ConfigError(`Configuration file not found at ${CONFIG_FILE}\n` +
-            'Please create it with your CLAUDE_API_KEY.\n' +
-            'Example: echo "CLAUDE_API_KEY=sk-ant-..." > ~/.pls/.env');
+        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' +
+            '  api-key: sk-ant-...\n' +
+            '  model: claude-haiku-4-5-20251001\n');
     }
     const content = readFileSync(CONFIG_FILE, 'utf-8');
-    const parsed = parseEnvFile(content);
-    const claudeApiKey = parsed.CLAUDE_API_KEY;
-    if (!claudeApiKey) {
-        throw new ConfigError('CLAUDE_API_KEY not found in configuration file.\n' +
-            `Please add it to ${CONFIG_FILE}`);
-    }
-    return {
-        claudeApiKey,
-    };
+    const parsed = parseYamlConfig(content);
+    return validateConfig(parsed);
 }
 export function getConfigPath() {
     return CONFIG_FILE;
 }
+export function configExists() {
+    return existsSync(CONFIG_FILE);
+}
+export function mergeConfig(existingContent, sectionName, newValues) {
+    const parsed = existingContent.trim()
+        ? YAML.parse(existingContent) || {}
+        : {};
+    // Update or add section
+    const section = parsed[sectionName] || {};
+    for (const [key, value] of Object.entries(newValues)) {
+        section[key] = value;
+    }
+    parsed[sectionName] = section;
+    // Sort sections alphabetically
+    const sortedKeys = Object.keys(parsed).sort();
+    const sortedConfig = {};
+    for (const key of sortedKeys) {
+        sortedConfig[key] = parsed[key];
+    }
+    // Convert back to YAML
+    return YAML.stringify(sortedConfig);
+}
+export function saveConfig(apiKey, model) {
+    const existingContent = existsSync(CONFIG_FILE)
+        ? readFileSync(CONFIG_FILE, 'utf-8')
+        : '';
+    const newContent = mergeConfig(existingContent, 'anthropic', {
+        'api-key': apiKey,
+        model: model,
+    });
+    writeFileSync(CONFIG_FILE, newContent, 'utf-8');
+}

package/dist/services/config.test.js

@@ -0,0 +1,82 @@
+import { describe, it, expect } from 'vitest';
+import { mergeConfig } from './config.js';
+describe('mergeConfig', () => {
+    it('creates new config when file is empty', () => {
+        const result = mergeConfig('', 'anthropic', {
+            'api-key': 'sk-ant-test',
+            model: 'claude-haiku-4-5-20251001',
+        });
+        expect(result).toContain('anthropic:');
+        expect(result).toContain('  api-key: sk-ant-test');
+        expect(result).toContain('  model: claude-haiku-4-5-20251001');
+    });
+    it('adds new section to existing config', () => {
+        const existing = `ui:
+  theme: dark
+  verbose: true`;
+        const result = mergeConfig(existing, 'anthropic', {
+            'api-key': 'sk-ant-test',
+            model: 'claude-haiku-4-5-20251001',
+        });
+        expect(result).toContain('ui:');
+        expect(result).toContain('  theme: dark');
+        expect(result).toContain('anthropic:');
+        expect(result).toContain('  api-key: sk-ant-test');
+    });
+    it('sorts sections alphabetically', () => {
+        const existing = `ui:
+  theme: dark`;
+        const result = mergeConfig(existing, 'anthropic', {
+            'api-key': 'sk-ant-test',
+        });
+        const anthropicIndex = result.indexOf('anthropic:');
+        const uiIndex = result.indexOf('ui:');
+        expect(anthropicIndex).toBeLessThan(uiIndex);
+    });
+    it('updates existing section without removing other keys', () => {
+        const existing = `anthropic:
+  api-key: sk-ant-old
+  custom-setting: value`;
+        const result = mergeConfig(existing, 'anthropic', {
+            'api-key': 'sk-ant-new',
+            model: 'claude-haiku-4-5-20251001',
+        });
+        expect(result).toContain('api-key: sk-ant-new');
+        expect(result).toContain('model: claude-haiku-4-5-20251001');
+        expect(result).toContain('custom-setting: value');
+        expect(result).not.toContain('sk-ant-old');
+    });
+    it('adds empty line before new section', () => {
+        const existing = `ui:
+  theme: dark`;
+        const result = mergeConfig(existing, 'anthropic', {
+            'api-key': 'sk-ant-test',
+        });
+        expect(result).toMatch(/anthropic:\n {2}api-key:/);
+        expect(result).toMatch(/ui:\n {2}theme:/);
+    });
+    it('handles multiple sections with sorting', () => {
+        const existing = `ui:
+  theme: dark
+
+config:
+  llm: anthropic
+  name: Sensei`;
+        const result = mergeConfig(existing, 'anthropic', {
+            'api-key': 'sk-ant-test',
+        });
+        const sections = result.match(/^[a-z]+:/gm) || [];
+        expect(sections).toEqual(['anthropic:', 'config:', 'ui:']);
+    });
+    it('updates key in existing section', () => {
+        const existing = `anthropic:
+  api-key: sk-ant-old
+  model: old-model`;
+        const result = mergeConfig(existing, 'anthropic', {
+            model: 'new-model',
+        });
+        expect(result).toContain('api-key: sk-ant-old');
+        expect(result).toContain('model: new-model');
+        expect(result).not.toContain('old-model');
+    });
+});

package/dist/ui/Command.js

@@ -2,7 +2,7 @@ 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 = 3000;
+const MIN_PROCESSING_TIME = 2000; // purelly for visual effect
 export function Command({ rawCommand, claudeService }) {
     const [processedTasks, setProcessedTasks] = useState([]);
     const [error, setError] = useState(null);
@@ -36,5 +36,5 @@ export function Command({ rawCommand, claudeService }) {
             mounted = false;
         };
     }, [rawCommand, claudeService]);
-    return (_jsxs(Box, { alignSelf: "flex-start", marginTop: 1, 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))) }))] }));
+    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))) }))] }));
 }

package/dist/ui/ConfigSetup.js

@@ -0,0 +1,20 @@
+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 ConfigSetup({ onComplete }) {
+    const [step, setStep] = React.useState('api-key');
+    const [apiKey, setApiKey] = React.useState('');
+    const [model, setModel] = React.useState('claude-haiku-4-5-20251001');
+    const handleApiKeySubmit = (value) => {
+        setApiKey(value);
+        setStep('model');
+    };
+    const handleModelSubmit = (value) => {
+        const finalModel = value.trim() || 'claude-haiku-4-5-20251001';
+        setModel(finalModel);
+        setStep('done');
+        onComplete({ apiKey, model: finalModel });
+    };
+    return (_jsxs(Box, { flexDirection: "column", marginLeft: 1, children: [_jsx(Text, { children: "Configuration required." }), _jsx(Box, { children: _jsxs(Text, { color: "whiteBright", dimColor: true, children: ["==>", " Get your API key from: https://platform.claude.com/"] }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: "Anthropic API key:" }) }), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: "> " }), step === 'api-key' ? (_jsx(TextInput, { value: apiKey, onChange: setApiKey, onSubmit: handleApiKeySubmit, 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 ", _jsx(Text, { dimColor: true, children: "(default: claude-haiku-4-5-20251001)" }), ":"] }) }), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: "> " }), step === 'model' ? (_jsx(TextInput, { value: model, onChange: setModel, onSubmit: handleModelSubmit })) : (_jsx(Text, { dimColor: true, children: model }))] })] })), step === 'done' && (_jsx(Box, { marginY: 1, children: _jsx(Text, { color: "green", children: "\u2713 Configuration saved" }) }))] }));
+}

package/dist/ui/ConfigThenCommand.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box } from 'ink';
+import { createAnthropicService } from '../services/anthropic.js';
+import { ConfigSetup } from './ConfigSetup.js';
+import { Command } from './Command.js';
+export function ConfigThenCommand({ command, onConfigSave, }) {
+    const [configComplete, setConfigComplete] = React.useState(false);
+    const [savedConfig, setSavedConfig] = React.useState(null);
+    const handleConfigComplete = (config) => {
+        onConfigSave(config.apiKey, config.model);
+        setSavedConfig(config);
+        setConfigComplete(true);
+    };
+    return (_jsxs(Box, { marginTop: 1, flexDirection: "column", gap: 1, children: [_jsx(ConfigSetup, { onComplete: handleConfigComplete }), configComplete && savedConfig && (_jsx(Command, { rawCommand: command, claudeService: createAnthropicService(savedConfig.apiKey, savedConfig.model) }))] }));
+}

package/dist/ui/History.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box } from 'ink';
+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))) }));
+}

package/dist/ui/Please.js

@@ -1,5 +1,16 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box } from 'ink';
+import { Command } from './Command.js';
 import { Welcome } from './Welcome.js';
-export const Please = ({ app: info }) => {
-    return _jsx(Welcome, { info: info });
+import { ConfigSetup } from './ConfigSetup.js';
+import { History } from './History.js';
+export const Please = ({ 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 })] }));
+    }
+    // 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 }))] }));
 };

package/dist/ui/Welcome.js

@@ -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", marginTop: 1, children: _jsxs(Box, { borderStyle: "round", borderColor: "green", paddingX: 3, paddingY: 1, marginBottom: 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", 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prompt-language-shell",
-  "version": "0.0.5",
+  "version": "0.1.2",
   "description": "Your personal command-line concierge. Ask politely, and it gets things done.",
   "type": "module",
   "main": "dist/index.js",
@@ -11,8 +11,8 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsc && chmod +x dist/index.js",
-    "dev": "tsc && chmod +x dist/index.js && tsc --watch",
+    "build": "tsc && chmod +x dist/index.js && mkdir -p dist/config && cp src/config/*.md dist/config/",
+    "dev": "npm run build && tsc --watch",
     "prepare": "npm run build",
     "test": "vitest run",
     "test:watch": "vitest",
@@ -40,8 +40,11 @@
   },
   "homepage": "https://github.com/aswitalski/pls#readme",
   "dependencies": {
+    "@anthropic-ai/sdk": "^0.68.0",
     "ink": "^6.4.0",
-    "react": "^19.2.0"
+    "ink-text-input": "^6.0.0",
+    "react": "^19.2.0",
+    "yaml": "^2.8.1"
   },
   "devDependencies": {
     "@types/node": "^20.10.6",