prompt-language-shell 0.9.4 → 0.9.8

package/dist/services/refinement.js

@@ -1,5 +1,6 @@
-import { TaskType } from '../types/types.js';
-import { createRefinement } from './components.js';
+import { ComponentStatus, } from '../types/components.js';
+import { formatTaskAsYaml } from '../execution/processing.js';
+import { createCommand, createRefinement } from './components.js';
 import { formatErrorMessage, getRefiningMessage } from './messages.js';
 import { routeTasksWithConfirm } from './router.js';
 /**
@@ -7,6 +8,11 @@ import { routeTasksWithConfirm } from './router.js';
  * Called when user selects options from a plan with DEFINE tasks
  */
 export async function handleRefinement(selectedTasks, service, originalCommand, lifecycleHandlers, workflowHandlers, requestHandlers) {
+    // Display the resolved command (from user's selection)
+    // The first task's action contains the full resolved command
+    const resolvedCommand = selectedTasks[0]?.action || originalCommand;
+    const commandDisplay = createCommand({ command: resolvedCommand, service, onAborted: requestHandlers.onAborted }, ComponentStatus.Done);
+    workflowHandlers.addToTimeline(commandDisplay);
     // Create and add refinement component to queue
     const refinementDef = createRefinement({
         text: getRefiningMessage(),
@@ -16,18 +22,15 @@ export async function handleRefinement(selectedTasks, service, originalCommand,
     });
     workflowHandlers.addToQueue(refinementDef);
     try {
-        // Build refined command from selected tasks
+        // Build refined command with action line followed by YAML metadata
         const refinedCommand = selectedTasks
             .map((task) => {
-            const action = task.action.toLowerCase().replace(/,/g, ' -');
-            const type = task.type;
-            // For execute/group tasks, use generic hint - let LLM decide based on skill
-            if (type === TaskType.Execute || type === TaskType.Group) {
-                return `${action} (shell execution)`;
-            }
-            return `${action} (type: ${type})`;
+            // Replace commas with dashes for cleaner LLM prompt formatting
+            const action = task.action.replace(/,/g, ' -');
+            const metadata = { ...task.params, type: task.type };
+            return formatTaskAsYaml(action, metadata);
         })
-            .join(', ');
+            .join('\n\n');
         // Call LLM to refine plan with selected tasks
         const refinedResult = await service.processWithTool(refinedCommand, 'schedule');
         // Complete the Refinement component with success state

package/dist/services/router.js

@@ -5,9 +5,74 @@ import { getConfigSchema } from '../configuration/schema.js';
 import { createConfigStepsFromSchema } from '../configuration/steps.js';
 import { unflattenConfig } from '../configuration/transformation.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 { createAnswer, createConfig, createConfirm, createExecute, createFeedback, createIntrospect, createSchedule, createValidate, } from './components.js';
+import { getCancellationMessage, getConfirmationMessage, getUnknownRequestMessage, } from './messages.js';
 import { validateExecuteTasks } from './validator.js';
+/**
+ * Flatten inner task structure completely - removes all nested groups.
+ * Used internally to flatten subtasks within a top-level group.
+ */
+function flattenInnerTasks(tasks) {
+    const result = [];
+    for (const task of tasks) {
+        if (task.type === TaskType.Group &&
+            task.subtasks &&
+            task.subtasks.length > 0) {
+            // Recursively flatten inner group
+            result.push(...flattenInnerTasks(task.subtasks));
+        }
+        else if (task.type !== TaskType.Group) {
+            // Leaf task - add as-is
+            const leafTask = {
+                action: task.action,
+                type: task.type,
+            };
+            if (task.params)
+                leafTask.params = task.params;
+            if (task.config)
+                leafTask.config = task.config;
+            result.push(leafTask);
+        }
+        // Skip empty groups
+    }
+    return result;
+}
+/**
+ * Flatten hierarchical task structure, preserving top-level groups.
+ * Top-level groups are kept with their subtasks flattened.
+ * Inner nested groups are removed and their subtasks extracted recursively.
+ */
+export function flattenTasks(tasks) {
+    const result = [];
+    for (const task of tasks) {
+        if (task.type === TaskType.Group &&
+            task.subtasks &&
+            task.subtasks.length > 0) {
+            // Preserve top-level group but flatten its subtasks
+            const flattenedSubtasks = flattenInnerTasks(task.subtasks);
+            const groupTask = {
+                action: task.action,
+                type: task.type,
+                subtasks: flattenedSubtasks,
+            };
+            result.push(groupTask);
+        }
+        else if (task.type !== TaskType.Group) {
+            // Non-group task - add as-is
+            const leafTask = {
+                action: task.action,
+                type: task.type,
+            };
+            if (task.params)
+                leafTask.params = task.params;
+            if (task.config)
+                leafTask.config = task.config;
+            result.push(leafTask);
+        }
+        // Skip empty groups (group with no subtasks)
+    }
+    return result;
+}
 /**
  * Determine the operation name based on task types
  */
@@ -31,8 +96,12 @@ 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 msg = createMessage({ text: getUnknownRequestMessage() });
-        workflowHandlers.addToQueue(msg);
+        // Use action from first ignore task if available, otherwise generic message
+        const ignoreTask = tasks.find((task) => task.type === TaskType.Ignore);
+        const message = ignoreTask?.action
+            ? `${ignoreTask.action}.`
+            : getUnknownRequestMessage();
+        workflowHandlers.addToQueue(createFeedback({ type: FeedbackType.Warning, message }));
         return;
     }
     const operation = getOperationName(validTasks);
@@ -80,61 +149,44 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, life
     }
 }
 /**
- * Validate task types - allows mixed types at top level with Groups,
- * but each Group must have uniform subtask types
+ * Validate task structure after flattening.
+ * Currently no-op since flattening removes Groups and mixed types are allowed.
  */
-function validateTaskTypes(tasks) {
-    if (tasks.length === 0)
-        return;
-    // Convert to ScheduledTask to access subtasks property
-    const scheduledTasks = asScheduledTasks(tasks);
-    // Check each Group task's subtasks for uniform types
-    for (const task of scheduledTasks) {
-        if (task.type === TaskType.Group &&
-            task.subtasks &&
-            task.subtasks.length > 0) {
-            const subtaskTypes = new Set(task.subtasks.map((t) => t.type));
-            if (subtaskTypes.size > 1) {
-                throw new Error(getMixedTaskTypesError(Array.from(subtaskTypes)));
-            }
-            // Recursively validate nested groups
-            validateTaskTypes(task.subtasks);
-        }
-    }
+function validateTaskTypes(_tasks) {
+    // After flattening, Groups are removed and mixed leaf types are allowed.
+    // The router handles different task types by routing each to its handler.
 }
 /**
  * Execute tasks after confirmation (internal helper)
- * Validates task types and routes each type appropriately
- * Supports mixed types at top level with Groups
+ * Flattens hierarchical structure, validates task types, and routes appropriately
  */
 function executeTasksAfterConfirm(tasks, context) {
     const { service, userRequest, workflowHandlers, requestHandlers } = context;
-    // Validate task types (Groups must have uniform subtasks)
+    // Flatten hierarchical structure into flat list of leaf tasks
+    const scheduledTasks = asScheduledTasks(tasks);
+    const flatTasks = flattenTasks(scheduledTasks);
+    // Validate that all tasks have uniform type
     try {
-        validateTaskTypes(tasks);
+        validateTaskTypes(flatTasks);
     }
     catch (error) {
         requestHandlers.onError(error instanceof Error ? error.message : String(error));
         return;
     }
-    const scheduledTasks = asScheduledTasks(tasks);
-    // Collect ALL Execute tasks (standalone and from groups) for upfront validation
-    const allExecuteTasks = [];
-    for (const task of scheduledTasks) {
+    // Collect all Execute tasks for validation (including those inside groups)
+    const executeTasks = [];
+    for (const task of flatTasks) {
         if (task.type === TaskType.Execute) {
-            allExecuteTasks.push(task);
+            executeTasks.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);
-            }
+            executeTasks.push(...task.subtasks.filter((t) => t.type === TaskType.Execute));
         }
     }
-    // Validate ALL Execute tasks together to collect ALL missing config upfront
-    if (allExecuteTasks.length > 0) {
+    // Validate Execute tasks to collect missing config upfront
+    if (executeTasks.length > 0) {
         try {
-            const validation = validateExecuteTasks(allExecuteTasks);
+            const validation = validateExecuteTasks(executeTasks);
             if (validation.validationErrors.length > 0) {
                 // Show error feedback for invalid skills
                 const errorMessages = validation.validationErrors.map((error) => {
@@ -150,7 +202,7 @@ function executeTasksAfterConfirm(tasks, context) {
                 return;
             }
             else if (validation.missingConfig.length > 0) {
-                // Missing config detected - create ONE Validate component for ALL missing config
+                // Missing config detected - create Validate component for all missing config
                 workflowHandlers.addToQueue(createValidate({
                     missingConfig: validation.missingConfig,
                     userRequest,
@@ -160,7 +212,7 @@ function executeTasksAfterConfirm(tasks, context) {
                     },
                     onValidationComplete: () => {
                         // After config is complete, resume task routing
-                        routeTasksAfterConfig(scheduledTasks, context);
+                        routeTasksAfterConfig(flatTasks, context);
                     },
                     onAborted: (operation) => {
                         requestHandlers.onAborted(operation);
@@ -175,105 +227,90 @@ function executeTasksAfterConfirm(tasks, context) {
         }
     }
     // No missing config - proceed with normal routing
-    routeTasksAfterConfig(scheduledTasks, context);
+    routeTasksAfterConfig(flatTasks, context);
 }
 /**
  * Task types that should appear in the upcoming display
  */
-const UPCOMING_TASK_TYPES = [TaskType.Execute, TaskType.Answer];
+const UPCOMING_TASK_TYPES = [TaskType.Execute, TaskType.Answer, TaskType.Group];
 /**
- * Collect names of all upcoming execution units (groups and standalone tasks)
- * for display during task execution
+ * Collect action names for tasks that appear in upcoming display.
+ * Groups are included with their group name (not individual subtask names).
  */
-function collectUpcomingNames(scheduledTasks) {
-    const names = [];
-    for (const task of scheduledTasks) {
-        if (task.type === TaskType.Group && task.subtasks?.length) {
-            const subtasks = task.subtasks;
-            if (UPCOMING_TASK_TYPES.includes(subtasks[0].type)) {
-                names.push(task.action);
-            }
-        }
-        else if (UPCOMING_TASK_TYPES.includes(task.type)) {
-            names.push(task.action);
-        }
-    }
-    return names;
+function collectUpcomingNames(tasks) {
+    return tasks
+        .filter((t) => UPCOMING_TASK_TYPES.includes(t.type))
+        .map((t) => t.action);
 }
 /**
  * Route tasks after config is complete (or when no config is needed)
- * Processes tasks in order, grouping by type
+ * Processes task list, routing each task type to its handler.
+ * Top-level groups are preserved: their subtasks are routed with the group name.
+ * Config tasks are grouped together; Execute/Answer are routed individually.
  */
-function routeTasksAfterConfig(scheduledTasks, context) {
-    // Collect all unit names for upcoming display
-    const allUnitNames = collectUpcomingNames(scheduledTasks);
-    let currentUnitIndex = 0;
-    // Process tasks in order, preserving Group boundaries
-    // Track consecutive standalone tasks to group them by type
-    let consecutiveStandaloneTasks = [];
-    const processStandaloneTasks = () => {
-        if (consecutiveStandaloneTasks.length === 0)
-            return;
-        // Group consecutive standalone tasks by type
-        const tasksByType = {};
-        for (const type of Object.values(TaskType)) {
-            tasksByType[type] = [];
+function routeTasksAfterConfig(tasks, context) {
+    if (tasks.length === 0)
+        return;
+    // Collect all upcoming names for display (Execute, Answer, and Group tasks)
+    const allUpcomingNames = collectUpcomingNames(tasks);
+    let upcomingIndex = 0;
+    // Task types that should be grouped together (one component for all tasks)
+    const groupedTypes = [TaskType.Config, TaskType.Introspect];
+    // Route grouped task types together (collect from all tasks including subtasks)
+    for (const groupedType of groupedTypes) {
+        const typeTasks = [];
+        for (const task of tasks) {
+            if (task.type === groupedType) {
+                typeTasks.push(task);
+            }
+            else if (task.type === TaskType.Group && task.subtasks) {
+                typeTasks.push(...task.subtasks.filter((t) => t.type === groupedType));
+            }
         }
-        for (const task of consecutiveStandaloneTasks) {
-            tasksByType[task.type].push(task);
+        if (typeTasks.length > 0) {
+            routeTasksByType(groupedType, typeTasks, context, []);
         }
-        // Route each type group
-        for (const [type, typeTasks] of Object.entries(tasksByType)) {
-            const taskType = type;
-            if (typeTasks.length === 0)
-                continue;
-            // For tasks that appear in upcoming, calculate from remaining units
-            if (UPCOMING_TASK_TYPES.includes(taskType)) {
-                // Each task advances the unit index
-                for (const task of typeTasks) {
-                    const upcoming = allUnitNames.slice(currentUnitIndex + 1);
-                    currentUnitIndex++;
-                    routeTasksByType(taskType, [task], context, upcoming);
-                }
+    }
+    // Process Execute, Answer, and Group tasks individually (with upcoming support)
+    for (let i = 0; i < tasks.length; i++) {
+        const task = tasks[i];
+        const taskType = task.type;
+        // Skip grouped task types (already routed above)
+        if (groupedTypes.includes(taskType))
+            continue;
+        if (taskType === TaskType.Group && task.subtasks) {
+            // Route group's subtasks - Execute tasks get group label, others routed normally
+            const upcoming = allUpcomingNames.slice(upcomingIndex + 1);
+            upcomingIndex++;
+            // Separate subtasks by type
+            const executeSubtasks = task.subtasks.filter((t) => t.type === TaskType.Execute);
+            const answerSubtasks = task.subtasks.filter((t) => t.type === TaskType.Answer);
+            // Route Execute subtasks with group name as label
+            if (executeSubtasks.length > 0) {
+                routeExecuteTasks(executeSubtasks, context, upcoming, task.action);
             }
-            else {
-                routeTasksByType(taskType, typeTasks, context, []);
+            // Route Answer subtasks individually
+            if (answerSubtasks.length > 0) {
+                routeAnswerTasks(answerSubtasks, context, upcoming);
             }
         }
-        consecutiveStandaloneTasks = [];
-    };
-    // Process tasks in original order
-    for (const task of scheduledTasks) {
-        if (task.type === TaskType.Group && task.subtasks) {
-            // Process any accumulated standalone tasks first
-            processStandaloneTasks();
-            // Process Group as separate component
-            if (task.subtasks.length > 0) {
-                const subtasks = task.subtasks;
-                const taskType = subtasks[0].type;
-                // Calculate upcoming (all units after this one)
-                const upcoming = UPCOMING_TASK_TYPES.includes(taskType)
-                    ? allUnitNames.slice(currentUnitIndex + 1)
-                    : [];
-                if (UPCOMING_TASK_TYPES.includes(taskType)) {
-                    currentUnitIndex++;
-                }
-                // Pass group name as label for Execute groups
-                if (taskType === TaskType.Execute) {
-                    routeExecuteTasks(subtasks, context, upcoming, task.action);
-                }
-                else {
-                    routeTasksByType(taskType, subtasks, context, upcoming);
-                }
-            }
+        else if (taskType === TaskType.Execute) {
+            // Calculate upcoming for this Execute task
+            const upcoming = allUpcomingNames.slice(upcomingIndex + 1);
+            upcomingIndex++;
+            routeExecuteTasks([task], context, upcoming);
+        }
+        else if (taskType === TaskType.Answer) {
+            // Calculate upcoming for this Answer task
+            const upcoming = allUpcomingNames.slice(upcomingIndex + 1);
+            upcomingIndex++;
+            routeTasksByType(taskType, [task], context, upcoming);
         }
         else {
-            // Accumulate standalone task
-            consecutiveStandaloneTasks.push(task);
+            // For other types (Report, etc.), route without upcoming
+            routeTasksByType(taskType, [task], context, []);
         }
     }
-    // Process any remaining standalone tasks
-    processStandaloneTasks();
 }
 /**
  * Route Answer tasks - creates separate Answer component for each question

package/dist/services/shell.js

@@ -1,4 +1,5 @@
 import { spawn } from 'child_process';
+import { killGracefully, MemoryMonitor, } from './monitor.js';
 export var ExecutionStatus;
 (function (ExecutionStatus) {
     ExecutionStatus["Pending"] = "pending";
@@ -60,12 +61,12 @@ export class DummyExecutor {
     }
 }
 // Marker for extracting pwd from command output
-const PWD_MARKER = '__PWD_MARKER_7x9k2m__';
-const MAX_OUTPUT_LINES = 128;
+export const PWD_MARKER = '__PWD_MARKER_7x9k2m__';
+export const MAX_OUTPUT_LINES = 128;
 /**
  * Limit output to last MAX_OUTPUT_LINES lines.
  */
-function limitLines(output) {
+export function limitLines(output) {
     const lines = output.split('\n');
     return lines.slice(-MAX_OUTPUT_LINES).join('\n');
 }
@@ -73,7 +74,7 @@ function limitLines(output) {
  * Parse stdout to extract workdir and clean output.
  * Returns the cleaned output and the extracted workdir.
  */
-function parseWorkdir(rawOutput) {
+export function parseWorkdir(rawOutput) {
     const markerIndex = rawOutput.lastIndexOf(PWD_MARKER);
     if (markerIndex === -1) {
         return { output: rawOutput };
@@ -88,7 +89,7 @@ function parseWorkdir(rawOutput) {
  * Manages streaming output while filtering out the PWD marker.
  * Buffers output to avoid emitting partial markers to the callback.
  */
-class OutputStreamer {
+export class OutputStreamer {
     chunks = [];
     emittedLength = 0;
     callback;
@@ -183,18 +184,22 @@ export class RealExecutor {
                 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);
+                    killTimeoutId = killGracefully(child);
                 }, cmd.timeout);
             }
+            // Handle memory limit monitoring
+            let memoryMonitor;
+            let memoryInfo;
+            if (cmd.memoryLimit) {
+                memoryMonitor = new MemoryMonitor(child, cmd.memoryLimit, (info) => {
+                    memoryInfo = info;
+                });
+                memoryMonitor.start();
+            }
             // Use OutputStreamer for buffered stdout streaming
             const stdoutStreamer = new OutputStreamer(this.outputCallback);
             child.stdout.on('data', (data) => {
@@ -217,6 +222,7 @@ export class RealExecutor {
                     clearTimeout(timeoutId);
                 if (killTimeoutId)
                     clearTimeout(killTimeoutId);
+                memoryMonitor?.stop();
                 const commandResult = {
                     description: cmd.description,
                     command: cmd.command,
@@ -228,20 +234,32 @@ export class RealExecutor {
                 onProgress?.(ExecutionStatus.Failed);
                 resolve(commandResult);
             });
-            child.on('close', (code) => {
+            child.on('exit', (code) => {
                 if (timeoutId)
                     clearTimeout(timeoutId);
                 if (killTimeoutId)
                     clearTimeout(killTimeoutId);
-                const success = code === 0;
+                memoryMonitor?.stop();
                 const { output, workdir } = parseWorkdir(stdoutStreamer.getAccumulated());
+                // Check if terminated due to memory limit
+                const killedByMemoryLimit = memoryMonitor?.wasKilledByMemoryLimit();
+                const success = code === 0 && !killedByMemoryLimit;
+                let errorMessage;
+                if (killedByMemoryLimit && memoryInfo) {
+                    errorMessage =
+                        `Process exceeded ${memoryInfo.limit} MB memory limit, ` +
+                            `${memoryInfo.used} MB was used.`;
+                }
+                else if (!success) {
+                    errorMessage = `Exit code: ${code}`;
+                }
                 const commandResult = {
                     description: cmd.description,
                     command: cmd.command,
                     output,
                     errors: limitLines(stderr.join('')),
                     result: success ? ExecutionResult.Success : ExecutionResult.Error,
-                    error: success ? undefined : `Exit code: ${code}`,
+                    error: errorMessage,
                     workdir,
                 };
                 onProgress?.(success ? ExecutionStatus.Success : ExecutionStatus.Failed);

package/dist/services/skills.js

@@ -94,17 +94,47 @@ export function loadSkillDefinitions(fs = defaultFileSystem) {
     const skills = loadSkills(fs);
     return skills.map(({ key, content }) => parseSkillMarkdown(key, content));
 }
+/**
+ * Mark incomplete skill in markdown by appending (INCOMPLETE) to name
+ */
+function markIncompleteSkill(content) {
+    return content.replace(/^(#{1,6}\s+Name\s*\n+)(.+?)(\n|$)/im, `$1$2 (INCOMPLETE)$3`);
+}
+/**
+ * Load skills with both formatted prompt section and parsed definitions
+ * Single source of truth for both LLM prompts and debug display
+ * Parses each skill only once for efficiency
+ */
+export function loadSkillsForPrompt(fs = defaultFileSystem) {
+    const skills = loadSkills(fs);
+    // Parse each skill once and build both outputs
+    const definitions = [];
+    const markedContent = [];
+    for (const { key, content } of skills) {
+        const parsed = parseSkillMarkdown(key, content);
+        definitions.push(parsed);
+        // Mark incomplete skills in markdown for LLM
+        if (parsed.isIncomplete) {
+            markedContent.push(markIncompleteSkill(content));
+        }
+        else {
+            markedContent.push(content);
+        }
+    }
+    const formatted = formatSkillsForPrompt(markedContent);
+    return { formatted, definitions };
+}
 /**
  * Load skills and mark incomplete ones in their markdown
  * Returns array of skill markdown with status markers
+ * Uses loadSkillsForPrompt internally to avoid duplicating logic
  */
 export function loadSkillsWithValidation(fs = defaultFileSystem) {
     const skills = loadSkills(fs);
     return skills.map(({ key, content }) => {
         const parsed = parseSkillMarkdown(key, content);
-        // If skill is incomplete (either validation failed or needs more documentation), append (INCOMPLETE) to the name
         if (parsed.isIncomplete) {
-            return content.replace(/^(#{1,6}\s+Name\s*\n+)(.+?)(\n|$)/im, `$1$2 (INCOMPLETE)$3`);
+            return markIncompleteSkill(content);
         }
         return content;
     });
@@ -127,6 +157,7 @@ export function createSkillLookup(definitions) {
 }
 /**
  * Format skills for inclusion in the planning prompt
+ * Skills are joined with double newlines (skill headers provide separation)
  */
 export function formatSkillsForPrompt(skills) {
     if (skills.length === 0) {
@@ -148,11 +179,8 @@ brackets for additional information. Use commas instead. For example:
 - WRONG: "Build project Alpha (the legacy version)"
 
 `;
-    const separator = '-'.repeat(64);
-    const skillsContent = skills
-        .map((s) => s.trim())
-        .join('\n\n' + separator + '\n\n');
-    return header + separator + '\n\n' + skillsContent;
+    const skillsContent = skills.map((s) => s.trim()).join('\n\n');
+    return header + skillsContent;
 }
 /**
  * Parse skill reference from execution line