prompt-language-shell 0.1.0 → 0.1.4

package/dist/config/PLAN.md

@@ -15,13 +15,110 @@ 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:
+
+**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:
+- **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 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, even after considering available skills and context.
+
+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
+- 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
@@ -47,7 +144,7 @@ When breaking down complex questions:
 - Separate conditional checks into distinct tasks
 - Keep each task simple and focused on one operation
 
-Before returning a JSON array, validate that:
+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
@@ -55,6 +152,12 @@ Before returning a JSON array, validate that:
 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.
@@ -62,28 +165,34 @@ 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")
+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.
+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)
-
-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")
+   - "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.
+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)
@@ -96,15 +205,15 @@ Keep as a single task when:
 - 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
+- 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)
+- 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)
@@ -114,7 +223,27 @@ 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
+
+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
 
@@ -123,25 +252,53 @@ Do not include explanations, commentary, or any other text.
 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"]
+  - 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"]
+  - 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"]
+  - 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"]
+  - wrong:
+    [
+      "list the directory contents",
+      "show all items",
+    ]
   - correct: "list all directory contents"
 
 - "install and set up dependencies" →
-  - wrong: ["install dependencies", "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:
@@ -158,15 +315,43 @@ Simple requests should remain as single 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"]
+- "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"]
+- "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

@@ -4,9 +4,9 @@ import { readFileSync, existsSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import { render, Text } from 'ink';
-import { loadConfig, ConfigError } from './services/config.js';
+import { loadConfig, ConfigError, configExists, saveConfig, } from './services/config.js';
 import { createAnthropicService } from './services/anthropic.js';
-import { Please } from './ui/Please.js';
+import { PLS } from './ui/Please.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // Get package info
@@ -26,16 +26,28 @@ const appInfo = {
 // Get command from command-line arguments
 const args = process.argv.slice(2);
 const rawCommand = args.join(' ').trim();
-// If no command provided, show welcome screen
-if (!rawCommand) {
-    render(_jsx(Please, { app: appInfo }));
-}
-else {
-    // Load config and create Claude service
+async function runApp() {
+    // First-time setup: config doesn't exist
+    if (!configExists()) {
+        const { waitUntilExit } = render(_jsx(PLS, { app: appInfo, command: rawCommand || null, showConfigSetup: true, onConfigComplete: ({ apiKey, model }) => {
+                saveConfig(apiKey, model);
+                return rawCommand ? createAnthropicService(apiKey, model) : undefined;
+            } }));
+        await waitUntilExit();
+        return;
+    }
+    // Try to load and validate config
     try {
         const config = loadConfig();
-        const claudeService = createAnthropicService(config.claudeApiKey);
-        render(_jsx(Please, { app: appInfo, command: rawCommand, claudeService: claudeService }));
+        if (!rawCommand) {
+            // "pls" when config present: show welcome box
+            render(_jsx(PLS, { app: appInfo, command: null }));
+        }
+        else {
+            // "pls do stuff": fetch and show the plan
+            const claudeService = createAnthropicService(config.anthropic.apiKey, config.anthropic.model);
+            render(_jsx(PLS, { app: appInfo, command: rawCommand, claudeService: claudeService }));
+        }
     }
     catch (error) {
         if (error instanceof ConfigError) {
@@ -45,3 +57,4 @@ else {
         throw error;
     }
 }
+runApp();

package/dist/services/anthropic.js

@@ -2,21 +2,26 @@ 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-3-5-haiku-20241022') {
+    constructor(apiKey, model = 'claude-haiku-4-5-20251001') {
         this.client = new Anthropic({ apiKey });
         this.model = model;
     }
     async processCommand(rawCommand) {
+        // 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,
+            system: systemPrompt,
             messages: [
                 {
                     role: 'user',
@@ -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) {
-    return new AnthropicService(apiKey);
+export function createAnthropicService(apiKey, model) {
+    return new AnthropicService(apiKey, model);
 }

package/dist/services/config.js

@@ -1,57 +1,101 @@
-import { existsSync, mkdirSync, readFileSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
+import YAML from 'yaml';
 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 });
-    }
-}
-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;
-        }
-        const key = trimmed.slice(0, equalsIndex).trim();
-        const value = trimmed.slice(equalsIndex + 1).trim();
-        if (key) {
-            result[key] = value;
-        }
-    }
-    return result;
+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 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;
+    }
+    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/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 (error) {
+        // 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/ui/Command.js

@@ -5,6 +5,7 @@ import { Spinner } from './Spinner.js';
 const MIN_PROCESSING_TIME = 2000; // purelly for visual effect
 export function Command({ rawCommand, claudeService }) {
     const [processedTasks, setProcessedTasks] = useState([]);
+    const [systemPrompt, setSystemPrompt] = useState();
     const [error, setError] = useState(null);
     const [isLoading, setIsLoading] = useState(true);
     useEffect(() => {
@@ -17,7 +18,8 @@ export function Command({ rawCommand, claudeService }) {
                 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);
                 }
             }
@@ -36,5 +38,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,9 +1,25 @@
-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, command, claudeService }) => {
-    if (command && claudeService) {
-        return _jsx(Command, { rawCommand: command, claudeService: claudeService });
+import { ConfigSetup } from './ConfigSetup.js';
+import { History } from './History.js';
+export const PLS = ({ app: info, command, claudeService, showConfigSetup, onConfigComplete, }) => {
+    const [history, setHistory] = React.useState([]);
+    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 })] }));
     }
-    return _jsx(Welcome, { info: info });
+    // Welcome screen with optional config setup
+    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

@@ -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.1.0",
+  "version": "0.1.4",
   "description": "Your personal command-line concierge. Ask politely, and it gets things done.",
   "type": "module",
   "main": "dist/index.js",
@@ -42,7 +42,9 @@
   "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",