prompt-language-shell 0.4.4 → 0.4.8

package/dist/services/components.js

@@ -1,6 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { ComponentName } from '../types/types.js';
-import { AnthropicModel, isValidAnthropicApiKey, isValidAnthropicModel, } from './configuration.js';
+import { getConfigSchema, loadConfig, } from './configuration.js';
 import { getConfirmationMessage } from './messages.js';
 import { StepType } from '../ui/Config.js';
 export function markAsDone(component) {
@@ -14,27 +14,132 @@ export function createWelcomeDefinition(app) {
     };
 }
 export function createConfigSteps() {
-    return [
-        {
-            description: 'Anthropic API key',
-            key: 'key',
-            type: StepType.Text,
-            value: null,
-            validate: isValidAnthropicApiKey,
-        },
-        {
-            description: 'Model',
-            key: 'model',
-            type: StepType.Selection,
-            options: [
-                { label: 'Haiku 4.5', value: AnthropicModel.Haiku },
-                { label: 'Sonnet 4.5', value: AnthropicModel.Sonnet },
-                { label: 'Opus 4.1', value: AnthropicModel.Opus },
-            ],
-            defaultIndex: 0,
-            validate: isValidAnthropicModel,
-        },
-    ];
+    // Use schema-based config step generation for required Anthropic settings
+    return createConfigStepsFromSchema(['anthropic.key', 'anthropic.model']);
+}
+/**
+ * Get current config value for a dotted key path
+ */
+function getConfigValue(config, key) {
+    if (!config)
+        return undefined;
+    const parts = key.split('.');
+    let value = config;
+    for (const part of parts) {
+        if (value && typeof value === 'object' && part in value) {
+            value = value[part];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return value;
+}
+/**
+ * Get validation function for a config definition
+ */
+function getValidator(definition) {
+    switch (definition.type) {
+        case 'regexp':
+            return (value) => definition.pattern.test(value);
+        case 'string':
+            return () => true; // Strings are always valid
+        case 'enum':
+            return (value) => definition.values.includes(value);
+        case 'number':
+            return (value) => !isNaN(Number(value));
+        case 'boolean':
+            return (value) => value === 'true' || value === 'false';
+    }
+}
+/**
+ * Create config steps from schema for specified keys
+ */
+export function createConfigStepsFromSchema(keys) {
+    const schema = getConfigSchema();
+    let currentConfig = null;
+    try {
+        currentConfig = loadConfig();
+    }
+    catch {
+        // Config doesn't exist yet, use defaults
+    }
+    return keys.map((key) => {
+        if (!(key in schema)) {
+            throw new Error(`Unknown config key: ${key}`);
+        }
+        const definition = schema[key];
+        const currentValue = getConfigValue(currentConfig, key);
+        const keyParts = key.split('.');
+        const shortKey = keyParts[keyParts.length - 1];
+        // Map definition to ConfigStep based on type
+        switch (definition.type) {
+            case 'regexp':
+            case 'string': {
+                const value = currentValue !== undefined && typeof currentValue === 'string'
+                    ? currentValue
+                    : definition.type === 'string'
+                        ? (definition.default ?? '')
+                        : null;
+                return {
+                    description: definition.description,
+                    key: shortKey,
+                    type: StepType.Text,
+                    value,
+                    validate: getValidator(definition),
+                };
+            }
+            case 'number': {
+                const value = currentValue !== undefined && typeof currentValue === 'number'
+                    ? String(currentValue)
+                    : definition.default !== undefined
+                        ? String(definition.default)
+                        : '0';
+                return {
+                    description: definition.description,
+                    key: shortKey,
+                    type: StepType.Text,
+                    value,
+                    validate: getValidator(definition),
+                };
+            }
+            case 'enum': {
+                const currentStr = currentValue !== undefined && typeof currentValue === 'string'
+                    ? currentValue
+                    : definition.default;
+                const defaultIndex = currentStr
+                    ? definition.values.indexOf(currentStr)
+                    : 0;
+                return {
+                    description: definition.description,
+                    key: shortKey,
+                    type: StepType.Selection,
+                    options: definition.values.map((value) => ({
+                        label: value,
+                        value,
+                    })),
+                    defaultIndex: Math.max(0, defaultIndex),
+                    validate: getValidator(definition),
+                };
+            }
+            case 'boolean': {
+                const currentBool = currentValue !== undefined && typeof currentValue === 'boolean'
+                    ? currentValue
+                    : undefined;
+                return {
+                    description: definition.description,
+                    key: shortKey,
+                    type: StepType.Selection,
+                    options: [
+                        { label: 'Yes', value: 'true' },
+                        { label: 'No', value: 'false' },
+                    ],
+                    defaultIndex: currentBool !== undefined ? (currentBool ? 0 : 1) : 0,
+                    validate: getValidator(definition),
+                };
+            }
+        }
+    });
 }
 export function createConfigDefinition(onFinished, onAborted) {
     return {
@@ -48,6 +153,21 @@ export function createConfigDefinition(onFinished, onAborted) {
         },
     };
 }
+/**
+ * Create config definition with specific keys
+ */
+export function createConfigDefinitionWithKeys(keys, onFinished, onAborted) {
+    return {
+        id: randomUUID(),
+        name: ComponentName.Config,
+        state: { done: false },
+        props: {
+            steps: createConfigStepsFromSchema(keys),
+            onFinished,
+            onAborted,
+        },
+    };
+}
 export function createCommandDefinition(command, service, onError, onComplete, onAborted) {
     return {
         id: randomUUID(),

package/dist/services/configuration.js

@@ -166,3 +166,83 @@ export function getConfigurationRequiredMessage(forFutureUse = false) {
     ];
     return messages[Math.floor(Math.random() * messages.length)];
 }
+/**
+ * Core configuration schema - defines structure and types for built-in settings
+ */
+const coreConfigSchema = {
+    'anthropic.key': {
+        type: 'regexp',
+        required: true,
+        pattern: /^sk-ant-api03-[A-Za-z0-9_-]{95}$/,
+        description: 'Anthropic API key',
+    },
+    'anthropic.model': {
+        type: 'enum',
+        required: true,
+        values: SUPPORTED_MODELS,
+        default: AnthropicModel.Haiku,
+        description: 'Anthropic model',
+    },
+    'settings.debug': {
+        type: 'boolean',
+        required: false,
+        description: 'Debug mode',
+    },
+};
+/**
+ * Get complete configuration schema
+ * Currently returns core schema only
+ * Future: will merge with skill-declared schemas
+ */
+export function getConfigSchema() {
+    return {
+        ...coreConfigSchema,
+        // Future: ...loadSkillSchemas()
+    };
+}
+/**
+ * Get available config structure for CONFIG tool
+ * Returns keys with descriptions only (no values for privacy)
+ */
+export function getAvailableConfigStructure() {
+    const schema = getConfigSchema();
+    const structure = {};
+    // Add core schema keys with descriptions
+    for (const [key, definition] of Object.entries(schema)) {
+        structure[key] = definition.description;
+    }
+    // Add discovered keys from config file (if it exists)
+    try {
+        const configFile = getConfigFile();
+        if (!existsSync(configFile)) {
+            return structure;
+        }
+        const content = readFileSync(configFile, 'utf-8');
+        const parsed = YAML.parse(content);
+        // Flatten nested config to dot notation
+        function flattenConfig(obj, prefix = '') {
+            const result = {};
+            for (const [key, value] of Object.entries(obj)) {
+                const fullKey = prefix ? `${prefix}.${key}` : key;
+                if (value && typeof value === 'object' && !Array.isArray(value)) {
+                    Object.assign(result, flattenConfig(value, fullKey));
+                }
+                else {
+                    result[fullKey] = value;
+                }
+            }
+            return result;
+        }
+        const flatConfig = flattenConfig(parsed);
+        // Add discovered keys that aren't in schema
+        for (const key of Object.keys(flatConfig)) {
+            if (!structure[key]) {
+                structure[key] = `${key} (discovered)`;
+            }
+        }
+    }
+    catch {
+        // Config file doesn't exist or can't be read, only use schema
+    }
+    return structure;
+}

package/dist/services/keyboard.js

@@ -0,0 +1,86 @@
+import { useInput as useInkInput } from 'ink';
+const globalShortcuts = new Map();
+/**
+ * Converts a Key object to a normalized pattern string
+ * Example: { shift: true, tab: true } → "shift+tab"
+ */
+function keyToPattern(key) {
+    const modifiers = [];
+    if (key.ctrl)
+        modifiers.push('ctrl');
+    if (key.meta)
+        modifiers.push('meta');
+    if (key.shift)
+        modifiers.push('shift');
+    // Get the key name
+    let keyName = '';
+    if (key.escape)
+        keyName = 'escape';
+    else if (key.tab)
+        keyName = 'tab';
+    else if (key.return)
+        keyName = 'return';
+    else if (key.upArrow)
+        keyName = 'up';
+    else if (key.downArrow)
+        keyName = 'down';
+    else if (key.leftArrow)
+        keyName = 'left';
+    else if (key.rightArrow)
+        keyName = 'right';
+    else if (key.backspace)
+        keyName = 'backspace';
+    else if (key.delete)
+        keyName = 'delete';
+    if (!keyName)
+        return null;
+    return [...modifiers, keyName].join('+');
+}
+/**
+ * Register a global keyboard shortcut
+ * @param pattern Pattern string like "shift+tab" or "ctrl+c"
+ * @param handler Function to call when shortcut is triggered
+ */
+export function registerGlobalShortcut(pattern, handler) {
+    globalShortcuts.set(pattern.toLowerCase(), handler);
+}
+/**
+ * Check if a key event matches a global shortcut
+ * If matched, calls the handler and returns true
+ * If not matched, returns false
+ * @param key The key object from ink's useInput
+ * @returns true if global shortcut was handled, false otherwise
+ */
+export function isGlobalShortcut(key) {
+    const pattern = keyToPattern(key);
+    if (!pattern)
+        return false;
+    const handler = globalShortcuts.get(pattern.toLowerCase());
+    if (handler) {
+        handler();
+        return true;
+    }
+    return false;
+}
+/**
+ * Clear all registered global shortcuts (useful for testing)
+ */
+export function clearGlobalShortcuts() {
+    globalShortcuts.clear();
+}
+/**
+ * Custom useInput hook that automatically handles global shortcuts
+ * before passing events to the component handler
+ * @param handler Component's keyboard event handler
+ * @param options Options for useInput (isActive, etc.)
+ */
+export function useInput(handler, options) {
+    useInkInput((input, key) => {
+        // Check for global shortcuts first
+        if (isGlobalShortcut(key)) {
+            return; // Global shortcut handled, don't propagate to component
+        }
+        // No global shortcut matched, call component handler
+        handler(input, key);
+    }, options);
+}

package/dist/services/messages.js

@@ -1,3 +1,4 @@
+import { loadDebugSetting } from './configuration.js';
 /**
  * Returns a natural language confirmation message for plan execution.
  * Randomly selects from variations to sound less robotic.
@@ -48,3 +49,32 @@ export const FeedbackMessages = {
     ConfigurationComplete: 'Configuration complete.',
     UnexpectedError: 'Unexpected error occurred:',
 };
+/**
+ * Extracts a user-friendly error message from API errors.
+ * In debug mode, returns the full error; otherwise, returns just the message.
+ *
+ * Handles Anthropic API error format:
+ * 400 {"type":"error","error":{"type":"...","message":"..."},"request_id":"..."}
+ */
+export function formatErrorMessage(error) {
+    const rawMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+    if (loadDebugSetting()) {
+        return rawMessage;
+    }
+    // Try to extract message from Anthropic API error format
+    // Format: "400 {json...}" or just "{json...}"
+    const jsonMatch = rawMessage.match(/\{.*\}/s);
+    if (jsonMatch) {
+        try {
+            const parsed = JSON.parse(jsonMatch[0]);
+            const message = parsed.error?.message ?? parsed.message;
+            if (message) {
+                return message;
+            }
+        }
+        catch {
+            // JSON parsing failed, return original message
+        }
+    }
+    return rawMessage;
+}

package/dist/services/tool-registry.js

@@ -34,6 +34,7 @@ class ToolRegistry {
 export const toolRegistry = new ToolRegistry();
 // Register built-in tools
 import { answerTool } from '../tools/answer.tool.js';
+import { configTool } from '../tools/config.tool.js';
 import { introspectTool } from '../tools/introspect.tool.js';
 import { planTool } from '../tools/plan.tool.js';
 toolRegistry.register('plan', {
@@ -48,3 +49,7 @@ toolRegistry.register('answer', {
     schema: answerTool,
     instructionsPath: 'config/ANSWER.md',
 });
+toolRegistry.register('config', {
+    schema: configTool,
+    instructionsPath: 'config/CONFIG.md',
+});

package/dist/tools/config.tool.js

@@ -0,0 +1,43 @@
+export const configTool = {
+    name: 'config',
+    description: 'Determine which configuration settings to show based on user query. Receives available config keys with descriptions and returns which keys the user wants to configure.',
+    input_schema: {
+        type: 'object',
+        properties: {
+            message: {
+                type: 'string',
+                description: 'Brief message to display before config plan. Single sentence, maximum 64 characters. End with period.',
+            },
+            tasks: {
+                type: 'array',
+                description: 'Array of config settings to configure. Each task has type "config" and params with the config key.',
+                items: {
+                    type: 'object',
+                    properties: {
+                        action: {
+                            type: 'string',
+                            description: 'Description of the config setting (from the provided descriptions). Maximum 64 characters.',
+                        },
+                        type: {
+                            type: 'string',
+                            description: 'Always "config" for configuration tasks.',
+                        },
+                        params: {
+                            type: 'object',
+                            description: 'Parameters for the config task.',
+                            properties: {
+                                key: {
+                                    type: 'string',
+                                    description: 'The config key to configure (e.g., "anthropic.key", "settings.debug").',
+                                },
+                            },
+                            required: ['key'],
+                        },
+                    },
+                    required: ['action', 'type', 'params'],
+                },
+            },
+        },
+        required: ['message', 'tasks'],
+    },
+};

package/dist/ui/Answer.js

@@ -1,9 +1,11 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
-import { Box, Text, useInput } from 'ink';
-import { getTextColor } from '../services/colors.js';
+import { Box, Text } from 'ink';
+import { Colors, getTextColor } from '../services/colors.js';
+import { useInput } from '../services/keyboard.js';
+import { formatErrorMessage } from '../services/messages.js';
 import { Spinner } from './Spinner.js';
-const MIN_PROCESSING_TIME = 1000;
+const MINIMUM_PROCESSING_TIME = 400;
 export function Answer({ question, state, service, onError, onComplete, onAborted, }) {
     const done = state?.done ?? false;
     const isCurrent = done === false;
@@ -33,7 +35,7 @@ export function Answer({ question, state, service, onError, onComplete, onAborte
                 // Call answer tool
                 const result = await svc.processWithTool(question, 'answer');
                 const elapsed = Date.now() - startTime;
-                const remainingTime = Math.max(0, MIN_PROCESSING_TIME - elapsed);
+                const remainingTime = Math.max(0, MINIMUM_PROCESSING_TIME - elapsed);
                 await new Promise((resolve) => setTimeout(resolve, remainingTime));
                 if (mounted) {
                     // Extract answer from result
@@ -44,10 +46,10 @@ export function Answer({ question, state, service, onError, onComplete, onAborte
             }
             catch (err) {
                 const elapsed = Date.now() - startTime;
-                const remainingTime = Math.max(0, MIN_PROCESSING_TIME - elapsed);
+                const remainingTime = Math.max(0, MINIMUM_PROCESSING_TIME - elapsed);
                 await new Promise((resolve) => setTimeout(resolve, remainingTime));
                 if (mounted) {
-                    const errorMessage = err instanceof Error ? err.message : 'Unknown error occurred';
+                    const errorMessage = formatErrorMessage(err);
                     setIsLoading(false);
                     if (onError) {
                         onError(errorMessage);
@@ -67,5 +69,5 @@ export function Answer({ question, state, service, onError, onComplete, onAborte
     if (done || (!isLoading && !error)) {
         return null;
     }
-    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isLoading && (_jsxs(Box, { children: [_jsx(Text, { color: getTextColor(isCurrent), children: "Finding answer. " }), _jsx(Spinner, {})] })), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "red", children: ["Error: ", error] }) }))] }));
+    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [isLoading && (_jsxs(Box, { children: [_jsx(Text, { color: getTextColor(isCurrent), children: "Finding answer. " }), _jsx(Spinner, {})] })), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) }))] }));
 }

package/dist/ui/Command.js

@@ -1,7 +1,10 @@
 import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
 import { useEffect, useState } from 'react';
-import { Box, Text, useInput } from 'ink';
-import { getTextColor } from '../services/colors.js';
+import { Box, Text } from 'ink';
+import { TaskType } from '../types/types.js';
+import { Colors } from '../services/colors.js';
+import { useInput } from '../services/keyboard.js';
+import { formatErrorMessage } from '../services/messages.js';
 import { Spinner } from './Spinner.js';
 const MIN_PROCESSING_TIME = 1000; // purely for visual effect
 export function Command({ command, state, service, children, onError, onComplete, onAborted, }) {
@@ -29,7 +32,16 @@ export function Command({ command, state, service, children, onError, onComplete
         async function process(svc) {
             const startTime = Date.now();
             try {
-                const result = await svc.processWithTool(command, 'plan');
+                let result = await svc.processWithTool(command, 'plan');
+                // If all tasks are config type, delegate to CONFIG tool
+                const allConfig = result.tasks.length > 0 &&
+                    result.tasks.every((task) => task.type === TaskType.Config);
+                if (allConfig) {
+                    // Extract query from first config task params, default to 'app'
+                    const query = result.tasks[0].params?.query || 'app';
+                    // Call CONFIG tool to get specific config keys
+                    result = await svc.processWithTool(query, 'config');
+                }
                 const elapsed = Date.now() - startTime;
                 const remainingTime = Math.max(0, MIN_PROCESSING_TIME - elapsed);
                 await new Promise((resolve) => setTimeout(resolve, remainingTime));
@@ -43,7 +55,7 @@ export function Command({ command, state, service, children, onError, onComplete
                 const remainingTime = Math.max(0, MIN_PROCESSING_TIME - elapsed);
                 await new Promise((resolve) => setTimeout(resolve, remainingTime));
                 if (mounted) {
-                    const errorMessage = err instanceof Error ? err.message : 'Unknown error occurred';
+                    const errorMessage = formatErrorMessage(err);
                     setIsLoading(false);
                     if (onError) {
                         onError(errorMessage);
@@ -60,5 +72,5 @@ export function Command({ command, state, service, children, onError, onComplete
         };
     }, [command, done, service]);
     const isCurrent = done === false;
-    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [_jsxs(Box, { children: [_jsxs(Text, { color: getTextColor(isCurrent), 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] }) })), children] }));
+    return (_jsxs(Box, { alignSelf: "flex-start", flexDirection: "column", children: [_jsxs(Box, { paddingX: done ? 1 : 0, marginX: done ? -1 : 0, backgroundColor: done ? Colors.Background.UserQuery : undefined, children: [_jsxs(Text, { color: isCurrent ? Colors.Text.Active : Colors.Text.UserQuery, children: ["> pls ", command] }), isLoading && (_jsxs(_Fragment, { children: [_jsx(Text, { children: " " }), _jsx(Spinner, {})] }))] }), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: Colors.Status.Error, children: ["Error: ", error] }) })), children] }));
 }

package/dist/ui/Component.js

@@ -49,7 +49,7 @@ export const Component = React.memo(function Component({ def, debug, }) {
         case ComponentName.Introspect: {
             const props = def.props;
             const state = def.state;
-            return _jsx(Introspect, { ...props, state: state });
+            return _jsx(Introspect, { ...props, state: state, debug: debug });
         }
         case ComponentName.Report:
             return _jsx(Report, { ...def.props });

package/dist/ui/Config.js

@@ -1,8 +1,9 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React from 'react';
-import { Box, Text, useFocus, useInput } from 'ink';
+import { Box, Text, useFocus } from 'ink';
 import TextInput from 'ink-text-input';
 import { Colors } from '../services/colors.js';
+import { useInput } from '../services/keyboard.js';
 export var StepType;
 (function (StepType) {
     StepType["Text"] = "text";
@@ -20,11 +21,13 @@ function TextStep({ value, placeholder, validate, onChange, onSubmit, }) {
         }
     };
     const handleSubmit = (value) => {
-        if (!validate(value)) {
+        // Use placeholder if input is empty
+        const finalValue = value || placeholder || '';
+        if (!validate(finalValue)) {
             setValidationFailed(true);
             return;
         }
-        onSubmit(value);
+        onSubmit(finalValue);
     };
     // Handle input manually when validation fails
     useInput((input, key) => {

package/dist/ui/Confirm.js

@@ -1,7 +1,8 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React from 'react';
-import { Box, Text, useInput } from 'ink';
+import { Box, Text } from 'ink';
 import { Colors } from '../services/colors.js';
+import { useInput } from '../services/keyboard.js';
 export function Confirm({ message, state, onConfirmed, onCancelled, }) {
     const done = state?.done ?? false;
     const isCurrent = done === false;
@@ -29,15 +30,15 @@ export function Confirm({ message, state, onConfirmed, onCancelled, }) {
         }
     }, { isActive: !done });
     const options = [
-        { label: 'Yes', value: 'yes', color: Colors.Action.Execute },
-        { label: 'No', value: 'no', color: Colors.Action.Discard },
+        { label: 'yes', value: 'yes', color: Colors.Action.Execute },
+        { label: 'no', value: 'no', color: Colors.Status.Error },
     ];
     if (done) {
         // When done, show both the message and user's choice in timeline
-        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: undefined, children: message }) }), _jsx(Box, { children: _jsxs(Text, { color: Colors.Text.Inactive, children: ["> ", options[selectedIndex].label] }) })] }));
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: undefined, children: message }) }), _jsx(Box, { paddingX: 1, marginX: -1, alignSelf: "flex-start", backgroundColor: Colors.Background.UserQuery, children: _jsxs(Text, { color: Colors.Text.UserQuery, children: ["> ", options[selectedIndex].label] }) })] }));
     }
     return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: isCurrent ? Colors.Text.Active : Colors.Text.Inactive, children: message }) }), _jsxs(Box, { children: [_jsx(Text, { color: Colors.Action.Select, children: ">" }), _jsx(Text, { children: " " }), _jsx(Box, { children: options.map((option, index) => {
                             const isSelected = index === selectedIndex;
-                            return (_jsx(Box, { marginRight: 2, children: _jsx(Text, { color: isSelected ? option.color : undefined, dimColor: !isSelected, bold: isSelected, children: option.label }) }, option.value));
+                            return (_jsx(Box, { marginRight: 2, children: _jsx(Text, { color: isSelected ? option.color : undefined, dimColor: !isSelected, children: option.label }) }, option.value));
                         }) })] })] }));
 }