prompt-language-shell 0.8.6 → 0.9.0

package/dist/services/router.js

@@ -30,11 +30,18 @@ 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(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
@@ -49,9 +56,9 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, life
         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
+                // User confirmed - complete both Confirm and Schedule, then route
                 lifecycleHandlers.completeActiveAndPending();
-                executeTasksAfterConfirm(validTasks, service, userRequest, workflowHandlers, requestHandlers);
+                executeTasksAfterConfirm(validTasks, context);
             }, () => {
                 // User cancelled - complete both Confirm and Schedule, then show cancellation
                 lifecycleHandlers.completeActiveAndPending();
@@ -91,7 +98,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);
@@ -101,6 +109,60 @@ function executeTasksAfterConfirm(tasks, service, userRequest, workflowHandlers,
         return;
     }
     const scheduledTasks = asScheduledTasks(tasks);
+    // Collect ALL Execute tasks (standalone and from groups) for upfront validation
+    const allExecuteTasks = [];
+    for (const task of scheduledTasks) {
+        if (task.type === TaskType.Execute) {
+            allExecuteTasks.push(task);
+        }
+        else if (task.type === TaskType.Group && task.subtasks) {
+            const subtasks = task.subtasks;
+            if (subtasks.length > 0 && subtasks[0].type === TaskType.Execute) {
+                allExecuteTasks.push(...subtasks);
+            }
+        }
+    }
+    // Validate ALL Execute tasks together to collect ALL missing config upfront
+    if (allExecuteTasks.length > 0) {
+        try {
+            const validation = validateExecuteTasks(allExecuteTasks);
+            if (validation.validationErrors.length > 0) {
+                // Show error feedback for invalid skills
+                const errorMessages = validation.validationErrors.map((error) => {
+                    const issuesList = error.issues
+                        .map((issue) => `  - ${issue}`)
+                        .join('\n');
+                    return `Invalid skill definition "${error.skill}":\n\n${issuesList}`;
+                });
+                workflowHandlers.addToQueue(createFeedback(FeedbackType.Failed, 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, context);
+                }, (operation) => {
+                    requestHandlers.onAborted(operation);
+                }));
+                return;
+            }
+        }
+        catch (error) {
+            requestHandlers.onError(error instanceof Error ? error.message : String(error));
+            return;
+        }
+    }
+    // No missing config - proceed with normal routing
+    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, context) {
     // Process tasks in order, preserving Group boundaries
     // Track consecutive standalone tasks to group them by type
     let consecutiveStandaloneTasks = [];
@@ -120,7 +182,7 @@ function executeTasksAfterConfirm(tasks, service, userRequest, workflowHandlers,
             const taskType = type;
             if (typeTasks.length === 0)
                 continue;
-            routeTasksByType(taskType, typeTasks, service, userRequest, workflowHandlers, requestHandlers);
+            routeTasksByType(taskType, typeTasks, context);
         }
         consecutiveStandaloneTasks = [];
     };
@@ -133,7 +195,7 @@ function executeTasksAfterConfirm(tasks, service, userRequest, workflowHandlers,
             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 {
@@ -145,89 +207,81 @@ function executeTasksAfterConfirm(tasks, service, userRequest, workflowHandlers,
     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 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 routeAnswerTasks(tasks, context) {
+    for (const task of tasks) {
+        context.workflowHandlers.addToQueue(createAnswerDefinition(task.action, context.service));
     }
-    else if (taskType === TaskType.Introspect) {
-        workflowHandlers.addToQueue(createIntrospectDefinition(typeTasks, service));
-    }
-    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);
+}
+/**
+ * Route Introspect tasks - creates single Introspect component for all tasks
+ */
+function routeIntrospectTasks(tasks, context) {
+    context.workflowHandlers.addToQueue(createIntrospectDefinition(tasks, context.service));
+}
+/**
+ * Route Config tasks - extracts keys, caches labels, creates Config component
+ */
+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;
         }
-        workflowHandlers.addToQueue(createConfigDefinitionWithKeys(configKeys, (config) => {
-            // Save config - Config component will handle completion and feedback
-            try {
-                // Convert flat dotted keys to nested structure grouped by section
-                const configBySection = unflattenConfig(config);
-                // Save each section
-                for (const [section, sectionConfig] of Object.entries(configBySection)) {
-                    saveConfig(section, sectionConfig);
-                }
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error
-                    ? error.message
-                    : 'Failed to save configuration';
-                throw new Error(errorMessage);
-            }
-        }, (operation) => {
-            requestHandlers.onAborted(operation);
-        }));
     }
-    else if (taskType === TaskType.Execute) {
-        // Execute tasks with validation
+    if (Object.keys(labels).length > 0) {
+        saveConfigLabels(labels);
+    }
+    context.workflowHandlers.addToQueue(createConfigDefinitionWithKeys(configKeys, (config) => {
+        // Save config - Config component will handle completion and feedback
         try {
-            const validation = validateExecuteTasks(typeTasks);
-            if (validation.validationErrors.length > 0) {
-                // Show error feedback for invalid skills
-                const errorMessages = validation.validationErrors.map((error) => {
-                    const issuesList = error.issues
-                        .map((issue) => `  - ${issue}`)
-                        .join('\n');
-                    return `Invalid skill definition "${error.skill}":\n\n${issuesList}`;
-                });
-                workflowHandlers.addToQueue(createFeedback(FeedbackType.Failed, errorMessages.join('\n\n')));
-            }
-            else if (validation.missingConfig.length > 0) {
-                workflowHandlers.addToQueue(createValidateDefinition(validation.missingConfig, userRequest, service, (error) => {
-                    requestHandlers.onError(error);
-                }, () => {
-                    workflowHandlers.addToQueue(createExecuteDefinition(typeTasks, service));
-                }, (operation) => {
-                    requestHandlers.onAborted(operation);
-                }));
-            }
-            else {
-                workflowHandlers.addToQueue(createExecuteDefinition(typeTasks, service));
+            // Convert flat dotted keys to nested structure grouped by section
+            const configBySection = unflattenConfig(config);
+            // Save each section
+            for (const [section, sectionConfig] of Object.entries(configBySection)) {
+                saveConfig(section, sectionConfig);
             }
         }
         catch (error) {
-            // Handle skill reference errors (e.g., unknown skills)
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            const message = createMessage(errorMessage);
-            workflowHandlers.addToQueue(message);
+            const errorMessage = error instanceof Error
+                ? error.message
+                : 'Failed to save configuration';
+            throw new Error(errorMessage);
         }
+    }, (operation) => {
+        context.requestHandlers.onAborted(operation);
+    }));
+}
+/**
+ * Route Execute tasks - creates Execute component (validation already done)
+ */
+function routeExecuteTasks(tasks, context) {
+    context.workflowHandlers.addToQueue(createExecuteDefinition(tasks, 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