prompt-language-shell 0.8.4 → 0.8.8

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,5 +1,5 @@
 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';
@@ -167,6 +167,7 @@ export class AnthropicService {
                 summary: input.summary,
                 tasks: [],
                 commands: input.commands,
+                error: input.error,
                 debug,
             });
             if (!validation.success) {

package/dist/services/colors.js

@@ -1,13 +1,16 @@
+import { DebugLevel } from '../configuration/types.js';
 import { FeedbackType, Origin, TaskType } from '../types/types.js';
-import { DebugLevel } from './configuration.js';
 import { ExecutionStatus } from './shell.js';
+import { ComponentStatus } from '../types/components.js';
 /**
  * Base color palette - raw color values with descriptive names.
  * All colors used in the interface are defined here.
  */
 export const Palette = {
     White: '#ffffff',
+    SoftWhite: '#fafafa',
     AshGray: '#d0d0d0',
+    LightGray: '#aaaaaa',
     Gray: '#888888',
     DarkGray: '#666666',
     CharcoalGray: '#282828',
@@ -32,6 +35,7 @@ export const Palette = {
 export const Colors = {
     Text: {
         Active: Palette.White,
+        Pending: Palette.SoftWhite,
         Inactive: Palette.AshGray,
         UserQuery: Palette.White,
     },
@@ -148,12 +152,18 @@ const originColors = {
  * - Colors.Text.Active for current items
  * - Colors.Text.Inactive (undefined) for historical items
  */
-function processColor(color, isCurrent) {
-    return color === null
-        ? isCurrent
-            ? Colors.Text.Active
-            : Colors.Text.Inactive
-        : color;
+function processColor(color, status) {
+    const getColor = () => {
+        switch (status) {
+            case ComponentStatus.Active:
+                return Colors.Text.Active;
+            case ComponentStatus.Pending:
+                return Colors.Text.Pending;
+            default:
+                return Colors.Text.Inactive;
+        }
+    };
+    return color || getColor();
 }
 /**
  * Get task colors with current/historical state handling.
@@ -162,11 +172,11 @@ function processColor(color, isCurrent) {
  * - Colors.Text.Inactive (undefined) for historical items
  * - Colors.Text.Active for current items
  */
-export function getTaskColors(type, isCurrent) {
+export function getTaskColors(type, status) {
     const colors = taskColors[type];
     return {
-        description: processColor(colors.description, isCurrent),
-        type: processColor(colors.type, isCurrent),
+        description: processColor(colors.description, status),
+        type: processColor(colors.type, status),
     };
 }
 /**
@@ -176,8 +186,8 @@ export function getTaskColors(type, isCurrent) {
  * - Colors.Text.Inactive (undefined) for historical items
  * - Colors.Text.Active for current items
  */
-export function getFeedbackColor(type, isCurrent) {
-    return processColor(feedbackColors[type], isCurrent);
+export function getFeedbackColor(type, status = ComponentStatus.Done) {
+    return processColor(feedbackColors[type], status);
 }
 /**
  * Get color for capability origin.

package/dist/services/components.js

@@ -1,8 +1,11 @@
 import { randomUUID } from 'node:crypto';
 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';
@@ -11,6 +14,7 @@ export function createWelcomeDefinition(app) {
         id: randomUUID(),
         name: ComponentName.Welcome,
         props: { app },
+        status: ComponentStatus.Awaiting,
     };
 }
 export function createConfigSteps() {
@@ -81,7 +85,7 @@ export function createConfigStepsFromSchema(keys, fs = defaultFileSystem) {
         // 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, fs = defaultFileSystem) {
             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,7 +401,7 @@ export function createValidateDefinition(missingConfig, userRequest, service, on
             userRequest,
             service,
             onError,
-            onComplete,
+            onValidationComplete,
             onAborted,
         },
     };

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

package/dist/services/logger.js

@@ -1,5 +1,6 @@
+import { DebugLevel } from '../configuration/types.js';
 import { createDebugDefinition } from './components.js';
-import { DebugLevel, loadDebugSetting } from './configuration.js';
+import { loadDebugSetting } from '../configuration/io.js';
 import { Palette } from './colors.js';
 /**
  * Debug logger for the application

package/dist/services/messages.js

@@ -1,4 +1,5 @@
-import { DebugLevel, loadDebugSetting } from './configuration.js';
+import { DebugLevel } from '../configuration/types.js';
+import { loadDebugSetting } from '../configuration/io.js';
 export { formatDuration } from './utils.js';
 /**
  * Returns a natural language confirmation message for plan execution.
@@ -80,6 +81,36 @@ export function getMixedTaskTypesError(types) {
     const typeList = types.join(', ');
     return `Mixed task types are not supported. Found: ${typeList}. All tasks in a plan must have the same type.`;
 }
+/**
+ * Returns a message for unresolved placeholders/missing configuration.
+ * Each message has two sentences: what's missing + what will be done.
+ * Both sentences are randomly selected independently for variety.
+ * Supports singular and plural forms.
+ */
+export function getUnresolvedPlaceholdersMessage(count) {
+    const plural = count === 1 ? '' : 's';
+    const it = count === 1 ? 'it' : 'them';
+    const valueWord = count === 1 ? 'value' : 'values';
+    // First sentence: what's missing
+    const firstSentences = [
+        `Missing configuration ${valueWord} detected.`,
+        `Configuration ${valueWord} needed.`,
+        `Found unresolved placeholder${plural}.`,
+        `Additional configuration ${valueWord} required.`,
+        `Setup requires configuration ${valueWord}.`,
+    ];
+    // Second sentence: what will be done
+    const secondSentences = [
+        `Let me gather ${it} now.`,
+        `I'll set ${it} up for you.`,
+        `Let me configure ${it} first.`,
+        `I'll help you provide ${it}.`,
+        `Let me collect ${it} from you.`,
+    ];
+    const first = firstSentences[Math.floor(Math.random() * firstSentences.length)];
+    const second = secondSentences[Math.floor(Math.random() * secondSentences.length)];
+    return `${first} ${second}`;
+}
 /**
  * Feedback messages for various operations
  */
@@ -116,3 +147,24 @@ export function formatErrorMessage(error) {
     }
     return rawMessage;
 }
+/**
+ * Returns an execution error message with varied phrasing.
+ * Randomly selects from variations to sound natural, like a concierge.
+ * Format: "[Cannot execute phrase]. [Error details]."
+ */
+export function getExecutionErrorMessage(error) {
+    const prefixes = [
+        "I can't execute this",
+        "I'm unable to execute this",
+        "I can't proceed with this",
+        "I'm unable to proceed with this",
+        'This cannot be executed',
+    ];
+    const prefix = prefixes[Math.floor(Math.random() * prefixes.length)];
+    // Capitalize first letter of error
+    const capitalizedError = error.charAt(0).toUpperCase() + error.slice(1);
+    const errorWithPeriod = capitalizedError.endsWith('.')
+        ? capitalizedError
+        : `${capitalizedError}.`;
+    return `${prefix}. ${errorWithPeriod}`;
+}

package/dist/services/refinement.js

@@ -1,3 +1,4 @@
+import { TaskType } from '../types/types.js';
 import { createRefinement } from './components.js';
 import { formatErrorMessage, getRefiningMessage } from './messages.js';
 import { routeTasksWithConfirm } from './router.js';
@@ -5,36 +6,40 @@ 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, queueHandlers, lifecycleHandlers, workflowHandlers, errorHandlers) {
+export async function handleRefinement(selectedTasks, service, originalCommand, lifecycleHandlers, workflowHandlers, requestHandlers) {
     // Create and add refinement component to queue
     const refinementDef = createRefinement(getRefiningMessage(), (operation) => {
-        errorHandlers.onAborted(operation);
+        requestHandlers.onAborted(operation);
     });
-    queueHandlers.addToQueue(refinementDef);
+    workflowHandlers.addToQueue(refinementDef);
     try {
         // Build refined command from selected tasks
         const refinedCommand = selectedTasks
             .map((task) => {
             const action = task.action.toLowerCase().replace(/,/g, ' -');
             const type = task.type;
+            // For execute/group tasks, use generic hint - let LLM decide based on skill
+            if (type === TaskType.Execute || type === TaskType.Group) {
+                return `${action} (shell execution)`;
+            }
             return `${action} (type: ${type})`;
         })
             .join(', ');
         // Call LLM to refine plan with selected tasks
         const refinedResult = await service.processWithTool(refinedCommand, 'schedule');
-        // Complete the Refinement component
+        // Complete the Refinement component with success state
         lifecycleHandlers.completeActive();
         // Add debug components to timeline if present
         if (refinedResult.debug?.length) {
             workflowHandlers.addToTimeline(...refinedResult.debug);
         }
         // Route refined tasks to appropriate components
-        routeTasksWithConfirm(refinedResult.tasks, refinedResult.message, service, originalCommand, queueHandlers, workflowHandlers, errorHandlers, false // No DEFINE tasks in refined result
+        routeTasksWithConfirm(refinedResult.tasks, refinedResult.message, service, originalCommand, lifecycleHandlers, workflowHandlers, requestHandlers, false // No DEFINE tasks in refined result
         );
     }
     catch (err) {
         lifecycleHandlers.completeActive();
         const errorMessage = formatErrorMessage(err);
-        errorHandlers.onError(errorMessage);
+        requestHandlers.onError(errorMessage);
     }
 }