prompt-language-shell 0.9.0 → 0.9.2

package/dist/{services/config-labels.js → configuration/labels.js}

@@ -1,6 +1,6 @@
 import { homedir } from 'os';
 import { join } from 'path';
-import { defaultFileSystem } from './filesystem.js';
+import { defaultFileSystem } from '../services/filesystem.js';
 /**
  * Get the path to the config labels cache file
  */

package/dist/configuration/schema.js

@@ -1,7 +1,7 @@
 import YAML from 'yaml';
 import { AnthropicModel, ConfigDefinitionType, DebugLevel, SUPPORTED_DEBUG_LEVELS, SUPPORTED_MODELS, } from './types.js';
-import { flattenConfig } from '../services/config-utils.js';
-import { getConfigLabel } from '../services/config-labels.js';
+import { flattenConfig } from './transformation.js';
+import { getConfigLabel } from './labels.js';
 import { defaultFileSystem } from '../services/filesystem.js';
 import { getConfigPath, loadConfig } from './io.js';
 /**

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 '../ui/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

@@ -19,7 +19,6 @@ export function handleTaskCompletion(index, elapsed, context) {
                 message,
                 summary,
                 tasks: updatedTaskInfos,
-                completed: index + 1,
                 completionMessage: null,
                 error: null,
             },
@@ -39,7 +38,6 @@ export function handleTaskCompletion(index, elapsed, context) {
             message,
             summary,
             tasks: updatedTaskInfos,
-            completed: index + 1,
             completionMessage: completion,
             error: null,
         },
@@ -65,7 +63,6 @@ export function handleTaskFailure(index, error, elapsed, context) {
                 message,
                 summary,
                 tasks: updatedTaskInfos,
-                completed: index + 1,
                 completionMessage: null,
                 error: null,
             },
@@ -83,7 +80,6 @@ export function handleTaskFailure(index, error, elapsed, context) {
                 message,
                 summary,
                 tasks: updatedTaskInfos,
-                completed: index + 1,
                 completionMessage: null,
                 error: null,
             },
@@ -104,7 +100,6 @@ export function handleTaskFailure(index, error, elapsed, context) {
             message,
             summary,
             tasks: updatedTaskInfos,
-            completed: index + 1,
             completionMessage: completion,
             error: null,
         },
@@ -114,12 +109,11 @@ export function handleTaskFailure(index, error, elapsed, context) {
 /**
  * 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/hooks.js

@@ -0,0 +1,291 @@
+import { useCallback, useEffect, useRef, useState, } from 'react';
+import { ComponentStatus, } from '../types/components.js';
+import { FeedbackType } from '../types/types.js';
+import { createFeedback, createMessage } from '../services/components.js';
+import { formatErrorMessage, getExecutionErrorMessage, } from '../services/messages.js';
+import { ExecutionStatus } from '../services/shell.js';
+import { ensureMinimumTime } from '../services/timing.js';
+import { handleTaskCompletion, handleTaskFailure } from './handlers.js';
+import { processTasks } from './processing.js';
+import { executeTask } from './runner.js';
+import { ExecuteActionType } from './types.js';
+import { getCurrentTaskIndex } from './utils.js';
+const ELAPSED_UPDATE_INTERVAL = 1000;
+/**
+ * Track elapsed time from a start timestamp.
+ * Returns 0 when not active or no start time.
+ */
+export function useElapsedTimer(startTime, isActive) {
+    const [elapsed, setElapsed] = useState(0);
+    useEffect(() => {
+        if (!startTime || !isActive)
+            return;
+        const interval = setInterval(() => {
+            setElapsed(Date.now() - startTime);
+        }, ELAPSED_UPDATE_INTERVAL);
+        return () => {
+            clearInterval(interval);
+        };
+    }, [startTime, isActive]);
+    return elapsed;
+}
+/**
+ * Manage live output and timing for the currently executing task.
+ * Groups related state for tracking a running task's output.
+ */
+export function useLiveTaskOutput() {
+    const [output, setOutput] = useState({
+        stdout: '',
+        stderr: '',
+        error: '',
+    });
+    const [startTime, setStartTime] = useState(null);
+    const start = useCallback(() => {
+        setOutput({ stdout: '', stderr: '', error: '' });
+        setStartTime(Date.now());
+    }, []);
+    const stop = useCallback(() => {
+        setStartTime(null);
+    }, []);
+    return {
+        output,
+        startTime,
+        setOutput,
+        start,
+        stop,
+    };
+}
+/**
+ * Handle execution cancellation with a ref-based flag.
+ * The ref is needed because callbacks check the current cancellation state.
+ */
+export function useCancellation() {
+    const cancelledRef = useRef(false);
+    const cancel = useCallback(() => {
+        cancelledRef.current = true;
+    }, []);
+    const reset = useCallback(() => {
+        cancelledRef.current = false;
+    }, []);
+    return {
+        cancelledRef,
+        cancel,
+        reset,
+    };
+}
+const MINIMUM_PROCESSING_TIME = 400;
+/**
+ * Helper to create ExecuteState with defaults
+ */
+function createExecuteState(overrides = {}) {
+    return {
+        message: '',
+        summary: '',
+        tasks: [],
+        completionMessage: null,
+        error: null,
+        ...overrides,
+    };
+}
+/**
+ * Process input tasks through AI to generate executable commands.
+ * Handles the initial phase of task execution.
+ */
+export function useTaskProcessor(config) {
+    const { inputTasks, service, isActive, hasProcessed, tasksCount, dispatch, requestHandlers, lifecycleHandlers, workflowHandlers, } = config;
+    useEffect(() => {
+        if (!isActive || tasksCount > 0 || hasProcessed) {
+            return;
+        }
+        let mounted = true;
+        async function process(svc) {
+            const startTime = Date.now();
+            try {
+                const result = await processTasks(inputTasks, svc);
+                await ensureMinimumTime(startTime, MINIMUM_PROCESSING_TIME);
+                if (!mounted)
+                    return;
+                // Add debug components to timeline if present
+                if (result.debug?.length) {
+                    workflowHandlers.addToTimeline(...result.debug);
+                }
+                if (result.commands.length === 0) {
+                    if (result.error) {
+                        const errorMessage = getExecutionErrorMessage(result.error);
+                        workflowHandlers.addToTimeline(createMessage({ text: errorMessage }, ComponentStatus.Done));
+                        requestHandlers.onCompleted(createExecuteState({ message: result.message }));
+                        lifecycleHandlers.completeActive();
+                        return;
+                    }
+                    dispatch({
+                        type: ExecuteActionType.ProcessingComplete,
+                        payload: { message: result.message },
+                    });
+                    requestHandlers.onCompleted(createExecuteState({ message: result.message }));
+                    lifecycleHandlers.completeActive();
+                    return;
+                }
+                // Create task infos from commands
+                const taskInfos = result.commands.map((cmd, index) => ({
+                    label: inputTasks[index]?.action ?? cmd.description,
+                    command: cmd,
+                    status: ExecutionStatus.Pending,
+                    elapsed: 0,
+                }));
+                dispatch({
+                    type: ExecuteActionType.CommandsReady,
+                    payload: {
+                        message: result.message,
+                        summary: result.summary,
+                        tasks: taskInfos,
+                    },
+                });
+                requestHandlers.onCompleted(createExecuteState({
+                    message: result.message,
+                    summary: result.summary,
+                    tasks: taskInfos,
+                }));
+            }
+            catch (err) {
+                await ensureMinimumTime(startTime, MINIMUM_PROCESSING_TIME);
+                if (mounted) {
+                    const errorMessage = formatErrorMessage(err);
+                    dispatch({
+                        type: ExecuteActionType.ProcessingError,
+                        payload: { error: errorMessage },
+                    });
+                    requestHandlers.onCompleted(createExecuteState({ error: errorMessage }));
+                    requestHandlers.onError(errorMessage);
+                }
+            }
+        }
+        void process(service);
+        return () => {
+            mounted = false;
+        };
+    }, [
+        inputTasks,
+        isActive,
+        service,
+        requestHandlers,
+        lifecycleHandlers,
+        workflowHandlers,
+        tasksCount,
+        hasProcessed,
+        dispatch,
+    ]);
+}
+/**
+ * Execute tasks sequentially, managing state and handling completion/errors.
+ */
+export function useTaskExecutor(config) {
+    const { isActive, tasks, message, summary, error, workdir, setWorkdir, cancelledRef, liveOutput, dispatch, requestHandlers, lifecycleHandlers, workflowHandlers, } = config;
+    const currentTaskIndex = getCurrentTaskIndex(tasks);
+    useEffect(() => {
+        if (!isActive ||
+            tasks.length === 0 ||
+            currentTaskIndex >= tasks.length ||
+            error) {
+            return;
+        }
+        const currentTask = tasks[currentTaskIndex];
+        if (currentTask.status !== ExecutionStatus.Pending) {
+            return;
+        }
+        cancelledRef.current = false;
+        // Mark task as started (running)
+        dispatch({
+            type: ExecuteActionType.TaskStarted,
+            payload: { index: currentTaskIndex },
+        });
+        // Reset live state for new task
+        liveOutput.start();
+        // Merge workdir into command
+        const command = workdir
+            ? { ...currentTask.command, workdir }
+            : currentTask.command;
+        void executeTask(command, currentTaskIndex, {
+            onOutputChange: (output) => {
+                if (!cancelledRef.current) {
+                    liveOutput.setOutput(output);
+                }
+            },
+            onComplete: (elapsed, output) => {
+                if (cancelledRef.current)
+                    return;
+                liveOutput.stop();
+                // Track working directory
+                if (output.workdir) {
+                    setWorkdir(output.workdir);
+                }
+                const tasksWithOutput = tasks.map((task, i) => i === currentTaskIndex
+                    ? {
+                        ...task,
+                        stdout: output.stdout,
+                        stderr: output.stderr,
+                        error: output.error,
+                    }
+                    : task);
+                const result = handleTaskCompletion(currentTaskIndex, elapsed, {
+                    tasks: tasksWithOutput,
+                    message,
+                    summary,
+                });
+                dispatch(result.action);
+                requestHandlers.onCompleted(result.finalState);
+                if (result.shouldComplete) {
+                    lifecycleHandlers.completeActive();
+                }
+            },
+            onError: (errorMsg, elapsed, output) => {
+                if (cancelledRef.current)
+                    return;
+                liveOutput.stop();
+                // Track working directory
+                if (output.workdir) {
+                    setWorkdir(output.workdir);
+                }
+                const tasksWithOutput = tasks.map((task, i) => i === currentTaskIndex
+                    ? {
+                        ...task,
+                        stdout: output.stdout,
+                        stderr: output.stderr,
+                        error: output.error,
+                    }
+                    : task);
+                const result = handleTaskFailure(currentTaskIndex, errorMsg, elapsed, {
+                    tasks: tasksWithOutput,
+                    message,
+                    summary,
+                });
+                dispatch(result.action);
+                requestHandlers.onCompleted(result.finalState);
+                if (result.action.type === ExecuteActionType.TaskErrorCritical) {
+                    const criticalErrorMessage = getExecutionErrorMessage(errorMsg);
+                    workflowHandlers.addToQueue(createFeedback({
+                        type: FeedbackType.Failed,
+                        message: criticalErrorMessage,
+                    }));
+                }
+                if (result.shouldComplete) {
+                    lifecycleHandlers.completeActive();
+                }
+            },
+        });
+    }, [
+        isActive,
+        tasks,
+        currentTaskIndex,
+        message,
+        summary,
+        error,
+        workdir,
+        setWorkdir,
+        cancelledRef,
+        liveOutput,
+        dispatch,
+        requestHandlers,
+        lifecycleHandlers,
+        workflowHandlers,
+    ]);
+}

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,6 +31,15 @@ export function executeReducer(state, action) {
                 error: action.payload.error,
                 hasProcessed: true,
             };
+        case ExecuteActionType.TaskStarted: {
+            const updatedTasks = state.tasks.map((task, i) => i === action.payload.index
+                ? { ...task, status: ExecutionStatus.Running }
+                : task);
+            return {
+                ...state,
+                tasks: updatedTasks,
+            };
+        }
         case ExecuteActionType.TaskComplete: {
             const updatedTaskInfos = state.tasks.map((task, i) => i === action.payload.index
                 ? {
@@ -44,7 +51,6 @@ export function executeReducer(state, action) {
             return {
                 ...state,
                 tasks: updatedTaskInfos,
-                completed: action.payload.index + 1,
             };
         }
         case ExecuteActionType.AllTasksComplete: {
@@ -60,7 +66,6 @@ export function executeReducer(state, action) {
             return {
                 ...state,
                 tasks: updatedTaskInfos,
-                completed: action.payload.index + 1,
                 completionMessage: completion,
             };
         }
@@ -85,7 +90,6 @@ export function executeReducer(state, action) {
             return {
                 ...state,
                 tasks: updatedTaskInfos,
-                completed: action.payload.index + 1,
             };
         }
         case ExecuteActionType.LastTaskError: {
@@ -101,21 +105,19 @@ export function executeReducer(state, action) {
             return {
                 ...state,
                 tasks: updatedTaskInfos,
-                completed: action.payload.index + 1,
                 completionMessage: completion,
             };
         }
         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 updatedTaskInfos = 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,