prompt-language-shell 0.8.2 → 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,6 +46,19 @@ 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;
@@ -148,88 +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,
-            };
+            });
+            if (!validation.success) {
+                throw new Error(`I received an unexpected response while answering your question:\n${formatValidationError(validation.error)}`);
+            }
+            return validation.data;
         }
         // Handle introspect tool response
         if (toolName === 'introspect') {
-            if (!input.message || typeof input.message !== 'string') {
-                throw new Error('Invalid tool response: missing or invalid message field');
-            }
-            if (!input.capabilities || !Array.isArray(input.capabilities)) {
-                throw new Error('Invalid tool response: missing or invalid capabilities array');
-            }
-            // Validate each capability has required fields
-            input.capabilities.forEach((cap, i) => {
-                if (!cap.name || typeof cap.name !== 'string') {
-                    throw new Error(`Invalid capability at index ${String(i)}: missing or invalid 'name' field`);
-                }
-                if (!cap.description || typeof cap.description !== 'string') {
-                    throw new Error(`Invalid capability at index ${String(i)}: missing or invalid 'description' field`);
-                }
-                if (typeof cap.origin !== 'string') {
-                    throw new Error(`Invalid capability at index ${String(i)}: invalid 'origin' field`);
-                }
-            });
-            return {
+            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 validation.data;
         }
         // Handle schedule 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');
-        }
-        // 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`);
-            }
-        });
-        return {
+        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

@@ -128,6 +128,7 @@ 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,

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);
         }
     }
@@ -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/configuration.js

@@ -1,9 +1,9 @@
-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"
@@ -96,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)
@@ -149,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 {
@@ -304,13 +304,13 @@ 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
         const flatConfig = flattenConfig(parsed);
@@ -325,15 +325,15 @@ 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
             flatConfig = flattenConfig(parsed);

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 {};
     }
 }

package/dist/services/logger.js

@@ -6,6 +6,10 @@ import { Palette } from './colors.js';
  * Logs information based on the current debug level setting
  */
 let currentDebugLevel = DebugLevel.None;
+/**
+ * Accumulated warnings to be displayed in the timeline
+ */
+const warnings = [];
 /**
  * Initialize the logger with the current debug level from config
  */
@@ -24,6 +28,26 @@ export function setDebugLevel(debug) {
 export function getDebugLevel() {
     return currentDebugLevel;
 }
+/**
+ * Store a warning message to be displayed in the timeline
+ * Only stores warnings at Info or Verbose debug levels
+ */
+export function displayWarning(message, error) {
+    if (currentDebugLevel === DebugLevel.None) {
+        return;
+    }
+    const errorDetails = error instanceof Error ? `: ${error.message}` : '';
+    warnings.push(`${message}${errorDetails}`);
+}
+/**
+ * Get all accumulated warnings and clear the list
+ * Returns array of warning messages
+ */
+export function getWarnings() {
+    const result = [...warnings];
+    warnings.length = 0;
+    return result;
+}
 /**
  * Create debug component for system prompts sent to the LLM
  * Only creates at Verbose level

package/dist/services/parser.js

@@ -1,4 +1,5 @@
 import YAML from 'yaml';
+import { displayWarning } from './logger.js';
 /**
  * Validate a skill without parsing it fully
  * Returns validation error if skill is invalid, null if valid
@@ -188,7 +189,8 @@ function parseConfigSchema(content) {
         }
         return parsed;
     }
-    catch {
+    catch (error) {
+        displayWarning('Failed to parse config schema in skill', error);
         return undefined;
     }
 }

package/dist/services/refinement.js

@@ -5,12 +5,12 @@ import { routeTasksWithConfirm } from './router.js';
  * Handle refinement flow for DEFINE tasks
  * Called when user selects options from a plan with DEFINE tasks
  */
-export async function handleRefinement(selectedTasks, service, originalCommand, handlers) {
+export async function handleRefinement(selectedTasks, service, originalCommand, queueHandlers, lifecycleHandlers, workflowHandlers, errorHandlers) {
     // Create and add refinement component to queue
     const refinementDef = createRefinement(getRefiningMessage(), (operation) => {
-        handlers.onAborted(operation);
+        errorHandlers.onAborted(operation);
     });
-    handlers.addToQueue(refinementDef);
+    queueHandlers.addToQueue(refinementDef);
     try {
         // Build refined command from selected tasks
         const refinedCommand = selectedTasks
@@ -23,18 +23,18 @@ export async function handleRefinement(selectedTasks, service, originalCommand,
         // Call LLM to refine plan with selected tasks
         const refinedResult = await service.processWithTool(refinedCommand, 'schedule');
         // Complete the Refinement component
-        handlers.completeActive();
+        lifecycleHandlers.completeActive();
         // Add debug components to timeline if present
-        if (refinedResult.debug && refinedResult.debug.length > 0) {
-            handlers.addToTimeline(...refinedResult.debug);
+        if (refinedResult.debug?.length) {
+            workflowHandlers.addToTimeline(...refinedResult.debug);
         }
         // Route refined tasks to appropriate components
-        routeTasksWithConfirm(refinedResult.tasks, refinedResult.message, service, originalCommand, handlers, false // No DEFINE tasks in refined result
+        routeTasksWithConfirm(refinedResult.tasks, refinedResult.message, service, originalCommand, queueHandlers, workflowHandlers, errorHandlers, false // No DEFINE tasks in refined result
         );
     }
     catch (err) {
-        handlers.completeActive();
+        lifecycleHandlers.completeActive();
         const errorMessage = formatErrorMessage(err);
-        handlers.onError(errorMessage);
+        errorHandlers.onError(errorMessage);
     }
 }