erosolar-cli 1.5.2 → 1.5.4

package/dist/bin/runtime/universal.js

@@ -0,0 +1,28 @@
+import { AgentHost } from './agentHost.js';
+export async function createUniversalRuntime(options) {
+    const env = options.env ? { ...options.env } : { ...process.env };
+    const host = new AgentHost({
+        profile: options.profile,
+        workspaceContext: options.workspaceContext,
+        workingDir: options.workingDir,
+        toolObserver: options.toolObserver,
+        env,
+    });
+    const adapterContext = {
+        profile: options.profile,
+        workspaceContext: options.workspaceContext,
+        workingDir: options.workingDir,
+        env,
+    };
+    const adapterModules = await options.adapter.createCapabilityModules(adapterContext);
+    const additionalModules = options.additionalModules ?? [];
+    if (adapterModules.length || additionalModules.length) {
+        await host.loadModules([...adapterModules, ...additionalModules]);
+    }
+    const session = await host.getSession();
+    return {
+        host,
+        session,
+        adapter: options.adapter,
+    };
+}

package/dist/bin/shell/bracketedPasteManager.js

@@ -0,0 +1,350 @@
+/**
+ * Bracketed paste manager for handling terminal paste operations.
+ *
+ * This class handles the bracketed paste mode in terminals, which allows
+ * pasted text to be distinguished from typed input. This is particularly
+ * useful for handling multi-line pastes and preventing unwanted execution
+ * of commands during paste operations.
+ */
+export class BracketedPasteManager {
+    constructor(enabled) {
+        this.inPaste = false;
+        this.pasteBuffer = [];
+        /** Tracks accumulated multi-line input even without bracketed paste support */
+        this.multiLineBuffer = [];
+        this.multiLineMode = false;
+        this.lastInputTime = 0;
+        /** Time threshold (ms) to consider rapid input as paste */
+        this.PASTE_THRESHOLD_MS = 50;
+        /** Raw data buffer for capturing complete bracketed paste content */
+        this.rawPasteBuffer = '';
+        /** Callback for when raw paste is complete */
+        this.onRawPasteComplete = null;
+        /** Whether we're currently capturing raw data */
+        this.capturingRaw = false;
+        this.enabled = enabled;
+    }
+    /**
+     * Process raw data from stdin before readline handles it.
+     * This intercepts bracketed paste content and captures it in full.
+     * Returns true if the data was consumed (should not be passed to readline).
+     */
+    processRawData(data) {
+        if (!this.enabled) {
+            return { consumed: false };
+        }
+        const startIdx = data.indexOf(BracketedPasteManager.START_MARKER);
+        const endIdx = data.indexOf(BracketedPasteManager.END_MARKER);
+        // Case 1: Not in paste mode and no start marker - pass through
+        if (!this.capturingRaw && startIdx === -1) {
+            return { consumed: false };
+        }
+        // Case 2: Found start marker - begin capturing
+        if (!this.capturingRaw && startIdx !== -1) {
+            this.capturingRaw = true;
+            const beforeStart = data.substring(0, startIdx);
+            const afterStart = data.substring(startIdx + BracketedPasteManager.START_MARKER.length);
+            // Check if end marker is in same chunk
+            const endInAfter = afterStart.indexOf(BracketedPasteManager.END_MARKER);
+            if (endInAfter !== -1) {
+                // Complete paste in single chunk
+                const pasteContent = afterStart.substring(0, endInAfter);
+                const afterEnd = afterStart.substring(endInAfter + BracketedPasteManager.END_MARKER.length);
+                this.capturingRaw = false;
+                this.rawPasteBuffer = '';
+                // Emit the complete paste
+                if (this.onRawPasteComplete) {
+                    this.onRawPasteComplete(pasteContent);
+                }
+                // Return any content before/after markers to be passed through
+                const passThrough = beforeStart + afterEnd;
+                return { consumed: true, passThrough: passThrough || undefined };
+            }
+            // Start marker found but no end marker yet
+            this.rawPasteBuffer = afterStart;
+            // Pass through anything before the start marker
+            return { consumed: true, passThrough: beforeStart || undefined };
+        }
+        // Case 3: Currently capturing and found end marker
+        if (this.capturingRaw && endIdx !== -1) {
+            const beforeEnd = data.substring(0, endIdx);
+            const afterEnd = data.substring(endIdx + BracketedPasteManager.END_MARKER.length);
+            const pasteContent = this.rawPasteBuffer + beforeEnd;
+            this.capturingRaw = false;
+            this.rawPasteBuffer = '';
+            // Emit the complete paste
+            if (this.onRawPasteComplete) {
+                this.onRawPasteComplete(pasteContent);
+            }
+            // Pass through anything after end marker
+            return { consumed: true, passThrough: afterEnd || undefined };
+        }
+        // Case 4: Currently capturing, no end marker - accumulate
+        if (this.capturingRaw) {
+            this.rawPasteBuffer += data;
+            return { consumed: true };
+        }
+        return { consumed: false };
+    }
+    /**
+     * Set callback for when a complete paste is captured via raw data processing
+     */
+    setRawPasteCallback(callback) {
+        this.onRawPasteComplete = callback;
+    }
+    /**
+     * Check if currently capturing raw paste data
+     */
+    isCapturingRaw() {
+        return this.capturingRaw;
+    }
+    /**
+     * Get current raw buffer size (for display)
+     */
+    getRawBufferLineCount() {
+        if (!this.rawPasteBuffer)
+            return 0;
+        return this.rawPasteBuffer.split('\n').length;
+    }
+    /**
+     * Get preview of raw buffer content
+     */
+    getRawBufferPreview() {
+        if (!this.rawPasteBuffer)
+            return '';
+        const lines = this.rawPasteBuffer.split('\n');
+        return this.getPreview(lines);
+    }
+    /**
+     * Process input text, handling bracketed paste sequences
+     */
+    process(input) {
+        if (!this.enabled) {
+            return this.processWithoutBracketed(input);
+        }
+        const startMarker = '\u001b[200~';
+        const endMarker = '\u001b[201~';
+        // If we're already in a paste, look for end marker
+        if (this.inPaste) {
+            const endIndex = input.indexOf(endMarker);
+            if (endIndex !== -1) {
+                // End of paste found
+                const beforeEnd = input.substring(0, endIndex);
+                const afterEnd = input.substring(endIndex + endMarker.length);
+                this.pasteBuffer.push(beforeEnd);
+                const result = this.pasteBuffer.join('\n');
+                const lineCount = this.pasteBuffer.length;
+                const preview = this.getPreview(this.pasteBuffer);
+                // Reset state
+                this.inPaste = false;
+                this.pasteBuffer = [];
+                // If there's text after the end marker, process it normally
+                if (afterEnd) {
+                    const afterResult = this.process(afterEnd);
+                    if (afterResult.handled && afterResult.result !== undefined) {
+                        return {
+                            handled: true,
+                            result: result + afterResult.result,
+                            lineCount,
+                            preview,
+                        };
+                    }
+                    return {
+                        handled: true,
+                        result: result + afterEnd,
+                        lineCount,
+                        preview,
+                    };
+                }
+                return {
+                    handled: true,
+                    result,
+                    lineCount,
+                    preview,
+                };
+            }
+            else {
+                // Still in paste, no end marker found
+                this.pasteBuffer.push(input);
+                return {
+                    handled: true,
+                    isPending: true,
+                    lineCount: this.pasteBuffer.length,
+                    preview: this.getPreview(this.pasteBuffer),
+                };
+            }
+        }
+        // Not in paste, look for start marker
+        const startIndex = input.indexOf(startMarker);
+        if (startIndex !== -1) {
+            // Start of paste found
+            const beforeStart = input.substring(0, startIndex);
+            const afterStart = input.substring(startIndex + startMarker.length);
+            // Start paste mode
+            this.inPaste = true;
+            this.pasteBuffer = [];
+            // Process the text after the start marker
+            if (afterStart) {
+                const afterResult = this.process(afterStart);
+                if (afterResult.handled && afterResult.result !== undefined) {
+                    return {
+                        handled: true,
+                        result: beforeStart + afterResult.result,
+                        lineCount: afterResult.lineCount,
+                        preview: afterResult.preview,
+                    };
+                }
+                // Still pending
+                return {
+                    handled: true,
+                    result: beforeStart,
+                    isPending: this.inPaste,
+                    lineCount: this.pasteBuffer.length,
+                    preview: this.getPreview(this.pasteBuffer),
+                };
+            }
+            return {
+                handled: true,
+                result: beforeStart,
+                isPending: true,
+                lineCount: 0,
+            };
+        }
+        // No paste markers found
+        return { handled: false };
+    }
+    /**
+     * Process input when bracketed paste is not enabled
+     * Uses timing heuristics to detect rapid multi-line input (likely paste)
+     */
+    processWithoutBracketed(input) {
+        const now = Date.now();
+        const timeSinceLastInput = now - this.lastInputTime;
+        this.lastInputTime = now;
+        // Check if this looks like part of a rapid paste
+        if (timeSinceLastInput < this.PASTE_THRESHOLD_MS && this.multiLineBuffer.length > 0) {
+            // Continue accumulating
+            this.multiLineBuffer.push(input);
+            this.multiLineMode = true;
+            return {
+                handled: true,
+                isPending: true,
+                lineCount: this.multiLineBuffer.length,
+                preview: this.getPreview(this.multiLineBuffer),
+            };
+        }
+        // If we were in multi-line mode and there's a pause, finalize
+        if (this.multiLineMode && this.multiLineBuffer.length > 0) {
+            this.multiLineBuffer.push(input);
+            const result = this.multiLineBuffer.join('\n');
+            const lineCount = this.multiLineBuffer.length;
+            const preview = this.getPreview(this.multiLineBuffer);
+            this.multiLineBuffer = [];
+            this.multiLineMode = false;
+            return {
+                handled: true,
+                result,
+                lineCount,
+                preview,
+            };
+        }
+        // Check for embedded newlines in a single input (indicates paste)
+        if (input.includes('\n')) {
+            const lines = input.split('\n');
+            return {
+                handled: true,
+                result: input,
+                lineCount: lines.length,
+                preview: this.getPreview(lines),
+            };
+        }
+        // Start tracking for potential multi-line paste
+        this.multiLineBuffer = [input];
+        return { handled: false };
+    }
+    /**
+     * Generate a preview string for multi-line content
+     */
+    getPreview(lines) {
+        if (lines.length === 0) {
+            return '';
+        }
+        const firstLine = lines[0] || '';
+        const truncatedFirst = firstLine.length > 50
+            ? firstLine.slice(0, 47) + '...'
+            : firstLine;
+        if (lines.length === 1) {
+            return truncatedFirst;
+        }
+        return `${truncatedFirst} [+${lines.length - 1} more lines]`;
+    }
+    /**
+     * Get current multi-line state for display purposes
+     */
+    getMultiLineState() {
+        const buffer = this.inPaste ? this.pasteBuffer :
+            this.multiLineMode ? this.multiLineBuffer : null;
+        if (!buffer || buffer.length === 0) {
+            return null;
+        }
+        const firstLine = buffer[0] || '';
+        const lastLine = buffer[buffer.length - 1] || '';
+        return {
+            content: buffer.join('\n'),
+            lineCount: buffer.length,
+            firstLinePreview: firstLine.length > 40 ? firstLine.slice(0, 37) + '...' : firstLine,
+            lastLinePreview: lastLine.length > 40 ? lastLine.slice(0, 37) + '...' : lastLine,
+        };
+    }
+    /**
+     * Format a multi-line paste as a collapsed block for display
+     */
+    static formatCollapsedBlock(content, maxPreviewLength = 60) {
+        const lines = content.split('\n');
+        if (lines.length <= 1) {
+            return content;
+        }
+        const firstLine = (lines[0] || '').trim();
+        const truncatedFirst = firstLine.length > maxPreviewLength
+            ? firstLine.slice(0, maxPreviewLength - 3) + '...'
+            : firstLine;
+        return `📋 ${truncatedFirst} [${lines.length} lines]`;
+    }
+    /**
+     * Check if currently processing a paste
+     */
+    isInPaste() {
+        return this.inPaste || this.multiLineMode;
+    }
+    /**
+     * Get the current paste buffer
+     */
+    getPasteBuffer() {
+        return this.inPaste ? [...this.pasteBuffer] : [...this.multiLineBuffer];
+    }
+    /**
+     * Finalize any pending multi-line input
+     */
+    finalize() {
+        if (this.multiLineMode && this.multiLineBuffer.length > 1) {
+            const result = this.multiLineBuffer.join('\n');
+            this.multiLineBuffer = [];
+            this.multiLineMode = false;
+            return result;
+        }
+        return null;
+    }
+    /**
+     * Reset the paste state
+     */
+    reset() {
+        this.inPaste = false;
+        this.pasteBuffer = [];
+        this.multiLineMode = false;
+        this.multiLineBuffer = [];
+        this.rawPasteBuffer = '';
+        this.capturingRaw = false;
+    }
+}
+BracketedPasteManager.START_MARKER = '\u001b[200~';
+BracketedPasteManager.END_MARKER = '\u001b[201~';

package/dist/bin/shell/fileChangeTracker.js

@@ -0,0 +1,65 @@
+/**
+ * File Change Tracker
+ * Tracks file modifications during a session to display summary stats
+ */
+export class FileChangeTracker {
+    constructor() {
+        this.changes = new Map();
+    }
+    /**
+     * Record a file edit/write operation
+     */
+    recordChange(path, type, additions = 0, removals = 0) {
+        const existing = this.changes.get(path);
+        if (existing) {
+            // Accumulate changes for the same file
+            existing.additions += additions;
+            existing.removals += removals;
+            existing.timestamp = Date.now();
+            existing.type = type; // Update to latest operation type
+        }
+        else {
+            this.changes.set(path, {
+                path,
+                type,
+                additions,
+                removals,
+                timestamp: Date.now(),
+            });
+        }
+    }
+    /**
+     * Get summary of all changes
+     */
+    getSummary() {
+        let totalAdditions = 0;
+        let totalRemovals = 0;
+        for (const change of this.changes.values()) {
+            totalAdditions += change.additions;
+            totalRemovals += change.removals;
+        }
+        return {
+            files: this.changes.size,
+            additions: totalAdditions,
+            removals: totalRemovals,
+        };
+    }
+    /**
+     * Get all changes
+     */
+    getAllChanges() {
+        return Array.from(this.changes.values()).sort((a, b) => b.timestamp - a.timestamp);
+    }
+    /**
+     * Clear all tracked changes
+     */
+    clear() {
+        this.changes.clear();
+    }
+    /**
+     * Get change for specific file
+     */
+    getChange(path) {
+        return this.changes.get(path);
+    }
+}