agentic-forge 0.0.0 → 0.7.0

package/dist/console.js

@@ -0,0 +1,670 @@
+/** Console output utilities for workflow execution. */
+// --- Enums and constants ---
+export const OutputLevel = {
+    BASE: "base",
+    ALL: "all",
+};
+export const Color = {
+    RESET: "\x1b[0m",
+    BOLD: "\x1b[1m",
+    DIM: "\x1b[2m",
+    RED: "\x1b[31m",
+    GREEN: "\x1b[32m",
+    YELLOW: "\x1b[33m",
+    BLUE: "\x1b[34m",
+    MAGENTA: "\x1b[35m",
+    CYAN: "\x1b[36m",
+    WHITE: "\x1b[37m",
+    BRIGHT_RED: "\x1b[91m",
+    BRIGHT_GREEN: "\x1b[92m",
+    BRIGHT_YELLOW: "\x1b[93m",
+    BRIGHT_BLUE: "\x1b[94m",
+    BRIGHT_CYAN: "\x1b[96m",
+};
+/** Maximum characters to accumulate in BASE mode before truncating (1MB). */
+const MAX_ACCUMULATED_TEXT = 1024 * 1024;
+// --- Utility functions ---
+export function supportsColor() {
+    if (typeof process.stdout.isTTY !== "boolean") {
+        return false;
+    }
+    return process.stdout.isTTY;
+}
+export function colorize(text, ...colors) {
+    if (!supportsColor()) {
+        return text;
+    }
+    const colorCodes = colors.join("");
+    return `${colorCodes}${text}${Color.RESET}`;
+}
+// --- ParallelOutputHandler ---
+export class ParallelOutputHandler {
+    stream;
+    level;
+    printFn;
+    branches = [];
+    branchIndex = new Map();
+    branchDone = new Map();
+    deferredMessages = [];
+    linesPerBranch = 4;
+    active = false;
+    // Per-branch accumulation (single-threaded, so we use maps instead of thread-local)
+    currentBranch = null;
+    accumulatedText = "";
+    accumulatedRole = "";
+    accumulatedModel = null;
+    baseAccumulatedText = "";
+    // Message queue for ALL mode parallel
+    messageQueue = [];
+    constructor(stream = process.stdout, level = OutputLevel.BASE, printFn) {
+        this.stream = stream;
+        this.level = level;
+        this.printFn = printFn ?? null;
+    }
+    print(message) {
+        if (this.printFn) {
+            this.printFn(message);
+        }
+        else {
+            this.stream.write(`${message}\n`);
+        }
+    }
+    get isActive() {
+        return this.active;
+    }
+    get hasBranches() {
+        return this.branches.length > 0;
+    }
+    registerBranches(branches) {
+        this.branches = [...branches];
+        this.branchIndex = new Map(branches.map((name, idx) => [name, idx]));
+        this.branchDone = new Map(branches.map((name) => [name, false]));
+        this.deferredMessages = [];
+        if (this.level === OutputLevel.BASE && supportsColor()) {
+            for (const branch of branches) {
+                const prefix = colorize(`[${branch}]`, Color.CYAN, Color.BOLD);
+                this.print(prefix);
+                const waiting = colorize("waiting...", Color.DIM);
+                this.print(`  ${waiting}`);
+                this.print(""); // Message line 2
+                this.print(""); // Blank line
+            }
+        }
+    }
+    updateBranchLine(branch, text, maxWidth = 100) {
+        if (!supportsColor() || !this.branchIndex.has(branch))
+            return;
+        if (this.branchDone.get(branch))
+            return;
+        const idx = this.branchIndex.get(branch) ?? 0;
+        const totalBranches = this.branches.length;
+        const totalLines = totalBranches * this.linesPerBranch;
+        const branchStartLine = idx * this.linesPerBranch;
+        const messageLine1 = branchStartLine + 1;
+        const messageLine2 = branchStartLine + 2;
+        const linesUpToMsg1 = totalLines - messageLine1;
+        const linesUpToMsg2 = totalLines - messageLine2;
+        const trimmed = text.trim();
+        let line1;
+        let line2 = "";
+        if (trimmed.length <= maxWidth) {
+            line1 = trimmed;
+        }
+        else {
+            let breakPoint = trimmed.lastIndexOf(" ", maxWidth);
+            if (breakPoint === -1)
+                breakPoint = maxWidth;
+            line1 = trimmed.slice(0, breakPoint).trim();
+            line2 = trimmed.slice(breakPoint).trim();
+            if (line2.length > maxWidth) {
+                line2 = `${line2.slice(0, maxWidth - 3)}...`;
+            }
+        }
+        const prefix = colorize("...", Color.DIM);
+        const w = this.stream;
+        w.write("\x1b[s"); // Save cursor
+        w.write(`\x1b[${linesUpToMsg1}A`); // Move up
+        w.write("\x1b[K"); // Clear line
+        w.write(`  ${prefix} ${line1}`);
+        w.write(`\x1b[${linesUpToMsg1 - linesUpToMsg2}B`); // Move down to line 2
+        w.write("\r\x1b[K"); // Clear line
+        if (line2) {
+            w.write(`  ${prefix} ${line2}`);
+        }
+        w.write("\x1b[u"); // Restore cursor
+    }
+    markBranchDone(branch, success = true) {
+        if (!supportsColor() || !this.branchIndex.has(branch))
+            return;
+        this.branchDone.set(branch, true);
+        const idx = this.branchIndex.get(branch) ?? 0;
+        const totalBranches = this.branches.length;
+        const totalLines = totalBranches * this.linesPerBranch;
+        const branchStartLine = idx * this.linesPerBranch;
+        const linesUpToHeader = totalLines - branchStartLine;
+        const messageLine1 = branchStartLine + 1;
+        const messageLine2 = branchStartLine + 2;
+        const linesUpToMsg1 = totalLines - messageLine1;
+        const linesUpToMsg2 = totalLines - messageLine2;
+        const branchPrefix = colorize(`[${branch}]`, Color.CYAN, Color.BOLD);
+        const status = success
+            ? colorize("[Done]", Color.BRIGHT_GREEN, Color.BOLD)
+            : colorize("[Failed]", Color.BRIGHT_RED, Color.BOLD);
+        const w = this.stream;
+        w.write("\x1b[s");
+        w.write(`\x1b[${linesUpToHeader}A`);
+        w.write("\x1b[K");
+        w.write(`${branchPrefix} ${status}`);
+        w.write(`\x1b[${linesUpToHeader - linesUpToMsg1}B`);
+        w.write("\r\x1b[K");
+        w.write(`\x1b[${linesUpToMsg1 - linesUpToMsg2}B`);
+        w.write("\r\x1b[K");
+        w.write("\x1b[u");
+    }
+    clearDisplay() {
+        if (this.branches.length === 0 || !supportsColor()) {
+            this.branches = [];
+            this.branchIndex = new Map();
+            this.branchDone = new Map();
+            return;
+        }
+        const totalLines = this.branches.length * this.linesPerBranch;
+        for (let i = 0; i < totalLines; i++) {
+            this.stream.write("\x1b[A\x1b[2K");
+        }
+        this.branches = [];
+        this.branchIndex = new Map();
+        this.branchDone = new Map();
+    }
+    enter() {
+        this.active = true;
+        if (this.level === OutputLevel.ALL) {
+            this.messageQueue = [];
+        }
+    }
+    exit() {
+        if (this.level === OutputLevel.BASE) {
+            if (this.branches.length > 0) {
+                this.clearDisplay();
+            }
+            for (const msg of this.deferredMessages) {
+                this.print(msg);
+            }
+            this.deferredMessages = [];
+        }
+        // Flush remaining messages in ALL mode
+        if (this.level === OutputLevel.ALL) {
+            for (const [branch, role, text, model] of this.messageQueue) {
+                this.printBranchMessage(branch, role, text, model);
+            }
+            this.messageQueue = [];
+        }
+        this.active = false;
+    }
+    deferMessage(message) {
+        this.deferredMessages.push(message);
+    }
+    setBranch(branchName) {
+        this.currentBranch = branchName;
+        this.accumulatedText = "";
+        this.accumulatedRole = "";
+        this.accumulatedModel = null;
+        this.baseAccumulatedText = "";
+    }
+    getCurrentBranch() {
+        return this.currentBranch;
+    }
+    enqueueCurrentMessage() {
+        if (this.level === OutputLevel.ALL &&
+            this.active &&
+            this.accumulatedText.trim() &&
+            this.accumulatedRole &&
+            this.currentBranch) {
+            this.messageQueue.push([
+                this.currentBranch,
+                this.accumulatedRole,
+                this.accumulatedText.trim(),
+                this.accumulatedModel,
+            ]);
+        }
+        this.accumulatedText = "";
+        this.accumulatedRole = "";
+        this.accumulatedModel = null;
+    }
+    printBranchMessage(branch, role, text, model, formatModelName) {
+        const formattedModel = formatModelName && model ? formatModelName(model) : null;
+        const branchPrefix = colorize(`[${branch}] `, Color.CYAN, Color.BOLD);
+        if (role === "user") {
+            const prefix = colorize(">", Color.BRIGHT_CYAN, Color.BOLD);
+            const label = colorize(" [user]", Color.DIM);
+            this.print(`\n${branchPrefix}${prefix}${label}`);
+            for (const line of text.split("\n")) {
+                const coloredLine = colorize(line, Color.GREEN);
+                this.print(`  ${coloredLine}`);
+            }
+        }
+        else {
+            const bullet = colorize("*", Color.BRIGHT_GREEN, Color.BOLD);
+            let modelLabel = "";
+            if (formattedModel) {
+                modelLabel = ` ${colorize(`[${formattedModel}]`, Color.DIM)}`;
+            }
+            const lines = text.split("\n");
+            this.print(`\n${branchPrefix}${bullet}${modelLabel} ${lines[0]}`);
+            for (const line of lines.slice(1)) {
+                this.print(`  ${line}`);
+            }
+        }
+    }
+    accumulateText(text, role, model) {
+        if (this.accumulatedRole && this.accumulatedRole !== role && this.accumulatedText.trim()) {
+            this.enqueueCurrentMessage();
+        }
+        this.accumulatedText += text;
+        this.accumulatedRole = role;
+        if (model) {
+            this.accumulatedModel = model;
+        }
+    }
+    accumulateBaseText(text) {
+        this.baseAccumulatedText += text;
+        const accumulated = this.baseAccumulatedText.trim();
+        if (accumulated) {
+            const lines = accumulated.split("\n");
+            return lines[lines.length - 1];
+        }
+        return "";
+    }
+}
+// --- ConsoleOutput ---
+export class ConsoleOutput {
+    level;
+    stream;
+    _baseAccumulatedText = "";
+    baseLastDisplayLines = 0;
+    _parallelHandler;
+    formatModelName = null;
+    constructor(level = OutputLevel.BASE, stream = process.stdout) {
+        this.level = level;
+        this.stream = stream;
+        this._parallelHandler = new ParallelOutputHandler(stream, level, (msg) => this.printLine(msg));
+    }
+    /** Set model name formatter to avoid circular imports with runner. */
+    setModelFormatter(fn) {
+        this.formatModelName = fn;
+    }
+    printLine(message, end = "\n") {
+        this.stream.write(`${message}${end}`);
+    }
+    printInplace(message) {
+        const lines = message.trim().split("\n");
+        const numLines = lines.length;
+        if (supportsColor()) {
+            if (this.baseLastDisplayLines > 0) {
+                this.stream.write(`\x1b[${this.baseLastDisplayLines}A`);
+                this.stream.write("\x1b[J");
+            }
+            const content = `${lines.join("\n")}\n`;
+            this.stream.write(content);
+        }
+        else {
+            const lastLine = lines[lines.length - 1] ?? "";
+            const truncated = lastLine.length > 80 ? `${lastLine.slice(0, 80)}...` : lastLine;
+            this.printLine(`  ... ${truncated}`);
+        }
+        this.baseLastDisplayLines = numLines;
+    }
+    clearInplace() {
+        if (this.baseLastDisplayLines > 0 && supportsColor()) {
+            this.stream.write(`\x1b[${this.baseLastDisplayLines}A\x1b[J`);
+        }
+        this.baseLastDisplayLines = 0;
+    }
+    // --- Parallel mode delegation ---
+    registerParallelBranches(branches) {
+        this._parallelHandler.registerBranches(branches);
+    }
+    enterParallelMode() {
+        this._parallelHandler.enter();
+    }
+    exitParallelMode() {
+        this._parallelHandler.exit();
+    }
+    setParallelBranch(branchName) {
+        this._parallelHandler.setBranch(branchName);
+    }
+    markParallelBranchDone(branch, success = true) {
+        this._parallelHandler.markBranchDone(branch, success);
+    }
+    isParallelMode() {
+        return this._parallelHandler.isActive;
+    }
+    shouldDeferMessage() {
+        return (this._parallelHandler.isActive &&
+            this.level === OutputLevel.BASE &&
+            this._parallelHandler.hasBranches);
+    }
+    deferMessage(message) {
+        this._parallelHandler.deferMessage(message);
+    }
+    // --- Workflow-level messages ---
+    workflowStart(workflowName, workflowId) {
+        const header = colorize(`Workflow: ${workflowName}`, Color.BOLD, Color.BRIGHT_CYAN);
+        const idStr = colorize(`[${workflowId}]`, Color.DIM);
+        this.printLine(`\n${header} ${idStr}`);
+        this.printLine(colorize("-".repeat(50), Color.DIM));
+    }
+    workflowComplete(workflowName, status) {
+        this.printLine(colorize("-".repeat(50), Color.DIM));
+        const statusStr = status === "completed"
+            ? colorize("COMPLETED", Color.BOLD, Color.BRIGHT_GREEN)
+            : colorize(status.toUpperCase(), Color.BOLD, Color.BRIGHT_RED);
+        this.printLine(`Workflow ${workflowName}: ${statusStr}\n`);
+    }
+    // --- Step-level messages ---
+    stepStart(stepName, stepType, model) {
+        let modelStr = "";
+        if (this.level === OutputLevel.BASE && model) {
+            const formattedModel = this.formatModelName ? this.formatModelName(model) : model;
+            if (formattedModel) {
+                modelStr = `${colorize(`[${formattedModel}] `, Color.DIM)}`;
+            }
+        }
+        const stepStr = colorize(`Step: ${stepName}`, Color.BOLD);
+        const typeStr = stepType ? colorize(`[${stepType}]`, Color.DIM) : "";
+        const formatted = `\n${modelStr}${stepStr} ${typeStr}`;
+        if (this.shouldDeferMessage()) {
+            this.deferMessage(formatted);
+        }
+        else {
+            this.printLine(formatted);
+        }
+    }
+    stepComplete(stepName, summary) {
+        if (this.level === OutputLevel.BASE && !this.isParallelMode()) {
+            this.baseLastDisplayLines = 0;
+            this._baseAccumulatedText = "";
+        }
+        const check = colorize("[OK]", Color.BRIGHT_GREEN);
+        const name = colorize(stepName, Color.GREEN);
+        const mainLine = `${check} ${name} completed`;
+        const lines = [mainLine];
+        if (summary && this.level === OutputLevel.BASE) {
+            const summaryLines = summary.trim().split("\n");
+            for (const line of summaryLines.slice(0, 5)) {
+                const truncated = line.length > 200 ? `${line.slice(0, 200)}...` : line;
+                lines.push(colorize(`    ${truncated}`, Color.DIM));
+            }
+            if (summaryLines.length > 5) {
+                lines.push(colorize(`    ... (${summaryLines.length - 5} more lines)`, Color.DIM));
+            }
+        }
+        if (this.shouldDeferMessage()) {
+            const branch = this._parallelHandler.getCurrentBranch();
+            if (branch) {
+                this.markParallelBranchDone(branch);
+            }
+            for (const line of lines) {
+                this.deferMessage(line);
+            }
+        }
+        else {
+            for (const line of lines) {
+                this.printLine(line);
+            }
+        }
+    }
+    stepFailed(stepName, error) {
+        if (this.level === OutputLevel.BASE && !this.isParallelMode()) {
+            this.baseLastDisplayLines = 0;
+            this._baseAccumulatedText = "";
+        }
+        const cross = colorize("[FAIL]", Color.BRIGHT_RED);
+        const name = colorize(stepName, Color.RED);
+        const mainLine = `${cross} ${name} failed`;
+        const lines = [mainLine];
+        if (error) {
+            const errorLines = error.trim().split("\n");
+            for (const line of errorLines.slice(0, 10)) {
+                const truncated = line.length > 200 ? `${line.slice(0, 200)}...` : line;
+                lines.push(colorize(`    ${truncated}`, Color.RED));
+            }
+            if (errorLines.length > 10) {
+                lines.push(colorize(`    ... (${errorLines.length - 10} more lines)`, Color.DIM));
+            }
+        }
+        if (this.shouldDeferMessage()) {
+            const branch = this._parallelHandler.getCurrentBranch();
+            if (branch) {
+                this.markParallelBranchDone(branch, false);
+            }
+            for (const line of lines) {
+                this.deferMessage(line);
+            }
+        }
+        else {
+            for (const line of lines) {
+                this.printLine(line);
+            }
+        }
+    }
+    stepRetry(stepName, attempt, maxAttempts, error) {
+        const retry = colorize(`[RETRY ${attempt}/${maxAttempts}]`, Color.YELLOW);
+        const name = colorize(stepName, Color.YELLOW);
+        const mainLine = `${retry} ${name}`;
+        const lines = [mainLine];
+        if (error) {
+            const firstLine = error.trim().split("\n")[0].slice(0, 100);
+            lines.push(colorize(`    Reason: ${firstLine}`, Color.DIM));
+        }
+        if (this.shouldDeferMessage()) {
+            for (const line of lines) {
+                this.deferMessage(line);
+            }
+        }
+        else {
+            for (const line of lines) {
+                this.printLine(line);
+            }
+        }
+    }
+    // --- Ralph loop messages ---
+    ralphIterationStart(stepName, iteration, maxIterations) {
+        if (this.level === OutputLevel.BASE && !this.isParallelMode()) {
+            this.baseLastDisplayLines = 0;
+            this._baseAccumulatedText = "";
+        }
+        const progress = colorize(`[${iteration}/${maxIterations}]`, Color.CYAN);
+        const name = colorize(stepName, Color.CYAN);
+        this.printLine(`${progress} ${name} iteration`);
+    }
+    ralphIteration(_stepName, _iteration, _maxIterations, summary) {
+        if (this.level === OutputLevel.BASE && !this.isParallelMode()) {
+            return;
+        }
+        if (summary && this.level === OutputLevel.ALL) {
+            const summaryLines = summary.trim().split("\n");
+            for (const line of summaryLines.slice(0, 3)) {
+                const truncated = line.length > 150 ? `${line.slice(0, 150)}...` : line;
+                this.printLine(colorize(`    ${truncated}`, Color.DIM));
+            }
+        }
+    }
+    ralphComplete(stepName, iteration, maxIterations) {
+        if (this.level === OutputLevel.BASE && !this.isParallelMode()) {
+            this.baseLastDisplayLines = 0;
+            this._baseAccumulatedText = "";
+        }
+        const check = colorize("[OK]", Color.BRIGHT_GREEN);
+        const name = colorize(stepName, Color.GREEN);
+        this.printLine(`${check} ${name} completed at iteration ${iteration}/${maxIterations}`);
+    }
+    ralphMaxIterations(stepName, maxIterations) {
+        if (this.level === OutputLevel.BASE && !this.isParallelMode()) {
+            this.baseLastDisplayLines = 0;
+            this._baseAccumulatedText = "";
+        }
+        const warn = colorize("[WARN]", Color.YELLOW);
+        const name = colorize(stepName, Color.YELLOW);
+        this.printLine(`${warn} ${name} reached max iterations (${maxIterations})`);
+    }
+    // --- Generic messages ---
+    info(message) {
+        const infoPrefix = colorize("[INFO]", Color.BLUE);
+        const formatted = `${infoPrefix} ${message}`;
+        if (this.shouldDeferMessage()) {
+            this.deferMessage(formatted);
+        }
+        else {
+            this.printLine(formatted);
+        }
+    }
+    warning(message) {
+        const warn = colorize("[WARN]", Color.YELLOW);
+        const formatted = `${warn} ${message}`;
+        if (this.shouldDeferMessage()) {
+            this.deferMessage(formatted);
+        }
+        else {
+            this.printLine(formatted);
+        }
+    }
+    error(message) {
+        const err = colorize("[ERROR]", Color.BRIGHT_RED);
+        const formatted = `${err} ${message}`;
+        if (this.shouldDeferMessage()) {
+            this.deferMessage(formatted);
+        }
+        else {
+            this.printLine(formatted);
+        }
+    }
+    // --- Streaming ---
+    streamText(text, role = "assistant", model) {
+        const formattedModel = this.formatModelName && model ? this.formatModelName(model) : null;
+        if (this.level === OutputLevel.ALL) {
+            if (!text || !text.trim())
+                return;
+            if (this.isParallelMode()) {
+                this._parallelHandler.accumulateText(text, role, model);
+                return;
+            }
+            if (role === "user") {
+                const prefix = colorize(">", Color.BRIGHT_CYAN, Color.BOLD);
+                const label = colorize(" [user]", Color.DIM);
+                this.printLine("");
+                this.printLine(`${prefix}${label}`);
+                for (const line of text.split("\n")) {
+                    const coloredLine = colorize(line, Color.GREEN);
+                    this.printLine(`  ${coloredLine}`);
+                }
+            }
+            else {
+                const bullet = colorize("*", Color.BRIGHT_GREEN, Color.BOLD);
+                let modelLabel = "";
+                if (formattedModel) {
+                    modelLabel = ` ${colorize(`[${formattedModel}]`, Color.DIM)}`;
+                }
+                const lines = text.split("\n");
+                this.printLine("");
+                this.printLine(`${bullet}${modelLabel} ${lines[0]}`);
+                for (const line of lines.slice(1)) {
+                    this.printLine(`  ${line}`);
+                }
+            }
+        }
+        else if (this.level === OutputLevel.BASE) {
+            if (role === "user")
+                return;
+            if (this.isParallelMode()) {
+                const branch = this._parallelHandler.getCurrentBranch();
+                if (branch && this._parallelHandler.hasBranches) {
+                    const lastLine = this._parallelHandler.accumulateBaseText(text);
+                    if (lastLine) {
+                        this._parallelHandler.updateBranchLine(branch, lastLine);
+                    }
+                }
+                return;
+            }
+            this._baseAccumulatedText += text;
+            if (this._baseAccumulatedText.length > MAX_ACCUMULATED_TEXT) {
+                this._baseAccumulatedText = this._baseAccumulatedText.slice(-MAX_ACCUMULATED_TEXT);
+            }
+            if (this._baseAccumulatedText.trim()) {
+                const prefix = colorize("...", Color.DIM);
+                const lines = this._baseAccumulatedText.trim().split("\n");
+                const formattedLines = [`${prefix} ${lines[0]}`];
+                for (const line of lines.slice(1)) {
+                    formattedLines.push(`    ${line}`);
+                }
+                const displayText = formattedLines.join("\n");
+                this.printInplace(displayText);
+            }
+        }
+    }
+    streamComplete() {
+        if (this.level === OutputLevel.ALL && this.isParallelMode()) {
+            this._parallelHandler.enqueueCurrentMessage();
+        }
+        this._baseAccumulatedText = "";
+    }
+}
+// --- Standalone utility functions ---
+export function extractJson(output) {
+    if (!output || !output.trim())
+        return null;
+    const pattern = /```json\s*([\s\S]*?)```/g;
+    const matches = [...output.matchAll(pattern)];
+    if (matches.length === 0)
+        return null;
+    const jsonStr = matches[matches.length - 1][1].trim();
+    try {
+        return JSON.parse(jsonStr);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        process.stderr.write(`[WARN] Failed to parse JSON from output: ${msg}\n`);
+        return null;
+    }
+}
+export function extractSummary(output, maxLines = 5, maxChars = 500) {
+    if (!output || !output.trim())
+        return "";
+    const trimmed = output.trim();
+    const summaryMarkers = [
+        "## Summary",
+        "### Summary",
+        "Summary:",
+        "Result:",
+        "Completed:",
+        "Done:",
+    ];
+    for (const marker of summaryMarkers) {
+        if (trimmed.includes(marker)) {
+            const idx = trimmed.indexOf(marker);
+            const summarySection = trimmed.slice(idx);
+            const lines = summarySection.split("\n");
+            const resultLines = [];
+            for (let i = 1; i < lines.length; i++) {
+                if (i > maxLines)
+                    break;
+                if (lines[i].startsWith("#") && i > 1)
+                    break;
+                resultLines.push(lines[i]);
+            }
+            if (resultLines.length > 0) {
+                return resultLines.join("\n").trim().slice(0, maxChars);
+            }
+        }
+    }
+    const nonEmptyLines = trimmed.split("\n").filter((line) => line.trim());
+    if (nonEmptyLines.length === 0)
+        return "";
+    const lastLines = nonEmptyLines.slice(-maxLines);
+    let summary = lastLines.join("\n");
+    if (summary.length > maxChars) {
+        summary = `${summary.slice(0, maxChars)}...`;
+    }
+    return summary;
+}
+//# sourceMappingURL=console.js.map