prompt-language-shell 0.9.6 → 1.0.0

package/dist/services/refinement.js

@@ -1,6 +1,5 @@
-import { ComponentStatus, } from '../types/components.js';
-import { TaskType } from '../types/types.js';
-import { createCommand, createRefinement } from './components.js';
+import { formatTaskAsYaml } from '../execution/processing.js';
+import { createRefinement } from './components.js';
 import { formatErrorMessage, getRefiningMessage } from './messages.js';
 import { routeTasksWithConfirm } from './router.js';
 /**
@@ -8,11 +7,6 @@ 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(),
@@ -22,18 +16,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) => {
+            // Replace commas with dashes for cleaner LLM prompt formatting
             const action = task.action.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})`;
+            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

@@ -8,6 +8,20 @@ import { saveConfigLabels } from '../configuration/labels.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';
+/**
+ * Task Routing Architecture
+ *
+ * Flow: Command -> SCHEDULE -> routeTasksWithConfirm() -> extractTaskGroups()
+ *       -> routeAllGroups() -> routeGroupTasks() -> Workflow queue
+ *
+ * Key Concepts:
+ * - TaskGroup: Logical grouping for sequential processing
+ * - Routing Category: Determines which tasks can be grouped together
+ * - Two-Phase Routing: Config/Introspect first, then Execute/Answer
+ *
+ * Isolation Principle: Explicit Group tasks always become their own
+ * TaskGroup, preventing cross-contamination between user-defined groups.
+ */
 /**
  * Flatten inner task structure completely - removes all nested groups.
  * Used internally to flatten subtasks within a top-level group.
@@ -92,10 +106,10 @@ export function getOperationName(tasks) {
 export function routeTasksWithConfirm(tasks, message, service, userRequest, lifecycleHandlers, workflowHandlers, requestHandlers, hasDefineTask = false) {
     if (tasks.length === 0)
         return;
-    // Filter out ignore and discard tasks early
-    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) {
+    // Check executable tasks (ignore/discard are shown but not executed)
+    const executableTasks = tasks.filter((task) => task.type !== TaskType.Ignore && task.type !== TaskType.Discard);
+    // Check if no executable tasks remain after filtering
+    if (executableTasks.length === 0) {
         // Use action from first ignore task if available, otherwise generic message
         const ignoreTask = tasks.find((task) => task.type === TaskType.Ignore);
         const message = ignoreTask?.action
@@ -104,7 +118,7 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, life
         workflowHandlers.addToQueue(createFeedback({ type: FeedbackType.Warning, message }));
         return;
     }
-    const operation = getOperationName(validTasks);
+    const operation = getOperationName(executableTasks);
     // Create routing context for downstream functions
     const context = {
         service,
@@ -115,7 +129,8 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, life
     if (hasDefineTask) {
         // Has DEFINE tasks - add Schedule to queue for user selection
         // Refinement flow will call this function again with refined tasks
-        const scheduleDefinition = createSchedule({ message, tasks: validTasks });
+        // Show all tasks (including ignore) for display
+        const scheduleDefinition = createSchedule({ message, tasks });
         workflowHandlers.addToQueue(scheduleDefinition);
     }
     else {
@@ -123,9 +138,10 @@ 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)
+        // Show all tasks (including ignore) for display
         const scheduleDefinition = createSchedule({
             message,
-            tasks: validTasks,
+            tasks,
             onSelectionConfirmed: () => {
                 // Schedule completed - add Confirm to queue
                 const confirmDefinition = createConfirm({
@@ -133,7 +149,8 @@ export function routeTasksWithConfirm(tasks, message, service, userRequest, life
                     onConfirmed: () => {
                         // User confirmed - complete both Confirm and Schedule, then route
                         lifecycleHandlers.completeActiveAndPending();
-                        executeTasksAfterConfirm(validTasks, context);
+                        // Only execute non-ignore/non-discard tasks
+                        executeTasksAfterConfirm(executableTasks, context);
                     },
                     onCancelled: () => {
                         // User cancelled - complete both Confirm and Schedule, then show cancellation
@@ -230,88 +247,187 @@ function executeTasksAfterConfirm(tasks, context) {
     routeTasksAfterConfig(flatTasks, context);
 }
 /**
- * Task types that should appear in the upcoming display
+ * Collect action names for upcoming display.
+ * All task types are shown so users see the full queue of work ahead.
  */
-const UPCOMING_TASK_TYPES = [TaskType.Execute, TaskType.Answer, TaskType.Group];
+function collectUpcomingNames(tasks) {
+    return tasks.map((t) => t.action);
+}
 /**
- * Collect action names for tasks that appear in upcoming display.
- * Groups are included with their group name (not individual subtask names).
+ * Get the routing category for a task type.
+ * Tasks in the same category can be grouped together.
+ * Config and Introspect are special categories that should be isolated.
  */
-function collectUpcomingNames(tasks) {
-    return tasks
-        .filter((t) => UPCOMING_TASK_TYPES.includes(t.type))
-        .map((t) => t.action);
+export function getRoutingCategory(task) {
+    // Groups with subtasks get their own category (based on subtask types)
+    if (task.type === TaskType.Group &&
+        task.subtasks &&
+        task.subtasks.length > 0) {
+        // Check what types of subtasks this group has
+        const hasConfig = task.subtasks.some((t) => t.type === TaskType.Config);
+        const hasIntrospect = task.subtasks.some((t) => t.type === TaskType.Introspect);
+        const hasExecute = task.subtasks.some((t) => t.type === TaskType.Execute);
+        const hasAnswer = task.subtasks.some((t) => t.type === TaskType.Answer);
+        // Mixed types get unique category to ensure isolation
+        const typeCount = (hasConfig ? 1 : 0) +
+            (hasIntrospect ? 1 : 0) +
+            (hasExecute ? 1 : 0) +
+            (hasAnswer ? 1 : 0);
+        if (typeCount > 1) {
+            return `mixed:${task.action}`;
+        }
+        // Single type groups use that type's category
+        if (hasConfig)
+            return 'config';
+        if (hasIntrospect)
+            return 'introspect';
+        if (hasExecute)
+            return 'execute';
+        if (hasAnswer)
+            return 'answer';
+        return 'group';
+    }
+    // Standalone tasks use their type as category
+    switch (task.type) {
+        case TaskType.Config:
+            return 'config';
+        case TaskType.Introspect:
+            return 'introspect';
+        case TaskType.Execute:
+            return 'execute';
+        case TaskType.Answer:
+            return 'answer';
+        default:
+            return task.type;
+    }
 }
 /**
- * Route tasks after config is complete (or when no config is needed)
- * 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.
+ * Extract logical task groups from a flat task list.
+ * Each explicit Group (TaskType.Group) becomes its own TaskGroup for isolation.
+ * Consecutive standalone tasks of the same routing category are grouped together.
  */
-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);
+export function extractTaskGroups(tasks) {
+    const groups = [];
+    let currentGroup = null;
+    let currentCategory = null;
+    for (const task of tasks) {
+        // Skip empty groups
+        if (task.type === TaskType.Group &&
+            (!task.subtasks || task.subtasks.length === 0)) {
+            continue;
+        }
+        // Explicit Groups always become their own TaskGroup for isolation
+        if (task.type === TaskType.Group) {
+            // Save current group if exists
+            if (currentGroup !== null) {
+                groups.push(currentGroup);
+                currentGroup = null;
+                currentCategory = null;
             }
-            else if (task.type === TaskType.Group && task.subtasks) {
-                typeTasks.push(...task.subtasks.filter((t) => t.type === groupedType));
+            // Create standalone TaskGroup for this Group
+            groups.push({
+                name: task.action,
+                tasks: [task],
+            });
+            continue;
+        }
+        const category = getRoutingCategory(task);
+        // Start new group when category changes (or first task)
+        if (currentGroup === null || category !== currentCategory) {
+            if (currentGroup !== null) {
+                groups.push(currentGroup);
             }
+            currentGroup = {
+                name: task.action,
+                tasks: [task],
+            };
+            currentCategory = category;
         }
-        if (typeTasks.length > 0) {
-            routeTasksByType(groupedType, typeTasks, context, []);
+        else {
+            // Same category - add to current group
+            currentGroup.tasks.push(task);
         }
     }
-    // Process Execute, Answer, and Group tasks individually (with upcoming support)
+    // Don't forget the last group
+    if (currentGroup !== null) {
+        groups.push(currentGroup);
+    }
+    return groups;
+}
+/**
+ * Route all groups in order, calculating correct upcoming for each.
+ * Groups are processed sequentially by the Workflow's queue mechanism.
+ */
+function routeAllGroups(groups, context) {
+    for (let i = 0; i < groups.length; i++) {
+        const group = groups[i];
+        // Calculate upcoming from LATER groups (not current group)
+        const laterGroups = groups.slice(i + 1);
+        const laterUpcoming = laterGroups.flatMap((g) => collectUpcomingNames(g.tasks));
+        // Route this group's tasks with upcoming from later groups
+        routeGroupTasks(group, context, laterUpcoming);
+    }
+}
+/**
+ * Route all tasks within a single group in the order received from LLM.
+ * Standalone tasks become individual components.
+ * Group subtasks are batched by type (Execute subtasks together, etc.).
+ */
+function routeGroupTasks(group, context, groupUpcoming) {
+    const tasks = group.tasks;
+    const withinGroupUpcoming = collectUpcomingNames(tasks);
     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;
+        // Calculate upcoming: remaining tasks in this group + tasks from later groups
+        const remainingInGroup = withinGroupUpcoming.slice(i + 1);
+        const taskUpcoming = [...remainingInGroup, ...groupUpcoming];
+        // Handle Group tasks with subtasks - batch subtasks by type
         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
+            // Batch Execute subtasks together (sent to LLM as single request)
             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);
+                routeExecuteTasks(executeSubtasks, context, taskUpcoming, task.action);
             }
-            // Route Answer subtasks individually
+            // Route Answer subtasks (each becomes its own component)
+            const answerSubtasks = task.subtasks.filter((t) => t.type === TaskType.Answer);
             if (answerSubtasks.length > 0) {
-                routeAnswerTasks(answerSubtasks, context, upcoming);
+                routeAnswerTasks(answerSubtasks, context, taskUpcoming);
+            }
+            // Route other subtask types individually
+            for (const subtask of task.subtasks) {
+                if (subtask.type !== TaskType.Execute &&
+                    subtask.type !== TaskType.Answer) {
+                    routeTasksByType(subtask.type, [subtask], context, taskUpcoming);
+                }
             }
         }
         else if (taskType === TaskType.Execute) {
-            // Calculate upcoming for this Execute task
-            const upcoming = allUpcomingNames.slice(upcomingIndex + 1);
-            upcomingIndex++;
-            routeExecuteTasks([task], context, upcoming);
+            routeExecuteTasks([task], context, taskUpcoming);
         }
         else if (taskType === TaskType.Answer) {
-            // Calculate upcoming for this Answer task
-            const upcoming = allUpcomingNames.slice(upcomingIndex + 1);
-            upcomingIndex++;
-            routeTasksByType(taskType, [task], context, upcoming);
+            routeAnswerTasks([task], context, taskUpcoming);
         }
         else {
-            // For other types (Report, etc.), route without upcoming
-            routeTasksByType(taskType, [task], context, []);
+            routeTasksByType(taskType, [task], context, taskUpcoming);
         }
     }
 }
+/**
+ * Route tasks after config is complete (or when no config is needed)
+ * Processes task groups in order - groups with different task types are
+ * kept separate to ensure proper lifecycle handling.
+ */
+function routeTasksAfterConfig(tasks, context) {
+    if (tasks.length === 0)
+        return;
+    // Extract logical task groups
+    const groups = extractTaskGroups(tasks);
+    if (groups.length === 0)
+        return;
+    // Route all groups in order
+    routeAllGroups(groups, context);
+}
 /**
  * Route Answer tasks - creates separate Answer component for each question
  */
@@ -335,48 +451,60 @@ function routeIntrospectTasks(tasks, context, _upcoming) {
     context.workflowHandlers.addToQueue(createIntrospect({ tasks, service: context.service }));
 }
 /**
- * Route Config tasks - extracts keys, caches labels, creates Config component
+ * Route Config tasks - extracts keys or uses query, creates Config component
  */
 function routeConfigTasks(tasks, context, _upcoming) {
+    // Extract specific keys from task params
     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;
+    // Handler for saving config values
+    const onFinished = (config) => {
+        try {
+            const configBySection = unflattenConfig(config);
+            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);
+        }
+    };
+    const onAborted = (operation) => {
+        context.requestHandlers.onAborted(operation);
+    };
+    if (configKeys.length > 0) {
+        // Has specific keys - create steps directly
+        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;
+            }
         }
+        if (Object.keys(labels).length > 0) {
+            saveConfigLabels(labels);
+        }
+        context.workflowHandlers.addToQueue(createConfig({
+            steps: createConfigStepsFromSchema(configKeys),
+            onFinished,
+            onAborted,
+        }));
     }
-    if (Object.keys(labels).length > 0) {
-        saveConfigLabels(labels);
+    else {
+        // No keys - use query (Config will resolve via CONFIGURE tool)
+        const query = tasks[0]?.params?.query;
+        if (query) {
+            context.workflowHandlers.addToQueue(createConfig({
+                query,
+                service: context.service,
+                onFinished,
+                onAborted,
+            }));
+        }
     }
-    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
-                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);
-            }
-        },
-        onAborted: (operation) => {
-            context.requestHandlers.onAborted(operation);
-        },
-    }));
 }
 /**
  * Route Execute tasks - creates Execute component (validation already done)

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;
@@ -104,8 +105,10 @@ class OutputStreamer {
         // Collapse when we have too many chunks to prevent memory growth
         if (this.chunks.length > 16) {
             const accumulated = this.chunks.join('');
-            this.chunks = [limitLines(accumulated)];
-            this.emittedLength = 0;
+            const limited = limitLines(accumulated);
+            this.chunks = [limited];
+            // Mark all collapsed content as emitted to prevent re-emission
+            this.emittedLength = limited.length;
         }
         if (!this.callback)
             return;
@@ -145,6 +148,7 @@ class OutputStreamer {
  */
 export class RealExecutor {
     outputCallback;
+    memoryCallback;
     constructor(outputCallback) {
         this.outputCallback = outputCallback;
     }
@@ -154,6 +158,12 @@ export class RealExecutor {
     setOutputCallback(callback) {
         this.outputCallback = callback;
     }
+    /**
+     * Set or update the memory callback
+     */
+    setMemoryCallback(callback) {
+        this.memoryCallback = callback;
+    }
     execute(cmd, onProgress, _ = 0) {
         return new Promise((resolve) => {
             onProgress?.(ExecutionStatus.Running);
@@ -183,18 +193,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;
+                }, undefined, this.memoryCallback);
+                memoryMonitor.start();
+            }
             // Use OutputStreamer for buffered stdout streaming
             const stdoutStreamer = new OutputStreamer(this.outputCallback);
             child.stdout.on('data', (data) => {
@@ -217,6 +231,7 @@ export class RealExecutor {
                     clearTimeout(timeoutId);
                 if (killTimeoutId)
                     clearTimeout(killTimeoutId);
+                memoryMonitor?.stop();
                 const commandResult = {
                     description: cmd.description,
                     command: cmd.command,
@@ -228,20 +243,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);
@@ -260,6 +287,12 @@ const executor = realExecutor;
 export function setOutputCallback(callback) {
     realExecutor.setOutputCallback(callback);
 }
+/**
+ * Set a callback to receive memory updates during execution
+ */
+export function setMemoryCallback(callback) {
+    realExecutor.setMemoryCallback(callback);
+}
 /**
  * Execute a single shell command
  */

package/dist/services/utils.js

@@ -25,6 +25,17 @@ export function formatDuration(ms) {
     }
     return parts.join(' ');
 }
+/**
+ * Formats memory in megabytes to a human-readable string.
+ * Uses MB for values under 1024 MB, GB for larger values.
+ */
+export function formatMemory(mb) {
+    if (mb >= 1024) {
+        const gb = mb / 1024;
+        return `${gb.toFixed(1)} GB`;
+    }
+    return `${mb} MB`;
+}
 /**
  * Recursively extracts all leaf tasks from a hierarchical task structure.
  * Leaf tasks are tasks without subtasks.