prompt-language-shell 0.2.0 → 0.2.4

package/dist/config/PLAN.md

@@ -84,6 +84,10 @@ derived from available skills:
    parameters
 3. Present these as concrete options, NOT generic categories
 4. Each option should be something the user can directly select and execute
+5. Format options WITHOUT brackets. Use commas to separate extra information
+   instead. For example:
+   - CORRECT: "Build project Alpha, the legacy version"
+   - WRONG: "Build project Alpha (the legacy version)"
 
 Example:
 - Available skills: "Build Product" (variant A, variant B), "Deploy
@@ -440,7 +444,8 @@ Examples showing proper use of skills and disambiguation:
 - "build" with build skill requiring {PROJECT} parameter (Alpha, Beta, Gamma,
   Delta) → One task: type "define", action "Clarify which project to build",
   params { options: ["Build Alpha", "Build Beta", "Build Gamma", "Build
-  Delta"] }
+  Delta"] }. NOTE: If variants have descriptions, format as "Build Alpha, the
+  legacy version" NOT "Build Alpha (the legacy version)"
 - "build Alpha" with same build skill → Three tasks extracted from skill
   steps: "Navigate to the Alpha project's root directory", "Execute the Alpha
   project generation script", "Compile the Alpha source code"

package/dist/index.js

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

package/dist/services/anthropic.js

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

package/dist/services/skills.js

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

package/dist/services/skills.test.js

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

package/dist/services/tool-registry.js

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

package/dist/types/components.js

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

package/dist/ui/Column.js

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

package/dist/ui/Command.js

@@ -2,27 +2,77 @@ import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-run
 import { useEffect, useState } from 'react';
 import { Box, Text } from 'ink';
 import { TaskType } from '../types/components.js';
+import { List } from './List.js';
 import { Spinner } from './Spinner.js';
 const MIN_PROCESSING_TIME = 1000; // purely for visual effect
-function getTaskActionColor(taskType) {
-    return taskType === TaskType.Ignore ? 'yellow' : 'white';
+// Color palette
+const ColorPalette = {
+    [TaskType.Config]: {
+        description: '#ffffff', // white
+        type: '#5c9ccc', // cyan
+    },
+    [TaskType.Plan]: {
+        description: '#ffffff', // white
+        type: '#cc5c9c', // magenta
+    },
+    [TaskType.Execute]: {
+        description: '#ffffff', // white
+        type: '#4a9a7a', // green
+    },
+    [TaskType.Answer]: {
+        description: '#ffffff', // white
+        type: '#9c5ccc', // purple
+    },
+    [TaskType.Report]: {
+        description: '#ffffff', // white
+        type: '#cc9c5c', // orange
+    },
+    [TaskType.Define]: {
+        description: '#ffffff', // white
+        type: '#cc9c5c', // amber
+    },
+    [TaskType.Ignore]: {
+        description: '#cccc5c', // yellow
+        type: '#cc7a5c', // orange
+    },
+    [TaskType.Select]: {
+        description: '#888888', // grey
+        type: '#5c8cbc', // steel blue
+    },
+};
+function taskToListItem(task) {
+    const colors = ColorPalette[task.type];
+    const item = {
+        description: {
+            text: task.action,
+            color: colors.description,
+        },
+        type: {
+            text: task.type,
+            color: colors.type,
+        },
+    };
+    // Add children for Define tasks with options
+    if (task.type === TaskType.Define && Array.isArray(task.params?.options)) {
+        const selectColors = ColorPalette[TaskType.Select];
+        item.children = task.params.options.map((option) => ({
+            description: {
+                text: String(option),
+                color: selectColors.description,
+            },
+            type: {
+                text: TaskType.Select,
+                color: selectColors.type,
+            },
+        }));
+    }
+    return item;
 }
-function getTaskTypeColor(taskType) {
-    if (taskType === TaskType.Ignore)
-        return 'red';
-    if (taskType === TaskType.Define)
-        return 'blue';
-    return 'greenBright';
-}
-function shouldDimTaskType(taskType) {
-    return taskType !== TaskType.Define;
-}
-export function Command({ command, state, service, tasks, error: errorProp, systemPrompt: systemPromptProp, }) {
+export function Command({ command, state, service, error: errorProp, children, }) {
     const done = state?.done ?? false;
-    const [processedTasks, setProcessedTasks] = useState(tasks || []);
-    const [systemPrompt, setSystemPrompt] = useState(systemPromptProp);
     const [error, setError] = useState(state?.error || errorProp || null);
     const [isLoading, setIsLoading] = useState(state?.isLoading ?? !done);
+    const [tasks, setTasks] = useState([]);
     useEffect(() => {
         // Skip processing if done (showing historical/final state)
         if (done) {
@@ -43,8 +93,7 @@ export function Command({ command, state, service, tasks, error: errorProp, syst
                 const remainingTime = Math.max(0, MIN_PROCESSING_TIME - elapsed);
                 await new Promise((resolve) => setTimeout(resolve, remainingTime));
                 if (mounted) {
-                    setProcessedTasks(result.tasks);
-                    setSystemPrompt(result.systemPrompt);
+                    setTasks(result.tasks);
                     setIsLoading(false);
                 }
             }
@@ -63,7 +112,5 @@ export function Command({ command, state, service, tasks, error: errorProp, syst
             mounted = false;
         };
     }, [command, done, service]);
-    return (_jsxs(Box, { alignSelf: "flex-start", marginBottom: 1, flexDirection: "column", children: [_jsxs(Box, { children: [_jsxs(Text, { color: "gray", children: ["> pls ", command] }), isLoading && (_jsxs(_Fragment, { children: [_jsx(Text, { children: " " }), _jsx(Spinner, {})] }))] }), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "red", children: ["Error: ", error] }) })), processedTasks.length > 0 && (_jsx(Box, { flexDirection: "column", children: processedTasks.map((task, index) => (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "whiteBright", children: '  - ' }), _jsx(Text, { color: getTaskActionColor(task.type), children: task.action }), _jsxs(Text, { color: getTaskTypeColor(task.type), dimColor: shouldDimTaskType(task.type), children: [' ', "(", task.type, ")"] })] }), (task.type === TaskType.Define &&
-                            task.params?.options &&
-                            Array.isArray(task.params.options) && (_jsx(Box, { flexDirection: "column", marginLeft: 4, children: task.params.options.map((option, optIndex) => (_jsx(Box, { children: _jsxs(Text, { color: "whiteBright", dimColor: true, children: ["- ", String(option)] }) }, optIndex))) })))] }, index))) }))] }));
+    return (_jsxs(Box, { alignSelf: "flex-start", marginBottom: 1, flexDirection: "column", children: [_jsxs(Box, { children: [_jsxs(Text, { color: "gray", children: ["> pls ", command] }), isLoading && (_jsxs(_Fragment, { children: [_jsx(Text, { children: " " }), _jsx(Spinner, {})] }))] }), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "red", children: ["Error: ", error] }) })), !isLoading && tasks.length > 0 && (_jsx(Box, { marginTop: 1, children: _jsx(List, { items: tasks.map(taskToListItem) }) })), children] }));
 }

package/dist/ui/Component.js

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

package/dist/ui/Config.js

@@ -0,0 +1,44 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text } from 'ink';
+import TextInput from 'ink-text-input';
+export function Config({ steps, state, onFinished }) {
+    const done = state?.done ?? false;
+    const [step, setStep] = React.useState(done ? steps.length : 0);
+    const [values, setValues] = React.useState(() => {
+        const initial = {};
+        steps.forEach((step) => {
+            if (step.value !== null) {
+                initial[step.key] = step.value;
+            }
+        });
+        return initial;
+    });
+    const [inputValue, setInputValue] = React.useState('');
+    const handleSubmit = (value) => {
+        const currentStepConfig = steps[step];
+        const finalValue = value.trim() || currentStepConfig.value || '';
+        const newValues = { ...values, [currentStepConfig.key]: finalValue };
+        setValues(newValues);
+        setInputValue('');
+        if (step === steps.length - 1) {
+            // Last step completed
+            if (onFinished) {
+                onFinished(newValues);
+            }
+            setStep(steps.length);
+        }
+        else {
+            setStep(step + 1);
+        }
+    };
+    return (_jsxs(Box, { flexDirection: "column", marginLeft: 1, children: [steps.map((stepConfig, index) => {
+                const isCurrentStep = index === step && !done;
+                const isCompleted = index < step || done;
+                const shouldShow = isCompleted || isCurrentStep;
+                if (!shouldShow) {
+                    return null;
+                }
+                return (_jsxs(Box, { flexDirection: "column", marginTop: index === 0 ? 0 : 1, children: [_jsx(Box, { children: _jsxs(Text, { children: [stepConfig.description, ":"] }) }), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: "> " }), isCurrentStep ? (_jsx(TextInput, { value: inputValue, onChange: setInputValue, onSubmit: handleSubmit })) : (_jsx(Text, { dimColor: true, children: values[stepConfig.key] || '' }))] })] }, stepConfig.key));
+            }), step === steps.length && !done && (_jsx(Box, { marginY: 1, children: _jsx(Text, { color: "green", children: "\u2713 Configuration complete" }) }))] }));
+}

package/dist/ui/List.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { Separator } from './Separator.js';
+export const List = ({ items, level = 0 }) => {
+    const marginLeft = level > 0 ? 4 : 0;
+    return (_jsx(Box, { flexDirection: "column", marginLeft: marginLeft, children: items.map((item, index) => (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "whiteBright", children: '  - ' }), _jsx(Text, { color: item.description.color, children: item.description.text }), _jsx(Separator, {}), _jsx(Text, { color: item.type.color, children: item.type.text })] }), item.children && item.children.length > 0 && (_jsx(List, { items: item.children, level: level + 1 }))] }, index))) }));
+};

package/dist/ui/Main.js

@@ -1,15 +1,13 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
 import React from 'react';
-import { Box } from 'ink';
-import { History } from './History.js';
-import { renderComponent } from './renderComponent.js';
+import { Column } from './Column.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
+            // Not configured - show welcome in history, config as current
             setHistory([
                 {
                     name: 'welcome',
@@ -18,14 +16,26 @@ export const Main = ({ app, command, service, isReady, onConfigured, }) => {
                     },
                 },
             ]);
+            const configSteps = [
+                { description: 'Anthropic API key', key: 'key', value: null },
+                {
+                    description: 'Model',
+                    key: 'model',
+                    value: 'claude-haiku-4-5-20251001',
+                },
+            ];
             setCurrent({
-                name: 'configure',
+                name: 'config',
                 state: {
                     done: false,
-                    step: 'key',
                 },
                 props: {
-                    onComplete: onConfigured,
+                    steps: configSteps,
+                    onFinished: (config) => {
+                        if (onConfigured) {
+                            onConfigured(config);
+                        }
+                    },
                 },
             });
         }
@@ -51,5 +61,6 @@ export const Main = ({ app, command, service, isReady, onConfigured, }) => {
             });
         }
     }, [isReady, command, service, app, onConfigured]);
-    return (_jsxs(Box, { marginTop: 1, flexDirection: "column", gap: 1, children: [_jsx(History, { items: history }), current && renderComponent(current)] }));
+    const items = [...history, ...(current ? [current] : [])];
+    return _jsx(Column, { items: items });
 };

package/dist/ui/Panel.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box } from 'ink';
+export const Panel = ({ children }) => {
+    return (_jsx(Box, { borderStyle: "round", borderColor: "green", paddingX: 3, paddingY: 1, flexDirection: "column", children: children }));
+};

package/dist/ui/Separator.js

@@ -0,0 +1,6 @@
+import { jsxs as _jsxs } from "react/jsx-runtime";
+import { Text } from 'ink';
+export const Separator = ({ color = '#666666', spaces = 1, }) => {
+    const spacing = ' '.repeat(spaces);
+    return (_jsxs(Text, { color: color, children: [spacing, "\u203A", spacing] }));
+};

package/dist/ui/Welcome.js

@@ -1,13 +1,22 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Text, Box } from 'ink';
-export function Welcome({ app: app }) {
-    const descriptionLines = app.description
-        .split('. ')
-        .map((line) => line.replace(/\.$/, ''))
-        .filter(Boolean);
-    // Transform package name: "prompt-language-shell" -> "Prompt Language Shell"
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { Panel } from './Panel.js';
+function Header({ app }) {
     const words = app.name
         .split('-')
         .map((word) => word.charAt(0).toUpperCase() + word.slice(1));
-    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]" })] })] })] })] }) }));
+    return (_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" })] }));
+}
+function Description({ description }) {
+    const lines = description
+        .split('. ')
+        .map((line) => line.replace(/\.$/, ''))
+        .filter(Boolean);
+    return (_jsx(_Fragment, { children: lines.map((line, index) => (_jsx(Box, { children: _jsxs(Text, { color: "white", children: [line, "."] }) }, index))) }));
+}
+function Usage() {
+    return (_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]" })] })] })] }));
+}
+export function Welcome({ app }) {
+    return (_jsx(Box, { alignSelf: "flex-start", marginBottom: 1, children: _jsxs(Panel, { children: [_jsx(Header, { app: app }), _jsx(Description, { description: app.description }), _jsx(Usage, {})] }) }));
 }

package/dist/ui/renderComponent.js

@@ -1,13 +1,13 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Welcome } from './Welcome.js';
-import { Configure } from './Configure.js';
+import { Config } from './Config.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 'config':
+            return (_jsx(Config, { ...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.2.0",
+  "version": "0.2.4",
   "description": "Your personal command-line concierge. Ask politely, and it gets things done.",
   "type": "module",
   "main": "dist/index.js",
@@ -13,25 +13,29 @@
   "scripts": {
     "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",
+    "prepare": "husky",
+    "prepublishOnly": "npm run check",
     "test": "vitest run",
     "test:watch": "vitest",
     "format": "prettier --write '**/*.{ts,tsx}'",
     "format:check": "prettier --check '**/*.{ts,tsx}'",
     "lint": "eslint .",
-    "lint:fix": "eslint --fix ."
+    "lint:fix": "eslint --fix .",
+    "check": "npm run build && npm run test && npm run lint && npm run format:check"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/aswitalski/pls.git"
   },
   "keywords": [
-    "shell",
-    "natural",
-    "language",
-    "command line",
-    "assistant",
-    "concierge"
+    "command line interface",
+    "developer tools",
+    "interactive shell",
+    "natural language processing",
+    "personal concierge",
+    "prompt language",
+    "task execution",
+    "workflow automation"
   ],
   "author": "Sensei Aleksander Świtalski",
   "license": "ISC",
@@ -50,6 +54,7 @@
     "@types/node": "^20.10.6",
     "@types/react": "^19.2.2",
     "eslint": "^9.17.0",
+    "husky": "^9.1.7",
     "prettier": "^3.6.2",
     "typescript": "^5.3.3",
     "typescript-eslint": "^8.19.1",

package/dist/config/SYSTEM.md

@@ -1,156 +0,0 @@
-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 refine the user's command into clear, professional English while
-preserving the original intent. Apply minimal necessary changes to achieve
-optimal clarity. Focus on:
-
-- 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", 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
-
-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
-
-- 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.
-
-## Examples
-
-### ❌ 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
-
-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/services/claude.js

@@ -1,54 +0,0 @@
-import { readFileSync } from 'fs';
-import { fileURLToPath } from 'url';
-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');
-export class AnthropicClaudeService {
-    client;
-    model;
-    constructor(apiKey, model = 'claude-3-5-haiku-20241022') {
-        this.client = new Anthropic({ apiKey });
-        this.model = model;
-    }
-    async processCommand(rawCommand) {
-        const response = await this.client.messages.create({
-            model: this.model,
-            max_tokens: 200,
-            system: SYSTEM_PROMPT,
-            messages: [
-                {
-                    role: 'user',
-                    content: rawCommand,
-                },
-            ],
-        });
-        const content = response.content[0];
-        if (content.type !== 'text') {
-            throw new Error('Unexpected response type from Claude API');
-        }
-        const text = content.text.trim();
-        // Try to parse as JSON array
-        if (text.startsWith('[') && text.endsWith(']')) {
-            try {
-                const parsed = JSON.parse(text);
-                if (Array.isArray(parsed) && parsed.length > 0) {
-                    // Validate all items are strings
-                    const allStrings = parsed.every((item) => typeof item === 'string');
-                    if (allStrings) {
-                        return parsed.filter((item) => typeof item === 'string');
-                    }
-                }
-            }
-            catch {
-                // If JSON parsing fails, treat as single task
-            }
-        }
-        // Single task
-        return [text];
-    }
-}
-export function createClaudeService(apiKey) {
-    return new AnthropicClaudeService(apiKey);
-}

package/dist/ui/CommandProcessor.js

@@ -1,31 +0,0 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-import { useEffect, useState } from 'react';
-import { Box, Text } from 'ink';
-export function CommandProcessor({ rawCommand, claudeService, }) {
-    const [processedTask, setProcessedTask] = useState(null);
-    const [error, setError] = useState(null);
-    const [isLoading, setIsLoading] = useState(true);
-    useEffect(() => {
-        let mounted = true;
-        async function process() {
-            try {
-                const result = await claudeService.processCommand(rawCommand);
-                if (mounted) {
-                    setProcessedTask(result);
-                    setIsLoading(false);
-                }
-            }
-            catch (err) {
-                if (mounted) {
-                    setError(err instanceof Error ? err.message : 'Unknown error occurred');
-                    setIsLoading(false);
-                }
-            }
-        }
-        process();
-        return () => {
-            mounted = false;
-        };
-    }, [rawCommand, claudeService]);
-    return (_jsxs(Box, { alignSelf: "flex-start", marginTop: 1, marginBottom: 1, flexDirection: "column", children: [_jsx(Box, { children: _jsxs(Text, { color: "gray", children: ["> pls ", rawCommand] }) }), isLoading && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "whiteBright", dimColor: true, children: "Processing..." }) })), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "red", children: ["Error: ", error] }) })), processedTask && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "whiteBright", dimColor: true, children: ['  ⎿  ', "Task: \"", processedTask, "\""] }) }))] }));
-}