prompt-language-shell 0.8.4 → 0.8.6

package/dist/configuration/io.js

@@ -0,0 +1,85 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import YAML from 'yaml';
+import { ConfigError, DebugLevel } from './types.js';
+import { defaultFileSystem } from '../services/filesystem.js';
+import { isValidAnthropicApiKey, validateConfig } from './validation.js';
+const RUNTIME_CONFIGURATION_FILE = '.plsrc';
+function getConfigFile() {
+    return join(homedir(), RUNTIME_CONFIGURATION_FILE);
+}
+function parseYamlConfig(content) {
+    try {
+        return YAML.parse(content);
+    }
+    catch (error) {
+        throw new ConfigError('Failed to parse configuration file', error instanceof Error ? error : undefined);
+    }
+}
+export function getConfigPath() {
+    return getConfigFile();
+}
+export function configExists(fs = defaultFileSystem) {
+    return fs.exists(getConfigFile());
+}
+export function loadConfig(fs = defaultFileSystem) {
+    const configFile = getConfigFile();
+    if (!fs.exists(configFile)) {
+        throw new ConfigError('Configuration not found');
+    }
+    const content = fs.readFile(configFile, 'utf-8');
+    const parsed = parseYamlConfig(content);
+    return validateConfig(parsed);
+}
+export function hasValidAnthropicKey() {
+    try {
+        const config = loadConfig();
+        return (!!config.anthropic.key && isValidAnthropicApiKey(config.anthropic.key));
+    }
+    catch {
+        return false;
+    }
+}
+export function mergeConfig(existingContent, sectionName, newValues) {
+    const parsed = existingContent.trim()
+        ? YAML.parse(existingContent)
+        : {};
+    // Update or add section
+    const section = parsed[sectionName] ?? {};
+    for (const [key, value] of Object.entries(newValues)) {
+        section[key] = value;
+    }
+    parsed[sectionName] = section;
+    // Sort sections alphabetically
+    const sortedKeys = Object.keys(parsed).sort();
+    const sortedConfig = {};
+    for (const key of sortedKeys) {
+        sortedConfig[key] = parsed[key];
+    }
+    // Convert back to YAML
+    return YAML.stringify(sortedConfig);
+}
+export function saveConfig(section, config, fs = defaultFileSystem) {
+    const configFile = getConfigFile();
+    const existingContent = fs.exists(configFile)
+        ? fs.readFile(configFile, 'utf-8')
+        : '';
+    const newContent = mergeConfig(existingContent, section, config);
+    fs.writeFile(configFile, newContent);
+}
+export function saveAnthropicConfig(config, fs = defaultFileSystem) {
+    saveConfig('anthropic', config, fs);
+    return loadConfig(fs);
+}
+export function saveDebugSetting(debug, fs = defaultFileSystem) {
+    saveConfig('settings', { debug }, fs);
+}
+export function loadDebugSetting(fs = defaultFileSystem) {
+    try {
+        const config = loadConfig(fs);
+        return config.settings?.debug ?? DebugLevel.None;
+    }
+    catch {
+        return DebugLevel.None;
+    }
+}

package/dist/configuration/messages.js

@@ -0,0 +1,30 @@
+/**
+ * Returns a message requesting initial setup.
+ * Provides natural language variations that sound like a professional concierge
+ * preparing to serve, avoiding technical jargon.
+ *
+ * @param forFutureUse - If true, indicates setup is for future requests rather than
+ *                       an immediate task
+ */
+export function getConfigurationRequiredMessage(forFutureUse = false) {
+    if (forFutureUse) {
+        const messages = [
+            "Before I can assist with your requests, let's get a few things ready.",
+            'Let me set up a few things so I can help you in the future.',
+            "I'll need to prepare a few things before I can assist you.",
+            "Let's get everything ready so I can help with your tasks.",
+            "I need to set up a few things first, then I'll be ready to assist.",
+            'Let me prepare everything so I can help you going forward.',
+        ];
+        return messages[Math.floor(Math.random() * messages.length)];
+    }
+    const messages = [
+        'Before I can help, let me get a few things ready.',
+        'I need to set up a few things first.',
+        'Let me prepare everything before we begin.',
+        'Just a moment while I get ready to assist you.',
+        "I'll need to get set up before I can help with that.",
+        'Let me get everything ready for you.',
+    ];
+    return messages[Math.floor(Math.random() * messages.length)];
+}

package/dist/configuration/schema.js

@@ -0,0 +1,167 @@
+import YAML from 'yaml';
+import { AnthropicModel, ConfigDefinitionType, DebugLevel, SUPPORTED_DEBUG_LEVELS, SUPPORTED_MODELS, } from './types.js';
+import { flattenConfig } from '../services/config-utils.js';
+import { getConfigLabel } from '../services/config-labels.js';
+import { defaultFileSystem } from '../services/filesystem.js';
+import { getConfigPath, loadConfig } from './io.js';
+/**
+ * Convert a dotted config key to a readable label
+ * Example: "project.alpha.repo" -> "Project Alpha Repo"
+ */
+export function keyToLabel(key) {
+    return key
+        .split('.')
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(' ');
+}
+/**
+ * Core configuration schema - defines structure and types for system settings
+ */
+const coreConfigSchema = {
+    'anthropic.key': {
+        type: ConfigDefinitionType.RegExp,
+        required: true,
+        pattern: /^sk-ant-api03-[A-Za-z0-9_-]{95}$/,
+        description: 'Anthropic API key',
+    },
+    'anthropic.model': {
+        type: ConfigDefinitionType.Enum,
+        required: true,
+        values: SUPPORTED_MODELS,
+        default: AnthropicModel.Haiku,
+        description: 'Anthropic model',
+    },
+    'settings.debug': {
+        type: ConfigDefinitionType.Enum,
+        required: false,
+        values: SUPPORTED_DEBUG_LEVELS,
+        default: DebugLevel.None,
+        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 missing required configuration keys
+ * Returns array of keys that are required but not present or invalid in config
+ */
+export function getMissingConfigKeys() {
+    const schema = getConfigSchema();
+    const missing = [];
+    let currentConfig = null;
+    try {
+        currentConfig = loadConfig();
+    }
+    catch {
+        // Config doesn't exist
+    }
+    for (const [key, definition] of Object.entries(schema)) {
+        if (!definition.required) {
+            continue;
+        }
+        // Get current value for this key
+        const parts = key.split('.');
+        let value = currentConfig;
+        for (const part of parts) {
+            if (value && typeof value === 'object' && part in value) {
+                value = value[part];
+            }
+            else {
+                value = undefined;
+                break;
+            }
+        }
+        // Check if value is missing or invalid
+        if (value === undefined || value === null) {
+            missing.push(key);
+            continue;
+        }
+        // Validate based on type
+        let isValid = false;
+        switch (definition.type) {
+            case ConfigDefinitionType.RegExp:
+                isValid = typeof value === 'string' && definition.pattern.test(value);
+                break;
+            case ConfigDefinitionType.String:
+                isValid = typeof value === 'string';
+                break;
+            case ConfigDefinitionType.Enum:
+                isValid =
+                    typeof value === 'string' && definition.values.includes(value);
+                break;
+            case ConfigDefinitionType.Number:
+                isValid = typeof value === 'number';
+                break;
+            case ConfigDefinitionType.Boolean:
+                isValid = typeof value === 'boolean';
+                break;
+        }
+        if (!isValid) {
+            missing.push(key);
+        }
+    }
+    return missing;
+}
+/**
+ * Get list of configured keys from config file
+ * Returns array of dot-notation keys that exist in the config file
+ */
+export function getConfiguredKeys(fs = defaultFileSystem) {
+    try {
+        const configFile = getConfigPath();
+        if (!fs.exists(configFile)) {
+            return [];
+        }
+        const content = fs.readFile(configFile, 'utf-8');
+        const parsed = YAML.parse(content);
+        // Flatten nested config to dot notation
+        const flatConfig = flattenConfig(parsed);
+        return Object.keys(flatConfig);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Get available config structure for CONFIG tool
+ * Returns keys with descriptions only (no values for privacy)
+ * Marks optional keys as "(optional)"
+ */
+export function getAvailableConfigStructure(fs = defaultFileSystem) {
+    const schema = getConfigSchema();
+    const structure = {};
+    // Try to load existing config to see which keys are already set
+    let flatConfig = {};
+    try {
+        const configFile = getConfigPath();
+        if (fs.exists(configFile)) {
+            const content = fs.readFile(configFile, 'utf-8');
+            const parsed = YAML.parse(content);
+            // Flatten nested config to dot notation
+            flatConfig = flattenConfig(parsed);
+        }
+    }
+    catch {
+        // Config file doesn't exist or can't be read
+    }
+    // Add schema keys with descriptions
+    for (const [key, definition] of Object.entries(schema)) {
+        structure[key] = definition.description;
+    }
+    // Add discovered keys that aren't in schema
+    for (const key of Object.keys(flatConfig)) {
+        if (!(key in structure)) {
+            structure[key] = getConfigLabel(key) || keyToLabel(key);
+        }
+    }
+    return structure;
+}

package/dist/configuration/transformation.js

@@ -0,0 +1,55 @@
+import { ConfigDefinitionType } from './types.js';
+import { getConfigSchema } from './schema.js';
+/**
+ * Convert string value to appropriate type based on schema definition
+ */
+export function parseConfigValue(key, stringValue, schema) {
+    // If we have a schema definition, use its type
+    if (key in schema) {
+        const definition = schema[key];
+        switch (definition.type) {
+            case ConfigDefinitionType.Boolean:
+                return stringValue === 'true';
+            case ConfigDefinitionType.Number:
+                return Number(stringValue);
+            case ConfigDefinitionType.String:
+            case ConfigDefinitionType.RegExp:
+            case ConfigDefinitionType.Enum:
+                return stringValue;
+        }
+    }
+    // No schema definition - try to infer type from string value
+    // This handles skill-defined configs that may not be in schema yet
+    if (stringValue === 'true' || stringValue === 'false') {
+        return stringValue === 'true';
+    }
+    if (!isNaN(Number(stringValue)) && stringValue.trim() !== '') {
+        return Number(stringValue);
+    }
+    return stringValue;
+}
+/**
+ * Unflatten dotted keys into nested structure
+ * Example: { "product.alpha.path": "value" } -> { product: { alpha: { path: "value" } } }
+ * Converts string values to appropriate types based on config schema
+ */
+export function unflattenConfig(dotted) {
+    const result = {};
+    const schema = getConfigSchema();
+    for (const [dottedKey, stringValue] of Object.entries(dotted)) {
+        const parts = dottedKey.split('.');
+        const section = parts[0];
+        // Initialize section if needed
+        result[section] = result[section] ?? {};
+        // Build nested structure for this section
+        let current = result[section];
+        for (let i = 1; i < parts.length - 1; i++) {
+            current[parts[i]] = current[parts[i]] ?? {};
+            current = current[parts[i]];
+        }
+        // Convert string value to appropriate type and set
+        const typedValue = parseConfigValue(dottedKey, stringValue, schema);
+        current[parts[parts.length - 1]] = typedValue;
+    }
+    return result;
+}

package/dist/configuration/types.js

@@ -0,0 +1,30 @@
+export var AnthropicModel;
+(function (AnthropicModel) {
+    AnthropicModel["Sonnet"] = "claude-sonnet-4-5";
+    AnthropicModel["Haiku"] = "claude-haiku-4-5";
+    AnthropicModel["Opus"] = "claude-opus-4-1";
+})(AnthropicModel || (AnthropicModel = {}));
+export const SUPPORTED_MODELS = Object.values(AnthropicModel);
+export var DebugLevel;
+(function (DebugLevel) {
+    DebugLevel["None"] = "none";
+    DebugLevel["Info"] = "info";
+    DebugLevel["Verbose"] = "verbose";
+})(DebugLevel || (DebugLevel = {}));
+export const SUPPORTED_DEBUG_LEVELS = Object.values(DebugLevel);
+export var ConfigDefinitionType;
+(function (ConfigDefinitionType) {
+    ConfigDefinitionType["RegExp"] = "regexp";
+    ConfigDefinitionType["String"] = "string";
+    ConfigDefinitionType["Enum"] = "enum";
+    ConfigDefinitionType["Number"] = "number";
+    ConfigDefinitionType["Boolean"] = "boolean";
+})(ConfigDefinitionType || (ConfigDefinitionType = {}));
+export class ConfigError extends Error {
+    origin;
+    constructor(message, origin) {
+        super(message);
+        this.name = 'ConfigError';
+        this.origin = origin;
+    }
+}

package/dist/configuration/validation.js

@@ -0,0 +1,52 @@
+import { ConfigError, DebugLevel, SUPPORTED_DEBUG_LEVELS, SUPPORTED_MODELS, } from './types.js';
+export function validateConfig(parsed) {
+    if (!parsed || typeof parsed !== 'object') {
+        throw new ConfigError('Invalid configuration format');
+    }
+    const config = parsed;
+    // Validate anthropic section
+    if (!config.anthropic || typeof config.anthropic !== 'object') {
+        throw new ConfigError('Missing or invalid anthropic configuration');
+    }
+    const { key, model } = config.anthropic;
+    if (!key || typeof key !== 'string') {
+        throw new ConfigError('Missing or invalid API key');
+    }
+    const validatedConfig = {
+        anthropic: {
+            key,
+        },
+    };
+    // Optional model - only set if valid
+    if (model && typeof model === 'string' && isValidAnthropicModel(model)) {
+        validatedConfig.anthropic.model = model;
+    }
+    // Optional settings section
+    if (config.settings && typeof config.settings === 'object') {
+        const settings = config.settings;
+        validatedConfig.settings = {};
+        if ('debug' in settings) {
+            // Handle migration from boolean to enum
+            if (typeof settings.debug === 'boolean') {
+                validatedConfig.settings.debug = settings.debug
+                    ? DebugLevel.Info
+                    : DebugLevel.None;
+            }
+            else if (typeof settings.debug === 'string' &&
+                SUPPORTED_DEBUG_LEVELS.includes(settings.debug)) {
+                validatedConfig.settings.debug = settings.debug;
+            }
+        }
+    }
+    return validatedConfig;
+}
+export function isValidAnthropicApiKey(key) {
+    // Anthropic API keys format: sk-ant-api03-XXXXX (108 chars total)
+    // - Prefix: sk-ant-api03- (13 chars)
+    // - Key body: 95 characters (uppercase, lowercase, digits, hyphens, underscores)
+    const apiKeyPattern = /^sk-ant-api03-[A-Za-z0-9_-]{95}$/;
+    return apiKeyPattern.test(key);
+}
+export function isValidAnthropicModel(model) {
+    return SUPPORTED_MODELS.includes(model);
+}

package/dist/execution/handlers.js

@@ -0,0 +1,135 @@
+import { ExecutionStatus } from '../services/shell.js';
+import { formatDuration } from '../services/utils.js';
+import { ExecuteActionType, } from './types.js';
+/**
+ * Handles task completion logic and returns the appropriate action and state.
+ */
+export function handleTaskCompletion(index, elapsed, context) {
+    const { taskInfos, message, summary, taskExecutionTimes } = context;
+    const updatedTimes = [...taskExecutionTimes, elapsed];
+    const updatedTaskInfos = taskInfos.map((task, i) => i === index ? { ...task, status: ExecutionStatus.Success, elapsed } : task);
+    if (index < taskInfos.length - 1) {
+        // More tasks to execute
+        return {
+            action: {
+                type: ExecuteActionType.TaskComplete,
+                payload: { index, elapsed },
+            },
+            finalState: {
+                message,
+                summary,
+                taskInfos: updatedTaskInfos,
+                completed: index + 1,
+                taskExecutionTimes: updatedTimes,
+                completionMessage: null,
+                error: null,
+            },
+            shouldComplete: false,
+        };
+    }
+    // All tasks complete
+    const summaryText = summary.trim() || 'Execution completed';
+    const totalElapsed = updatedTimes.reduce((sum, time) => sum + time, 0);
+    const completion = `${summaryText} in ${formatDuration(totalElapsed)}.`;
+    return {
+        action: {
+            type: ExecuteActionType.AllTasksComplete,
+            payload: { index, elapsed, summaryText },
+        },
+        finalState: {
+            message,
+            summary,
+            taskInfos: updatedTaskInfos,
+            completed: index + 1,
+            taskExecutionTimes: updatedTimes,
+            completionMessage: completion,
+            error: null,
+        },
+        shouldComplete: true,
+    };
+}
+/**
+ * Handles task error logic and returns the appropriate action and state.
+ */
+export function handleTaskFailure(index, error, elapsed, context) {
+    const { taskInfos, message, summary, taskExecutionTimes } = context;
+    const task = taskInfos[index];
+    const isCritical = task.command.critical !== false; // Default to true
+    const updatedTaskInfos = taskInfos.map((task, i) => i === index ? { ...task, status: ExecutionStatus.Failed, elapsed } : task);
+    if (isCritical) {
+        // Critical failure - stop execution
+        return {
+            action: {
+                type: ExecuteActionType.TaskErrorCritical,
+                payload: { index, error },
+            },
+            finalState: {
+                message,
+                summary,
+                taskInfos: updatedTaskInfos,
+                completed: index + 1,
+                taskExecutionTimes,
+                completionMessage: null,
+                error,
+            },
+            shouldComplete: true,
+            shouldReportError: true,
+        };
+    }
+    // Non-critical failure - continue to next task
+    const updatedTimes = [...taskExecutionTimes, elapsed];
+    if (index < taskInfos.length - 1) {
+        return {
+            action: {
+                type: ExecuteActionType.TaskErrorContinue,
+                payload: { index, elapsed },
+            },
+            finalState: {
+                message,
+                summary,
+                taskInfos: updatedTaskInfos,
+                completed: index + 1,
+                taskExecutionTimes: updatedTimes,
+                completionMessage: null,
+                error: null,
+            },
+            shouldComplete: false,
+            shouldReportError: false,
+        };
+    }
+    // Last task, complete execution
+    const summaryText = summary.trim() || 'Execution completed';
+    const totalElapsed = updatedTimes.reduce((sum, time) => sum + time, 0);
+    const completion = `${summaryText} in ${formatDuration(totalElapsed)}.`;
+    return {
+        action: {
+            type: ExecuteActionType.LastTaskError,
+            payload: { index, elapsed, summaryText },
+        },
+        finalState: {
+            message,
+            summary,
+            taskInfos: updatedTaskInfos,
+            completed: index + 1,
+            taskExecutionTimes: updatedTimes,
+            completionMessage: completion,
+            error: null,
+        },
+        shouldComplete: true,
+        shouldReportError: false,
+    };
+}
+/**
+ * Builds final state for task abortion.
+ */
+export function buildAbortedState(taskInfos, message, summary, completed, taskExecutionTimes) {
+    return {
+        message,
+        summary,
+        taskInfos,
+        completed,
+        taskExecutionTimes,
+        completionMessage: null,
+        error: null,
+    };
+}

package/dist/execution/processing.js

@@ -0,0 +1,35 @@
+import { loadUserConfig } from '../services/loader.js';
+import { replacePlaceholders } from '../services/resolver.js';
+import { validatePlaceholderResolution } from './validation.js';
+/**
+ * Processes tasks through the AI service to generate executable commands.
+ * Resolves placeholders in task descriptions and validates the results.
+ */
+export async function processTasks(tasks, service) {
+    // Load user config for placeholder resolution
+    const userConfig = loadUserConfig();
+    // Format tasks for the execute tool and resolve placeholders
+    const taskDescriptions = tasks
+        .map((task) => {
+        const resolvedAction = replacePlaceholders(task.action, userConfig);
+        const params = task.params
+            ? ` (params: ${JSON.stringify(task.params)})`
+            : '';
+        return `- ${resolvedAction}${params}`;
+    })
+        .join('\n');
+    // Call execute tool to get commands
+    const result = await service.processWithTool(taskDescriptions, 'execute');
+    // Resolve placeholders in command strings
+    const resolvedCommands = (result.commands || []).map((cmd) => {
+        const resolved = replacePlaceholders(cmd.command, userConfig);
+        validatePlaceholderResolution(resolved);
+        return { ...cmd, command: resolved };
+    });
+    return {
+        message: result.message,
+        summary: result.summary || '',
+        commands: resolvedCommands,
+        debug: result.debug,
+    };
+}