prompt-language-shell 0.9.4 → 0.9.8

package/dist/services/logger.js

@@ -1,7 +1,22 @@
+import { homedir, platform } from 'os';
+import { dirname, join } from 'path';
 import { DebugLevel } from '../configuration/types.js';
-import { createDebug } from './components.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)
+ * - Skills: Same content with visual separators for readability
+ * - Summary: Condensed view (Name, Steps, Execution only)
+ */
+export var PromptDisplay;
+(function (PromptDisplay) {
+    PromptDisplay["LLM"] = "llm";
+    PromptDisplay["Skills"] = "skills";
+    PromptDisplay["Summary"] = "summary";
+})(PromptDisplay || (PromptDisplay = {}));
 /**
  * Debug logger for the application
  * Logs information based on the current debug level setting
@@ -11,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
  */
@@ -49,41 +170,153 @@ export function getWarnings() {
     warnings.length = 0;
     return result;
 }
+/**
+ * Join sections with separators matching display width
+ */
+function joinWithSeparators(sections) {
+    const separator = '-'.repeat(DISPLAY_CONTENT_WIDTH);
+    return sections.join('\n\n' + separator + '\n\n');
+}
+/**
+ * Format a single skill definition as summary markdown
+ */
+function formatSkillSummary(skill) {
+    const lines = [];
+    lines.push(`### Name`);
+    lines.push(skill.name);
+    lines.push('');
+    if (skill.steps.length > 0) {
+        lines.push(`### Steps`);
+        for (const step of skill.steps) {
+            lines.push(`- ${step}`);
+        }
+        lines.push('');
+    }
+    if (skill.execution.length > 0) {
+        lines.push(`### Execution`);
+        for (const cmd of skill.execution) {
+            lines.push(`- ${cmd}`);
+        }
+    }
+    return lines.join('\n').trim();
+}
+/**
+ * Format skill definitions as summary for debug display
+ * Shows only Name, Steps, and Execution with visual separators
+ */
+export function formatSkillsSummary(definitions) {
+    if (definitions.length === 0) {
+        return '(no skills)';
+    }
+    const header = '## Available Skills';
+    const skillSummaries = definitions.map(formatSkillSummary);
+    return joinWithSeparators([header, ...skillSummaries]);
+}
+/**
+ * Format skills section with visual separators for debug display
+ * Layout: Header description -> separator -> skills separated by lines
+ */
+function formatSkillsForDisplay(formattedSkills) {
+    if (!formattedSkills) {
+        return '(no skills)';
+    }
+    // Find the header (everything before first ### Name)
+    const firstNameIndex = formattedSkills.search(/^###\s+Name/m);
+    if (firstNameIndex === -1) {
+        return '(no skills)';
+    }
+    const header = formattedSkills.slice(0, firstNameIndex).trim();
+    const skillsContent = formattedSkills.slice(firstNameIndex);
+    // Split by ### Name to get individual skills
+    const skillParts = skillsContent
+        .split(/(?=^###\s+Name)/m)
+        .map((s) => s.trim())
+        .filter(Boolean);
+    if (skillParts.length === 0) {
+        return '(no skills)';
+    }
+    // Join header and skills with separators
+    return joinWithSeparators([header, ...skillParts]);
+}
+/**
+ * Format prompt content based on the specified detail level
+ *
+ * - 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)
+ */
+export function formatPromptContent(toolName, command, baseInstructions, formattedSkills, mode, definitions) {
+    switch (mode) {
+        case PromptDisplay.LLM: {
+            const header = ['', `**Tool:** ${toolName}`];
+            return [...header, '', baseInstructions + formattedSkills].join('\n');
+        }
+        case PromptDisplay.Skills: {
+            const header = `\nTool: ${toolName}\nCommand: ${command}`;
+            const skillsDisplay = formatSkillsForDisplay(formattedSkills);
+            return joinWithSeparators([header, skillsDisplay]);
+        }
+        case PromptDisplay.Summary: {
+            const header = `\nTool: ${toolName}\nCommand: ${command}`;
+            const summary = definitions
+                ? formatSkillsSummary(definitions)
+                : '(no skills)';
+            return joinWithSeparators([header, summary]);
+        }
+    }
+}
 /**
  * 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
  */
-export function logPrompt(toolName, command, instructions) {
+export function logPrompt(toolName, command, baseInstructions, formattedSkills, definitions = []) {
+    // 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 = [
-        '',
-        `Tool: ${toolName}`,
-        `Command: ${command}`,
-        '',
-        instructions,
-    ].join('\n');
-    // Calculate stats for the instructions
-    const lines = instructions.split('\n').length;
-    const bytes = Buffer.byteLength(instructions, 'utf-8');
+    const content = formatPromptContent(toolName, command, baseInstructions, formattedSkills, PromptDisplay.Summary, definitions);
+    // Calculate stats for the full prompt
+    const fullPrompt = baseInstructions + formattedSkills;
+    const lines = fullPrompt.split('\n').length;
+    const bytes = Buffer.byteLength(fullPrompt, 'utf-8');
     const title = `SYSTEM PROMPT (${String(lines)} lines, ${String(bytes)} bytes)`;
     return createDebug({ title, content, color: Palette.Gray });
 }
 /**
  * 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.AshGray });
+    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,288 @@
+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 = 1000;
+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;
+    state = MonitorState.Idle;
+    getMemoryFn;
+    constructor(child, memoryLimitMB, onExceeded, getMemoryFn) {
+        this.child = child;
+        this.memoryLimit = memoryLimitMB;
+        this.limitBytes = memoryLimitMB * 1024 * 1024;
+        this.onExceeded = onExceeded;
+        // 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.
+     */
+    start() {
+        if (!this.child.pid)
+            return;
+        this.state = MonitorState.Running;
+        this.scheduleNextCheck();
+    }
+    /**
+     * 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
+        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;
+    }
+}

package/dist/services/parser.js

@@ -1,12 +1,11 @@
 import YAML from 'yaml';
 import { displayWarning } from './logger.js';
 /**
- * Validate a skill without parsing it fully
+ * Validate extracted sections from a skill
  * Returns validation error if skill is invalid, null if valid
  * Note: Name section is optional - key from filename is used as fallback
  */
-export function validateSkillStructure(content, key) {
-    const sections = extractSections(content);
+function validateSections(sections, key) {
     // Use key for error reporting if name not present
     const skillName = sections.name || key;
     // Check required sections (Name is now optional)
@@ -37,6 +36,15 @@ export function validateSkillStructure(content, key) {
     }
     return null;
 }
+/**
+ * Validate a skill without parsing it fully
+ * Returns validation error if skill is invalid, null if valid
+ * Note: Name section is optional - key from filename is used as fallback
+ */
+export function validateSkillStructure(content, key) {
+    const sections = extractSections(content);
+    return validateSections(sections, key);
+}
 /**
  * Convert kebab-case key to Title Case display name
  * Examples: "deploy-app" -> "Deploy App", "build-project-2" -> "Build Project 2"
@@ -64,8 +72,8 @@ export function parseSkillMarkdown(key, content) {
     const sections = extractSections(content);
     // Determine display name: prefer Name section, otherwise derive from key
     const displayName = sections.name || keyToDisplayName(key);
-    // Validate the skill (Name is no longer required since we have key)
-    const validationError = validateSkillStructure(content, key);
+    // Validate using already-extracted sections (avoids re-parsing)
+    const validationError = validateSections(sections, key);
     // For invalid skills, return minimal definition with error
     if (validationError) {
         return {

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();
+}