prompt-language-shell 0.9.6 → 1.0.0

package/dist/services/anthropic.js

@@ -1,6 +1,6 @@
 import Anthropic from '@anthropic-ai/sdk';
 import { getAvailableConfigStructure, getConfiguredKeys, } from '../configuration/schema.js';
-import { logPrompt, logResponse } from './logger.js';
+import { formatConfigContext, formatSkillsContext, logPrompt, logResponse, } from './logger.js';
 import { loadSkillsForPrompt } from './skills.js';
 import { toolRegistry } from './registry.js';
 import { CommandResultSchema, IntrospectResultSchema, } from '../types/schemas.js';
@@ -77,13 +77,13 @@ export class AnthropicService {
         // Load base instructions and skills
         const baseInstructions = customInstructions || toolRegistry.getInstructions(toolName);
         let formattedSkills = '';
-        let skillDefinitions = [];
         let systemPrompt = baseInstructions;
+        let context;
         if (!customInstructions && usesSkills) {
             const skillsResult = loadSkillsForPrompt();
             formattedSkills = skillsResult.formatted;
-            skillDefinitions = skillsResult.definitions;
             systemPrompt += formattedSkills;
+            context = formatSkillsContext(skillsResult.definitions);
         }
         // Add config structure for configure tool only
         if (!customInstructions && toolName === 'configure') {
@@ -95,6 +95,7 @@ export class AnthropicService {
                 '\n\nConfigured keys (keys that exist in config file):\n' +
                 JSON.stringify(configuredKeys, null, 2);
             systemPrompt += configSection;
+            context = formatConfigContext(configStructure, configuredKeys);
         }
         // Build tools array - add web search for answer tool
         const tools = [tool];
@@ -107,7 +108,7 @@ export class AnthropicService {
         // Collect debug components
         const debug = [];
         // Log prompt at Verbose level
-        const promptDebug = logPrompt(toolName, command, baseInstructions, formattedSkills, skillDefinitions);
+        const promptDebug = logPrompt(toolName, command, baseInstructions, formattedSkills, context);
         if (promptDebug) {
             debug.push(promptDebug);
         }

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}'`);

package/dist/services/logger.js

@@ -1,7 +1,10 @@
+import { homedir, platform } from 'os';
+import { dirname, join } from 'path';
 import { DebugLevel } from '../configuration/types.js';
 import { loadDebugSetting } from '../configuration/io.js';
 import { Palette } from './colors.js';
 import { createDebug } from './components.js';
+import { defaultFileSystem } from './filesystem.js';
 /**
  * Enum controlling what content is shown in debug prompt output
  * - LLM: Exact prompt as sent to LLM (no display formatting)
@@ -23,6 +26,112 @@ let currentDebugLevel = DebugLevel.None;
  * Accumulated warnings to be displayed in the timeline
  */
 const warnings = [];
+/**
+ * Content width for debug display (matches Debug component)
+ * Box width 80 - 2 borders - 4 padding = 74 chars
+ */
+const DISPLAY_CONTENT_WIDTH = 74;
+/**
+ * File logging configuration
+ */
+const LOGS_DIR = join(homedir(), '.pls', 'logs');
+/**
+ * Whether running on Windows (affects filename separators)
+ */
+const IS_WINDOWS = platform() === 'win32';
+/**
+ * Maximum number of letter suffixes (a-z) for unique filenames
+ */
+const MAX_LETTER_SUFFIXES = 26;
+/**
+ * Pad a number with leading zeros to the specified width
+ */
+const pad = (n, width = 2) => String(n).padStart(width, '0');
+/**
+ * Current session's log file path (null until first log entry)
+ */
+let currentLogFile = null;
+/**
+ * Filesystem instance for file operations (injectable for testing)
+ */
+let fileSystem = defaultFileSystem;
+/**
+ * Set the filesystem instance (used for testing)
+ */
+export function setFileSystem(fs) {
+    fileSystem = fs;
+}
+/**
+ * Reset the session log file (used for testing)
+ */
+export function resetSessionLog() {
+    currentLogFile = null;
+}
+/**
+ * Generate a timestamped log file path using local time
+ * Format: ~/.pls/logs/YYYY-MM-DD/HH:MM:SS.log.md (HH-MM-SS on Windows)
+ */
+function getLogFilePath() {
+    const now = new Date();
+    const date = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}`;
+    const separator = IS_WINDOWS ? '-' : ':';
+    const time = `${pad(now.getHours())}${separator}${pad(now.getMinutes())}${separator}${pad(now.getSeconds())}`;
+    return join(LOGS_DIR, date, `${time}.log.md`);
+}
+/**
+ * Generate a unique log file path by adding suffix if file exists
+ */
+function getUniqueLogFilePath(basePath) {
+    if (!fileSystem.exists(basePath)) {
+        return basePath;
+    }
+    const dir = dirname(basePath);
+    const ext = '.log.md';
+    const name = basePath.slice(dir.length + 1, -ext.length);
+    for (let i = 0; i < MAX_LETTER_SUFFIXES; i++) {
+        const suffix = String.fromCharCode(97 + i); // a-z
+        const candidate = join(dir, `${name}-${suffix}${ext}`);
+        if (!fileSystem.exists(candidate)) {
+            return candidate;
+        }
+    }
+    // Fallback: use milliseconds for uniqueness (avoids overwriting)
+    return join(dir, `${name}-${pad(new Date().getMilliseconds(), 3)}${ext}`);
+}
+/**
+ * Initialize the session log file if not already created
+ */
+function initializeSessionLog() {
+    if (currentLogFile)
+        return true;
+    try {
+        const basePath = getLogFilePath();
+        const logDir = dirname(basePath);
+        if (!fileSystem.exists(logDir)) {
+            fileSystem.createDirectory(logDir, { recursive: true });
+        }
+        const logPath = getUniqueLogFilePath(basePath);
+        fileSystem.writeFile(logPath, '');
+        currentLogFile = logPath;
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Append content to the current session's log file
+ */
+function appendToLog(content) {
+    if (!initializeSessionLog() || !currentLogFile)
+        return;
+    try {
+        fileSystem.appendFile(currentLogFile, content);
+    }
+    catch {
+        // Silently fail - logging should not crash the app
+    }
+}
 /**
  * Initialize the logger with the current debug level from config
  */
@@ -61,11 +170,6 @@ export function getWarnings() {
     warnings.length = 0;
     return result;
 }
-/**
- * Content width for debug display (matches Debug component)
- * Box width 80 - 2 borders - 4 padding = 74 chars
- */
-const DISPLAY_CONTENT_WIDTH = 74;
 /**
  * Join sections with separators matching display width
  */
@@ -139,43 +243,78 @@ function formatSkillsForDisplay(formattedSkills) {
  *
  * - LLM: Returns header + base instructions + formatted skills (as sent to LLM)
  * - Skills: Returns header + skills with visual separators (no base instructions)
- * - Summary: Returns header + skill summaries (Name, Steps, Execution)
+ * - Summary: Returns header + context (caller-provided summary)
  */
-export function formatPromptContent(toolName, command, baseInstructions, formattedSkills, mode, definitions) {
-    const header = ['', `Tool: ${toolName}`, `Command: ${command}`];
+export function formatPromptContent(toolName, command, baseInstructions, formattedSkills, mode, context) {
     switch (mode) {
-        case PromptDisplay.LLM:
+        case PromptDisplay.LLM: {
+            const header = ['', `**Tool:** ${toolName}`];
             return [...header, '', baseInstructions + formattedSkills].join('\n');
+        }
         case PromptDisplay.Skills: {
-            // Layout: header -> separator -> skills with visual separators
-            const headerString = header.join('\n');
+            const header = `\nTool: ${toolName}\nCommand: ${command}`;
             const skillsDisplay = formatSkillsForDisplay(formattedSkills);
-            return joinWithSeparators([headerString, skillsDisplay]);
+            return joinWithSeparators([header, skillsDisplay]);
         }
         case PromptDisplay.Summary: {
-            const headerString = header.join('\n');
-            const summary = definitions
-                ? formatSkillsSummary(definitions)
-                : '(no skills)';
-            return joinWithSeparators([headerString, summary]);
+            const header = `\nTool: ${toolName}\nCommand: ${command}`;
+            return context
+                ? joinWithSeparators([header, context])
+                : joinWithSeparators([header]);
         }
     }
 }
+/**
+ * Context for tools that have no skills or custom context
+ */
+export const NO_SKILLS_CONTEXT = '(no skills)';
+/**
+ * Format skill definitions as context for debug display
+ * Returns NO_SKILLS_CONTEXT when definitions array is empty
+ */
+export function formatSkillsContext(definitions) {
+    if (definitions.length === 0) {
+        return NO_SKILLS_CONTEXT;
+    }
+    return formatSkillsSummary(definitions);
+}
+/**
+ * Format config structure as context for debug display
+ */
+export function formatConfigContext(structure, configuredKeys) {
+    const structureYaml = Object.entries(structure)
+        .map(([key, desc]) => `${key}: ${String(desc)}`)
+        .join('\n');
+    const keysSection = configuredKeys.length > 0
+        ? configuredKeys.map((k) => `- ${k}`).join('\n')
+        : '(none)';
+    return ('## Config Structure\n\n' +
+        structureYaml +
+        '\n\n## Configured Keys\n\n' +
+        keysSection);
+}
 /**
  * Create debug component for system prompts sent to the LLM
- * Only creates at Verbose level
+ * Creates UI component at Verbose level, writes to file at Info or Verbose
  *
  * @param toolName - Name of the tool being invoked
  * @param command - User command being processed
  * @param baseInstructions - Base tool instructions (without skills)
  * @param formattedSkills - Formatted skills section (as sent to LLM)
- * @param definitions - Parsed skill definitions for summary display
+ * @param context - Context summary to display in debug output
  */
-export function logPrompt(toolName, command, baseInstructions, formattedSkills, definitions = []) {
+export function logPrompt(toolName, command, baseInstructions, formattedSkills, context) {
+    // Write to file at Info or Verbose level (full LLM format)
+    if (currentDebugLevel !== DebugLevel.None) {
+        const userPrompt = `# User Command\n\n\`\`\`\n${command}\n\`\`\`\n\n`;
+        const fileContent = formatPromptContent(toolName, command, baseInstructions, formattedSkills, PromptDisplay.LLM);
+        appendToLog(userPrompt + '# System Prompt\n' + fileContent + '\n\n');
+    }
+    // Create UI component only at Verbose level
     if (currentDebugLevel !== DebugLevel.Verbose) {
         return null;
     }
-    const content = formatPromptContent(toolName, command, baseInstructions, formattedSkills, PromptDisplay.Summary, definitions);
+    const content = formatPromptContent(toolName, command, baseInstructions, formattedSkills, PromptDisplay.Summary, context);
     // Calculate stats for the full prompt
     const fullPrompt = baseInstructions + formattedSkills;
     const lines = fullPrompt.split('\n').length;
@@ -185,18 +324,27 @@ export function logPrompt(toolName, command, baseInstructions, formattedSkills,
 }
 /**
  * Create debug component for LLM responses received
- * Only creates at Verbose level
+ * Creates UI component at Verbose level, writes to file at Info or Verbose
  */
 export function logResponse(toolName, response, durationMs) {
+    const jsonContent = JSON.stringify(response, null, 2);
+    // Write to file at Info or Verbose level (markdown format)
+    if (currentDebugLevel !== DebugLevel.None) {
+        const fileContent = [
+            '',
+            `**Tool:** ${toolName}`,
+            '',
+            '```json',
+            jsonContent,
+            '```',
+        ].join('\n');
+        appendToLog('# LLM Response\n' + fileContent + '\n\n');
+    }
+    // Create UI component only at Verbose level
     if (currentDebugLevel !== DebugLevel.Verbose) {
         return null;
     }
-    const content = [
-        '',
-        `Tool: ${toolName}`,
-        '',
-        JSON.stringify(response, null, 2),
-    ].join('\n');
+    const content = ['', `Tool: ${toolName}`, '', jsonContent].join('\n');
     const title = `LLM RESPONSE (${String(durationMs)} ms)`;
     return createDebug({ title, content, color: Palette.LightGray });
 }

package/dist/services/messages.js

@@ -148,11 +148,14 @@ export function formatErrorMessage(error) {
     return rawMessage;
 }
 /**
- * Returns an execution error message with varied phrasing.
- * Error details are shown in the task output, so this is just a summary.
- * Randomly selects from variations to sound natural.
+ * Returns an execution error message.
+ * If a specific error is provided, returns it directly.
+ * Otherwise, returns a generic failure message with varied phrasing.
  */
-export function getExecutionErrorMessage(_error) {
+export function getExecutionErrorMessage(error) {
+    if (error) {
+        return error;
+    }
     const messages = [
         'The execution failed.',
         'Execution has failed.',

package/dist/services/monitor.js

@@ -0,0 +1,304 @@
+import { execFile, execSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { platform } from 'os';
+import { promisify } from 'util';
+// Memory monitoring constants
+const MEMORY_CHECK_INTERVAL = 250;
+const DEFAULT_PAGE_SIZE = 4096;
+export const SIGKILL_GRACE_PERIOD = 3000;
+/**
+ * Get system page size in bytes.
+ * Computed lazily on first call, then cached at module level.
+ */
+let cachedPageSize;
+function getPageSize() {
+    if (cachedPageSize !== undefined) {
+        return cachedPageSize;
+    }
+    if (platform() === 'linux') {
+        try {
+            const output = execSync('getconf PAGESIZE', {
+                encoding: 'utf-8',
+                timeout: 1000,
+            }).trim();
+            const size = parseInt(output, 10);
+            if (!isNaN(size) && size > 0) {
+                cachedPageSize = size;
+                return cachedPageSize;
+            }
+        }
+        catch {
+            // Fall through to default
+        }
+    }
+    cachedPageSize = DEFAULT_PAGE_SIZE;
+    return cachedPageSize;
+}
+/**
+ * Gracefully terminate a child process with SIGTERM, escalating to SIGKILL
+ * after a grace period if the process doesn't terminate.
+ * Returns the kill timeout ID for cleanup.
+ */
+export function killGracefully(child, gracePeriod = SIGKILL_GRACE_PERIOD) {
+    child.kill('SIGTERM');
+    return setTimeout(() => {
+        try {
+            child.kill('SIGKILL');
+        }
+        catch {
+            // Process already terminated
+        }
+    }, gracePeriod);
+}
+const execFileAsync = promisify(execFile);
+/**
+ * Run a command asynchronously and return stdout.
+ * Returns undefined on error or timeout.
+ */
+async function runCommandAsync(command, args, timeout = 1000) {
+    try {
+        const { stdout } = await execFileAsync(command, args, { timeout });
+        return stdout.trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Get memory usage of a process in bytes.
+ * Returns undefined if the process doesn't exist or memory can't be read.
+ * On macOS, uses async subprocess; on Linux, reads from /proc (fast).
+ */
+async function getProcessMemoryBytes(pid) {
+    try {
+        if (platform() === 'linux') {
+            // Linux: Read from /proc/[pid]/statm (memory in pages)
+            // This is fast and effectively non-blocking for procfs
+            const statmPath = `/proc/${pid}/statm`;
+            if (!existsSync(statmPath))
+                return undefined;
+            const statm = readFileSync(statmPath, 'utf-8');
+            const rssPages = parseInt(statm.split(' ')[1], 10);
+            return rssPages * getPageSize();
+        }
+        else {
+            // macOS/BSD: Use ps command asynchronously
+            const output = await runCommandAsync('ps', [
+                '-o',
+                'rss=',
+                '-p',
+                `${pid}`,
+            ]);
+            if (!output)
+                return undefined;
+            const rssKB = parseInt(output, 10);
+            if (isNaN(rssKB))
+                return undefined;
+            return rssKB * 1024;
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Get child PIDs of a single process.
+ */
+async function getChildPids(pid) {
+    try {
+        let output;
+        if (platform() === 'linux') {
+            output = await runCommandAsync('ps', ['-o', 'pid=', '--ppid', `${pid}`]);
+        }
+        else {
+            output = await runCommandAsync('pgrep', ['-P', `${pid}`]);
+        }
+        if (!output)
+            return [];
+        return output
+            .split('\n')
+            .map((p) => parseInt(p.trim(), 10))
+            .filter((p) => !isNaN(p) && p > 0);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Get all descendant PIDs of a process.
+ * Uses iterative BFS with parallel child lookups at each level.
+ */
+async function getAllDescendantPids(pid) {
+    const visited = new Set();
+    const pids = [];
+    let currentLevel = [pid];
+    while (currentLevel.length > 0) {
+        // Add unvisited PIDs from current level
+        const unvisited = currentLevel.filter((p) => !visited.has(p));
+        for (const p of unvisited)
+            visited.add(p);
+        pids.push(...unvisited);
+        // Fetch children of all current level PIDs in parallel
+        const childArrays = await Promise.all(unvisited.map(getChildPids));
+        currentLevel = childArrays.flat();
+    }
+    return pids;
+}
+/**
+ * Get total memory usage of a process tree.
+ * Sums memory of the process and all its descendants.
+ */
+async function getProcessTreeMemoryBytes(pid) {
+    try {
+        const allPids = await getAllDescendantPids(pid);
+        let totalBytes = 0;
+        for (const p of allPids) {
+            const mem = await getProcessMemoryBytes(p);
+            if (mem)
+                totalBytes += mem;
+        }
+        return totalBytes > 0 ? totalBytes : undefined;
+    }
+    catch {
+        return getProcessMemoryBytes(pid);
+    }
+}
+/** Monitor lifecycle state */
+var MonitorState;
+(function (MonitorState) {
+    MonitorState["Idle"] = "idle";
+    MonitorState["Running"] = "running";
+    MonitorState["Stopped"] = "stopped";
+    MonitorState["Killed"] = "killed";
+})(MonitorState || (MonitorState = {}));
+/**
+ * Monitors a child process memory and kills it when the limit is exceeded.
+ * Uses async self-scheduling to avoid blocking the event loop.
+ * By default monitors only the root process; set includeDescendants for tree.
+ */
+export class MemoryMonitor {
+    nextCheckId;
+    killTimeoutId;
+    child;
+    memoryLimit;
+    limitBytes;
+    onExceeded;
+    onMemoryUpdate;
+    state = MonitorState.Idle;
+    getMemoryFn;
+    currentMemoryMB = 0;
+    constructor(child, memoryLimitMB, onExceeded, getMemoryFn, onMemoryUpdate) {
+        this.child = child;
+        this.memoryLimit = memoryLimitMB;
+        this.limitBytes = memoryLimitMB * 1024 * 1024;
+        this.onExceeded = onExceeded;
+        this.onMemoryUpdate = onMemoryUpdate;
+        // Always monitor full process tree by default
+        this.getMemoryFn = getMemoryFn ?? getProcessTreeMemoryBytes;
+    }
+    /**
+     * Start monitoring the child process memory.
+     * Uses async self-scheduling loop instead of setInterval for non-blocking.
+     * Performs an immediate check, then polls at regular intervals.
+     */
+    start() {
+        if (!this.child.pid)
+            return;
+        this.state = MonitorState.Running;
+        void this.checkMemory();
+    }
+    /**
+     * Schedule the next memory check after the configured interval.
+     */
+    scheduleNextCheck() {
+        if (this.state !== MonitorState.Running)
+            return;
+        this.nextCheckId = setTimeout(() => {
+            void this.checkMemory();
+        }, MEMORY_CHECK_INTERVAL);
+    }
+    /**
+     * Perform async memory check and schedule next one.
+     */
+    async checkMemory() {
+        if (this.state !== MonitorState.Running || !this.child.pid)
+            return;
+        let memoryBytes;
+        try {
+            memoryBytes = await this.getMemoryFn(this.child.pid);
+        }
+        catch {
+            // Memory reading failed, schedule next check and continue
+            this.scheduleNextCheck();
+            return;
+        }
+        // Re-check after async operation - state may have changed
+        if (this.state !== MonitorState.Running)
+            return; // eslint-disable-line @typescript-eslint/no-unnecessary-condition
+        // Track current memory
+        if (memoryBytes !== undefined) {
+            this.currentMemoryMB = Math.ceil(memoryBytes / 1024 / 1024);
+            this.onMemoryUpdate?.(this.currentMemoryMB);
+        }
+        if (memoryBytes !== undefined && memoryBytes >= this.limitBytes) {
+            this.terminateProcess(memoryBytes);
+        }
+        else {
+            this.scheduleNextCheck();
+        }
+    }
+    /**
+     * Stop monitoring and cancel any pending timeouts.
+     */
+    stop() {
+        if (this.state !== MonitorState.Killed) {
+            this.state = MonitorState.Stopped;
+        }
+        if (this.nextCheckId) {
+            clearTimeout(this.nextCheckId);
+            this.nextCheckId = undefined;
+        }
+        if (this.killTimeoutId) {
+            clearTimeout(this.killTimeoutId);
+            this.killTimeoutId = undefined;
+        }
+    }
+    /**
+     * Terminate the child process due to memory limit exceeded.
+     */
+    terminateProcess(currentMemoryBytes) {
+        if (this.state === MonitorState.Killed)
+            return;
+        this.state = MonitorState.Killed;
+        // Clear only the next check timeout, keep killTimeoutId for cleanup
+        if (this.nextCheckId) {
+            clearTimeout(this.nextCheckId);
+            this.nextCheckId = undefined;
+        }
+        // Kill first, then notify - ensures termination even if callback throws
+        this.killTimeoutId = killGracefully(this.child);
+        const info = {
+            used: Math.ceil(currentMemoryBytes / 1024 / 1024),
+            limit: this.memoryLimit,
+        };
+        try {
+            this.onExceeded?.(info);
+        }
+        catch {
+            // Ignore callback errors - kill already initiated
+        }
+    }
+    /**
+     * Check if the process was killed due to memory limit.
+     */
+    wasKilledByMemoryLimit() {
+        return this.state === MonitorState.Killed;
+    }
+    /**
+     * Get current memory in MB.
+     * Returns 0 if no memory has been recorded yet.
+     */
+    getCurrentMemoryMB() {
+        return this.currentMemoryMB;
+    }
+}

package/dist/services/performance.js

@@ -0,0 +1,14 @@
+import { performance } from 'perf_hooks';
+/**
+ * Prevent perf_hooks memory leak warning during long-running operations.
+ * React and Ink create performance measurements internally that accumulate
+ * in the global buffer. This clears them immediately and periodically.
+ */
+export function preventPerformanceBufferOverflow(intervalMs = 60000) {
+    performance.clearMarks();
+    performance.clearMeasures();
+    setInterval(() => {
+        performance.clearMarks();
+        performance.clearMeasures();
+    }, intervalMs).unref();
+}