prompt-language-shell 0.4.6 → 0.4.9

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(),
@@ -181,3 +301,20 @@ export function createAnswerDisplayDefinition(answer) {
 export function isStateless(component) {
     return !('state' in component);
 }
+export function createExecuteDefinition(tasks, service, onError, onComplete, onAborted) {
+    return {
+        id: randomUUID(),
+        name: ComponentName.Execute,
+        state: {
+            done: false,
+            isLoading: true,
+        },
+        props: {
+            tasks,
+            service,
+            onError,
+            onComplete,
+            onAborted,
+        },
+    };
+}

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,5 @@
+import { loadDebugSetting } from './configuration.js';
+export { formatDuration } from './utils.js';
 /**
  * Returns a natural language confirmation message for plan execution.
  * Randomly selects from variations to sound less robotic.
@@ -48,3 +50,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/shell.js

@@ -0,0 +1,117 @@
+export var ExecutionStatus;
+(function (ExecutionStatus) {
+    ExecutionStatus["Pending"] = "pending";
+    ExecutionStatus["Running"] = "running";
+    ExecutionStatus["Success"] = "success";
+    ExecutionStatus["Failed"] = "failed";
+})(ExecutionStatus || (ExecutionStatus = {}));
+export var ExecutionResult;
+(function (ExecutionResult) {
+    ExecutionResult["Success"] = "success";
+    ExecutionResult["Error"] = "error";
+    ExecutionResult["Aborted"] = "aborted";
+})(ExecutionResult || (ExecutionResult = {}));
+const DEFAULT_DELAY_GENERATOR = (index) => (Math.pow(3, index + 1) * Math.max(Math.random(), Math.random()) + 1) * 1000;
+/**
+ * Dummy executor that simulates command execution with configurable delays.
+ * Supports mocked responses for testing different scenarios.
+ */
+export class DummyExecutor {
+    mockedResponses = new Map();
+    delayGenerator;
+    constructor(delayGenerator = DEFAULT_DELAY_GENERATOR) {
+        this.delayGenerator = delayGenerator;
+    }
+    /**
+     * Set a mocked response for a specific command
+     */
+    mock(command, response) {
+        this.mockedResponses.set(command, response);
+    }
+    /**
+     * Clear all mocked responses
+     */
+    clearMocks() {
+        this.mockedResponses.clear();
+    }
+    execute(cmd, onProgress, index = 0) {
+        return new Promise((resolve) => {
+            onProgress?.(ExecutionStatus.Running);
+            const delay = this.delayGenerator(index);
+            setTimeout(() => {
+                const mocked = this.mockedResponses.get(cmd.command);
+                const commandResult = {
+                    description: cmd.description,
+                    command: cmd.command,
+                    output: mocked?.output ?? '',
+                    errors: mocked?.errors ?? '',
+                    result: mocked?.result ?? ExecutionResult.Success,
+                    error: mocked?.error,
+                };
+                onProgress?.(commandResult.result === ExecutionResult.Success
+                    ? ExecutionStatus.Success
+                    : ExecutionStatus.Failed);
+                resolve(commandResult);
+            }, delay);
+        });
+    }
+}
+/**
+ * Default executor uses DummyExecutor for development and testing.
+ * To implement real shell execution, create a RealExecutor class that:
+ * - Spawns process with cmd.command in shell mode using child_process.spawn()
+ * - Sets working directory from cmd.workdir
+ * - Handles cmd.timeout for command timeout
+ * - Captures stdout and stderr streams
+ * - Calls onProgress with Running/Success/Failed status
+ * - Returns CommandOutput with actual stdout, stderr, exitCode
+ * - Handles errors (spawn failures, timeouts, non-zero exit codes)
+ */
+const executor = new DummyExecutor();
+/**
+ * Execute a single shell command
+ */
+export function executeCommand(cmd, onProgress, index = 0) {
+    return executor.execute(cmd, onProgress, index);
+}
+/**
+ * Execute multiple commands sequentially
+ */
+export async function executeCommands(commands, onProgress) {
+    const results = [];
+    for (let i = 0; i < commands.length; i++) {
+        const cmd = commands[i];
+        onProgress?.({
+            currentIndex: i,
+            total: commands.length,
+            command: cmd,
+            status: ExecutionStatus.Running,
+        });
+        const output = await executeCommand(cmd, (status) => {
+            onProgress?.({
+                currentIndex: i,
+                total: commands.length,
+                command: cmd,
+                status,
+                output: status !== ExecutionStatus.Running ? results[i] : undefined,
+            });
+        }, i);
+        results.push(output);
+        // Update with final status
+        onProgress?.({
+            currentIndex: i,
+            total: commands.length,
+            command: cmd,
+            status: output.result === ExecutionResult.Success
+                ? ExecutionStatus.Success
+                : ExecutionStatus.Failed,
+            output,
+        });
+        // Stop if critical command failed
+        const isCritical = cmd.critical !== false;
+        if (output.result !== ExecutionResult.Success && isCritical) {
+            break;
+        }
+    }
+    return results;
+}

package/dist/services/tool-registry.js

@@ -34,6 +34,8 @@ 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 { executeTool } from '../tools/execute.tool.js';
 import { introspectTool } from '../tools/introspect.tool.js';
 import { planTool } from '../tools/plan.tool.js';
 toolRegistry.register('plan', {
@@ -48,3 +50,11 @@ toolRegistry.register('answer', {
     schema: answerTool,
     instructionsPath: 'config/ANSWER.md',
 });
+toolRegistry.register('config', {
+    schema: configTool,
+    instructionsPath: 'config/CONFIG.md',
+});
+toolRegistry.register('execute', {
+    schema: executeTool,
+    instructionsPath: 'config/EXECUTE.md',
+});

package/dist/services/utils.js

@@ -0,0 +1,21 @@
+/**
+ * Formats a duration in milliseconds to a human-readable string.
+ * Uses correct singular/plural forms.
+ */
+export function formatDuration(ms) {
+    const totalSeconds = Math.floor(ms / 1000);
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    const parts = [];
+    if (hours > 0) {
+        parts.push(`${String(hours)} ${hours === 1 ? 'hour' : 'hours'}`);
+    }
+    if (minutes > 0) {
+        parts.push(`${String(minutes)} ${minutes === 1 ? 'minute' : 'minutes'}`);
+    }
+    if (seconds > 0 || parts.length === 0) {
+        parts.push(`${String(seconds)} ${seconds === 1 ? 'second' : 'seconds'}`);
+    }
+    return parts.join(' ');
+}

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/tools/execute.tool.js

@@ -0,0 +1,44 @@
+export const executeTool = {
+    name: 'execute',
+    description: 'Execute shell commands from planned tasks. Translates task descriptions into specific shell commands that can be run in the terminal. Called after PLAN has created execute tasks and user has confirmed.',
+    input_schema: {
+        type: 'object',
+        properties: {
+            message: {
+                type: 'string',
+                description: 'Brief status message about the execution. Must be a single sentence, maximum 64 characters, ending with a period.',
+            },
+            commands: {
+                type: 'array',
+                description: 'Array of commands to execute sequentially',
+                items: {
+                    type: 'object',
+                    properties: {
+                        description: {
+                            type: 'string',
+                            description: 'Brief description of what this command does. Maximum 64 characters.',
+                        },
+                        command: {
+                            type: 'string',
+                            description: 'The exact shell command to run. Must be a valid shell command.',
+                        },
+                        workdir: {
+                            type: 'string',
+                            description: 'Optional working directory for the command. Defaults to current directory if not specified.',
+                        },
+                        timeout: {
+                            type: 'number',
+                            description: 'Optional timeout in milliseconds. Defaults to 30000 (30 seconds).',
+                        },
+                        critical: {
+                            type: 'boolean',
+                            description: 'Whether failure should stop execution of subsequent commands. Defaults to true.',
+                        },
+                    },
+                    required: ['description', 'command'],
+                },
+            },
+        },
+        required: ['message', 'commands'],
+    },
+};

package/dist/types/handlers.js

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

package/dist/types/types.js

@@ -12,6 +12,7 @@ export var ComponentName;
     ComponentName["Report"] = "report";
     ComponentName["Answer"] = "answer";
     ComponentName["AnswerDisplay"] = "answerDisplay";
+    ComponentName["Execute"] = "execute";
 })(ComponentName || (ComponentName = {}));
 export var TaskType;
 (function (TaskType) {