toolcraft 0.0.232 → 0.0.233

package/node_modules/toolcraft-design/dist/dashboard/ansi.js

@@ -1,4 +1,16 @@
+import { graphemes, graphemeWidth } from "./terminal-width.js";
+import { createTerminalStringFilter } from "./terminal-strings.js";
 const ESC = "\u001b";
+/** Visible text for a plain screen row; styles are supplied by the caller. */
+export function plainTerminalText(text) {
+    for (let index = 0; index < text.length; index++) {
+        const code = text.charCodeAt(index);
+        if ((code < 0x20 && code !== 0x09) || (code >= 0x7f && code <= 0x9f)) {
+            return parseAnsi(text).map(line => line.segments.map(segment => segment.text).join("")).join(" ");
+        }
+    }
+    return text;
+}
 export function hasAnsi(text) {
     return text.includes(ESC);
 }
@@ -11,12 +23,38 @@ export function hasAnsi(text) {
  * `baseStyle` is used as the initial style and as the restore target for SGR reset / default color.
  */
 export function parseAnsi(text, baseStyle) {
+    text = createTerminalStringFilter().push(text);
     const base = normalizeStyle(baseStyle);
     let style = { ...base };
     let concealed = false;
     const lines = [];
     let cells = [];
     let column = 0;
+    const clearCell = (position) => {
+        if (cells[position]?.ch === "" && position > 0) {
+            cells[position - 1] = { ch: " ", style: { ...style } };
+        }
+        if (cells[position + 1]?.ch === "") {
+            cells[position + 1] = { ch: " ", style: { ...style } };
+        }
+        cells[position] = undefined;
+    };
+    const writeGrapheme = (ch) => {
+        const width = graphemeWidth(ch);
+        if (width === 0) {
+            const previous = cells[column - 1]?.ch === "" ? column - 2 : column - 1;
+            if (!concealed && cells[previous])
+                cells[previous].ch += ch;
+            return;
+        }
+        clearCell(column);
+        if (width === 2)
+            clearCell(column + 1);
+        cells[column] = { ch: concealed ? " " : ch, style: { ...style } };
+        if (width === 2)
+            cells[column + 1] = { ch: concealed ? " " : "", style: { ...style } };
+        column += width;
+    };
     const finishLine = () => {
         lines.push({ segments: cellsToSegments(cells) });
         cells = [];
@@ -25,8 +63,8 @@ export function parseAnsi(text, baseStyle) {
     let index = 0;
     while (index < text.length) {
         const ch = text[index];
-        if (ch === ESC && text[index + 1] === "[") {
-            const paramsStart = index + 2;
+        if ((ch === ESC && text[index + 1] === "[") || ch === "\u009b") {
+            const paramsStart = index + (ch === ESC ? 2 : 1);
             let cursor = paramsStart;
             while (cursor < text.length && !isCsiFinalByte(text[cursor])) {
                 cursor += 1;
@@ -42,18 +80,30 @@ export function parseAnsi(text, baseStyle) {
                 style = sgr.style;
                 concealed = sgr.concealed;
             }
-            else if (finalByte === "K" && parseParams(params)[0] === 2) {
-                cells = [];
+            else if (finalByte === "K") {
+                const mode = parseParams(params)[0];
+                if (mode === 0) {
+                    clearCell(column);
+                    cells.length = Math.min(cells.length, column);
+                }
+                else if (mode === 1) {
+                    const end = Math.min(column, cells.length - 1);
+                    for (let position = 0; position <= end; position += 1)
+                        clearCell(position);
+                }
+                else if (mode === 2) {
+                    cells = [];
+                }
             }
             index = cursor + 1;
             continue;
         }
+        if (ch === "\u0085") {
+            finishLine();
+            index += 1;
+            continue;
+        }
         if (ch === ESC) {
-            const next = text[index + 1];
-            if (next === "]" || next === "P" || next === "X" || next === "^" || next === "_") {
-                index = skipStringTerminated(text, index + 2);
-                continue;
-            }
             index += 2;
             continue;
         }
@@ -72,14 +122,32 @@ export function parseAnsi(text, baseStyle) {
             index += 1;
             continue;
         }
+        if (ch === "\t") {
+            const spaces = 8 - (column % 8);
+            for (let offset = 0; offset < spaces; offset++) {
+                if (cells[column] === undefined)
+                    writeGrapheme(" ");
+                else
+                    column += 1;
+            }
+            index += 1;
+            continue;
+        }
         const code = ch.charCodeAt(0);
-        if (code < 0x20 && ch !== "\t") {
+        if (code < 0x20 || (code >= 0x7f && code <= 0x9f)) {
             index += 1;
             continue;
         }
-        cells[column] = { ch: concealed ? " " : ch, style: { ...style } };
-        column += 1;
-        index += 1;
+        let end = index + 1;
+        while (end < text.length) {
+            const next = text.charCodeAt(end);
+            if (next < 0x20 || (next >= 0x7f && next <= 0x9f))
+                break;
+            end += 1;
+        }
+        for (const grapheme of graphemes(text.slice(index, end)))
+            writeGrapheme(grapheme);
+        index = end;
     }
     finishLine();
     return lines;
@@ -102,20 +170,6 @@ function isCsiFinalByte(ch) {
     const code = ch.charCodeAt(0);
     return code >= 0x40 && code <= 0x7e;
 }
-function skipStringTerminated(text, start) {
-    let index = start;
-    while (index < text.length) {
-        const ch = text[index];
-        if (ch === "\u0007") {
-            return index + 1;
-        }
-        if (ch === ESC && text[index + 1] === "\\") {
-            return index + 2;
-        }
-        index += 1;
-    }
-    return index;
-}
 function parseParams(params) {
     if (params.length === 0) {
         return [0];

package/node_modules/toolcraft-design/dist/dashboard/buffer.js

@@ -1,5 +1,6 @@
 import { color } from "../components/color.js";
 import { expandTabs, graphemes, graphemeWidth } from "./terminal-width.js";
+import { parseAnsi } from "./ansi.js";
 const EMPTY_CELL = { ch: " ", style: {} };
 export class ScreenBuffer {
     _width;
@@ -22,17 +23,19 @@ export class ScreenBuffer {
         }
         const normalizedStyle = normalizeStyle(style);
         let offset = 0;
-        for (const ch of graphemes(expandTabs(text, Math.max(0, x)))) {
-            const targetX = x + offset;
-            const width = graphemeWidth(ch);
-            offset += width;
-            if (!this.isInBoundsX(targetX)) {
-                continue;
-            }
-            this._cells[this.index(targetX, y)] = { ch, style: normalizedStyle };
-            for (let continuation = 1; continuation < width; continuation += 1) {
-                if (this.isInBoundsX(targetX + continuation)) {
-                    this._cells[this.index(targetX + continuation, y)] = { ch: "", style: normalizedStyle };
+        for (const segment of screenSegments(text, normalizedStyle)) {
+            for (const ch of graphemes(expandTabs(segment.text, Math.max(0, x + offset)))) {
+                const targetX = x + offset;
+                const width = graphemeWidth(ch);
+                offset += width;
+                if (!this.isInBoundsX(targetX)) {
+                    continue;
+                }
+                this._cells[this.index(targetX, y)] = { ch, style: segment.style };
+                for (let continuation = 1; continuation < width; continuation += 1) {
+                    if (this.isInBoundsX(targetX + continuation)) {
+                        this._cells[this.index(targetX + continuation, y)] = { ch: "", style: segment.style };
+                    }
                 }
             }
         }
@@ -84,20 +87,22 @@ export class ScreenBuffer {
         const normalizedStyle = normalizeStyle(style);
         const rectEndX = rect.x + rect.width;
         let offset = 0;
-        for (const ch of graphemes(expandTabs(text))) {
-            const targetX = rect.x + offset;
-            const width = graphemeWidth(ch);
-            offset += width;
-            if (targetX + width > rectEndX) {
-                break;
-            }
-            if (!this.isInBoundsX(targetX)) {
-                continue;
-            }
-            this._cells[this.index(targetX, y)] = { ch, style: normalizedStyle };
-            for (let continuation = 1; continuation < width; continuation += 1) {
-                if (this.isInBoundsX(targetX + continuation)) {
-                    this._cells[this.index(targetX + continuation, y)] = { ch: "", style: normalizedStyle };
+        for (const segment of screenSegments(text, normalizedStyle)) {
+            for (const ch of graphemes(expandTabs(segment.text, offset))) {
+                const targetX = rect.x + offset;
+                const width = graphemeWidth(ch);
+                offset += width;
+                if (targetX + width > rectEndX) {
+                    break;
+                }
+                if (!this.isInBoundsX(targetX)) {
+                    continue;
+                }
+                this._cells[this.index(targetX, y)] = { ch, style: segment.style };
+                for (let continuation = 1; continuation < width; continuation += 1) {
+                    if (this.isInBoundsX(targetX + continuation)) {
+                        this._cells[this.index(targetX + continuation, y)] = { ch: "", style: segment.style };
+                    }
                 }
             }
         }
@@ -115,6 +120,15 @@ export class ScreenBuffer {
         return y >= 0 && y < this._height;
     }
 }
+function screenSegments(text, style) {
+    for (let index = 0; index < text.length; index++) {
+        const code = text.charCodeAt(index);
+        if ((code < 0x20 && code !== 0x09) || (code >= 0x7f && code <= 0x9f)) {
+            return parseAnsi(text, style).flatMap((line, row) => row === 0 ? line.segments : [{ text: " ", style }, ...line.segments]);
+        }
+    }
+    return [{ text, style }];
+}
 export function diff(prev, next) {
     const changes = [];
     const width = Math.max(prev.width, next.width);

package/node_modules/toolcraft-design/dist/dashboard/components/border.js

@@ -1,3 +1,5 @@
+import { plainTerminalText } from "../ansi.js";
+import { displayWidth, truncateToWidth } from "../terminal-width.js";
 export function renderBorder(buffer, layout, opts) {
     const outer = layout.outerBorder;
     if (outer.width <= 0 || outer.height <= 0) {
@@ -100,17 +102,16 @@ function renderFooterDivider(buffer, left, right, bottom, layout, style) {
     }
 }
 function renderTopSegment(width, title) {
+    if (title !== undefined)
+        title = plainTerminalText(title);
     if (width <= 0) {
         return "";
     }
     if (!title) {
         return "─".repeat(width);
     }
-    const content = `─ ${title} `;
-    if (content.length >= width) {
-        return content.slice(0, width);
-    }
-    return `${content}${"─".repeat(width - content.length)}`;
+    const content = truncateToWidth(`─ ${title} `, width);
+    return `${content}${"─".repeat(width - displayWidth(content))}`;
 }
 function hasInteriorRows(top, bottom) {
     return (bottom - top) > 1;

package/node_modules/toolcraft-design/dist/dashboard/components/footer.js

@@ -1,14 +1,32 @@
 import { getTheme } from "../../internal/theme-detect.js";
+import { displayWidth, graphemes, graphemeWidth, truncateToWidth } from "../terminal-width.js";
+import { plainTerminalText } from "../ansi.js";
 export function renderFooter(buffer, rect, hints) {
     buffer.clearRect(rect);
     if (rect.width <= 0 || rect.height <= 0 || hints.length === 0) {
         return;
     }
-    const cells = truncateCells(hintsToCells(hints), rect.width);
-    const startX = rect.x + Math.floor((rect.width - cells.length) / 2);
+    const fitted = [];
+    hints = hints.map(hint => ({ key: plainTerminalText(hint.key), label: plainTerminalText(hint.label) }));
+    let width = 0;
+    for (const hint of hints) {
+        const nextWidth = displayWidth(`${hint.key} ${hint.label}`) + (fitted.length > 0 ? 2 : 0);
+        if (width + nextWidth > rect.width)
+            break;
+        fitted.push(hint);
+        width += nextWidth;
+    }
+    if (fitted.length === 0) {
+        const key = truncateToWidth(hints[0].key, rect.width);
+        fitted.push({ key, label: "" });
+        width = displayWidth(key);
+    }
+    const cells = hintsToCells(fitted);
+    let x = rect.x + Math.floor((rect.width - width) / 2);
     const y = rect.y + Math.floor(rect.height / 2);
-    cells.forEach((cell, index) => {
-        buffer.put(startX + index, y, cell.ch, cell.style);
+    cells.forEach((cell) => {
+        buffer.put(x, y, cell.ch, cell.style);
+        x += graphemeWidth(cell.ch);
     });
 }
 export function defaultHints() {
@@ -27,30 +45,17 @@ function hintsToCells(hints) {
         if (hintIndex > 0) {
             cells.push({ ch: " ", style: {} }, { ch: " ", style: {} });
         }
-        for (const ch of hint.key) {
+        for (const ch of graphemes(hint.key)) {
             cells.push({ ch, style: accentStyle });
         }
-        cells.push({ ch: " ", style: {} });
-        for (const ch of hint.label) {
+        if (hint.label.length > 0)
+            cells.push({ ch: " ", style: {} });
+        for (const ch of graphemes(hint.label)) {
             cells.push({ ch, style: {} });
         }
     });
     return cells;
 }
-function truncateCells(cells, width) {
-    if (cells.length <= width) {
-        return cells;
-    }
-    if (width <= 3) {
-        return Array.from({ length: Math.max(0, width) }, () => ({ ch: ".", style: {} }));
-    }
-    return [
-        ...cells.slice(0, width - 3),
-        { ch: ".", style: {} },
-        { ch: ".", style: {} },
-        { ch: ".", style: {} }
-    ];
-}
 function getAccentStyle() {
     return getTheme().styles.accent;
 }

package/node_modules/toolcraft-design/dist/dashboard/components/output-pane.d.ts

@@ -8,5 +8,5 @@ export type VisualLine = {
     prefixStyle: CellStyle;
     segments?: StyledSegment[];
 };
-export declare function renderOutputPane(buffer: ScreenBuffer, rect: Rect, items: OutputItem[]): void;
+export declare function renderOutputPane(buffer: ScreenBuffer, rect: Rect, items: OutputItem[], scrollOffset?: number): number;
 export declare function computeVisualLines(items: OutputItem[], width: number): VisualLine[];

package/node_modules/toolcraft-design/dist/dashboard/components/output-pane.js

@@ -1,15 +1,15 @@
+import { selectViewportTail } from "../../viewport.js";
 import { getTheme } from "../../internal/theme-detect.js";
 import { hasAnsi, parseAnsi } from "../ansi.js";
 import { displayWidth, expandTabs, graphemes, graphemeWidth } from "../terminal-width.js";
 const TEXT_OFFSET = 3;
 const CONTINUATION_PREFIX = "│";
-export function renderOutputPane(buffer, rect, items) {
+export function renderOutputPane(buffer, rect, items, scrollOffset = 0) {
     buffer.clearRect(rect);
     if (rect.width <= 0 || rect.height <= 0) {
-        return;
+        return 0;
     }
-    const visualLines = computeVisualLines(items, rect.width);
-    const startLine = Math.max(visualLines.length - rect.height, 0);
+    const { rows: visualLines, offset: actualOffset } = selectViewportTail(items, rect.height, scrollOffset, item => computeVisualLines([item], rect.width));
     const textRect = {
         x: rect.x + TEXT_OFFSET,
         y: rect.y,
@@ -17,7 +17,7 @@ export function renderOutputPane(buffer, rect, items) {
         height: rect.height
     };
     for (let row = 0; row < rect.height; row += 1) {
-        const line = visualLines[startLine + row];
+        const line = visualLines[row];
         if (line === undefined) {
             continue;
         }
@@ -44,6 +44,7 @@ export function renderOutputPane(buffer, rect, items) {
         }
         buffer.putInRect(textRect, row, line.text, line.style);
     }
+    return actualOffset;
 }
 export function computeVisualLines(items, width) {
     if (width <= 0) {
@@ -85,7 +86,12 @@ export function computeVisualLines(items, width) {
     return visualLines;
 }
 function hasCursorControls(text) {
-    return text.includes("\r") || text.includes("\b");
+    for (let index = 0; index < text.length; index += 1) {
+        const code = text.charCodeAt(index);
+        if ((code < 0x20 && code !== 0x0a && code !== 0x09) || (code >= 0x7f && code <= 0x9f))
+            return true;
+    }
+    return false;
 }
 function hardWrapSegments(segments, width) {
     if (width <= 0) {

package/node_modules/toolcraft-design/dist/dashboard/components/stats-pane.d.ts

@@ -1,6 +1,7 @@
 import { ScreenBuffer } from "../buffer.js";
 import type { DashboardStats, Rect } from "../types.js";
-import type { VisualLine } from "./output-pane.js";
+import { type VisualLine } from "./output-pane.js";
+export declare function renderCompactStatsPane(buffer: ScreenBuffer, rect: Rect, stats: DashboardStats): void;
 export declare function renderStatsPane(buffer: ScreenBuffer, rect: Rect, stats: DashboardStats): void;
 export declare function formatElapsed(ms: number): string;
 export declare function formatNumber(n: number): string;

package/node_modules/toolcraft-design/dist/dashboard/components/stats-pane.js

@@ -1,10 +1,42 @@
 import { getTheme } from "../../internal/theme-detect.js";
+import { plainTerminalText } from "../ansi.js";
+import { displayWidth, graphemes, graphemeWidth, truncateToWidth } from "../terminal-width.js";
+import { computeVisualLines } from "./output-pane.js";
+export function renderCompactStatsPane(buffer, rect, stats) {
+    buffer.clearRect(rect);
+    if (rect.width <= 0 || rect.height <= 0)
+        return;
+    const status = formatStatus(stats.status);
+    const metrics = `${status} · ${stats.iterationsLabel ?? "Iteration"} ${formatNumber(stats.iterations)} · ${formatElapsed(stats.elapsedMs)} · ${formatNumber(stats.tokensIn + stats.tokensOut)} tokens`;
+    const firstLine = rect.height === 1 && stats.currentAction ? `${status} · ${stats.currentAction}` : metrics;
+    const messages = [firstLine, stats.currentAction ?? ""].map(plainTerminalText);
+    buffer.putInRect(rect, 0, truncateToWidth(messages[0], rect.width), getStatusStyle(stats.status));
+    if (rect.height > 1 && stats.currentAction !== undefined) {
+        buffer.putInRect(rect, 1, truncateToWidth(messages[1], rect.width), getToneStyle("muted"));
+    }
+}
 export function renderStatsPane(buffer, rect, stats) {
     buffer.clearRect(rect);
     if (rect.width <= 0 || rect.height <= 0) {
         return;
     }
-    const lines = statsToLines(stats, rect.width);
+    let lines = statsToLines(stats, rect.width);
+    if (lines.length > rect.height) {
+        const actions = stats.currentAction === undefined ? [] : lines.slice(9);
+        const visibleActions = actions.slice(0, Math.max(0, rect.height - 1));
+        if (visibleActions.length > 0 && visibleActions.length < actions.length) {
+            const last = visibleActions[visibleActions.length - 1];
+            visibleActions[visibleActions.length - 1] = {
+                ...last,
+                text: truncateToWidth(`${last.text}…`, Math.max(0, rect.width - displayWidth(last.prefix)))
+            };
+        }
+        lines = [
+            lines[0],
+            ...visibleActions,
+            ...lines.slice(1, 7).filter((line) => line.prefix.length > 0 || line.text.length > 0)
+        ];
+    }
     for (let row = 0; row < rect.height; row += 1) {
         const line = lines[row];
         if (line === undefined) {
@@ -16,7 +48,7 @@ export function renderStatsPane(buffer, rect, stats) {
         if (line.text.length === 0) {
             continue;
         }
-        const textStart = Math.min(line.prefix.length, rect.width);
+        const textStart = Math.min(displayWidth(line.prefix), rect.width);
         buffer.putInRect({ x: rect.x + textStart, y: rect.y + row, width: rect.width - textStart, height: 1 }, 0, line.text, line.style);
     }
 }
@@ -37,7 +69,7 @@ export function statsToLines(stats, width) {
     }
     const mutedStyle = getToneStyle("muted");
     const totalTokens = stats.tokensIn + stats.tokensOut;
-    const iterationsLabel = stats.iterationsLabel ?? "Iteration";
+    const iterationsLabel = plainTerminalText(stats.iterationsLabel ?? "Iteration");
     const lines = [
         createKeyValueLine("Status", formatStatus(stats.status), width, getStatusStyle(stats.status)),
         createKeyValueLine(iterationsLabel, formatNumber(stats.iterations), width),
@@ -53,12 +85,12 @@ export function statsToLines(stats, width) {
             prefixStyle: {},
             style: {},
             text: ""
-        }, {
-            prefix: width > 0 ? clipText("  ", width) : "",
+        }, ...computeVisualLines([{ kind: "status", text: stats.currentAction, ts: 0 }], width + 1).map((line) => ({
+            prefix: clipText("  ", width),
             prefixStyle: mutedStyle,
             style: mutedStyle,
-            text: clipText(stats.currentAction, Math.max(width - 2, 0))
-        });
+            text: line.text
+        })));
     }
     return lines;
 }
@@ -72,17 +104,26 @@ function createBlankLine() {
 }
 function createKeyValueLine(label, value, width, valueStyle = {}) {
     const clippedValue = clipText(value, width);
-    const availableBeforeValue = Math.max(width - clippedValue.length, 0);
+    const availableBeforeValue = Math.max(width - displayWidth(clippedValue), 0);
     const clippedLabel = clipText(label, Math.max(availableBeforeValue - 1, 0));
     return {
-        prefix: clippedLabel + " ".repeat(Math.max(availableBeforeValue - clippedLabel.length, 0)),
+        prefix: clippedLabel + " ".repeat(Math.max(availableBeforeValue - displayWidth(clippedLabel), 0)),
         prefixStyle: {},
         style: valueStyle,
         text: clippedValue
     };
 }
 function clipText(value, width) {
-    return width <= 0 ? "" : value.slice(0, width);
+    let result = "";
+    let cells = 0;
+    for (const grapheme of graphemes(value)) {
+        const size = graphemeWidth(grapheme);
+        if (cells + size > width)
+            break;
+        result += grapheme;
+        cells += size;
+    }
+    return result;
 }
 function formatStatus(status) {
     return `${status.slice(0, 1).toUpperCase()}${status.slice(1)}`;

package/node_modules/toolcraft-design/dist/dashboard/dashboard.d.ts

@@ -1,3 +1,4 @@
+import { type RenderPerformanceSnapshot } from "../render-performance.js";
 import type { FooterHint } from "./components/footer.js";
 import type { Command, DashboardStats, OutputItem } from "./types.js";
 export type DashboardOptions = {
@@ -8,6 +9,8 @@ export type DashboardOptions = {
     hints?: FooterHint[];
     stdin?: NodeJS.ReadStream;
     stdout?: NodeJS.WriteStream;
+    /** Observe bounded performance snapshots without forcing idle repaints. */
+    onPerformance?: (stats: RenderPerformanceSnapshot) => void;
 };
 export type Dashboard = {
     start(): void;
@@ -16,5 +19,6 @@ export type Dashboard = {
     updateStats(stats: Partial<DashboardStats>): void;
     onCommand(handler: (cmd: Command) => void): void;
     destroy(): void;
+    getPerformance(): RenderPerformanceSnapshot;
 };
 export declare function createDashboard(opts?: DashboardOptions): Dashboard;