prompt-language-shell 0.8.2 → 0.8.6

package/dist/execution/reducer.js

@@ -0,0 +1,148 @@
+import { ExecutionStatus } from '../services/shell.js';
+import { formatDuration } from '../services/utils.js';
+import { ExecuteActionType, } from './types.js';
+export const initialState = {
+    error: null,
+    taskInfos: [],
+    message: '',
+    completed: 0,
+    hasProcessed: false,
+    taskExecutionTimes: [],
+    completionMessage: null,
+    summary: '',
+};
+export function executeReducer(state, action) {
+    switch (action.type) {
+        case ExecuteActionType.ProcessingComplete:
+            return {
+                ...state,
+                message: action.payload.message,
+                hasProcessed: true,
+            };
+        case ExecuteActionType.CommandsReady:
+            return {
+                ...state,
+                message: action.payload.message,
+                summary: action.payload.summary,
+                taskInfos: action.payload.taskInfos,
+                completed: 0,
+            };
+        case ExecuteActionType.ProcessingError:
+            return {
+                ...state,
+                error: action.payload.error,
+                hasProcessed: true,
+            };
+        case ExecuteActionType.TaskComplete: {
+            const updatedTimes = [
+                ...state.taskExecutionTimes,
+                action.payload.elapsed,
+            ];
+            const updatedTaskInfos = state.taskInfos.map((task, i) => i === action.payload.index
+                ? {
+                    ...task,
+                    status: ExecutionStatus.Success,
+                    elapsed: action.payload.elapsed,
+                }
+                : task);
+            return {
+                ...state,
+                taskInfos: updatedTaskInfos,
+                taskExecutionTimes: updatedTimes,
+                completed: action.payload.index + 1,
+            };
+        }
+        case ExecuteActionType.AllTasksComplete: {
+            const updatedTimes = [
+                ...state.taskExecutionTimes,
+                action.payload.elapsed,
+            ];
+            const updatedTaskInfos = state.taskInfos.map((task, i) => i === action.payload.index
+                ? {
+                    ...task,
+                    status: ExecutionStatus.Success,
+                    elapsed: action.payload.elapsed,
+                }
+                : task);
+            const totalElapsed = updatedTimes.reduce((sum, time) => sum + time, 0);
+            const completion = `${action.payload.summaryText} in ${formatDuration(totalElapsed)}.`;
+            return {
+                ...state,
+                taskInfos: updatedTaskInfos,
+                taskExecutionTimes: updatedTimes,
+                completed: action.payload.index + 1,
+                completionMessage: completion,
+            };
+        }
+        case ExecuteActionType.TaskErrorCritical: {
+            const updatedTaskInfos = state.taskInfos.map((task, i) => i === action.payload.index
+                ? { ...task, status: ExecutionStatus.Failed, elapsed: 0 }
+                : task);
+            return {
+                ...state,
+                taskInfos: updatedTaskInfos,
+                error: action.payload.error,
+            };
+        }
+        case ExecuteActionType.TaskErrorContinue: {
+            const updatedTimes = [
+                ...state.taskExecutionTimes,
+                action.payload.elapsed,
+            ];
+            const updatedTaskInfos = state.taskInfos.map((task, i) => i === action.payload.index
+                ? {
+                    ...task,
+                    status: ExecutionStatus.Failed,
+                    elapsed: action.payload.elapsed,
+                }
+                : task);
+            return {
+                ...state,
+                taskInfos: updatedTaskInfos,
+                taskExecutionTimes: updatedTimes,
+                completed: action.payload.index + 1,
+            };
+        }
+        case ExecuteActionType.LastTaskError: {
+            const updatedTimes = [
+                ...state.taskExecutionTimes,
+                action.payload.elapsed,
+            ];
+            const updatedTaskInfos = state.taskInfos.map((task, i) => i === action.payload.index
+                ? {
+                    ...task,
+                    status: ExecutionStatus.Failed,
+                    elapsed: action.payload.elapsed,
+                }
+                : task);
+            const totalElapsed = updatedTimes.reduce((sum, time) => sum + time, 0);
+            const completion = `${action.payload.summaryText} in ${formatDuration(totalElapsed)}.`;
+            return {
+                ...state,
+                taskInfos: updatedTaskInfos,
+                taskExecutionTimes: updatedTimes,
+                completed: action.payload.index + 1,
+                completionMessage: completion,
+            };
+        }
+        case ExecuteActionType.CancelExecution: {
+            const updatedTaskInfos = state.taskInfos.map((task, taskIndex) => {
+                if (taskIndex < action.payload.completed) {
+                    return { ...task, status: ExecutionStatus.Success };
+                }
+                else if (taskIndex === action.payload.completed) {
+                    return { ...task, status: ExecutionStatus.Aborted };
+                }
+                else {
+                    return { ...task, status: ExecutionStatus.Cancelled };
+                }
+            });
+            return {
+                ...state,
+                taskInfos: updatedTaskInfos,
+            };
+        }
+        default:
+            return state;
+    }
+}

package/dist/execution/types.js

@@ -0,0 +1,12 @@
+export var ExecuteActionType;
+(function (ExecuteActionType) {
+    ExecuteActionType["ProcessingComplete"] = "PROCESSING_COMPLETE";
+    ExecuteActionType["CommandsReady"] = "COMMANDS_READY";
+    ExecuteActionType["ProcessingError"] = "PROCESSING_ERROR";
+    ExecuteActionType["TaskComplete"] = "TASK_COMPLETE";
+    ExecuteActionType["AllTasksComplete"] = "ALL_TASKS_COMPLETE";
+    ExecuteActionType["TaskErrorCritical"] = "TASK_ERROR_CRITICAL";
+    ExecuteActionType["TaskErrorContinue"] = "TASK_ERROR_CONTINUE";
+    ExecuteActionType["LastTaskError"] = "LAST_TASK_ERROR";
+    ExecuteActionType["CancelExecution"] = "CANCEL_EXECUTION";
+})(ExecuteActionType || (ExecuteActionType = {}));

package/dist/execution/validation.js

@@ -0,0 +1,12 @@
+import { getUnresolvedPlaceholdersMessage } from '../services/messages.js';
+/**
+ * Validates that all placeholders in a command have been resolved.
+ * Throws an error if unresolved placeholders are found.
+ */
+export function validatePlaceholderResolution(command) {
+    const unresolvedPattern = /\{[^}]+\}/g;
+    const matches = command.match(unresolvedPattern);
+    if (matches && matches.length > 0) {
+        throw new Error(getUnresolvedPlaceholdersMessage(matches.length));
+    }
+}

package/dist/index.js

@@ -4,7 +4,7 @@ import { existsSync, readFileSync } from 'fs';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 import { render } from 'ink';
-import { DebugLevel } from './services/configuration.js';
+import { DebugLevel } from './configuration/types.js';
 import { Main } from './ui/Main.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);

package/dist/services/anthropic.js

@@ -1,8 +1,9 @@
 import Anthropic from '@anthropic-ai/sdk';
-import { getAvailableConfigStructure, getConfiguredKeys, } from './configuration.js';
+import { getAvailableConfigStructure, getConfiguredKeys, } from '../configuration/schema.js';
 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

@@ -1,5 +1,5 @@
+import { DebugLevel } from '../configuration/types.js';
 import { FeedbackType, Origin, TaskType } from '../types/types.js';
-import { DebugLevel } from './configuration.js';
 import { ExecutionStatus } from './shell.js';
 /**
  * Base color palette - raw color values with descriptive names.
@@ -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,12 @@
 import { randomUUID } from 'node:crypto';
-import { existsSync, readFileSync } from 'node:fs';
 import { parse as parseYaml } from 'yaml';
+import { ConfigDefinitionType, } from '../configuration/types.js';
 import { ComponentStatus, } from '../types/components.js';
 import { ComponentName } from '../types/types.js';
-import { ConfigDefinitionType, getConfigPath, getConfigSchema, loadConfig, } from './configuration.js';
+import { getConfigPath, loadConfig } from '../configuration/io.js';
+import { getConfigSchema } from '../configuration/schema.js';
+import { getConfigLabel } from './config-labels.js';
+import { defaultFileSystem } from './filesystem.js';
 import { getConfirmationMessage } from './messages.js';
 import { StepType } from '../ui/Config.js';
 export function createWelcomeDefinition(app) {
@@ -11,6 +14,7 @@ export function createWelcomeDefinition(app) {
         id: randomUUID(),
         name: ComponentName.Welcome,
         props: { app },
+        status: ComponentStatus.Awaiting,
     };
 }
 export function createConfigSteps() {
@@ -55,13 +59,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 +73,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);
         }
     }
@@ -81,7 +85,7 @@ export function createConfigStepsFromSchema(keys) {
         // 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
+            // Create a simple text step with cached label or full path as description
             const keyParts = key.split('.');
             const shortKey = keyParts[keyParts.length - 1];
             // Load current value if it exists (use rawConfig since discovered keys aren't in validated config)
@@ -89,8 +93,10 @@ export function createConfigStepsFromSchema(keys) {
             const value = currentValue !== undefined && typeof currentValue === 'string'
                 ? currentValue
                 : null;
+            // Use cached label if available, fallback to key path
+            const cachedLabel = getConfigLabel(key, fs);
             return {
-                description: key,
+                description: cachedLabel ?? key,
                 key: shortKey,
                 path: key,
                 type: StepType.Text,
@@ -217,7 +223,11 @@ export function createCommandDefinition(command, service) {
         id: randomUUID(),
         name: ComponentName.Command,
         status: ComponentStatus.Awaiting,
-        state: {},
+        state: {
+            error: null,
+            message: null,
+            tasks: [],
+        },
         props: {
             command,
             service,
@@ -249,6 +259,7 @@ export function createFeedback(type, ...messages) {
             type,
             message: messages.join('\n\n'),
         },
+        status: ComponentStatus.Awaiting,
     };
 }
 export function createMessage(text) {
@@ -258,6 +269,7 @@ export function createMessage(text) {
         props: {
             text,
         },
+        status: ComponentStatus.Awaiting,
     };
 }
 export function createDebugDefinition(title, content, color) {
@@ -269,6 +281,7 @@ export function createDebugDefinition(title, content, color) {
             content,
             color,
         },
+        status: ComponentStatus.Awaiting,
     };
 }
 export function createRefinement(text, onAborted) {
@@ -288,7 +301,10 @@ export function createConfirmDefinition(onConfirmed, onCancelled) {
         id: randomUUID(),
         name: ComponentName.Confirm,
         status: ComponentStatus.Awaiting,
-        state: {},
+        state: {
+            confirmed: false,
+            selectedIndex: 0,
+        },
         props: {
             message: getConfirmationMessage(),
             onConfirmed,
@@ -301,7 +317,11 @@ export function createIntrospectDefinition(tasks, service) {
         id: randomUUID(),
         name: ComponentName.Introspect,
         status: ComponentStatus.Awaiting,
-        state: {},
+        state: {
+            error: null,
+            capabilities: [],
+            message: null,
+        },
         props: {
             tasks,
             service,
@@ -316,6 +336,7 @@ export function createReportDefinition(message, capabilities) {
             message,
             capabilities,
         },
+        status: ComponentStatus.Awaiting,
     };
 }
 export function createAnswerDefinition(question, service) {
@@ -323,14 +344,17 @@ export function createAnswerDefinition(question, service) {
         id: randomUUID(),
         name: ComponentName.Answer,
         status: ComponentStatus.Awaiting,
-        state: {},
+        state: {
+            error: null,
+            answer: null,
+        },
         props: {
             question,
             service,
         },
     };
 }
-export function isStateless(component) {
+export function isSimple(component) {
     return !('state' in component);
 }
 /**
@@ -361,7 +385,7 @@ export function createExecuteDefinition(tasks, service) {
         },
     };
 }
-export function createValidateDefinition(missingConfig, userRequest, service, onError, onComplete, onAborted) {
+export function createValidateDefinition(missingConfig, userRequest, service, onError, onValidationComplete, onAborted) {
     return {
         id: randomUUID(),
         name: ComponentName.Validate,
@@ -369,7 +393,7 @@ export function createValidateDefinition(missingConfig, userRequest, service, on
         state: {
             error: null,
             completionMessage: null,
-            configRequirements: null,
+            configRequirements: [],
             validated: false,
         },
         props: {
@@ -377,16 +401,8 @@ export function createValidateDefinition(missingConfig, userRequest, service, on
             userRequest,
             service,
             onError,
-            onComplete,
+            onValidationComplete,
             onAborted,
         },
     };
 }
-/**
- * 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

@@ -1,6 +1,6 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
+import { defaultFileSystem } from './filesystem.js';
 /**
  * Get the path to the config labels cache file
  */
@@ -16,23 +16,23 @@ function getCacheDirectoryPath() {
 /**
  * Ensure the cache directory exists
  */
-function ensureCacheDirectoryExists() {
+function ensureCacheDirectoryExists(fs = defaultFileSystem) {
     const cacheDir = getCacheDirectoryPath();
-    if (!existsSync(cacheDir)) {
-        mkdirSync(cacheDir, { recursive: true });
+    if (!fs.exists(cacheDir)) {
+        fs.createDirectory(cacheDir, { recursive: true });
     }
 }
 /**
  * Load config labels from cache file
  * Returns empty object if file doesn't exist or is corrupted
  */
-export function loadConfigLabels() {
+export function loadConfigLabels(fs = defaultFileSystem) {
     try {
         const cachePath = getConfigLabelsCachePath();
-        if (!existsSync(cachePath)) {
+        if (!fs.exists(cachePath)) {
             return {};
         }
-        const content = readFileSync(cachePath, 'utf-8');
+        const content = fs.readFile(cachePath, 'utf-8');
         const parsed = JSON.parse(content);
         // Validate that parsed content is an object
         if (typeof parsed !== 'object' ||
@@ -50,26 +50,26 @@ export function loadConfigLabels() {
 /**
  * Save multiple config labels to cache
  */
-export function saveConfigLabels(labels) {
-    ensureCacheDirectoryExists();
+export function saveConfigLabels(labels, fs = defaultFileSystem) {
+    ensureCacheDirectoryExists(fs);
     // Load existing labels and merge with new ones
-    const existing = loadConfigLabels();
+    const existing = loadConfigLabels(fs);
     const merged = { ...existing, ...labels };
     const cachePath = getConfigLabelsCachePath();
     const content = JSON.stringify(merged, null, 2);
-    writeFileSync(cachePath, content, 'utf-8');
+    fs.writeFile(cachePath, content);
 }
 /**
  * Save a single config label to cache
  */
-export function saveConfigLabel(key, label) {
-    saveConfigLabels({ [key]: label });
+export function saveConfigLabel(key, label, fs = defaultFileSystem) {
+    saveConfigLabels({ [key]: label }, fs);
 }
 /**
  * Get a config label from cache
  * Returns undefined if label doesn't exist
  */
-export function getConfigLabel(key) {
-    const labels = loadConfigLabels();
+export function getConfigLabel(key, fs = defaultFileSystem) {
+    const labels = loadConfigLabels(fs);
     return labels[key];
 }