prompt-language-shell 0.9.0 → 0.9.2

package/dist/execution/runner.js

@@ -0,0 +1,81 @@
+import { ExecutionResult, ExecutionStatus, executeCommand, setOutputCallback, } from '../services/shell.js';
+import { calculateElapsed } from '../services/utils.js';
+/**
+ * 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,
+    });
+    // Set up output streaming callback
+    setOutputCallback((data, stream) => {
+        if (stream === 'stdout') {
+            stdout += data;
+        }
+        else {
+            stderr += data;
+        }
+        callbacks.onOutputChange?.(createOutput());
+    });
+    callbacks.onStart?.();
+    try {
+        const result = await executeCommand(command, undefined, index);
+        // Clear callback
+        setOutputCallback(undefined);
+        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.onComplete?.(elapsed, output);
+            return {
+                status: ExecutionStatus.Success,
+                elapsed,
+                output,
+            };
+        }
+        else {
+            const errorMsg = result.errors || result.error || 'Command failed';
+            error = errorMsg;
+            const output = createOutput();
+            callbacks.onError?.(errorMsg, elapsed, output);
+            return {
+                status: ExecutionStatus.Failed,
+                elapsed,
+                output,
+            };
+        }
+    }
+    catch (err) {
+        // Clear callback
+        setOutputCallback(undefined);
+        const elapsed = calculateElapsed(startTime);
+        const errorMsg = err instanceof Error ? err.message : 'Unknown error';
+        error = errorMsg;
+        const output = createOutput();
+        callbacks.onError?.(errorMsg, elapsed, output);
+        return {
+            status: ExecutionStatus.Failed,
+            elapsed,
+            output,
+        };
+    }
+}
+/**
+ * Create an empty task output
+ */
+export function createEmptyOutput() {
+    return { stdout: '', stderr: '', error: '' };
+}

package/dist/execution/types.js

@@ -3,6 +3,7 @@ export var ExecuteActionType;
     ExecuteActionType["ProcessingComplete"] = "PROCESSING_COMPLETE";
     ExecuteActionType["CommandsReady"] = "COMMANDS_READY";
     ExecuteActionType["ProcessingError"] = "PROCESSING_ERROR";
+    ExecuteActionType["TaskStarted"] = "TASK_STARTED";
     ExecuteActionType["TaskComplete"] = "TASK_COMPLETE";
     ExecuteActionType["AllTasksComplete"] = "ALL_TASKS_COMPLETE";
     ExecuteActionType["TaskErrorCritical"] = "TASK_ERROR_CRITICAL";

package/dist/execution/utils.js

@@ -1,6 +1,28 @@
+import { ExecutionStatus } from '../services/shell.js';
 /**
  * Calculate total elapsed time from task infos
  */
 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/services/components.js

@@ -1,407 +1,122 @@
 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 { 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) {
-    return {
-        id: randomUUID(),
-        name: ComponentName.Welcome,
-        props: { app },
-        status: ComponentStatus.Awaiting,
-    };
-}
-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
+ * Shared component creation utility
  */
-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;
-}
+const createComponent = (name, props, state, status = ComponentStatus.Awaiting) => ({
+    id: randomUUID(),
+    name,
+    props,
+    ...(state !== undefined ? { state } : {}),
+    status,
+});
 /**
- * Get validation function for a config definition
+ * Create a simple component without state
  */
-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';
-    }
-}
+const createSimpleComponent = (name, props, status) => createComponent(name, props, undefined, status);
 /**
- * Create config steps from schema for specified keys
+ * Create a managed component with state
  */
-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),
-                };
-            }
-        }
-    });
-}
-export function createConfigDefinition(onFinished, onAborted) {
-    return {
-        id: randomUUID(),
-        name: ComponentName.Config,
-        status: ComponentStatus.Awaiting,
-        state: {
-            values: {},
-            completedStep: 0,
-            selectedIndex: 0,
-        },
-        props: {
-            steps: createConfigSteps(),
-            onFinished,
-            onAborted,
-        },
-    };
-}
+const createManagedComponent = (name, props, state, status) => createComponent(name, props, state, status);
 /**
- * Create config definition with specific keys
+ * Initial state constants for managed components
  */
-export function createConfigDefinitionWithKeys(keys, onFinished, onAborted) {
-    return {
-        id: randomUUID(),
-        name: ComponentName.Config,
-        status: ComponentStatus.Awaiting,
-        state: {
-            values: {},
-            completedStep: 0,
-            selectedIndex: 0,
-        },
-        props: {
-            steps: createConfigStepsFromSchema(keys),
-            onFinished,
-            onAborted,
-        },
-    };
-}
-export function createCommandDefinition(command, service) {
-    return {
-        id: randomUUID(),
-        name: ComponentName.Command,
-        status: ComponentStatus.Awaiting,
-        state: {
-            error: null,
-            message: null,
-            tasks: [],
-        },
-        props: {
-            command,
-            service,
-        },
-    };
-}
-export function createScheduleDefinition(message, tasks, onSelectionConfirmed) {
-    return {
-        id: randomUUID(),
-        name: ComponentName.Schedule,
-        status: ComponentStatus.Awaiting,
-        state: {
-            highlightedIndex: null,
-            currentDefineGroupIndex: 0,
-            completedSelections: [],
-        },
-        props: {
-            message,
-            tasks,
-            onSelectionConfirmed,
-        },
-    };
-}
-export function createFeedback(type, ...messages) {
-    return {
-        id: randomUUID(),
-        name: ComponentName.Feedback,
-        props: {
-            type,
-            message: messages.join('\n\n'),
-        },
-        status: ComponentStatus.Awaiting,
-    };
-}
-export function createMessage(text) {
-    return {
-        id: randomUUID(),
-        name: ComponentName.Message,
-        props: {
-            text,
-        },
-        status: ComponentStatus.Awaiting,
-    };
-}
-export function createDebugDefinition(title, content, color) {
-    return {
-        id: randomUUID(),
-        name: ComponentName.Debug,
-        props: {
-            title,
-            content,
-            color,
-        },
-        status: ComponentStatus.Awaiting,
-    };
-}
-export function createRefinement(text, onAborted) {
-    return {
-        id: randomUUID(),
-        name: ComponentName.Refinement,
-        status: ComponentStatus.Awaiting,
-        state: {},
-        props: {
-            text,
-            onAborted,
-        },
-    };
-}
-export function createConfirmDefinition(onConfirmed, onCancelled) {
-    return {
-        id: randomUUID(),
-        name: ComponentName.Confirm,
-        status: ComponentStatus.Awaiting,
-        state: {
-            confirmed: false,
-            selectedIndex: 0,
-        },
-        props: {
-            message: getConfirmationMessage(),
-            onConfirmed,
-            onCancelled,
-        },
-    };
-}
-export function createIntrospectDefinition(tasks, service) {
-    return {
-        id: randomUUID(),
-        name: ComponentName.Introspect,
-        status: ComponentStatus.Awaiting,
-        state: {
-            error: null,
-            capabilities: [],
-            message: null,
-        },
-        props: {
-            tasks,
-            service,
-        },
-    };
-}
-export function createReportDefinition(message, capabilities) {
-    return {
-        id: randomUUID(),
-        name: ComponentName.Report,
-        props: {
-            message,
-            capabilities,
-        },
-        status: ComponentStatus.Awaiting,
-    };
-}
-export function createAnswerDefinition(question, service) {
-    return {
-        id: randomUUID(),
-        name: ComponentName.Answer,
-        status: ComponentStatus.Awaiting,
-        state: {
-            error: null,
-            answer: null,
-        },
-        props: {
-            question,
-            service,
-        },
-    };
-}
-export function isSimple(component) {
-    return !('state' in component);
-}
+const InitialConfigState = {
+    values: {},
+    completedStep: 0,
+    selectedIndex: 0,
+};
+const InitialCommandState = {
+    error: null,
+    message: null,
+    tasks: [],
+};
+const InitialScheduleState = {
+    highlightedIndex: null,
+    currentDefineGroupIndex: 0,
+    completedSelections: [],
+};
+const InitialRefinementState = {};
+const InitialConfirmState = {
+    confirmed: false,
+    selectedIndex: 0,
+};
+const InitialIntrospectState = {
+    error: null,
+    capabilities: [],
+    message: null,
+};
+const InitialAnswerState = {
+    error: null,
+    answer: null,
+};
+const InitialExecuteState = {
+    error: null,
+    message: '',
+    summary: '',
+    tasks: [],
+    completionMessage: null,
+};
+const InitialValidateState = {
+    error: null,
+    completionMessage: null,
+    configRequirements: [],
+    validated: false,
+};
 /**
- * Mark a component as done. Returns the component to be added to timeline.
- * Components use handlers.updateState to save their state before completion,
- * so this function sets the status to Done and returns the updated component.
+ * Create a welcome component that displays application information
  */
-export function markAsDone(component) {
-    return { ...component, status: ComponentStatus.Done };
-}
-export function createExecuteDefinition(tasks, service) {
-    return {
-        id: randomUUID(),
-        name: ComponentName.Execute,
-        status: ComponentStatus.Awaiting,
-        state: {
-            error: null,
-            message: '',
-            summary: '',
-            tasks: [],
-            completed: 0,
-            completionMessage: null,
-        },
-        props: {
-            tasks,
-            service,
-        },
-    };
-}
-export function createValidateDefinition(missingConfig, userRequest, service, onError, onValidationComplete, onAborted) {
-    return {
-        id: randomUUID(),
-        name: ComponentName.Validate,
-        status: ComponentStatus.Awaiting,
-        state: {
-            error: null,
-            completionMessage: null,
-            configRequirements: [],
-            validated: false,
-        },
-        props: {
-            missingConfig,
-            userRequest,
-            service,
-            onError,
-            onValidationComplete,
-            onAborted,
-        },
-    };
-}
+export const createWelcome = (props, status) => createSimpleComponent(ComponentName.Welcome, props, status);
+/**
+ * Create a feedback component that displays status messages
+ */
+export const createFeedback = (props, status) => createSimpleComponent(ComponentName.Feedback, props, status);
+/**
+ * Create a message component that displays informational text
+ */
+export const createMessage = (props, status) => createSimpleComponent(ComponentName.Message, props, status);
+/**
+ * Create a debug component that displays diagnostic information
+ */
+export const createDebug = (props, status) => createSimpleComponent(ComponentName.Debug, props, status);
+/**
+ * Create a report component that displays capability listings
+ */
+export const createReport = (props, status) => createSimpleComponent(ComponentName.Report, props, status);
+/**
+ * Create a configuration component for multi-step user input
+ */
+export const createConfig = (props, status) => createManagedComponent(ComponentName.Config, props, InitialConfigState, status);
+/**
+ * Create a command component that processes user requests via LLM
+ */
+export const createCommand = (props, status) => createManagedComponent(ComponentName.Command, props, InitialCommandState, status);
+/**
+ * Create a schedule component that displays and manages task execution plans
+ */
+export const createSchedule = (props, status) => createManagedComponent(ComponentName.Schedule, props, InitialScheduleState, status);
+/**
+ * Create a refinement component for interactive task selection
+ */
+export const createRefinement = (props, status) => createManagedComponent(ComponentName.Refinement, props, InitialRefinementState, status);
+/**
+ * Create a confirmation component that prompts user for yes/no decisions
+ */
+export const createConfirm = (props, status) => createManagedComponent(ComponentName.Confirm, props, InitialConfirmState, status);
+/**
+ * Create an introspect component that lists available capabilities
+ */
+export const createIntrospect = (props, status) => createManagedComponent(ComponentName.Introspect, props, InitialIntrospectState, status);
+/**
+ * Create an answer component that responds to information requests via LLM
+ */
+export const createAnswer = (props, status) => createManagedComponent(ComponentName.Answer, props, InitialAnswerState, status);
+/**
+ * Create an execute component that runs shell commands and processes operations
+ */
+export const createExecute = (props, status) => createManagedComponent(ComponentName.Execute, props, InitialExecuteState, status);
+/**
+ * Create a validate component that checks and collects missing configuration
+ */
+export const createValidate = (props, status) => createManagedComponent(ComponentName.Validate, props, InitialValidateState, status);

package/dist/services/logger.js

@@ -1,5 +1,5 @@
 import { DebugLevel } from '../configuration/types.js';
-import { createDebugDefinition } from './components.js';
+import { createDebug } from './components.js';
 import { loadDebugSetting } from '../configuration/io.js';
 import { Palette } from './colors.js';
 /**
@@ -68,7 +68,7 @@ export function logPrompt(toolName, command, instructions) {
     const lines = instructions.split('\n').length;
     const bytes = Buffer.byteLength(instructions, 'utf-8');
     const title = `SYSTEM PROMPT (${String(lines)} lines, ${String(bytes)} bytes)`;
-    return createDebugDefinition(title, content, Palette.Gray);
+    return createDebug({ title, content, color: Palette.Gray });
 }
 /**
  * Create debug component for LLM responses received
@@ -85,5 +85,5 @@ export function logResponse(toolName, response, durationMs) {
         JSON.stringify(response, null, 2),
     ].join('\n');
     const title = `LLM RESPONSE (${String(durationMs)} ms)`;
-    return createDebugDefinition(title, content, Palette.AshGray);
+    return createDebug({ title, content, color: Palette.AshGray });
 }

package/dist/services/refinement.js

@@ -8,8 +8,11 @@ import { routeTasksWithConfirm } from './router.js';
  */
 export async function handleRefinement(selectedTasks, service, originalCommand, lifecycleHandlers, workflowHandlers, requestHandlers) {
     // Create and add refinement component to queue
-    const refinementDef = createRefinement(getRefiningMessage(), (operation) => {
-        requestHandlers.onAborted(operation);
+    const refinementDef = createRefinement({
+        text: getRefiningMessage(),
+        onAborted: (operation) => {
+            requestHandlers.onAborted(operation);
+        },
     });
     workflowHandlers.addToQueue(refinementDef);
     try {