prompt-language-shell 0.2.6 → 0.2.9

package/dist/config/PLAN.md

@@ -333,6 +333,7 @@ When creating task definitions, focus on:
   with precise, contextually appropriate alternatives. Use professional, clear
   terminology suitable for technical documentation. Maintain natural, fluent
   English phrasing while preserving the original intent.
+  **Keep action descriptions concise, at most 64 characters.**
 
 - **Type**: Categorize the operation using one of these supported types:
   - `config` - Configuration changes, settings updates

package/dist/index.js

@@ -3,8 +3,8 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { existsSync, readFileSync } from 'fs';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
-import { render, Text } from 'ink';
-import { ConfigError, configExists, loadConfig, saveConfig, } from './services/config.js';
+import { render } from 'ink';
+import { hasValidConfig, loadConfig, saveAnthropicConfig, } from './services/config.js';
 import { createAnthropicService } from './services/anthropic.js';
 import { Main } from './ui/Main.js';
 const __filename = fileURLToPath(import.meta.url);
@@ -27,29 +27,25 @@ const app = {
 const args = process.argv.slice(2);
 const command = args.join(' ').trim() || null;
 async function runApp() {
-    // First-time setup: config doesn't exist
-    if (!configExists()) {
-        const { waitUntilExit } = render(_jsx(Main, { app: app, command: command, isReady: false, onConfigured: (config) => {
-                saveConfig('anthropic', config);
-                // Create service once for the session
-                return command ? createAnthropicService(config) : undefined;
-            } }));
-        await waitUntilExit();
-        return;
-    }
-    // Try to load and validate config
-    try {
+    // Happy path: valid config exists
+    if (hasValidConfig()) {
         const config = loadConfig();
-        // Create service once at app initialization
         const service = createAnthropicService(config.anthropic);
         render(_jsx(Main, { app: app, command: command, service: service, isReady: true }));
+        return;
     }
-    catch (error) {
-        if (error instanceof ConfigError) {
-            render(_jsx(Text, { color: "red", children: error.message }));
-            process.exit(1);
-        }
-        throw error;
-    }
+    // Setup: config doesn't exist or is invalid
+    const { waitUntilExit, unmount } = render(_jsx(Main, { app: app, command: command, isReady: false, onConfigured: (config) => {
+            saveAnthropicConfig(config);
+            if (command) {
+                return createAnthropicService(config);
+            }
+            else {
+                // No command - exit after showing completion message
+                setTimeout(() => unmount(), 100);
+                return undefined;
+            }
+        } }));
+    await waitUntilExit();
 }
 runApp();

package/dist/services/config.js

@@ -3,9 +3,11 @@ import { homedir } from 'os';
 import { join } from 'path';
 import YAML from 'yaml';
 export class ConfigError extends Error {
-    constructor(message) {
+    origin;
+    constructor(message, origin) {
         super(message);
         this.name = 'ConfigError';
+        this.origin = origin;
     }
 }
 const CONFIG_FILE = join(homedir(), '.plsrc');
@@ -14,30 +16,21 @@ function parseYamlConfig(content) {
         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)}`);
+        throw new ConfigError('Failed to parse configuration file', error instanceof Error ? error : undefined);
     }
 }
 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.');
+        throw new ConfigError('Invalid configuration format');
     }
     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' +
-            '  key: sk-ant-...');
+        throw new ConfigError('Missing or invalid anthropic configuration');
     }
-    const anthropic = config.anthropic;
-    const key = anthropic['key'];
+    const { key, model } = config.anthropic;
     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' +
-            '  key: sk-ant-...');
+        throw new ConfigError('Missing or invalid API key');
     }
     const validatedConfig = {
         anthropic: {
@@ -45,19 +38,14 @@ function validateConfig(parsed) {
         },
     };
     // Optional model
-    if (anthropic.model && typeof anthropic.model === 'string') {
-        validatedConfig.anthropic.model = anthropic.model;
+    if (model && typeof model === 'string') {
+        validatedConfig.anthropic.model = model;
     }
     return validatedConfig;
 }
 export function loadConfig() {
     if (!existsSync(CONFIG_FILE)) {
-        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' +
-            '  key: sk-ant-...\n' +
-            '  model: claude-haiku-4-5-20251001\n');
+        throw new ConfigError('Configuration not found');
     }
     const content = readFileSync(CONFIG_FILE, 'utf-8');
     const parsed = parseYamlConfig(content);
@@ -69,6 +57,15 @@ export function getConfigPath() {
 export function configExists() {
     return existsSync(CONFIG_FILE);
 }
+export function hasValidConfig() {
+    try {
+        const config = loadConfig();
+        return !!config.anthropic.key;
+    }
+    catch {
+        return false;
+    }
+}
 export function mergeConfig(existingContent, sectionName, newValues) {
     const parsed = existingContent.trim()
         ? YAML.parse(existingContent)
@@ -95,3 +92,6 @@ export function saveConfig(section, config) {
     const newContent = mergeConfig(existingContent, section, config);
     writeFileSync(CONFIG_FILE, newContent, 'utf-8');
 }
+export function saveAnthropicConfig(config) {
+    saveConfig('anthropic', config);
+}

package/dist/types/components.js

@@ -9,3 +9,9 @@ export var TaskType;
     TaskType["Ignore"] = "ignore";
     TaskType["Select"] = "select";
 })(TaskType || (TaskType = {}));
+export var FeedbackType;
+(function (FeedbackType) {
+    FeedbackType["Succeeded"] = "succeeded";
+    FeedbackType["Aborted"] = "aborted";
+    FeedbackType["Failed"] = "failed";
+})(FeedbackType || (FeedbackType = {}));

package/dist/ui/Column.js

@@ -2,5 +2,5 @@ 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))) }));
+    return (_jsx(Box, { marginTop: 1, marginBottom: 1, flexDirection: "column", gap: 1, children: items.map((item, index) => (_jsx(Box, { children: _jsx(Component, { def: item }) }, index))) }));
 };

package/dist/ui/Command.js

@@ -69,7 +69,7 @@ function taskToListItem(task) {
     }
     return item;
 }
-export function Command({ command, state, service, error: errorProp, children, }) {
+export function Command({ command, state, service, error: errorProp, children, onError, onComplete, }) {
     const done = state?.done ?? false;
     const [error, setError] = useState(state?.error || errorProp || null);
     const [isLoading, setIsLoading] = useState(state?.isLoading ?? !done);
@@ -98,6 +98,7 @@ export function Command({ command, state, service, error: errorProp, children, }
                     setMessage(result.message);
                     setTasks(result.tasks);
                     setIsLoading(false);
+                    onComplete?.();
                 }
             }
             catch (err) {
@@ -105,8 +106,14 @@ export function Command({ command, state, service, error: errorProp, children, }
                 const remainingTime = Math.max(0, MIN_PROCESSING_TIME - elapsed);
                 await new Promise((resolve) => setTimeout(resolve, remainingTime));
                 if (mounted) {
-                    setError(err instanceof Error ? err.message : 'Unknown error occurred');
+                    const errorMessage = err instanceof Error ? err.message : 'Unknown error occurred';
                     setIsLoading(false);
+                    if (onError) {
+                        onError(errorMessage);
+                    }
+                    else {
+                        setError(errorMessage);
+                    }
                 }
             }
         }
@@ -115,5 +122,5 @@ export function Command({ command, state, service, error: errorProp, children, }
             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] }) })), !isLoading && tasks.length > 0 && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [message && (_jsxs(Box, { marginBottom: 1, children: [_jsxs(Text, { children: [" ", message] }), _jsx(Separator, { color: "#9c5ccc" }), _jsx(Text, { color: "#9c5ccc", children: "plan" })] })), _jsx(List, { items: tasks.map(taskToListItem) })] })), children] }));
+    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", marginLeft: 1, 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 && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [message && (_jsxs(Box, { marginBottom: 1, children: [_jsxs(Text, { children: [" ", message] }), _jsx(Separator, { color: "#9c5ccc" }), _jsx(Text, { color: "#9c5ccc", children: "plan" })] })), _jsx(List, { items: tasks.map(taskToListItem) })] })), children] }));
 }

package/dist/ui/Component.js

@@ -1,6 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Command } from './Command.js';
 import { Config } from './Config.js';
+import { Feedback } from './Feedback.js';
 import { Welcome } from './Welcome.js';
 export function Component({ def }) {
     switch (def.name) {
@@ -11,6 +12,8 @@ export function Component({ def }) {
             const state = def.state;
             return _jsx(Config, { ...props, state: state });
         }
+        case 'feedback':
+            return _jsx(Feedback, { ...def.props });
         case 'command': {
             const props = def.props;
             const state = def.state;

package/dist/ui/Config.js

@@ -1,8 +1,8 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import React from 'react';
-import { Box, Text } from 'ink';
+import { Box, Text, useInput } from 'ink';
 import TextInput from 'ink-text-input';
-export function Config({ steps, state, onFinished }) {
+export function Config({ steps, state, onFinished, onAborted }) {
     const done = state?.done ?? false;
     const [step, setStep] = React.useState(done ? steps.length : 0);
     const [values, setValues] = React.useState(() => {
@@ -15,9 +15,26 @@ export function Config({ steps, state, onFinished }) {
         return initial;
     });
     const [inputValue, setInputValue] = React.useState('');
+    const normalizeValue = (value) => {
+        if (value === null || value === undefined) {
+            return '';
+        }
+        return value.replace(/\n/g, '').trim();
+    };
+    useInput((input, key) => {
+        if (key.escape && !done && step < steps.length) {
+            if (onAborted) {
+                onAborted();
+            }
+        }
+    });
     const handleSubmit = (value) => {
         const currentStepConfig = steps[step];
-        const finalValue = value.trim() || currentStepConfig.value || '';
+        const finalValue = normalizeValue(value) || normalizeValue(currentStepConfig.value);
+        // Don't allow empty value if step has no default (mandatory field)
+        if (!finalValue && !currentStepConfig.value) {
+            return;
+        }
         const newValues = { ...values, [currentStepConfig.key]: finalValue };
         setValues(newValues);
         setInputValue('');
@@ -32,13 +49,14 @@ export function Config({ steps, state, onFinished }) {
             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" }) }))] }));
+    return (_jsx(Box, { flexDirection: "column", marginLeft: 1, children: steps.map((stepConfig, index) => {
+            const isCurrentStep = index === step && !done;
+            const isCompleted = index < step;
+            const wasAborted = index === step && done;
+            const shouldShow = isCompleted || isCurrentStep || wasAborted;
+            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, { children: " " }), _jsx(Text, { color: "#5c8cbc", dimColor: !isCurrentStep, children: ">" }), _jsx(Text, { children: " " }), isCurrentStep ? (_jsx(TextInput, { value: inputValue, onChange: setInputValue, onSubmit: handleSubmit, placeholder: stepConfig.value || undefined })) : (_jsx(Text, { dimColor: true, children: values[stepConfig.key] || '' }))] })] }, stepConfig.key));
+        }) }));
 }

package/dist/ui/Feedback.js

@@ -0,0 +1,22 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { FeedbackType } from '../types/components.js';
+function getSymbol(type) {
+    return {
+        [FeedbackType.Succeeded]: '✓',
+        [FeedbackType.Aborted]: '⊘',
+        [FeedbackType.Failed]: '✗',
+    }[type];
+}
+function getColor(type) {
+    return {
+        [FeedbackType.Succeeded]: '#00aa00', // green
+        [FeedbackType.Aborted]: '#cc9c5c', // orange
+        [FeedbackType.Failed]: '#aa0000', // red
+    }[type];
+}
+export function Feedback({ type, message }) {
+    const color = getColor(type);
+    const symbol = getSymbol(type);
+    return (_jsx(Box, { marginLeft: 1, children: _jsxs(Text, { color: color, children: [symbol, " ", message] }) }));
+}

package/dist/ui/Main.js

@@ -1,66 +1,136 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import React from 'react';
+import { FeedbackType } from '../types/components.js';
 import { Column } from './Column.js';
-export const Main = ({ app, command, service, isReady, onConfigured, }) => {
+function exit(code) {
+    setTimeout(() => globalThis.process.exit(code), 100);
+}
+function markAsDone(component) {
+    return { ...component, state: { ...component.state, done: true } };
+}
+function createWelcomeDefinition(app) {
+    return {
+        name: 'welcome',
+        props: { app },
+    };
+}
+function createConfigSteps() {
+    return [
+        { description: 'Anthropic API key', key: 'key', value: null },
+        {
+            description: 'Model',
+            key: 'model',
+            value: 'claude-haiku-4-5-20251001',
+        },
+    ];
+}
+function createConfigDefinition(onFinished, onAborted) {
+    return {
+        name: 'config',
+        state: { done: false },
+        props: {
+            steps: createConfigSteps(),
+            onFinished,
+            onAborted,
+        },
+    };
+}
+function createCommandDefinition(command, service, onError, onComplete) {
+    return {
+        name: 'command',
+        state: {
+            done: false,
+            isLoading: true,
+        },
+        props: {
+            command,
+            service,
+            onError,
+            onComplete,
+        },
+    };
+}
+function createFeedback(type, ...messages) {
+    return {
+        name: 'feedback',
+        props: {
+            type,
+            message: messages.join('\n\n'),
+        },
+    };
+}
+export const Main = ({ app, command, service: initialService, isReady, onConfigured, }) => {
     const [history, setHistory] = React.useState([]);
     const [current, setCurrent] = React.useState(null);
+    const [service, setService] = React.useState(initialService);
+    const addToHistory = React.useCallback((...items) => {
+        setHistory((history) => [...history, ...items]);
+    }, []);
+    const handleConfigFinished = React.useCallback((config) => {
+        const service = onConfigured?.(config);
+        if (service) {
+            setService(service);
+        }
+        // Move config to history with done state and add success feedback
+        setCurrent((previous) => {
+            if (previous && previous.name === 'config') {
+                addToHistory(markAsDone(previous), createFeedback(FeedbackType.Succeeded, 'Configuration complete'));
+            }
+            return null;
+        });
+    }, [onConfigured, addToHistory]);
+    const handleConfigAborted = React.useCallback(() => {
+        // Move config to history with done state and add aborted feedback
+        setCurrent((previous) => {
+            if (previous && previous.name === 'config') {
+                addToHistory(markAsDone(previous), createFeedback(FeedbackType.Aborted, 'Configuration aborted by user'));
+                // Exit after showing abort message
+                exit(0);
+            }
+            return null;
+        });
+    }, [addToHistory]);
+    const handleCommandError = React.useCallback((error) => {
+        // Move command to history with done state and add error feedback
+        setCurrent((previous) => {
+            if (previous && previous.name === 'command') {
+                addToHistory(markAsDone(previous), createFeedback(FeedbackType.Failed, 'Unexpected error occurred:', error));
+                // Exit after showing error
+                exit(1);
+            }
+            return null;
+        });
+    }, [addToHistory]);
+    const handleCommandComplete = React.useCallback(() => {
+        // Move command to history with done state
+        setCurrent((previous) => {
+            if (previous && previous.name === 'command') {
+                addToHistory(markAsDone(previous));
+                // Exit after showing plan
+                exit(0);
+            }
+            return null;
+        });
+    }, [addToHistory]);
+    // Initialize configuration flow when not ready
     React.useEffect(() => {
-        // Initialize history and current component based on props
         if (!isReady) {
-            // Not configured - show welcome in history, config as current
-            setHistory([
-                {
-                    name: 'welcome',
-                    props: {
-                        app,
-                    },
-                },
-            ]);
-            const configSteps = [
-                { description: 'Anthropic API key', key: 'key', value: null },
-                {
-                    description: 'Model',
-                    key: 'model',
-                    value: 'claude-haiku-4-5-20251001',
-                },
-            ];
-            setCurrent({
-                name: 'config',
-                state: {
-                    done: false,
-                },
-                props: {
-                    steps: configSteps,
-                    onFinished: (config) => {
-                        if (onConfigured) {
-                            onConfigured(config);
-                        }
-                    },
-                },
-            });
+            setHistory(command ? [] : [createWelcomeDefinition(app)]);
+            setCurrent(createConfigDefinition(handleConfigFinished, handleConfigAborted));
         }
-        else if (command && service) {
-            setCurrent({
-                name: 'command',
-                state: {
-                    done: false,
-                    isLoading: true,
-                },
-                props: {
-                    command,
-                    service,
-                },
-            });
+    }, [isReady, app, command, handleConfigFinished, handleConfigAborted]);
+    // Execute command when service and command are available
+    React.useEffect(() => {
+        if (command && service) {
+            setCurrent(createCommandDefinition(command, service, handleCommandError, handleCommandComplete));
         }
-        else {
-            setCurrent({
-                name: 'welcome',
-                props: {
-                    app,
-                },
-            });
+    }, [command, service, handleCommandError, handleCommandComplete]);
+    // Show welcome screen when ready but no command
+    React.useEffect(() => {
+        if (isReady && !command) {
+            setCurrent(createWelcomeDefinition(app));
         }
-    }, [isReady, command, service, app, onConfigured]);
+    }, [isReady, command, app]);
     const items = [...history, ...(current ? [current] : [])];
     return _jsx(Column, { items: items });
 };

package/dist/ui/Welcome.js

@@ -18,5 +18,5 @@ 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, {})] }) }));
+    return (_jsx(Box, { alignSelf: "flex-start", children: _jsxs(Panel, { children: [_jsx(Header, { app: app }), _jsx(Description, { description: app.description }), _jsx(Usage, {})] }) }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prompt-language-shell",
-  "version": "0.2.6",
+  "version": "0.2.9",
   "description": "Your personal command-line concierge. Ask politely, and it gets things done.",
   "type": "module",
   "main": "dist/index.js",
@@ -11,7 +11,8 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsc && chmod +x dist/index.js && mkdir -p dist/config && cp src/config/*.md dist/config/",
+    "clean": "rm -rf dist",
+    "build": "npm run clean && tsc && chmod +x dist/index.js && mkdir -p dist/config && cp src/config/*.md dist/config/",
     "dev": "npm run build && tsc --watch",
     "prepare": "husky",
     "prepublishOnly": "npm run check",