prompt-language-shell 0.9.0 → 0.9.4

package/dist/configuration/steps.js

@@ -0,0 +1,171 @@
+import { parse as parseYaml } from 'yaml';
+import { ConfigDefinitionType } from './types.js';
+import { getConfigPath, loadConfig } from './io.js';
+import { getConfigSchema } from './schema.js';
+import { getConfigLabel } from './labels.js';
+import { defaultFileSystem } from '../services/filesystem.js';
+import { StepType } from '../components/controllers/Config.js';
+export function createConfigSteps() {
+    // Use schema-based config step generation for required Anthropic settings
+    return createConfigStepsFromSchema(['anthropic.key', 'anthropic.model']);
+}
+/**
+ * Get current config value for a dotted key path
+ */
+function getConfigValue(config, key) {
+    if (!config)
+        return undefined;
+    const parts = key.split('.');
+    let value = config;
+    for (const part of parts) {
+        if (value && typeof value === 'object' && part in value) {
+            value = value[part];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return value;
+}
+/**
+ * Get validation function for a config definition
+ */
+function getValidator(definition) {
+    switch (definition.type) {
+        case ConfigDefinitionType.RegExp:
+            return (value) => definition.pattern.test(value);
+        case ConfigDefinitionType.String:
+            return () => true; // Strings are always valid
+        case ConfigDefinitionType.Enum:
+            return (value) => definition.values.includes(value);
+        case ConfigDefinitionType.Number:
+            return (value) => !isNaN(Number(value));
+        case ConfigDefinitionType.Boolean:
+            return (value) => value === 'true' || value === 'false';
+    }
+}
+/**
+ * Create config steps from schema for specified 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(fs);
+    }
+    catch {
+        // Config doesn't exist or has validation errors, use defaults
+    }
+    // Load raw config separately (for discovered keys not in schema)
+    try {
+        const configFile = getConfigPath();
+        if (fs.exists(configFile)) {
+            const content = fs.readFile(configFile, 'utf-8');
+            rawConfig = parseYaml(content);
+        }
+    }
+    catch {
+        // Config file doesn't exist or can't be parsed
+    }
+    return keys.map((key) => {
+        // 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 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)
+            const currentValue = getConfigValue(rawConfig, key);
+            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: cachedLabel ?? key,
+                key: shortKey,
+                path: key,
+                type: StepType.Text,
+                value,
+                validate: () => true, // Accept any string for now
+            };
+        }
+        const definition = schema[key];
+        const currentValue = getConfigValue(currentConfig, key);
+        const keyParts = key.split('.');
+        const shortKey = keyParts[keyParts.length - 1];
+        // Map definition to ConfigStep based on type
+        switch (definition.type) {
+            case ConfigDefinitionType.RegExp:
+            case ConfigDefinitionType.String: {
+                const value = currentValue !== undefined && typeof currentValue === 'string'
+                    ? currentValue
+                    : definition.type === ConfigDefinitionType.String
+                        ? (definition.default ?? '')
+                        : null;
+                return {
+                    description: definition.description,
+                    key: shortKey,
+                    path: key,
+                    type: StepType.Text,
+                    value,
+                    validate: getValidator(definition),
+                };
+            }
+            case ConfigDefinitionType.Number: {
+                const value = currentValue !== undefined && typeof currentValue === 'number'
+                    ? String(currentValue)
+                    : definition.default !== undefined
+                        ? String(definition.default)
+                        : '0';
+                return {
+                    description: definition.description,
+                    key: shortKey,
+                    path: key,
+                    type: StepType.Text,
+                    value,
+                    validate: getValidator(definition),
+                };
+            }
+            case ConfigDefinitionType.Enum: {
+                const currentStr = currentValue !== undefined && typeof currentValue === 'string'
+                    ? currentValue
+                    : definition.default;
+                const defaultIndex = currentStr
+                    ? definition.values.indexOf(currentStr)
+                    : 0;
+                return {
+                    description: definition.description,
+                    key: shortKey,
+                    path: key,
+                    type: StepType.Selection,
+                    options: definition.values.map((value) => ({
+                        label: value,
+                        value,
+                    })),
+                    defaultIndex: Math.max(0, defaultIndex),
+                    validate: getValidator(definition),
+                };
+            }
+            case ConfigDefinitionType.Boolean: {
+                const currentBool = currentValue !== undefined && typeof currentValue === 'boolean'
+                    ? currentValue
+                    : undefined;
+                return {
+                    description: definition.description,
+                    key: shortKey,
+                    path: key,
+                    type: StepType.Selection,
+                    options: [
+                        { label: 'yes', value: 'true' },
+                        { label: 'no', value: 'false' },
+                    ],
+                    defaultIndex: currentBool !== undefined ? (currentBool ? 0 : 1) : 0,
+                    validate: getValidator(definition),
+                };
+            }
+        }
+    });
+}

package/dist/configuration/transformation.js

@@ -1,5 +1,22 @@
 import { ConfigDefinitionType } from './types.js';
 import { getConfigSchema } from './schema.js';
+/**
+ * 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;
+}
 /**
  * Convert string value to appropriate type based on schema definition
  */

package/dist/execution/handlers.js

@@ -7,7 +7,7 @@ import { getTotalElapsed } from './utils.js';
  */
 export function handleTaskCompletion(index, elapsed, context) {
     const { tasks, message, summary } = context;
-    const updatedTaskInfos = tasks.map((task, i) => i === index ? { ...task, status: ExecutionStatus.Success, elapsed } : task);
+    const updatedTasks = tasks.map((task, i) => i === index ? { ...task, status: ExecutionStatus.Success, elapsed } : task);
     if (index < tasks.length - 1) {
         // More tasks to execute
         return {
@@ -18,8 +18,7 @@ export function handleTaskCompletion(index, elapsed, context) {
             finalState: {
                 message,
                 summary,
-                tasks: updatedTaskInfos,
-                completed: index + 1,
+                tasks: updatedTasks,
                 completionMessage: null,
                 error: null,
             },
@@ -28,18 +27,17 @@ export function handleTaskCompletion(index, elapsed, context) {
     }
     // All tasks complete
     const summaryText = summary.trim() || 'Execution completed';
-    const totalElapsed = getTotalElapsed(updatedTaskInfos);
+    const totalElapsed = getTotalElapsed(updatedTasks);
     const completion = `${summaryText} in ${formatDuration(totalElapsed)}.`;
     return {
         action: {
-            type: ExecuteActionType.AllTasksComplete,
+            type: ExecuteActionType.ExecutionComplete,
             payload: { index, elapsed, summaryText },
         },
         finalState: {
             message,
             summary,
-            tasks: updatedTaskInfos,
-            completed: index + 1,
+            tasks: updatedTasks,
             completionMessage: completion,
             error: null,
         },
@@ -49,77 +47,39 @@ export function handleTaskCompletion(index, elapsed, context) {
 /**
  * Handles task error logic and returns the appropriate action and state.
  */
-export function handleTaskFailure(index, error, elapsed, context) {
+export function handleTaskFailure(index, error, context) {
     const { tasks, message, summary } = context;
-    const task = tasks[index];
-    const isCritical = task.command.critical !== false; // Default to true
-    const updatedTaskInfos = tasks.map((task, i) => i === index ? { ...task, status: ExecutionStatus.Failed, elapsed } : task);
-    if (isCritical) {
-        // Critical failure - stop execution
-        return {
-            action: {
-                type: ExecuteActionType.TaskErrorCritical,
-                payload: { index, error },
-            },
-            finalState: {
-                message,
-                summary,
-                tasks: updatedTaskInfos,
-                completed: index + 1,
-                completionMessage: null,
-                error: null,
-            },
-            shouldComplete: true,
-        };
-    }
-    // Non-critical failure - continue to next task
-    if (index < tasks.length - 1) {
-        return {
-            action: {
-                type: ExecuteActionType.TaskErrorContinue,
-                payload: { index, elapsed },
-            },
-            finalState: {
-                message,
-                summary,
-                tasks: updatedTaskInfos,
-                completed: index + 1,
-                completionMessage: null,
-                error: null,
-            },
-            shouldComplete: false,
-        };
-    }
-    // Last task failed (non-critical), complete execution
-    // Non-critical failures still show completion message with summary
-    const summaryText = summary.trim() || 'Execution completed';
-    const totalElapsed = getTotalElapsed(updatedTaskInfos);
-    const completion = `${summaryText} in ${formatDuration(totalElapsed)}.`;
+    const updatedTasks = tasks.map((task, i) => {
+        if (i === index) {
+            return { ...task, status: ExecutionStatus.Failed, elapsed: 0 };
+        }
+        else if (i > index && task.status === ExecutionStatus.Pending) {
+            return { ...task, status: ExecutionStatus.Cancelled };
+        }
+        return task;
+    });
     return {
         action: {
-            type: ExecuteActionType.LastTaskError,
-            payload: { index, elapsed, summaryText },
+            type: ExecuteActionType.TaskError,
+            payload: { index, error },
         },
         finalState: {
             message,
             summary,
-            tasks: updatedTaskInfos,
-            completed: index + 1,
-            completionMessage: completion,
+            tasks: updatedTasks,
+            completionMessage: null,
             error: null,
         },
-        shouldComplete: true,
     };
 }
 /**
  * Builds final state for task abortion.
  */
-export function buildAbortedState(tasks, message, summary, completed) {
+export function buildAbortedState(tasks, message, summary) {
     return {
         message,
         summary,
         tasks,
-        completed,
         completionMessage: null,
         error: null,
     };

package/dist/execution/processing.js

@@ -18,7 +18,7 @@ export async function processTasks(tasks, service) {
     // Load user config for placeholder resolution
     const userConfig = loadUserConfig();
     // Format tasks for the execute tool and resolve placeholders
-    const taskDescriptions = tasks
+    const taskList = tasks
         .map((task) => {
         const resolvedAction = replacePlaceholders(task.action, userConfig);
         const params = task.params
@@ -27,6 +27,8 @@ export async function processTasks(tasks, service) {
         return `- ${resolvedAction}${params}`;
     })
         .join('\n');
+    // Build message with confirmed schedule header
+    const taskDescriptions = `Confirmed schedule (${tasks.length} tasks):\n${taskList}`;
     // Call execute tool to get commands
     const result = await service.processWithTool(taskDescriptions, 'execute');
     // Resolve placeholders in command strings

package/dist/execution/reducer.js

@@ -6,7 +6,6 @@ export const initialState = {
     error: null,
     tasks: [],
     message: '',
-    completed: 0,
     hasProcessed: false,
     completionMessage: null,
     summary: '',
@@ -25,7 +24,6 @@ export function executeReducer(state, action) {
                 message: action.payload.message,
                 summary: action.payload.summary,
                 tasks: action.payload.tasks,
-                completed: 0,
             };
         case ExecuteActionType.ProcessingError:
             return {
@@ -33,93 +31,85 @@ export function executeReducer(state, action) {
                 error: action.payload.error,
                 hasProcessed: true,
             };
-        case ExecuteActionType.TaskComplete: {
-            const updatedTaskInfos = state.tasks.map((task, i) => i === action.payload.index
+        case ExecuteActionType.TaskStarted: {
+            const updatedTasks = state.tasks.map((task, i) => i === action.payload.index
                 ? {
                     ...task,
-                    status: ExecutionStatus.Success,
-                    elapsed: action.payload.elapsed,
+                    status: ExecutionStatus.Running,
+                    startTime: action.payload.startTime,
                 }
                 : task);
             return {
                 ...state,
-                tasks: updatedTaskInfos,
-                completed: action.payload.index + 1,
+                tasks: updatedTasks,
             };
         }
-        case ExecuteActionType.AllTasksComplete: {
-            const updatedTaskInfos = state.tasks.map((task, i) => i === action.payload.index
+        case ExecuteActionType.TaskProgress: {
+            const updatedTasks = state.tasks.map((task, i) => i === action.payload.index
                 ? {
                     ...task,
-                    status: ExecutionStatus.Success,
                     elapsed: action.payload.elapsed,
+                    output: action.payload.output,
                 }
                 : task);
-            const totalElapsed = getTotalElapsed(updatedTaskInfos);
-            const completion = `${action.payload.summaryText} in ${formatDuration(totalElapsed)}.`;
-            return {
-                ...state,
-                tasks: updatedTaskInfos,
-                completed: action.payload.index + 1,
-                completionMessage: completion,
-            };
-        }
-        case ExecuteActionType.TaskErrorCritical: {
-            const updatedTaskInfos = state.tasks.map((task, i) => i === action.payload.index
-                ? { ...task, status: ExecutionStatus.Failed, elapsed: 0 }
-                : task);
             return {
                 ...state,
-                tasks: updatedTaskInfos,
-                error: action.payload.error,
+                tasks: updatedTasks,
             };
         }
-        case ExecuteActionType.TaskErrorContinue: {
-            const updatedTaskInfos = state.tasks.map((task, i) => i === action.payload.index
+        case ExecuteActionType.TaskComplete: {
+            const updatedTasks = state.tasks.map((task, i) => i === action.payload.index
                 ? {
                     ...task,
-                    status: ExecutionStatus.Failed,
+                    status: ExecutionStatus.Success,
                     elapsed: action.payload.elapsed,
                 }
                 : task);
             return {
                 ...state,
-                tasks: updatedTaskInfos,
-                completed: action.payload.index + 1,
+                tasks: updatedTasks,
             };
         }
-        case ExecuteActionType.LastTaskError: {
-            const updatedTaskInfos = state.tasks.map((task, i) => i === action.payload.index
+        case ExecuteActionType.ExecutionComplete: {
+            const updatedTasks = state.tasks.map((task, i) => i === action.payload.index
                 ? {
                     ...task,
-                    status: ExecutionStatus.Failed,
+                    status: ExecutionStatus.Success,
                     elapsed: action.payload.elapsed,
                 }
                 : task);
-            const totalElapsed = getTotalElapsed(updatedTaskInfos);
+            const totalElapsed = getTotalElapsed(updatedTasks);
             const completion = `${action.payload.summaryText} in ${formatDuration(totalElapsed)}.`;
             return {
                 ...state,
-                tasks: updatedTaskInfos,
-                completed: action.payload.index + 1,
+                tasks: updatedTasks,
                 completionMessage: completion,
             };
         }
+        case ExecuteActionType.TaskError: {
+            const updatedTasks = state.tasks.map((task, i) => i === action.payload.index
+                ? { ...task, status: ExecutionStatus.Failed, elapsed: 0 }
+                : task);
+            return {
+                ...state,
+                tasks: updatedTasks,
+                error: action.payload.error,
+            };
+        }
         case ExecuteActionType.CancelExecution: {
-            const updatedTaskInfos = state.tasks.map((task, taskIndex) => {
-                if (taskIndex < action.payload.completed) {
-                    return { ...task, status: ExecutionStatus.Success };
-                }
-                else if (taskIndex === action.payload.completed) {
+            // Mark running task as aborted, pending tasks as cancelled
+            const updatedTasks = state.tasks.map((task) => {
+                if (task.status === ExecutionStatus.Running) {
                     return { ...task, status: ExecutionStatus.Aborted };
                 }
-                else {
+                else if (task.status === ExecutionStatus.Pending) {
                     return { ...task, status: ExecutionStatus.Cancelled };
                 }
+                return task;
             });
             return {
                 ...state,
-                tasks: updatedTaskInfos,
+                tasks: updatedTasks,
             };
         }
         default:

package/dist/execution/runner.js

@@ -0,0 +1,99 @@
+import { ExecutionResult, ExecutionStatus, executeCommand, setOutputCallback, } from '../services/shell.js';
+import { calculateElapsed } from '../services/utils.js';
+// Maximum number of output lines to keep in memory
+const MAX_OUTPUT_LINES = 128;
+/**
+ * Limit output to last MAX_OUTPUT_LINES lines to prevent memory exhaustion
+ */
+function limitLines(output) {
+    const lines = output.split('\n');
+    return lines.slice(-MAX_OUTPUT_LINES).join('\n');
+}
+/**
+ * Execute a single task and track its progress.
+ * All execution logic is contained here, outside of React components.
+ */
+export async function executeTask(command, index, callbacks) {
+    const startTime = Date.now();
+    let stdout = '';
+    let stderr = '';
+    let error = '';
+    let workdir;
+    // Helper to create current output snapshot
+    const createOutput = () => ({
+        stdout,
+        stderr,
+        error,
+        workdir,
+    });
+    // Throttle updates to avoid excessive re-renders (100ms minimum interval)
+    let lastUpdateTime = 0;
+    let pendingTimeout;
+    const throttledUpdate = () => {
+        const now = Date.now();
+        if (now - lastUpdateTime >= 100) {
+            lastUpdateTime = now;
+            callbacks.onUpdate(createOutput());
+        }
+        else if (!pendingTimeout) {
+            pendingTimeout = setTimeout(() => {
+                pendingTimeout = undefined;
+                lastUpdateTime = Date.now();
+                callbacks.onUpdate(createOutput());
+            }, 100 - (now - lastUpdateTime));
+        }
+    };
+    // Set up output streaming callback
+    setOutputCallback((data, stream) => {
+        if (stream === 'stdout') {
+            stdout = limitLines(stdout + data);
+        }
+        else {
+            stderr = limitLines(stderr + data);
+        }
+        throttledUpdate();
+    });
+    try {
+        const result = await executeCommand(command, undefined, index);
+        // Clear callback and pending timeout
+        setOutputCallback(undefined);
+        clearTimeout(pendingTimeout);
+        const elapsed = calculateElapsed(startTime);
+        // Update final output from result
+        stdout = result.output;
+        stderr = result.errors;
+        workdir = result.workdir;
+        if (result.result === ExecutionResult.Success) {
+            const output = createOutput();
+            callbacks.onUpdate(output);
+            callbacks.onComplete(elapsed, output);
+            return { status: ExecutionStatus.Success, elapsed, output };
+        }
+        else {
+            const errorMsg = result.errors || result.error || 'Command failed';
+            error = errorMsg;
+            const output = createOutput();
+            callbacks.onUpdate(output);
+            callbacks.onError(errorMsg, output);
+            return { status: ExecutionStatus.Failed, elapsed, output };
+        }
+    }
+    catch (err) {
+        // Clear callback and pending timeout
+        setOutputCallback(undefined);
+        clearTimeout(pendingTimeout);
+        const elapsed = calculateElapsed(startTime);
+        const errorMsg = err instanceof Error ? err.message : 'Unknown error';
+        error = errorMsg;
+        const output = createOutput();
+        callbacks.onUpdate(output);
+        callbacks.onError(errorMsg, output);
+        return { status: ExecutionStatus.Failed, elapsed, output };
+    }
+}
+/**
+ * Create an empty execution output
+ */
+export function createEmptyOutput() {
+    return { stdout: '', stderr: '', error: '' };
+}

package/dist/execution/types.js

@@ -3,10 +3,10 @@ export var ExecuteActionType;
     ExecuteActionType["ProcessingComplete"] = "PROCESSING_COMPLETE";
     ExecuteActionType["CommandsReady"] = "COMMANDS_READY";
     ExecuteActionType["ProcessingError"] = "PROCESSING_ERROR";
+    ExecuteActionType["TaskStarted"] = "TASK_STARTED";
+    ExecuteActionType["TaskProgress"] = "TASK_PROGRESS";
     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["ExecutionComplete"] = "EXECUTION_COMPLETE";
+    ExecuteActionType["TaskError"] = "TASK_ERROR";
     ExecuteActionType["CancelExecution"] = "CANCEL_EXECUTION";
 })(ExecuteActionType || (ExecuteActionType = {}));

package/dist/execution/utils.js

@@ -1,6 +1,28 @@
+import { ExecutionStatus } from '../services/shell.js';
 /**
- * Calculate total elapsed time from task infos
+ * Calculate total elapsed time from task data
  */
 export function getTotalElapsed(tasks) {
     return tasks.reduce((sum, task) => sum + task.elapsed, 0);
 }
+/**
+ * Calculate the number of finished tasks (success, failed, or aborted)
+ */
+export function getCompletedCount(tasks) {
+    return tasks.filter((task) => task.status === ExecutionStatus.Success ||
+        task.status === ExecutionStatus.Failed ||
+        task.status === ExecutionStatus.Aborted).length;
+}
+/**
+ * Get the index of the current task to execute.
+ * Returns the index of the first Running or Pending task, or tasks.length if all done.
+ */
+export function getCurrentTaskIndex(tasks) {
+    const runningIndex = tasks.findIndex((t) => t.status === ExecutionStatus.Running);
+    if (runningIndex !== -1)
+        return runningIndex;
+    const pendingIndex = tasks.findIndex((t) => t.status === ExecutionStatus.Pending);
+    if (pendingIndex !== -1)
+        return pendingIndex;
+    return tasks.length;
+}

package/dist/index.js

@@ -5,7 +5,7 @@ import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 import { render } from 'ink';
 import { DebugLevel } from './configuration/types.js';
-import { Main } from './ui/Main.js';
+import { Main } from './Main.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // Get package info