prompt-language-shell 0.1.4 → 0.1.6

package/README.md

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

package/dist/index.js

@@ -6,7 +6,7 @@ import { dirname, join } from 'path';
 import { render, Text } from 'ink';
 import { loadConfig, ConfigError, configExists, saveConfig, } from './services/config.js';
 import { createAnthropicService } from './services/anthropic.js';
-import { PLS } from './ui/Please.js';
+import { Main } from './ui/Main.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // Get package info
@@ -17,7 +17,7 @@ const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
 // In production, we're in node_modules and src/ doesn't exist alongside
 const srcPath = join(__dirname, '../src');
 const isDev = existsSync(srcPath);
-const appInfo = {
+const app = {
     name: packageJson.name,
     version: packageJson.version,
     description: packageJson.description,
@@ -25,13 +25,14 @@ const appInfo = {
 };
 // Get command from command-line arguments
 const args = process.argv.slice(2);
-const rawCommand = args.join(' ').trim();
+const command = args.join(' ').trim() || null;
 async function runApp() {
     // 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;
+        const { waitUntilExit } = render(_jsx(Main, { app: app, command: command, isReady: false, onConfigured: (config) => {
+                saveConfig('anthropic', config);
+                // Create service once for the session
+                return command ? createAnthropicService(config) : undefined;
             } }));
         await waitUntilExit();
         return;
@@ -39,15 +40,9 @@ async function runApp() {
     // Try to load and validate config
     try {
         const config = loadConfig();
-        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 }));
-        }
+        // Create service once at app initialization
+        const service = createAnthropicService(config.anthropic);
+        render(_jsx(Main, { app: app, command: command, service: service, isReady: true }));
     }
     catch (error) {
         if (error instanceof ConfigError) {

package/dist/services/anthropic.js

@@ -9,23 +9,23 @@ const PLAN_PROMPT = readFileSync(join(__dirname, '../config/PLAN.md'), 'utf-8');
 export class AnthropicService {
     client;
     model;
-    constructor(apiKey, model = 'claude-haiku-4-5-20251001') {
-        this.client = new Anthropic({ apiKey });
+    constructor(key, model = 'claude-haiku-4-5-20251001') {
+        this.client = new Anthropic({ apiKey: key });
         this.model = model;
     }
-    async processCommand(rawCommand) {
+    async processCommand(command) {
         // Load skills and augment the planning prompt
         const skills = loadSkills();
         const skillsSection = formatSkillsForPrompt(skills);
         const systemPrompt = PLAN_PROMPT + skillsSection;
         const response = await this.client.messages.create({
             model: this.model,
-            max_tokens: 200,
+            max_tokens: 512,
             system: systemPrompt,
             messages: [
                 {
                     role: 'user',
-                    content: rawCommand,
+                    content: command,
                 },
             ],
         });
@@ -69,6 +69,6 @@ export class AnthropicService {
         };
     }
 }
-export function createAnthropicService(apiKey, model) {
-    return new AnthropicService(apiKey, model);
+export function createAnthropicService(config) {
+    return new AnthropicService(config.key, config.model);
 }

package/dist/services/config.js

@@ -29,20 +29,19 @@ function validateConfig(parsed) {
         throw new ConfigError(`\nMissing or invalid 'anthropic' section in ${CONFIG_FILE}\n` +
             'Please add:\n' +
             'anthropic:\n' +
-            '  api-key: sk-ant-...');
+            '  key: sk-ant-...');
     }
     const anthropic = config.anthropic;
-    // Support both 'api-key' (kebab-case) and 'apiKey' (camelCase)
-    const apiKey = anthropic['api-key'] || anthropic.apiKey;
-    if (!apiKey || typeof apiKey !== 'string') {
-        throw new ConfigError(`\nMissing or invalid 'anthropic.api-key' in ${CONFIG_FILE}\n` +
+    const key = anthropic['key'];
+    if (!key || typeof key !== 'string') {
+        throw new ConfigError(`\nMissing or invalid 'anthropic.key' in ${CONFIG_FILE}\n` +
             'Please add your Anthropic API key:\n' +
             'anthropic:\n' +
-            '  api-key: sk-ant-...');
+            '  key: sk-ant-...');
     }
     const validatedConfig = {
         anthropic: {
-            apiKey: apiKey,
+            key,
         },
     };
     // Optional model
@@ -57,7 +56,7 @@ export function loadConfig() {
             'Please create it with your Anthropic API key.\n' +
             'Example:\n\n' +
             'anthropic:\n' +
-            '  api-key: sk-ant-...\n' +
+            '  key: sk-ant-...\n' +
             '  model: claude-haiku-4-5-20251001\n');
     }
     const content = readFileSync(CONFIG_FILE, 'utf-8');
@@ -72,10 +71,10 @@ export function configExists() {
 }
 export function mergeConfig(existingContent, sectionName, newValues) {
     const parsed = existingContent.trim()
-        ? YAML.parse(existingContent) || {}
+        ? YAML.parse(existingContent)
         : {};
     // Update or add section
-    const section = parsed[sectionName] || {};
+    const section = parsed[sectionName] ?? {};
     for (const [key, value] of Object.entries(newValues)) {
         section[key] = value;
     }
@@ -89,13 +88,10 @@ export function mergeConfig(existingContent, sectionName, newValues) {
     // Convert back to YAML
     return YAML.stringify(sortedConfig);
 }
-export function saveConfig(apiKey, model) {
+export function saveConfig(section, config) {
     const existingContent = existsSync(CONFIG_FILE)
         ? readFileSync(CONFIG_FILE, 'utf-8')
         : '';
-    const newContent = mergeConfig(existingContent, 'anthropic', {
-        'api-key': apiKey,
-        model: model,
-    });
+    const newContent = mergeConfig(existingContent, section, config);
     writeFileSync(CONFIG_FILE, newContent, 'utf-8');
 }

package/dist/services/skills.js

@@ -27,7 +27,7 @@ export function loadSkills() {
             return readFileSync(filePath, 'utf-8');
         });
     }
-    catch (error) {
+    catch {
         // Return empty array if there's any error reading the directory
         return [];
     }

package/dist/types/components.js

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

package/dist/ui/Command.js

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

package/dist/ui/Configure.js

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

package/dist/ui/History.js

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

package/dist/ui/Main.js

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

package/dist/ui/Welcome.js

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

package/dist/ui/renderComponent.js

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

package/package.json

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