prompt-language-shell 0.8.8 → 0.9.2

package/dist/services/router.js

@@ -2,10 +2,11 @@ import { asScheduledTasks } from '../types/guards.js';
 import { FeedbackType, TaskType } from '../types/types.js';
 import { saveConfig } from '../configuration/io.js';
 import { getConfigSchema } from '../configuration/schema.js';
+import { createConfigStepsFromSchema } from '../configuration/steps.js';
 import { unflattenConfig } from '../configuration/transformation.js';
-import { saveConfigLabels } from './config-labels.js';
-import { createAnswerDefinition, createConfigDefinitionWithKeys, createConfirmDefinition, createExecuteDefinition, createFeedback, createIntrospectDefinition, createMessage, createScheduleDefinition, createValidateDefinition, } from './components.js';
-import { getCancellationMessage, getMixedTaskTypesError, getUnknownRequestMessage, } from './messages.js';
+import { saveConfigLabels } from '../configuration/labels.js';
+import { createAnswer, createConfig, createConfirm, createExecute, createFeedback, createIntrospect, createMessage, createSchedule, createValidate, } from './components.js';
+import { getCancellationMessage, getConfirmationMessage, getMixedTaskTypesError, getUnknownRequestMessage, } from './messages.js';
 import { validateExecuteTasks } from './validator.js';
 /**
  * Determine the operation name based on task types
@@ -30,15 +31,22 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, life
     const validTasks = tasks.filter((task) => task.type !== TaskType.Ignore && task.type !== TaskType.Discard);
     // Check if no valid tasks remain after filtering
     if (validTasks.length === 0) {
-        const message = createMessage(getUnknownRequestMessage());
-        workflowHandlers.addToQueue(message);
+        const msg = createMessage({ text: getUnknownRequestMessage() });
+        workflowHandlers.addToQueue(msg);
         return;
     }
     const operation = getOperationName(validTasks);
+    // Create routing context for downstream functions
+    const context = {
+        service,
+        userRequest,
+        workflowHandlers,
+        requestHandlers: requestHandlers,
+    };
     if (hasDefineTask) {
         // Has DEFINE tasks - add Schedule to queue for user selection
         // Refinement flow will call this function again with refined tasks
-        const scheduleDefinition = createScheduleDefinition(message, validTasks);
+        const scheduleDefinition = createSchedule({ message, tasks: validTasks });
         workflowHandlers.addToQueue(scheduleDefinition);
     }
     else {
@@ -46,19 +54,27 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, life
         // When Schedule activates, Command moves to timeline
         // When Schedule completes, it moves to pending
         // When Confirm activates, Schedule stays pending (visible for context)
-        const scheduleDefinition = createScheduleDefinition(message, validTasks, () => {
-            // Schedule completed - add Confirm to queue
-            const confirmDefinition = createConfirmDefinition(() => {
-                // User confirmed - complete both Confirm and Schedule, then route to appropriate component
-                lifecycleHandlers.completeActiveAndPending();
-                executeTasksAfterConfirm(validTasks, service, userRequest, workflowHandlers, requestHandlers);
-            }, () => {
-                // User cancelled - complete both Confirm and Schedule, then show cancellation
-                lifecycleHandlers.completeActiveAndPending();
-                const message = getCancellationMessage(operation);
-                workflowHandlers.addToQueue(createFeedback(FeedbackType.Aborted, message));
-            });
-            workflowHandlers.addToQueue(confirmDefinition);
+        const scheduleDefinition = createSchedule({
+            message,
+            tasks: validTasks,
+            onSelectionConfirmed: () => {
+                // Schedule completed - add Confirm to queue
+                const confirmDefinition = createConfirm({
+                    message: getConfirmationMessage(),
+                    onConfirmed: () => {
+                        // User confirmed - complete both Confirm and Schedule, then route
+                        lifecycleHandlers.completeActiveAndPending();
+                        executeTasksAfterConfirm(validTasks, context);
+                    },
+                    onCancelled: () => {
+                        // User cancelled - complete both Confirm and Schedule, then show cancellation
+                        lifecycleHandlers.completeActiveAndPending();
+                        const message = getCancellationMessage(operation);
+                        workflowHandlers.addToQueue(createFeedback({ type: FeedbackType.Aborted, message }));
+                    },
+                });
+                workflowHandlers.addToQueue(confirmDefinition);
+            },
         });
         workflowHandlers.addToQueue(scheduleDefinition);
     }
@@ -91,7 +107,8 @@ function validateTaskTypes(tasks) {
  * Validates task types and routes each type appropriately
  * Supports mixed types at top level with Groups
  */
-function executeTasksAfterConfirm(tasks, service, userRequest, workflowHandlers, requestHandlers) {
+function executeTasksAfterConfirm(tasks, context) {
+    const { service, userRequest, workflowHandlers, requestHandlers } = context;
     // Validate task types (Groups must have uniform subtasks)
     try {
         validateTaskTypes(tasks);
@@ -126,18 +143,28 @@ function executeTasksAfterConfirm(tasks, service, userRequest, workflowHandlers,
                         .join('\n');
                     return `Invalid skill definition "${error.skill}":\n\n${issuesList}`;
                 });
-                workflowHandlers.addToQueue(createFeedback(FeedbackType.Failed, errorMessages.join('\n\n')));
+                workflowHandlers.addToQueue(createFeedback({
+                    type: FeedbackType.Failed,
+                    message: errorMessages.join('\n\n'),
+                }));
                 return;
             }
             else if (validation.missingConfig.length > 0) {
                 // Missing config detected - create ONE Validate component for ALL missing config
-                workflowHandlers.addToQueue(createValidateDefinition(validation.missingConfig, userRequest, service, (error) => {
-                    requestHandlers.onError(error);
-                }, () => {
-                    // After config is complete, resume task routing
-                    routeTasksAfterConfig(scheduledTasks, service, userRequest, workflowHandlers, requestHandlers);
-                }, (operation) => {
-                    requestHandlers.onAborted(operation);
+                workflowHandlers.addToQueue(createValidate({
+                    missingConfig: validation.missingConfig,
+                    userRequest,
+                    service,
+                    onError: (error) => {
+                        requestHandlers.onError(error);
+                    },
+                    onValidationComplete: () => {
+                        // After config is complete, resume task routing
+                        routeTasksAfterConfig(scheduledTasks, context);
+                    },
+                    onAborted: (operation) => {
+                        requestHandlers.onAborted(operation);
+                    },
                 }));
                 return;
             }
@@ -148,13 +175,13 @@ function executeTasksAfterConfirm(tasks, service, userRequest, workflowHandlers,
         }
     }
     // No missing config - proceed with normal routing
-    routeTasksAfterConfig(scheduledTasks, service, userRequest, workflowHandlers, requestHandlers);
+    routeTasksAfterConfig(scheduledTasks, context);
 }
 /**
  * Route tasks after config is complete (or when no config is needed)
  * Processes tasks in order, grouping by type
  */
-function routeTasksAfterConfig(scheduledTasks, service, userRequest, workflowHandlers, requestHandlers) {
+function routeTasksAfterConfig(scheduledTasks, context) {
     // Process tasks in order, preserving Group boundaries
     // Track consecutive standalone tasks to group them by type
     let consecutiveStandaloneTasks = [];
@@ -174,7 +201,7 @@ function routeTasksAfterConfig(scheduledTasks, service, userRequest, workflowHan
             const taskType = type;
             if (typeTasks.length === 0)
                 continue;
-            routeTasksByType(taskType, typeTasks, service, userRequest, workflowHandlers, requestHandlers);
+            routeTasksByType(taskType, typeTasks, context);
         }
         consecutiveStandaloneTasks = [];
     };
@@ -187,7 +214,7 @@ function routeTasksAfterConfig(scheduledTasks, service, userRequest, workflowHan
             if (task.subtasks.length > 0) {
                 const subtasks = task.subtasks;
                 const taskType = subtasks[0].type;
-                routeTasksByType(taskType, subtasks, service, userRequest, workflowHandlers, requestHandlers);
+                routeTasksByType(taskType, subtasks, context);
             }
         }
         else {
@@ -199,38 +226,42 @@ function routeTasksAfterConfig(scheduledTasks, service, userRequest, workflowHan
     processStandaloneTasks();
 }
 /**
- * Route tasks by type to appropriate components
- * Extracted to allow reuse for both Groups and standalone tasks
+ * Route Answer tasks - creates separate Answer component for each question
+ */
+function routeAnswerTasks(tasks, context) {
+    for (const task of tasks) {
+        context.workflowHandlers.addToQueue(createAnswer({ question: task.action, service: context.service }));
+    }
+}
+/**
+ * Route Introspect tasks - creates single Introspect component for all tasks
+ */
+function routeIntrospectTasks(tasks, context) {
+    context.workflowHandlers.addToQueue(createIntrospect({ tasks, service: context.service }));
+}
+/**
+ * Route Config tasks - extracts keys, caches labels, creates Config component
  */
-function routeTasksByType(taskType, typeTasks, service, userRequest, workflowHandlers, requestHandlers) {
-    if (taskType === TaskType.Answer) {
-        // Create separate Answer component for each question
-        for (const task of typeTasks) {
-            workflowHandlers.addToQueue(createAnswerDefinition(task.action, service));
+function routeConfigTasks(tasks, context) {
+    const configKeys = tasks
+        .map((task) => task.params?.key)
+        .filter((key) => key !== undefined);
+    // Extract and cache labels from task descriptions
+    // Only cache labels for dynamically discovered keys (not in schema)
+    const schema = getConfigSchema();
+    const labels = {};
+    for (const task of tasks) {
+        const key = task.params?.key;
+        if (key && task.action && !(key in schema)) {
+            labels[key] = task.action;
         }
     }
-    else if (taskType === TaskType.Introspect) {
-        workflowHandlers.addToQueue(createIntrospectDefinition(typeTasks, service));
+    if (Object.keys(labels).length > 0) {
+        saveConfigLabels(labels);
     }
-    else if (taskType === TaskType.Config) {
-        // Route to Config flow - extract keys and descriptions from task params
-        const configKeys = typeTasks
-            .map((task) => task.params?.key)
-            .filter((key) => key !== undefined);
-        // Extract and cache labels from task descriptions
-        // Only cache labels for dynamically discovered keys (not in schema)
-        const schema = getConfigSchema();
-        const labels = {};
-        for (const task of typeTasks) {
-            const key = task.params?.key;
-            if (key && task.action && !(key in schema)) {
-                labels[key] = task.action;
-            }
-        }
-        if (Object.keys(labels).length > 0) {
-            saveConfigLabels(labels);
-        }
-        workflowHandlers.addToQueue(createConfigDefinitionWithKeys(configKeys, (config) => {
+    context.workflowHandlers.addToQueue(createConfig({
+        steps: createConfigStepsFromSchema(configKeys),
+        onFinished: (config) => {
             // Save config - Config component will handle completion and feedback
             try {
                 // Convert flat dotted keys to nested structure grouped by section
@@ -246,12 +277,34 @@ function routeTasksByType(taskType, typeTasks, service, userRequest, workflowHan
                     : 'Failed to save configuration';
                 throw new Error(errorMessage);
             }
-        }, (operation) => {
-            requestHandlers.onAborted(operation);
-        }));
-    }
-    else if (taskType === TaskType.Execute) {
-        // Execute tasks (validation already happened upfront in executeTasksAfterConfirm)
-        workflowHandlers.addToQueue(createExecuteDefinition(typeTasks, service));
+        },
+        onAborted: (operation) => {
+            context.requestHandlers.onAborted(operation);
+        },
+    }));
+}
+/**
+ * Route Execute tasks - creates Execute component (validation already done)
+ */
+function routeExecuteTasks(tasks, context) {
+    context.workflowHandlers.addToQueue(createExecute({ tasks, service: context.service }));
+}
+/**
+ * Registry mapping task types to their route handlers
+ */
+const taskRouteHandlers = {
+    [TaskType.Answer]: routeAnswerTasks,
+    [TaskType.Introspect]: routeIntrospectTasks,
+    [TaskType.Config]: routeConfigTasks,
+    [TaskType.Execute]: routeExecuteTasks,
+};
+/**
+ * Route tasks by type to appropriate components
+ * Uses registry pattern for extensibility
+ */
+function routeTasksByType(taskType, tasks, context) {
+    const handler = taskRouteHandlers[taskType];
+    if (handler) {
+        handler(tasks, context);
     }
 }

package/dist/services/shell.js

@@ -1,3 +1,4 @@
+import { spawn } from 'child_process';
 export var ExecutionStatus;
 (function (ExecutionStatus) {
     ExecutionStatus["Pending"] = "pending";
@@ -58,18 +59,186 @@ export class DummyExecutor {
         });
     }
 }
+// Marker for extracting pwd from command output
+const PWD_MARKER = '__PWD_MARKER_7x9k2m__';
 /**
- * Default executor uses DummyExecutor for development and testing.
- * To implement real shell execution, create a RealExecutor class that:
- * - Spawns process with cmd.command in shell mode using child_process.spawn()
- * - Sets working directory from cmd.workdir
- * - Handles cmd.timeout for command timeout
- * - Captures stdout and stderr streams
- * - Calls onProgress with Running/Success/Failed status
- * - Returns CommandOutput with actual stdout, stderr, exitCode
- * - Handles errors (spawn failures, timeouts, non-zero exit codes)
+ * Parse stdout to extract workdir and clean output.
+ * Returns the cleaned output and the extracted workdir.
  */
-const executor = new DummyExecutor();
+function parseWorkdir(rawOutput) {
+    const markerIndex = rawOutput.lastIndexOf(PWD_MARKER);
+    if (markerIndex === -1) {
+        return { output: rawOutput };
+    }
+    const output = rawOutput.slice(0, markerIndex).trimEnd();
+    const pwdPart = rawOutput.slice(markerIndex + PWD_MARKER.length).trim();
+    const lines = pwdPart.split('\n').filter((l) => l.trim());
+    const workdir = lines[0];
+    return { output, workdir };
+}
+/**
+ * Manages streaming output while filtering out the PWD marker.
+ * Buffers output to avoid emitting partial markers to the callback.
+ */
+class OutputStreamer {
+    chunks = [];
+    emittedLength = 0;
+    callback;
+    constructor(callback) {
+        this.callback = callback;
+    }
+    /**
+     * Add new stdout data and emit safe content to callback.
+     * Buffers data to avoid emitting partial PWD markers.
+     */
+    pushStdout(data) {
+        this.chunks.push(data);
+        if (!this.callback)
+            return;
+        const accumulated = this.chunks.join('');
+        const markerIndex = accumulated.indexOf(PWD_MARKER);
+        if (markerIndex !== -1) {
+            // Marker found - emit everything before it (trimmed)
+            this.emitUpTo(accumulated.slice(0, markerIndex).trimEnd().length);
+        }
+        else {
+            // No marker yet - emit all but buffer for potential partial marker
+            const bufferSize = PWD_MARKER.length + 5;
+            const safeLength = Math.max(this.emittedLength, accumulated.length - bufferSize);
+            this.emitUpTo(safeLength);
+        }
+    }
+    /**
+     * Emit content up to the specified length if there's new content.
+     */
+    emitUpTo(length) {
+        if (length > this.emittedLength && this.callback) {
+            const accumulated = this.chunks.join('');
+            const newContent = accumulated.slice(this.emittedLength, length);
+            this.callback(newContent, 'stdout');
+            this.emittedLength = length;
+        }
+    }
+    /**
+     * Get the accumulated raw output.
+     */
+    getAccumulated() {
+        return this.chunks.join('');
+    }
+}
+/**
+ * Real executor that spawns shell processes and captures output.
+ */
+export class RealExecutor {
+    outputCallback;
+    constructor(outputCallback) {
+        this.outputCallback = outputCallback;
+    }
+    /**
+     * Set or update the output callback
+     */
+    setOutputCallback(callback) {
+        this.outputCallback = callback;
+    }
+    execute(cmd, onProgress, _ = 0) {
+        return new Promise((resolve) => {
+            onProgress?.(ExecutionStatus.Running);
+            const stderr = [];
+            // Wrap command to capture final working directory
+            const wrappedCommand = `${cmd.command}; __exit=$?; echo ""; echo "${PWD_MARKER}"; pwd; exit $__exit`;
+            // Wrap spawn in try/catch to handle synchronous errors
+            let child;
+            try {
+                child = spawn(wrappedCommand, {
+                    shell: true,
+                    cwd: cmd.workdir || process.cwd(),
+                });
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Failed to spawn process';
+                const commandResult = {
+                    description: cmd.description,
+                    command: cmd.command,
+                    output: '',
+                    errors: errorMessage,
+                    result: ExecutionResult.Error,
+                    error: errorMessage,
+                };
+                onProgress?.(ExecutionStatus.Failed);
+                resolve(commandResult);
+                return;
+            }
+            // Handle timeout if specified
+            const SIGKILL_GRACE_PERIOD = 3000;
+            let timeoutId;
+            let killTimeoutId;
+            if (cmd.timeout && cmd.timeout > 0) {
+                timeoutId = setTimeout(() => {
+                    child.kill('SIGTERM');
+                    // Escalate to SIGKILL if process doesn't terminate
+                    killTimeoutId = setTimeout(() => {
+                        child.kill('SIGKILL');
+                    }, SIGKILL_GRACE_PERIOD);
+                }, cmd.timeout);
+            }
+            // Use OutputStreamer for buffered stdout streaming
+            const stdoutStreamer = new OutputStreamer(this.outputCallback);
+            child.stdout.on('data', (data) => {
+                stdoutStreamer.pushStdout(data.toString());
+            });
+            child.stderr.on('data', (data) => {
+                const text = data.toString();
+                stderr.push(text);
+                this.outputCallback?.(text, 'stderr');
+            });
+            child.on('error', (error) => {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                if (killTimeoutId)
+                    clearTimeout(killTimeoutId);
+                const commandResult = {
+                    description: cmd.description,
+                    command: cmd.command,
+                    output: stdoutStreamer.getAccumulated(),
+                    errors: error.message,
+                    result: ExecutionResult.Error,
+                    error: error.message,
+                };
+                onProgress?.(ExecutionStatus.Failed);
+                resolve(commandResult);
+            });
+            child.on('close', (code) => {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                if (killTimeoutId)
+                    clearTimeout(killTimeoutId);
+                const success = code === 0;
+                const { output, workdir } = parseWorkdir(stdoutStreamer.getAccumulated());
+                const commandResult = {
+                    description: cmd.description,
+                    command: cmd.command,
+                    output,
+                    errors: stderr.join(''),
+                    result: success ? ExecutionResult.Success : ExecutionResult.Error,
+                    error: success ? undefined : `Exit code: ${code}`,
+                    workdir,
+                };
+                onProgress?.(success ? ExecutionStatus.Success : ExecutionStatus.Failed);
+                resolve(commandResult);
+            });
+        });
+    }
+}
+// Create real executor instance
+const realExecutor = new RealExecutor();
+// Default executor for production use
+const executor = realExecutor;
+/**
+ * Set a callback to receive command output in real-time
+ */
+export function setOutputCallback(callback) {
+    realExecutor.setOutputCallback(callback);
+}
 /**
  * Execute a single shell command
  */

package/dist/services/skills.js

@@ -1,5 +1,6 @@
 import { homedir } from 'os';
 import { join } from 'path';
+import { AppError, ErrorCode } from '../types/errors.js';
 import { defaultFileSystem } from './filesystem.js';
 import { displayWarning } from './logger.js';
 import { getUnknownSkillMessage } from './messages.js';
@@ -189,7 +190,7 @@ export function expandSkillReferences(execution, skillLookup, visited = new Set(
         }
         // Check for circular reference
         if (visited.has(skillName)) {
-            throw new Error(`Circular skill reference detected: ${Array.from(visited).join(' → ')} → ${skillName}`);
+            throw new AppError(`Circular skill reference detected: ${Array.from(visited).join(' → ')} → ${skillName}`, ErrorCode.CircularReference);
         }
         // Second: Match against skill name
         const skill = skillLookup(skillName);

package/dist/skills/answer.md

@@ -110,15 +110,17 @@ They enable cleaner, more reusable component logic.
 
 ## Common Mistakes to Avoid
 
-❌ Starting with "Here's the answer:" or "Let me explain:"
-❌ Exceeding 4 lines or 80 characters per line
-❌ Including unnecessary details
-❌ Using overly technical jargon without explanation
-❌ Repeating the question in the answer
-❌ Using citation tags like `<cite>` or any HTML/XML markup
-
-✅ Direct, concise answers
-✅ Proper line breaks at natural phrase boundaries
-✅ Essential information only
-✅ Clear, accessible language
-✅ Plain text only - no markup tags
+**DO NOT:**
+- Start with "Here's the answer:" or "Let me explain:"
+- Exceed 4 lines or 80 characters per line
+- Include unnecessary details
+- Use overly technical jargon without explanation
+- Repeat the question in the answer
+- Use citation tags like `<cite>` or any HTML/XML markup
+
+**DO:**
+- Give direct, concise answers
+- Use proper line breaks at natural phrase boundaries
+- Include essential information only
+- Use clear, accessible language
+- Use plain text only - no markup tags