prompt-language-shell 0.9.4 → 0.9.8

package/README.md

@@ -31,7 +31,7 @@ Here's what I can help with:
   - Configure - manage and configure system settings
   - Answer - respond to questions and provide information
   - Execute - run shell commands and process operations
-  ```
+```
 
 Skills are custom workflows you can define to teach `pls` about your specific
 projects and commands. Once defined, you can use them naturally:
@@ -87,16 +87,47 @@ commands your environment requires.
 
 ## Configuration
 
-Your configuration is stored in `~/.plsrc` as a YAML file. Supported settings:
+Your configuration is stored in `~/.plsrc` as a YAML file:
+
+```yaml
+# Mandatory
+anthropic:
+  key: sk-ant-...
+  model: claude-...
+
+# Optional
+settings:
+  memory: 1024 # Child process memory limit (MB)
+  debug: none # none | info | verbose
+
+# Custom
+project:
+  path: ~/projects/app
+```
+
+Skills can define their own configuration properties via a `Config` section. When
+a skill requires config values that don't exist, `pls` prompts you to provide
+them before execution. See [Skills](#skills) for details.
+
+## Reference
+
+### Debug Mode
+Press `Shift+Tab` during execution to cycle through debug levels
+(none → info → verbose).
+Logs are saved to `~/.pls/logs/` when debug is `info` or `verbose`.
 
-- `anthropic.key` - Your API key
-- `anthropic.model` - The model to use
+### Data Locations
+```
+~/.plsrc              # Configuration
+~/.pls/skills/        # Custom skills
+~/.pls/logs/          # Debug logs
+```
 
 ## Skills
 
 Skills let you teach `pls` about your project-specific workflows. Create
-markdown files in `~/.pls/skills/` to define custom operations that `pls` can
-understand and execute.
+markdown files in `~/.pls/skills/` to define custom operations that
+`pls` can understand and execute.
 
 For complete documentation, see [docs/SKILLS.md](./docs/SKILLS.md).
 

package/dist/components/Workflow.js

@@ -107,7 +107,18 @@ export const Workflow = ({ initialQueue, debug }) => {
             setQueue((queue) => [...queue, ...items]);
         },
         addToTimeline: (...items) => {
-            setTimeline((prev) => [...prev, ...items]);
+            // Flush pending to timeline first, then add new items
+            // Both are added in a SINGLE setTimeline call to guarantee order
+            setCurrent((curr) => {
+                const { active, pending } = curr;
+                if (pending) {
+                    const donePending = markAsDone(pending);
+                    setTimeline((prev) => [...prev, donePending, ...items]);
+                    return { active, pending: null };
+                }
+                setTimeline((prev) => [...prev, ...items]);
+                return curr;
+            });
         },
     }), []);
     // Global Esc handler removed - components handle their own Esc individually

package/dist/components/controllers/Execute.js

@@ -139,9 +139,9 @@ export function Execute({ tasks: inputTasks, status, service, upcoming, label, r
                     lifecycleHandlers.completeActive();
                     return;
                 }
-                // Create task data from commands
-                const tasks = result.commands.map((cmd, index) => ({
-                    label: inputTasks[index]?.action ?? cmd.description,
+                // Create task data from commands - use descriptions from execute response
+                const tasks = result.commands.map((cmd) => ({
+                    label: cmd.description,
                     command: cmd,
                     status: ExecutionStatus.Pending,
                     elapsed: 0,

package/dist/components/controllers/Schedule.js

@@ -37,8 +37,7 @@ export function Schedule({ message, tasks, status, debug = DebugLevel.None, requ
                 completedSelections,
             };
             requestHandlers.onCompleted(finalState);
-            // Complete the selection phase - it goes to timeline
-            // Callback will create a new Plan showing refined tasks (pending) + Confirm (active)
+            // Move Schedule to pending - callback will flush to timeline
             lifecycleHandlers.completeActive();
             void onSelectionConfirmed(concreteTasks);
         }
@@ -102,9 +101,9 @@ export function Schedule({ message, tasks, status, debug = DebugLevel.None, requ
                         const options = task.params.options;
                         const selectedIndex = newCompletedSelections[defineGroupIndex];
                         const selectedOption = options[selectedIndex];
-                        // Use Execute as default - LLM will properly classify during refinement
+                        // Use the command from the selected option
                         refinedTasks.push({
-                            action: selectedOption,
+                            action: selectedOption.command,
                             type: TaskType.Execute,
                             config: [],
                         });
@@ -122,16 +121,12 @@ export function Schedule({ message, tasks, status, debug = DebugLevel.None, requ
                     completedSelections: newCompletedSelections,
                 };
                 requestHandlers.onCompleted(finalState);
+                // Move Schedule to pending - refinement will flush it to timeline
+                // before adding Command, ensuring correct order
+                lifecycleHandlers.completeActive();
                 if (onSelectionConfirmed) {
-                    // Complete the selection phase - it goes to timeline
-                    // Callback will create a new Plan showing refined tasks (pending) + Confirm (active)
-                    lifecycleHandlers.completeActive();
                     void onSelectionConfirmed(refinedTasks);
                 }
-                else {
-                    // No selection callback, just complete normally
-                    lifecycleHandlers.completeActive();
-                }
             }
         }
     }, { isActive: isActive && defineTask !== null });

package/dist/components/views/Debug.js

@@ -3,5 +3,10 @@ import { Box, Text } from 'ink';
 const CONTENT_WIDTH = 80;
 const HORIZONTAL_PADDING = 2;
 export const Debug = ({ title, content, color }) => {
-    return (_jsxs(Box, { flexDirection: "column", paddingX: HORIZONTAL_PADDING, paddingY: 1, borderStyle: "single", borderColor: color, width: CONTENT_WIDTH, children: [_jsx(Text, { color: color, wrap: "wrap", children: title }), _jsx(Text, { color: color, wrap: "wrap", children: content })] }));
+    // Plain text content - single bordered box
+    if (typeof content === 'string') {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: HORIZONTAL_PADDING, paddingY: 1, borderStyle: "single", borderColor: color, width: CONTENT_WIDTH, children: [_jsx(Text, { color: color, wrap: "wrap", children: title }), _jsx(Text, { color: color, wrap: "wrap", children: content })] }));
+    }
+    // Array content - table with one column, each item in bordered row
+    return (_jsxs(Box, { flexDirection: "column", width: CONTENT_WIDTH, children: [_jsx(Box, { paddingX: HORIZONTAL_PADDING, paddingY: 1, borderStyle: "single", borderColor: color, width: CONTENT_WIDTH, children: _jsx(Text, { color: color, wrap: "wrap", children: title }) }), content.map((section, index) => (_jsx(Box, { paddingX: HORIZONTAL_PADDING, paddingY: 1, borderStyle: "single", borderColor: color, width: CONTENT_WIDTH, marginTop: -1, children: _jsx(Text, { color: color, wrap: "wrap", children: section }) }, index)))] }));
 };

package/dist/components/views/Feedback.js

@@ -1,19 +1,8 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import { ComponentStatus } from '../../types/components.js';
-import { FeedbackType } from '../../types/types.js';
 import { getFeedbackColor } from '../../services/colors.js';
-function getSymbol(type) {
-    return {
-        [FeedbackType.Info]: 'ℹ',
-        [FeedbackType.Warning]: '⚠',
-        [FeedbackType.Succeeded]: '✓',
-        [FeedbackType.Aborted]: '⊘',
-        [FeedbackType.Failed]: '✗',
-    }[type];
-}
 export function Feedback({ type, message }) {
     const color = getFeedbackColor(type, ComponentStatus.Done);
-    const symbol = getSymbol(type);
-    return (_jsx(Box, { marginLeft: 1, children: _jsxs(Text, { color: color, children: [symbol, " ", message] }) }));
+    return (_jsx(Box, { marginLeft: 1, children: _jsx(Text, { color: color, children: message }) }));
 }

package/dist/components/views/Output.js

@@ -4,15 +4,21 @@ import { Palette } from '../../services/colors.js';
 import { ExecutionStatus } from '../../services/shell.js';
 const MAX_LINES = 8;
 const MAX_WIDTH = 75;
-const SHORT_OUTPUT_THRESHOLD = 4;
 const MINIMAL_INFO_THRESHOLD = 2;
 /**
- * Get the last N lines from text, filtering out empty/whitespace-only lines
+ * Get the last N lines from text, filtering out empty/whitespace-only lines.
+ * Handles carriage returns used in progress output by keeping only the
+ * content after the last \r in each line.
  */
 export function getLastLines(text, maxLines = MAX_LINES) {
     const lines = text
         .trim()
         .split(/\r?\n/)
+        .map((line) => {
+        // Handle carriage returns: keep only content after the last \r
+        const lastCR = line.lastIndexOf('\r');
+        return lastCR >= 0 ? line.slice(lastCR + 1) : line;
+    })
         .filter((line) => line.trim().length > 0);
     return lines.length <= maxLines ? lines : lines.slice(-maxLines);
 }
@@ -29,9 +35,6 @@ export function computeDisplayConfig(stdout, stderr, status, isFinished) {
     const stderrLines = hasStderr ? getLastLines(stderr) : [];
     // Show stdout if no stderr, or if stderr is minimal (provides context)
     const showStdout = hasStdout && (!hasStderr || stderrLines.length <= MINIMAL_INFO_THRESHOLD);
-    // Use word wrapping for short outputs to show more detail
-    const totalLines = stdoutLines.length + stderrLines.length;
-    const wrapMode = totalLines <= SHORT_OUTPUT_THRESHOLD ? 'wrap' : 'truncate-end';
     // Darker colors for finished tasks
     const baseColor = isFinished ? Palette.DarkGray : Palette.Gray;
     const stderrColor = status === ExecutionStatus.Failed ? Palette.Yellow : baseColor;
@@ -39,7 +42,6 @@ export function computeDisplayConfig(stdout, stderr, status, isFinished) {
         stdoutLines,
         stderrLines,
         showStdout,
-        wrapMode,
         stdoutColor: baseColor,
         stderrColor,
     };
@@ -48,7 +50,7 @@ export function Output({ stdout, stderr, status, isFinished }) {
     const config = computeDisplayConfig(stdout, stderr, status, isFinished ?? false);
     if (!config)
         return null;
-    const { stdoutLines, stderrLines, showStdout, wrapMode, stdoutColor, stderrColor, } = config;
+    const { stdoutLines, stderrLines, showStdout, stdoutColor, stderrColor } = config;
     return (_jsxs(Box, { marginTop: 1, marginLeft: 5, flexDirection: "column", width: MAX_WIDTH, children: [showStdout &&
-                stdoutLines.map((line, index) => (_jsx(Text, { color: stdoutColor, wrap: wrapMode, children: line }, `out-${index}`))), stderrLines.map((line, index) => (_jsx(Text, { color: stderrColor, wrap: wrapMode, children: line }, `err-${index}`)))] }));
+                stdoutLines.map((line, index) => (_jsx(Text, { color: stdoutColor, wrap: "wrap", children: line }, `out-${index}`))), stderrLines.map((line, index) => (_jsx(Text, { color: stderrColor, wrap: "wrap", children: line }, `err-${index}`)))] }));
 }

package/dist/components/views/Schedule.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box } from 'ink';
 import { ComponentStatus } from '../../types/components.js';
-import { TaskType } from '../../types/types.js';
+import { TaskType, } from '../../types/types.js';
 import { DebugLevel } from '../../configuration/types.js';
 import { getTaskColors, getTaskTypeLabel, Palette, } from '../../services/colors.js';
 import { Label } from './Label.js';
@@ -28,7 +28,8 @@ export function taskToListItem(task, highlightedChildIndex = null, isDefineTaskW
     }
     // Add children for Define tasks with options
     if (task.type === TaskType.Define && Array.isArray(task.params?.options)) {
-        item.children = task.params.options.map((option, index) => {
+        const options = task.params.options;
+        item.children = options.map((option, index) => {
             // Determine the type based on selection state
             let childType = TaskType.Select;
             if (highlightedChildIndex !== null) {
@@ -40,7 +41,7 @@ export function taskToListItem(task, highlightedChildIndex = null, isDefineTaskW
             const planColors = getTaskColors(TaskType.Schedule, status);
             return {
                 description: {
-                    text: option,
+                    text: option.name,
                     color: colors.description,
                     highlightedColor: planColors.description,
                 },

package/dist/components/views/Table.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text } from 'ink';
+const DEFAULT_WIDTH = 80;
+const DEFAULT_PADDING = 1;
+export const Cell = ({ children, padding = DEFAULT_PADDING }) => (_jsx(Box, { paddingX: padding, children: _jsx(Text, { wrap: "wrap", children: children }) }));
+export const Column = ({ children, width }) => (_jsx(Box, { flexDirection: "column", width: width, children: children }));
+const Row = ({ children, color, innerWidth }) => (_jsxs(Box, { children: [_jsx(Text, { color: color, children: '│' }), _jsx(Box, { width: innerWidth, children: children }), _jsx(Text, { color: color, children: '│' })] }));
+export const Table = ({ data, width = DEFAULT_WIDTH, color }) => {
+    const innerWidth = width - 2;
+    const TOP = '┌' + '─'.repeat(innerWidth) + '┐';
+    const DIV = '├' + '─'.repeat(innerWidth) + '┤';
+    const BOT = '└' + '─'.repeat(innerWidth) + '┘';
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: color, children: TOP }), data.map((content, index) => (_jsxs(React.Fragment, { children: [index > 0 && _jsx(Text, { color: color, children: DIV }), _jsx(Row, { color: color, innerWidth: innerWidth, children: _jsx(Cell, { children: content }) })] }, index))), _jsx(Text, { color: color, children: BOT })] }));
+};

package/dist/configuration/io.js

@@ -104,3 +104,13 @@ export function loadDebugSetting(fs = defaultFileSystem) {
         return DebugLevel.None;
     }
 }
+const DEFAULT_MEMORY_LIMIT = 1024;
+export function loadMemorySetting(fs = defaultFileSystem) {
+    try {
+        const config = loadConfig(fs);
+        return config.settings?.memory ?? DEFAULT_MEMORY_LIMIT;
+    }
+    catch {
+        return DEFAULT_MEMORY_LIMIT;
+    }
+}

package/dist/configuration/schema.js

@@ -38,6 +38,12 @@ const coreConfigSchema = {
         default: DebugLevel.None,
         description: 'Debug mode',
     },
+    'settings.memory': {
+        type: ConfigDefinitionType.Number,
+        required: false,
+        default: 1024,
+        description: 'Child process memory limit (MB)',
+    },
 };
 /**
  * Get complete configuration schema

package/dist/configuration/validation.js

@@ -37,6 +37,11 @@ export function validateConfig(parsed) {
                 validatedConfig.settings.debug = settings.debug;
             }
         }
+        if ('memory' in settings) {
+            if (typeof settings.memory === 'number' && settings.memory > 0) {
+                validatedConfig.settings.memory = settings.memory;
+            }
+        }
     }
     return validatedConfig;
 }

package/dist/execution/processing.js

@@ -1,3 +1,5 @@
+import { stringify } from 'yaml';
+import { loadMemorySetting } from '../configuration/io.js';
 import { loadUserConfig } from '../services/loader.js';
 import { replacePlaceholders } from '../services/resolver.js';
 import { validatePlaceholderResolution } from './validation.js';
@@ -10,6 +12,36 @@ export function fixEscapedQuotes(command) {
     // Replace ="value" with =\"value\"
     return command.replace(/="([^"]*)"/g, '=\\"$1\\"');
 }
+/**
+ * Format a task as YAML with action line and metadata block
+ */
+export function formatTaskAsYaml(action, metadata, indent = '') {
+    const normalizedAction = action.charAt(0).toLowerCase() + action.slice(1);
+    if (!metadata || Object.keys(metadata).length === 0) {
+        return normalizedAction;
+    }
+    const metadataYaml = stringify({ metadata })
+        .trim()
+        .split('\n')
+        .map((line) => `${indent}${line}`)
+        .join('\n');
+    return `${normalizedAction}\n\n${metadataYaml}`;
+}
+/**
+ * Build task descriptions for the LLM
+ * Single task: use as-is; multiple tasks: add header and bullet prefix
+ */
+function buildTaskDescriptions(resolvedTasks) {
+    if (resolvedTasks.length === 1) {
+        const { action, params } = resolvedTasks[0];
+        return formatTaskAsYaml(action, params);
+    }
+    const header = `complete these ${resolvedTasks.length} tasks:`;
+    const bulletedTasks = resolvedTasks
+        .map(({ action, params }) => `- ${formatTaskAsYaml(action, params, '  ')}`)
+        .join('\n\n');
+    return `${header}\n\n${bulletedTasks}`;
+}
 /**
  * Processes tasks through the AI service to generate executable commands.
  * Resolves placeholders in task descriptions and validates the results.
@@ -17,27 +49,26 @@ export function fixEscapedQuotes(command) {
 export async function processTasks(tasks, service) {
     // Load user config for placeholder resolution
     const userConfig = loadUserConfig();
-    // Format tasks for the execute tool and resolve placeholders
-    const taskList = tasks
-        .map((task) => {
-        const resolvedAction = replacePlaceholders(task.action, userConfig);
-        const params = task.params
-            ? ` (params: ${JSON.stringify(task.params)})`
-            : '';
-        return `- ${resolvedAction}${params}`;
-    })
-        .join('\n');
-    // Build message with confirmed schedule header
-    const taskDescriptions = `Confirmed schedule (${tasks.length} tasks):\n${taskList}`;
+    const memoryLimitMB = loadMemorySetting();
+    // Resolve placeholders in task actions
+    const resolvedTasks = tasks.map((task) => ({
+        action: replacePlaceholders(task.action, userConfig),
+        params: task.params,
+    }));
+    const taskDescriptions = buildTaskDescriptions(resolvedTasks);
     // Call execute tool to get commands
     const result = await service.processWithTool(taskDescriptions, 'execute');
-    // Resolve placeholders in command strings
+    // Resolve placeholders in command strings and inject memory limit
     const resolvedCommands = (result.commands || []).map((cmd) => {
         // Fix escaped quotes lost in JSON parsing
         const fixed = fixEscapedQuotes(cmd.command);
         const resolved = replacePlaceholders(fixed, userConfig);
         validatePlaceholderResolution(resolved);
-        return { ...cmd, command: resolved };
+        return {
+            ...cmd,
+            command: resolved,
+            memoryLimit: memoryLimitMB,
+        };
     });
     return {
         message: result.message,

package/dist/execution/runner.js

@@ -70,7 +70,7 @@ export async function executeTask(command, index, callbacks) {
             return { status: ExecutionStatus.Success, elapsed, output };
         }
         else {
-            const errorMsg = result.errors || result.error || 'Command failed';
+            const errorMsg = result.error || result.errors || 'Command failed';
             error = errorMsg;
             const output = createOutput();
             callbacks.onUpdate(output);

package/dist/index.js

@@ -5,7 +5,9 @@ import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 import { render } from 'ink';
 import { DebugLevel } from './configuration/types.js';
+import { preventPerformanceBufferOverflow } from './services/performance.js';
 import { Main } from './Main.js';
+preventPerformanceBufferOverflow();
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // Get package info

package/dist/services/anthropic.js

@@ -1,7 +1,7 @@
 import Anthropic from '@anthropic-ai/sdk';
 import { getAvailableConfigStructure, getConfiguredKeys, } from '../configuration/schema.js';
 import { logPrompt, logResponse } from './logger.js';
-import { formatSkillsForPrompt, loadSkillsWithValidation } from './skills.js';
+import { loadSkillsForPrompt } from './skills.js';
 import { toolRegistry } from './registry.js';
 import { CommandResultSchema, IntrospectResultSchema, } from '../types/schemas.js';
 /**
@@ -69,36 +69,32 @@ export class AnthropicService {
     async processWithTool(command, toolName, customInstructions) {
         // Load tool from registry
         const tool = toolRegistry.getSchema(toolName);
-        // Use custom instructions if provided, otherwise load from registry
-        let systemPrompt;
-        if (customInstructions) {
-            // Custom instructions provided (typically for testing)
-            systemPrompt = customInstructions;
+        // Check if this tool uses skills
+        const usesSkills = toolName === 'schedule' ||
+            toolName === 'introspect' ||
+            toolName === 'execute' ||
+            toolName === 'validate';
+        // Load base instructions and skills
+        const baseInstructions = customInstructions || toolRegistry.getInstructions(toolName);
+        let formattedSkills = '';
+        let skillDefinitions = [];
+        let systemPrompt = baseInstructions;
+        if (!customInstructions && usesSkills) {
+            const skillsResult = loadSkillsForPrompt();
+            formattedSkills = skillsResult.formatted;
+            skillDefinitions = skillsResult.definitions;
+            systemPrompt += formattedSkills;
         }
-        else {
-            // Load and build system prompt automatically (production)
-            const instructions = toolRegistry.getInstructions(toolName);
-            systemPrompt = instructions;
-            // Add skills section for applicable tools
-            if (toolName === 'schedule' ||
-                toolName === 'introspect' ||
-                toolName === 'execute' ||
-                toolName === 'validate') {
-                const skills = loadSkillsWithValidation();
-                const skillsSection = formatSkillsForPrompt(skills);
-                systemPrompt += skillsSection;
-            }
-            // Add config structure for configure tool only
-            if (toolName === 'configure') {
-                const configStructure = getAvailableConfigStructure();
-                const configuredKeys = getConfiguredKeys();
-                const configSection = '\n## Available Configuration\n\n' +
-                    'Config structure (key: description):\n' +
-                    JSON.stringify(configStructure, null, 2) +
-                    '\n\nConfigured keys (keys that exist in config file):\n' +
-                    JSON.stringify(configuredKeys, null, 2);
-                systemPrompt += configSection;
-            }
+        // Add config structure for configure tool only
+        if (!customInstructions && toolName === 'configure') {
+            const configStructure = getAvailableConfigStructure();
+            const configuredKeys = getConfiguredKeys();
+            const configSection = '\n## Available Configuration\n\n' +
+                'Config structure (key: description):\n' +
+                JSON.stringify(configStructure, null, 2) +
+                '\n\nConfigured keys (keys that exist in config file):\n' +
+                JSON.stringify(configuredKeys, null, 2);
+            systemPrompt += configSection;
         }
         // Build tools array - add web search for answer tool
         const tools = [tool];
@@ -111,7 +107,7 @@ export class AnthropicService {
         // Collect debug components
         const debug = [];
         // Log prompt at Verbose level
-        const promptDebug = logPrompt(toolName, command, systemPrompt);
+        const promptDebug = logPrompt(toolName, command, baseInstructions, formattedSkills, skillDefinitions);
         if (promptDebug) {
             debug.push(promptDebug);
         }

package/dist/services/colors.js

@@ -20,6 +20,7 @@ export const Palette = {
     Yellow: '#cccc5c',
     Orange: '#f48c80',
     MediumOrange: '#d07560',
+    WarmOrange: '#ce985e',
     DarkOrange: '#ab5e40',
     BurntOrange: '#cc7a5c',
     Red: '#cc5c5c',
@@ -132,7 +133,7 @@ const taskColors = {
  */
 const feedbackColors = {
     [FeedbackType.Info]: Colors.Status.Info,
-    [FeedbackType.Warning]: Palette.Yellow,
+    [FeedbackType.Warning]: Palette.WarmOrange,
     [FeedbackType.Succeeded]: Colors.Status.Success,
     [FeedbackType.Aborted]: Palette.MediumOrange,
     [FeedbackType.Failed]: Colors.Status.Error,

package/dist/services/filesystem.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from 'fs';
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from 'fs';
 import { dirname } from 'path';
 /**
  * Real filesystem implementation using Node's fs module
@@ -13,6 +13,9 @@ export class RealFileSystem {
     writeFile(path, data) {
         writeFileSync(path, data, 'utf-8');
     }
+    appendFile(path, data) {
+        appendFileSync(path, data, 'utf-8');
+    }
     readDirectory(path) {
         return readdirSync(path);
     }
@@ -51,6 +54,15 @@ export class MemoryFileSystem {
         }
         this.files.set(path, data);
     }
+    appendFile(path, data) {
+        // Auto-create parent directories (consistent with writeFile)
+        const dir = dirname(path);
+        if (dir !== '.' && dir !== path) {
+            this.createDirectory(dir, { recursive: true });
+        }
+        const existing = this.files.get(path) ?? '';
+        this.files.set(path, existing + data);
+    }
     readDirectory(path) {
         if (!this.directories.has(path)) {
             throw new Error(`ENOENT: no such file or directory, scandir '${path}'`);