prompt-language-shell 0.8.0 → 0.8.4

package/dist/services/anthropic.js

@@ -3,6 +3,7 @@ import { getAvailableConfigStructure, getConfiguredKeys, } from './configuration
 import { logPrompt, logResponse } from './logger.js';
 import { formatSkillsForPrompt, loadSkillsWithValidation } from './skills.js';
 import { toolRegistry } from './registry.js';
+import { CommandResultSchema, IntrospectResultSchema, } from '../types/schemas.js';
 /**
  * Wraps text to ensure no line exceeds the specified width.
  * Breaks at word boundaries to maintain readability.
@@ -45,11 +46,24 @@ export function cleanAnswerText(text) {
     cleaned = wrapText(cleaned, 80);
     return cleaned;
 }
+/**
+ * Formats Zod validation errors into readable error messages.
+ * Provides detailed information about what failed validation.
+ */
+function formatValidationError(error) {
+    const issues = error.issues
+        .map((issue) => {
+        const path = issue.path.length > 0 ? issue.path.join('.') : 'root';
+        return `  - ${path}: ${issue.message}`;
+    })
+        .join('\n');
+    return `LLM response validation failed:\n${issues}`;
+}
 export class AnthropicService {
     client;
     model;
-    constructor(key, model = 'claude-haiku-4-5-20251001') {
-        this.client = new Anthropic({ apiKey: key });
+    constructor(key, model = 'claude-haiku-4-5', timeout = 30000) {
+        this.client = new Anthropic({ apiKey: key, timeout });
         this.model = model;
     }
     async processWithTool(command, toolName, customInstructions) {
@@ -148,62 +162,61 @@ export class AnthropicService {
         const input = content.input;
         // Handle execute tool response
         if (toolName === 'execute') {
-            if (!input.message || typeof input.message !== 'string') {
-                throw new Error('Invalid tool response: missing or invalid message field');
-            }
-            if (!input.commands || !Array.isArray(input.commands)) {
-                throw new Error('Invalid tool response: missing or invalid commands array');
-            }
-            // Validate each command has required fields
-            input.commands.forEach((cmd, i) => {
-                if (!cmd.description || typeof cmd.description !== 'string') {
-                    throw new Error(`Invalid command at index ${String(i)}: missing or invalid 'description' field`);
-                }
-                if (!cmd.command || typeof cmd.command !== 'string') {
-                    throw new Error(`Invalid command at index ${String(i)}: missing or invalid 'command' field`);
-                }
-            });
-            return {
+            const validation = CommandResultSchema.safeParse({
                 message: input.message,
                 summary: input.summary,
                 tasks: [],
                 commands: input.commands,
                 debug,
-            };
+            });
+            if (!validation.success) {
+                throw new Error(`I received an unexpected response while preparing to execute commands:\n${formatValidationError(validation.error)}`);
+            }
+            return validation.data;
         }
         // Handle answer tool response
         if (toolName === 'answer') {
+            // Validate question and answer fields exist
             if (!input.question || typeof input.question !== 'string') {
-                throw new Error('Invalid tool response: missing or invalid question field');
+                throw new Error('I received an unexpected response while answering your question:\nLLM response validation failed:\n  - question: missing or invalid');
             }
             if (!input.answer || typeof input.answer !== 'string') {
-                throw new Error('Invalid tool response: missing or invalid answer field');
+                throw new Error('I received an unexpected response while answering your question:\nLLM response validation failed:\n  - answer: missing or invalid');
             }
-            return {
+            // Validate the result structure with Zod
+            const validation = CommandResultSchema.safeParse({
                 message: '',
                 tasks: [],
                 answer: cleanAnswerText(input.answer),
                 debug,
-            };
-        }
-        // Handle schedule and introspect tool responses
-        if (input.message === undefined || typeof input.message !== 'string') {
-            throw new Error('Invalid tool response: missing or invalid message field');
-        }
-        if (!input.tasks || !Array.isArray(input.tasks)) {
-            throw new Error('Invalid tool response: missing or invalid tasks array');
+            });
+            if (!validation.success) {
+                throw new Error(`I received an unexpected response while answering your question:\n${formatValidationError(validation.error)}`);
+            }
+            return validation.data;
         }
-        // Validate each task has required action field
-        input.tasks.forEach((task, i) => {
-            if (!task.action || typeof task.action !== 'string') {
-                throw new Error(`Invalid task at index ${String(i)}: missing or invalid 'action' field`);
+        // Handle introspect tool response
+        if (toolName === 'introspect') {
+            const validation = IntrospectResultSchema.safeParse({
+                message: input.message,
+                capabilities: input.capabilities,
+                debug,
+            });
+            if (!validation.success) {
+                throw new Error(`I received an unexpected response while listing capabilities:\n${formatValidationError(validation.error)}`);
             }
-        });
-        return {
+            return validation.data;
+        }
+        // Handle schedule tool responses
+        const validation = CommandResultSchema.safeParse({
             message: input.message,
             tasks: input.tasks,
             debug,
-        };
+        });
+        if (!validation.success) {
+            throw new Error(`I received an unexpected response while planning tasks:\n${formatValidationError(validation.error)}`);
+        }
+        return validation.data;
     }
 }
 export function createAnthropicService(config) {

package/dist/services/colors.js

@@ -1,4 +1,4 @@
-import { FeedbackType, TaskType } from '../types/types.js';
+import { FeedbackType, Origin, TaskType } from '../types/types.js';
 import { DebugLevel } from './configuration.js';
 import { ExecutionStatus } from './shell.js';
 /**
@@ -128,10 +128,19 @@ const taskColors = {
  */
 const feedbackColors = {
     [FeedbackType.Info]: Colors.Status.Info,
+    [FeedbackType.Warning]: Palette.Yellow,
     [FeedbackType.Succeeded]: Colors.Status.Success,
     [FeedbackType.Aborted]: Palette.MediumOrange,
     [FeedbackType.Failed]: Colors.Status.Error,
 };
+/**
+ * Origin-specific color mappings (internal)
+ */
+const originColors = {
+    [Origin.BuiltIn]: Colors.Origin.BuiltIn,
+    [Origin.UserProvided]: Colors.Origin.UserProvided,
+    [Origin.Indirect]: Colors.Origin.Indirect,
+};
 /**
  * Process null color values based on current/historical state.
  *
@@ -170,6 +179,17 @@ export function getTaskColors(type, isCurrent) {
 export function getFeedbackColor(type, isCurrent) {
     return processColor(feedbackColors[type], isCurrent);
 }
+/**
+ * Get color for capability origin.
+ *
+ * Returns the color associated with each origin type:
+ * - BuiltIn: Cyan
+ * - UserProvided: Green
+ * - Indirect: Purple
+ */
+export function getOriginColor(origin) {
+    return originColors[origin];
+}
 /**
  * Get text color based on current/historical state.
  *

package/dist/services/components.js

@@ -1,9 +1,9 @@
 import { randomUUID } from 'node:crypto';
-import { existsSync, readFileSync } from 'node:fs';
 import { parse as parseYaml } from 'yaml';
 import { ComponentStatus, } from '../types/components.js';
 import { ComponentName } from '../types/types.js';
 import { ConfigDefinitionType, getConfigPath, getConfigSchema, loadConfig, } from './configuration.js';
+import { defaultFileSystem } from './filesystem.js';
 import { getConfirmationMessage } from './messages.js';
 import { StepType } from '../ui/Config.js';
 export function createWelcomeDefinition(app) {
@@ -55,13 +55,13 @@ function getValidator(definition) {
 /**
  * Create config steps from schema for specified keys
  */
-export function createConfigStepsFromSchema(keys) {
+export function createConfigStepsFromSchema(keys, fs = defaultFileSystem) {
     const schema = getConfigSchema();
     let currentConfig = null;
     let rawConfig = null;
     // Load validated config (may fail if config has validation errors)
     try {
-        currentConfig = loadConfig();
+        currentConfig = loadConfig(fs);
     }
     catch {
         // Config doesn't exist or has validation errors, use defaults
@@ -69,8 +69,8 @@ export function createConfigStepsFromSchema(keys) {
     // Load raw config separately (for discovered keys not in schema)
     try {
         const configFile = getConfigPath();
-        if (existsSync(configFile)) {
-            const content = readFileSync(configFile, 'utf-8');
+        if (fs.exists(configFile)) {
+            const content = fs.readFile(configFile, 'utf-8');
             rawConfig = parseYaml(content);
         }
     }
@@ -78,7 +78,7 @@ export function createConfigStepsFromSchema(keys) {
         // Config file doesn't exist or can't be parsed
     }
     return keys.map((key) => {
-        // Check if key is in schema (built-in config)
+        // Check if key is in schema (system config)
         if (!(key in schema)) {
             // Key is not in schema - it's from a skill or discovered config
             // Create a simple text step with the full path as description
@@ -382,11 +382,3 @@ export function createValidateDefinition(missingConfig, userRequest, service, on
         },
     };
 }
-/**
- * Add debug components to timeline if present in result
- */
-export function addDebugToTimeline(debugComponents, handlers) {
-    if (debugComponents && debugComponents.length > 0 && handlers) {
-        handlers.addToTimeline(...debugComponents);
-    }
-}

package/dist/services/config-labels.js

@@ -0,0 +1,75 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+/**
+ * Get the path to the config labels cache file
+ */
+export function getConfigLabelsCachePath() {
+    return join(homedir(), '.pls', 'cache', 'config.json');
+}
+/**
+ * Get the cache directory path
+ */
+function getCacheDirectoryPath() {
+    return join(homedir(), '.pls', 'cache');
+}
+/**
+ * Ensure the cache directory exists
+ */
+function ensureCacheDirectoryExists() {
+    const cacheDir = getCacheDirectoryPath();
+    if (!existsSync(cacheDir)) {
+        mkdirSync(cacheDir, { recursive: true });
+    }
+}
+/**
+ * Load config labels from cache file
+ * Returns empty object if file doesn't exist or is corrupted
+ */
+export function loadConfigLabels() {
+    try {
+        const cachePath = getConfigLabelsCachePath();
+        if (!existsSync(cachePath)) {
+            return {};
+        }
+        const content = readFileSync(cachePath, 'utf-8');
+        const parsed = JSON.parse(content);
+        // Validate that parsed content is an object
+        if (typeof parsed !== 'object' ||
+            parsed === null ||
+            Array.isArray(parsed)) {
+            return {};
+        }
+        return parsed;
+    }
+    catch {
+        // Return empty object on any error (parse error, read error, etc.)
+        return {};
+    }
+}
+/**
+ * Save multiple config labels to cache
+ */
+export function saveConfigLabels(labels) {
+    ensureCacheDirectoryExists();
+    // Load existing labels and merge with new ones
+    const existing = loadConfigLabels();
+    const merged = { ...existing, ...labels };
+    const cachePath = getConfigLabelsCachePath();
+    const content = JSON.stringify(merged, null, 2);
+    writeFileSync(cachePath, content, 'utf-8');
+}
+/**
+ * Save a single config label to cache
+ */
+export function saveConfigLabel(key, label) {
+    saveConfigLabels({ [key]: label });
+}
+/**
+ * Get a config label from cache
+ * Returns undefined if label doesn't exist
+ */
+export function getConfigLabel(key) {
+    const labels = loadConfigLabels();
+    return labels[key];
+}

package/dist/services/config-utils.js

@@ -0,0 +1,20 @@
+/**
+ * Utility functions for config manipulation
+ */
+/**
+ * Flatten nested config object to dot notation
+ * Example: { a: { b: 1 } } => { 'a.b': 1 }
+ */
+export 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;
+}

package/dist/services/configuration.js

@@ -1,7 +1,19 @@
-import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
 import YAML from 'yaml';
+import { getConfigLabel } from './config-labels.js';
+import { flattenConfig } from './config-utils.js';
+import { defaultFileSystem } from './filesystem.js';
+/**
+ * Convert a dotted config key to a readable label
+ * Example: "project.alpha.repo" -> "Project Alpha Repo"
+ */
+function keyToLabel(key) {
+    return key
+        .split('.')
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(' ');
+}
 export var AnthropicModel;
 (function (AnthropicModel) {
     AnthropicModel["Sonnet"] = "claude-sonnet-4-5";
@@ -84,20 +96,20 @@ function validateConfig(parsed) {
     }
     return validatedConfig;
 }
-export function loadConfig() {
+export function loadConfig(fs = defaultFileSystem) {
     const configFile = getConfigFile();
-    if (!existsSync(configFile)) {
+    if (!fs.exists(configFile)) {
         throw new ConfigError('Configuration not found');
     }
-    const content = readFileSync(configFile, 'utf-8');
+    const content = fs.readFile(configFile, 'utf-8');
     const parsed = parseYamlConfig(content);
     return validateConfig(parsed);
 }
 export function getConfigPath() {
     return getConfigFile();
 }
-export function configExists() {
-    return existsSync(getConfigFile());
+export function configExists(fs = defaultFileSystem) {
+    return fs.exists(getConfigFile());
 }
 export function isValidAnthropicApiKey(key) {
     // Anthropic API keys format: sk-ant-api03-XXXXX (108 chars total)
@@ -137,24 +149,24 @@ export function mergeConfig(existingContent, sectionName, newValues) {
     // Convert back to YAML
     return YAML.stringify(sortedConfig);
 }
-export function saveConfig(section, config) {
+export function saveConfig(section, config, fs = defaultFileSystem) {
     const configFile = getConfigFile();
-    const existingContent = existsSync(configFile)
-        ? readFileSync(configFile, 'utf-8')
+    const existingContent = fs.exists(configFile)
+        ? fs.readFile(configFile, 'utf-8')
         : '';
     const newContent = mergeConfig(existingContent, section, config);
-    writeFileSync(configFile, newContent, 'utf-8');
+    fs.writeFile(configFile, newContent);
 }
-export function saveAnthropicConfig(config) {
-    saveConfig('anthropic', config);
-    return loadConfig();
+export function saveAnthropicConfig(config, fs = defaultFileSystem) {
+    saveConfig('anthropic', config, fs);
+    return loadConfig(fs);
 }
-export function saveDebugSetting(debug) {
-    saveConfig('settings', { debug });
+export function saveDebugSetting(debug, fs = defaultFileSystem) {
+    saveConfig('settings', { debug }, fs);
 }
-export function loadDebugSetting() {
+export function loadDebugSetting(fs = defaultFileSystem) {
     try {
-        const config = loadConfig();
+        const config = loadConfig(fs);
         return config.settings?.debug ?? DebugLevel.None;
     }
     catch {
@@ -192,7 +204,7 @@ export function getConfigurationRequiredMessage(forFutureUse = false) {
     return messages[Math.floor(Math.random() * messages.length)];
 }
 /**
- * Core configuration schema - defines structure and types for built-in settings
+ * Core configuration schema - defines structure and types for system settings
  */
 const coreConfigSchema = {
     'anthropic.key': {
@@ -292,28 +304,15 @@ export function getMissingConfigKeys() {
  * Get list of configured keys from config file
  * Returns array of dot-notation keys that exist in the config file
  */
-export function getConfiguredKeys() {
+export function getConfiguredKeys(fs = defaultFileSystem) {
     try {
         const configFile = getConfigFile();
-        if (!existsSync(configFile)) {
+        if (!fs.exists(configFile)) {
             return [];
         }
-        const content = readFileSync(configFile, 'utf-8');
+        const content = fs.readFile(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);
         return Object.keys(flatConfig);
     }
@@ -326,30 +325,17 @@ export function getConfiguredKeys() {
  * Returns keys with descriptions only (no values for privacy)
  * Marks optional keys as "(optional)"
  */
-export function getAvailableConfigStructure() {
+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 = getConfigFile();
-        if (existsSync(configFile)) {
-            const content = readFileSync(configFile, 'utf-8');
+        if (fs.exists(configFile)) {
+            const content = fs.readFile(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;
-            }
             flatConfig = flattenConfig(parsed);
         }
     }
@@ -357,20 +343,13 @@ export function getAvailableConfigStructure() {
         // Config file doesn't exist or can't be read
     }
     // Add schema keys with descriptions
-    // Mark optional keys as (optional)
     for (const [key, definition] of Object.entries(schema)) {
-        const isOptional = !definition.required;
-        if (isOptional) {
-            structure[key] = `${definition.description} (optional)`;
-        }
-        else {
-            structure[key] = definition.description;
-        }
+        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] = `${key} (discovered)`;
+            structure[key] = getConfigLabel(key) || keyToLabel(key);
         }
     }
     return structure;

package/dist/services/filesystem.js

@@ -0,0 +1,114 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, } from 'fs';
+import { dirname } from 'path';
+/**
+ * Real filesystem implementation using Node's fs module
+ */
+export class RealFileSystem {
+    exists(path) {
+        return existsSync(path);
+    }
+    readFile(path, encoding) {
+        return readFileSync(path, encoding);
+    }
+    writeFile(path, data) {
+        writeFileSync(path, data, 'utf-8');
+    }
+    readDirectory(path) {
+        return readdirSync(path);
+    }
+    createDirectory(path, options) {
+        mkdirSync(path, options);
+    }
+}
+/**
+ * In-memory filesystem implementation for testing
+ * Simulates filesystem behavior without touching disk
+ */
+export class MemoryFileSystem {
+    files = new Map();
+    directories = new Set();
+    exists(path) {
+        return this.files.has(path) || this.directories.has(path);
+    }
+    readFile(path, _encoding) {
+        const content = this.files.get(path);
+        if (content === undefined) {
+            throw new Error(`ENOENT: no such file or directory, open '${path}'`);
+        }
+        return content;
+    }
+    writeFile(path, data) {
+        // Auto-create parent directories
+        const dir = dirname(path);
+        if (dir !== '.' && dir !== path) {
+            this.createDirectory(dir, { recursive: true });
+        }
+        this.files.set(path, data);
+    }
+    readDirectory(path) {
+        if (!this.directories.has(path)) {
+            throw new Error(`ENOENT: no such file or directory, scandir '${path}'`);
+        }
+        const results = [];
+        const prefix = path.endsWith('/') ? path : `${path}/`;
+        // Find all direct children (files and directories)
+        for (const filePath of this.files.keys()) {
+            if (filePath.startsWith(prefix)) {
+                const relative = filePath.slice(prefix.length);
+                const firstSlash = relative.indexOf('/');
+                if (firstSlash === -1) {
+                    // Direct file child
+                    results.push(relative);
+                }
+            }
+        }
+        for (const dirPath of this.directories) {
+            if (dirPath.startsWith(prefix) && dirPath !== path) {
+                const relative = dirPath.slice(prefix.length);
+                const firstSlash = relative.indexOf('/');
+                if (firstSlash === -1) {
+                    // Direct directory child
+                    results.push(relative);
+                }
+            }
+        }
+        return results;
+    }
+    createDirectory(path, options) {
+        if (options?.recursive) {
+            // Create all parent directories
+            const parts = path.split('/').filter((p) => p);
+            let current = path.startsWith('/') ? '/' : '';
+            for (const part of parts) {
+                current = current === '/' ? `/${part}` : `${current}/${part}`;
+                this.directories.add(current);
+            }
+        }
+        else {
+            // Non-recursive: parent must exist
+            const parent = dirname(path);
+            if (parent !== '.' && parent !== path && !this.directories.has(parent)) {
+                throw new Error(`ENOENT: no such file or directory, mkdir '${path}'`);
+            }
+            this.directories.add(path);
+        }
+    }
+    /**
+     * Clear all files and directories (useful for test cleanup)
+     */
+    clear() {
+        this.files.clear();
+        this.directories.clear();
+    }
+    /**
+     * Get all files for debugging
+     */
+    getFiles() {
+        return new Map(this.files);
+    }
+}
+/**
+ * Default filesystem instance (uses real fs)
+ * Services can accept optional FileSystem parameter for testing
+ */
+export const defaultFileSystem = new RealFileSystem();

package/dist/services/loader.js

@@ -1,24 +1,27 @@
-import { existsSync, readFileSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
 import YAML from 'yaml';
+import { defaultFileSystem } from './filesystem.js';
+import { displayWarning } from './logger.js';
 /**
  * Load user config from ~/.plsrc
  */
-export function loadUserConfig() {
+export function loadUserConfig(fs = defaultFileSystem) {
     const configPath = join(homedir(), '.plsrc');
-    if (!existsSync(configPath)) {
+    if (!fs.exists(configPath)) {
         return {};
     }
     try {
-        const content = readFileSync(configPath, 'utf-8');
+        const content = fs.readFile(configPath, 'utf-8');
         const parsed = YAML.parse(content);
         if (parsed && typeof parsed === 'object') {
             return parsed;
         }
+        displayWarning('User config file exists but is not a valid object');
         return {};
     }
-    catch {
+    catch (error) {
+        displayWarning('Failed to load user config', error);
         return {};
     }
 }