toolcraft 0.0.1

package/node_modules/@poe-code/design-system/dist/dashboard/buffer.js

@@ -0,0 +1,189 @@
+import chalk from "chalk";
+const EMPTY_CELL = { ch: " ", style: {} };
+export class ScreenBuffer {
+    _width;
+    _height;
+    _cells;
+    constructor(width, height) {
+        this._width = normalizeSize(width);
+        this._height = normalizeSize(height);
+        this._cells = createCells(this._width, this._height);
+    }
+    get width() {
+        return this._width;
+    }
+    get height() {
+        return this._height;
+    }
+    put(x, y, text, style) {
+        if (!this.isInBoundsY(y) || text.length === 0) {
+            return;
+        }
+        const normalizedStyle = normalizeStyle(style);
+        let offset = 0;
+        for (const ch of text) {
+            const targetX = x + offset;
+            offset += 1;
+            if (!this.isInBoundsX(targetX)) {
+                continue;
+            }
+            this._cells[this.index(targetX, y)] = { ch, style: normalizedStyle };
+        }
+    }
+    get(x, y) {
+        if (!this.isInBounds(x, y)) {
+            return cloneCell(EMPTY_CELL);
+        }
+        return cloneCell(this._cells[this.index(x, y)] ?? EMPTY_CELL);
+    }
+    clear(style) {
+        this._cells = createCells(this._width, this._height, style);
+    }
+    clearRect(rect, style) {
+        const startX = Math.max(0, rect.x);
+        const startY = Math.max(0, rect.y);
+        const endX = Math.min(this._width, rect.x + Math.max(0, rect.width));
+        const endY = Math.min(this._height, rect.y + Math.max(0, rect.height));
+        const normalizedStyle = normalizeStyle(style);
+        for (let y = startY; y < endY; y += 1) {
+            for (let x = startX; x < endX; x += 1) {
+                this._cells[this.index(x, y)] = { ch: " ", style: normalizedStyle };
+            }
+        }
+    }
+    resize(width, height) {
+        const nextWidth = normalizeSize(width);
+        const nextHeight = normalizeSize(height);
+        const nextCells = createCells(nextWidth, nextHeight);
+        const copyWidth = Math.min(this._width, nextWidth);
+        const copyHeight = Math.min(this._height, nextHeight);
+        for (let y = 0; y < copyHeight; y += 1) {
+            for (let x = 0; x < copyWidth; x += 1) {
+                nextCells[(y * nextWidth) + x] = cloneCell(this._cells[this.index(x, y)] ?? EMPTY_CELL);
+            }
+        }
+        this._width = nextWidth;
+        this._height = nextHeight;
+        this._cells = nextCells;
+    }
+    putInRect(rect, row, text, style) {
+        if (row < 0 || row >= rect.height || text.length === 0 || rect.width <= 0) {
+            return;
+        }
+        const y = rect.y + row;
+        if (!this.isInBoundsY(y)) {
+            return;
+        }
+        const normalizedStyle = normalizeStyle(style);
+        const rectEndX = rect.x + rect.width;
+        let offset = 0;
+        for (const ch of text) {
+            const targetX = rect.x + offset;
+            offset += 1;
+            if (targetX >= rectEndX) {
+                break;
+            }
+            if (!this.isInBoundsX(targetX)) {
+                continue;
+            }
+            this._cells[this.index(targetX, y)] = { ch, style: normalizedStyle };
+        }
+    }
+    index(x, y) {
+        return (y * this._width) + x;
+    }
+    isInBounds(x, y) {
+        return this.isInBoundsX(x) && this.isInBoundsY(y);
+    }
+    isInBoundsX(x) {
+        return x >= 0 && x < this._width;
+    }
+    isInBoundsY(y) {
+        return y >= 0 && y < this._height;
+    }
+}
+export function diff(prev, next) {
+    const changes = [];
+    const width = Math.max(prev.width, next.width);
+    const height = Math.max(prev.height, next.height);
+    for (let y = 0; y < height; y += 1) {
+        for (let x = 0; x < width; x += 1) {
+            const previousCell = prev.get(x, y);
+            const nextCell = next.get(x, y);
+            if (!cellsEqual(previousCell, nextCell)) {
+                changes.push({ x, y, cell: nextCell });
+            }
+        }
+    }
+    return changes;
+}
+export function cellToAnsi(cell) {
+    const style = cell.style ?? {};
+    let painter = chalk;
+    if (style.bold) {
+        painter = painter.bold;
+    }
+    if (style.dim) {
+        painter = painter.dim;
+    }
+    if (style.fg) {
+        painter = applyForegroundColor(painter, style.fg);
+    }
+    if (style.bg) {
+        painter = applyBackgroundColor(painter, style.bg);
+    }
+    return painter(cell.ch);
+}
+function createCells(width, height, style) {
+    const normalizedStyle = normalizeStyle(style);
+    return Array.from({ length: width * height }, () => ({ ch: " ", style: normalizedStyle }));
+}
+function cloneCell(cell) {
+    return {
+        ch: cell.ch,
+        style: normalizeStyle(cell.style)
+    };
+}
+function normalizeStyle(style) {
+    const next = {};
+    if (style?.fg !== undefined) {
+        next.fg = style.fg;
+    }
+    if (style?.bg !== undefined) {
+        next.bg = style.bg;
+    }
+    if (style?.bold !== undefined) {
+        next.bold = style.bold;
+    }
+    if (style?.dim !== undefined) {
+        next.dim = style.dim;
+    }
+    return next;
+}
+function normalizeSize(value) {
+    return Math.max(0, Math.floor(value));
+}
+function cellsEqual(left, right) {
+    return left.ch === right.ch
+        && left.style.fg === right.style.fg
+        && left.style.bg === right.style.bg
+        && left.style.bold === right.style.bold
+        && left.style.dim === right.style.dim;
+}
+function applyForegroundColor(instance, color) {
+    if (color.startsWith("#")) {
+        return instance.hex(color);
+    }
+    const painter = instance[color];
+    return typeof painter === "function" ? painter : instance;
+}
+function applyBackgroundColor(instance, color) {
+    if (color.startsWith("#")) {
+        return instance.bgHex(color);
+    }
+    const methodName = color.startsWith("bg")
+        ? color
+        : `bg${color.charAt(0).toUpperCase()}${color.slice(1)}`;
+    const painter = instance[methodName];
+    return typeof painter === "function" ? painter : instance;
+}

package/node_modules/@poe-code/design-system/dist/dashboard/components/border.d.ts

@@ -0,0 +1,9 @@
+import { ScreenBuffer } from "../buffer.js";
+import type { DashboardLayout } from "../layout.js";
+import type { CellStyle } from "../types.js";
+export type BorderOptions = {
+    leftTitle?: string;
+    rightTitle?: string;
+    style: CellStyle;
+};
+export declare function renderBorder(buffer: ScreenBuffer, layout: DashboardLayout, opts: BorderOptions): void;

package/node_modules/@poe-code/design-system/dist/dashboard/components/border.js

@@ -0,0 +1,123 @@
+export function renderBorder(buffer, layout, opts) {
+    const outer = layout.outerBorder;
+    if (outer.width <= 0 || outer.height <= 0) {
+        return;
+    }
+    const left = outer.x;
+    const top = outer.y;
+    const right = outer.x + outer.width - 1;
+    const bottom = outer.y + outer.height - 1;
+    renderTopBorder(buffer, left, top, right, layout, opts);
+    renderSideBorders(buffer, left, right, top, bottom, opts.style);
+    renderBottomBorder(buffer, left, top, right, bottom, layout, opts.style);
+    renderVerticalDivider(buffer, layout, opts.style);
+    renderFooterDivider(buffer, left, right, bottom, layout, opts.style);
+}
+function renderTopBorder(buffer, left, top, right, layout, opts) {
+    if (left === right) {
+        buffer.put(left, top, "┌", opts.style);
+        return;
+    }
+    const hasTopJunction = hasInteriorRows(top, layout.outerBorder.y + layout.outerBorder.height - 1)
+        && hasPaneDivider(layout, left, right)
+        && layout.divider.top <= top + 1
+        && layout.divider.bottom >= top + 1;
+    if (!hasTopJunction) {
+        buffer.put(left, top, `┌${renderTopSegment(right - left - 1, opts.leftTitle)}┐`, opts.style);
+        return;
+    }
+    const leftWidth = layout.divider.x - left - 1;
+    const rightWidth = right - layout.divider.x - 1;
+    const row = [
+        "┌",
+        renderTopSegment(leftWidth, opts.leftTitle),
+        "┬",
+        renderTopSegment(rightWidth, opts.rightTitle),
+        "┐"
+    ].join("");
+    buffer.put(left, top, row, opts.style);
+}
+function renderSideBorders(buffer, left, right, top, bottom, style) {
+    for (let y = top + 1; y < bottom; y += 1) {
+        buffer.put(left, y, "│", style);
+        buffer.put(right, y, "│", style);
+    }
+}
+function renderBottomBorder(buffer, left, top, right, bottom, layout, style) {
+    if (bottom <= top) {
+        return;
+    }
+    if (left === right) {
+        buffer.put(left, bottom, "└", style);
+        return;
+    }
+    buffer.put(left, bottom, "└", style);
+    buffer.put(left + 1, bottom, "─".repeat(Math.max(0, right - left - 1)), style);
+    buffer.put(right, bottom, "┘", style);
+    if (hasInteriorRows(top, bottom)
+        && hasPaneDivider(layout, left, right)
+        && layout.divider.top <= bottom - 1
+        && layout.divider.bottom >= bottom - 1) {
+        buffer.put(layout.divider.x, bottom, "┴", style);
+    }
+}
+function renderVerticalDivider(buffer, layout, style) {
+    const left = layout.outerBorder.x;
+    const right = layout.outerBorder.x + layout.outerBorder.width - 1;
+    if (!hasPaneDivider(layout, left, right)) {
+        return;
+    }
+    const startY = Math.max(layout.divider.top, layout.outerBorder.y + 1);
+    const endY = Math.min(layout.divider.bottom, layout.outerBorder.y + layout.outerBorder.height - 2);
+    for (let y = startY; y <= endY; y += 1) {
+        buffer.put(layout.divider.x, y, "│", style);
+    }
+}
+function renderFooterDivider(buffer, left, right, bottom, layout, style) {
+    const y = layout.footerDivider.y;
+    if (y <= layout.outerBorder.y || y >= bottom) {
+        return;
+    }
+    const width = layout.footerDivider.right - layout.footerDivider.left + 1;
+    if (width > 0) {
+        buffer.put(layout.footerDivider.left, y, "─".repeat(width), style);
+    }
+    buffer.put(left, y, "├", style);
+    buffer.put(right, y, "┤", style);
+    if (!hasPaneDivider(layout, left, right)
+        || layout.divider.x < layout.footerDivider.left
+        || layout.divider.x > layout.footerDivider.right) {
+        return;
+    }
+    const connectsAbove = layout.divider.bottom >= y - 1 && layout.divider.top <= y;
+    const connectsBelow = layout.divider.bottom > y;
+    if (connectsAbove && connectsBelow) {
+        buffer.put(layout.divider.x, y, "┼", style);
+        return;
+    }
+    if (connectsAbove) {
+        buffer.put(layout.divider.x, y, "┴", style);
+    }
+}
+function renderTopSegment(width, 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)}`;
+}
+function hasInteriorRows(top, bottom) {
+    return (bottom - top) > 1;
+}
+function hasPaneDivider(layout, left, right) {
+    return layout.leftPane.width > 0
+        && layout.rightPane.width > 0
+        && layout.divider.x > left
+        && layout.divider.x < right;
+}

package/node_modules/@poe-code/design-system/dist/dashboard/components/footer.d.ts

@@ -0,0 +1,8 @@
+import { ScreenBuffer } from "../buffer.js";
+import type { Rect } from "../types.js";
+export type FooterHint = {
+    key: string;
+    label: string;
+};
+export declare function renderFooter(buffer: ScreenBuffer, rect: Rect, hints: FooterHint[]): void;
+export declare function defaultHints(): FooterHint[];

package/node_modules/@poe-code/design-system/dist/dashboard/components/footer.js

@@ -0,0 +1,57 @@
+import { getTheme } from "../../internal/theme-detect.js";
+import { light } from "../../tokens/colors.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 y = rect.y + Math.floor(rect.height / 2);
+    cells.forEach((cell, index) => {
+        buffer.put(startX + index, y, cell.ch, cell.style);
+    });
+}
+export function defaultHints() {
+    return [
+        { key: "q", label: "Quit" },
+        { key: "e", label: "Edit" },
+        { key: "l", label: "Log" },
+        { key: "p", label: "Pause" },
+        { key: "r", label: "Retry" }
+    ];
+}
+function hintsToCells(hints) {
+    const accentStyle = getAccentStyle();
+    const cells = [];
+    hints.forEach((hint, hintIndex) => {
+        if (hintIndex > 0) {
+            cells.push({ ch: " ", style: {} }, { ch: " ", style: {} });
+        }
+        for (const ch of hint.key) {
+            cells.push({ ch, style: accentStyle });
+        }
+        cells.push({ ch: " ", style: {} });
+        for (const ch of 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() === light ? { fg: "#006699", bold: true } : { fg: "cyan", bold: true };
+}

package/node_modules/@poe-code/design-system/dist/dashboard/components/output-pane.d.ts

@@ -0,0 +1,12 @@
+import { type StyledSegment } from "../ansi.js";
+import { ScreenBuffer } from "../buffer.js";
+import type { CellStyle, OutputItem, Rect } from "../types.js";
+export type VisualLine = {
+    text: string;
+    style: CellStyle;
+    prefix: string;
+    prefixStyle: CellStyle;
+    segments?: StyledSegment[];
+};
+export declare function renderOutputPane(buffer: ScreenBuffer, rect: Rect, items: OutputItem[]): void;
+export declare function computeVisualLines(items: OutputItem[], width: number): VisualLine[];

package/node_modules/@poe-code/design-system/dist/dashboard/components/output-pane.js

@@ -0,0 +1,254 @@
+import { resolveThemeName } from "../../internal/theme-detect.js";
+import { hasAnsi, parseAnsi } from "../ansi.js";
+const TEXT_OFFSET = 3;
+const CONTINUATION_PREFIX = "│";
+export function renderOutputPane(buffer, rect, items) {
+    buffer.clearRect(rect);
+    if (rect.width <= 0 || rect.height <= 0) {
+        return;
+    }
+    const visualLines = computeVisualLines(items, rect.width);
+    const startLine = Math.max(visualLines.length - rect.height, 0);
+    const textRect = {
+        x: rect.x + TEXT_OFFSET,
+        y: rect.y,
+        width: rect.width - TEXT_OFFSET,
+        height: rect.height
+    };
+    for (let row = 0; row < rect.height; row += 1) {
+        const line = visualLines[startLine + row];
+        if (line === undefined) {
+            continue;
+        }
+        buffer.putInRect(rect, row, line.prefix, line.prefixStyle);
+        if (line.segments && line.segments.length > 0) {
+            let offsetX = 0;
+            for (const segment of line.segments) {
+                if (segment.text.length === 0) {
+                    continue;
+                }
+                const remaining = textRect.width - offsetX;
+                if (remaining <= 0) {
+                    break;
+                }
+                buffer.putInRect({
+                    x: textRect.x + offsetX,
+                    y: textRect.y,
+                    width: remaining,
+                    height: textRect.height
+                }, row, segment.text, segment.style);
+                offsetX += countCells(segment.text);
+            }
+            continue;
+        }
+        buffer.putInRect(textRect, row, line.text, line.style);
+    }
+}
+export function computeVisualLines(items, width) {
+    if (width <= 0) {
+        return [];
+    }
+    const themeName = resolveThemeName();
+    const mutedStyle = getMutedStyle(themeName);
+    const textWidth = Math.max(width - TEXT_OFFSET, 0);
+    const visualLines = [];
+    for (const item of items) {
+        const itemStyle = getItemStyle(item.kind, themeName);
+        if (hasAnsi(item.text)) {
+            const styledLines = parseAnsi(item.text, {});
+            let firstRow = true;
+            for (const styledLine of styledLines) {
+                const rows = hardWrapSegments(styledLine.segments, textWidth);
+                for (const rowSegments of rows) {
+                    visualLines.push({
+                        prefix: firstRow ? getPrefix(item.kind) : CONTINUATION_PREFIX,
+                        prefixStyle: firstRow ? itemStyle : mutedStyle,
+                        style: itemStyle,
+                        text: rowSegments.map((segment) => segment.text).join(""),
+                        segments: rowSegments
+                    });
+                    firstRow = false;
+                }
+            }
+            continue;
+        }
+        const wrappedLines = wrapText(item.text, textWidth);
+        for (let index = 0; index < wrappedLines.length; index += 1) {
+            visualLines.push({
+                prefix: index === 0 ? getPrefix(item.kind) : CONTINUATION_PREFIX,
+                prefixStyle: index === 0 ? itemStyle : mutedStyle,
+                style: itemStyle,
+                text: wrappedLines[index] ?? ""
+            });
+        }
+    }
+    return visualLines;
+}
+function hardWrapSegments(segments, width) {
+    if (width <= 0) {
+        return [[]];
+    }
+    const rows = [[]];
+    let rowWidth = 0;
+    for (const segment of segments) {
+        if (segment.text.length === 0) {
+            continue;
+        }
+        const chars = [...segment.text];
+        let cursor = 0;
+        while (cursor < chars.length) {
+            const space = width - rowWidth;
+            if (space <= 0) {
+                rows.push([]);
+                rowWidth = 0;
+                continue;
+            }
+            const take = chars.slice(cursor, cursor + space).join("");
+            const currentRow = rows[rows.length - 1];
+            currentRow.push({ text: take, style: { ...segment.style } });
+            rowWidth += Math.min(space, chars.length - cursor);
+            cursor += space;
+            if (cursor < chars.length) {
+                rows.push([]);
+                rowWidth = 0;
+            }
+        }
+    }
+    return rows;
+}
+function countCells(text) {
+    return Array.from(text).length;
+}
+function getPrefix(kind) {
+    if (kind === "success") {
+        return "◆";
+    }
+    if (kind === "error") {
+        return "■";
+    }
+    if (kind === "tool") {
+        return CONTINUATION_PREFIX;
+    }
+    if (kind === "status") {
+        return "●";
+    }
+    return "◇";
+}
+function getItemStyle(kind, themeName) {
+    if (kind === "success") {
+        return themeName === "light" ? { fg: "#008800" } : { fg: "green" };
+    }
+    if (kind === "error") {
+        return themeName === "light" ? { fg: "#cc0000" } : { fg: "red" };
+    }
+    if (kind === "tool") {
+        return getMutedStyle(themeName);
+    }
+    if (kind === "status") {
+        return themeName === "light" ? { fg: "#a200ff" } : { fg: "magenta" };
+    }
+    return themeName === "light" ? { fg: "#a200ff" } : { fg: "magenta" };
+}
+function getMutedStyle(themeName) {
+    return themeName === "light" ? { fg: "#666666" } : { dim: true };
+}
+function wrapText(value, width) {
+    const logicalLines = splitLogicalLines(value);
+    if (logicalLines.length === 0) {
+        return [""];
+    }
+    if (width <= 0) {
+        return logicalLines.map(() => "");
+    }
+    return logicalLines.flatMap((line) => wrapParagraph(line, width));
+}
+function wrapParagraph(value, width) {
+    if (value.length === 0) {
+        return [""];
+    }
+    const tokens = tokenize(value);
+    const lines = [];
+    let currentLine = "";
+    let pendingSpace = "";
+    const flushLine = () => {
+        lines.push(currentLine);
+        currentLine = "";
+        pendingSpace = "";
+    };
+    for (const token of tokens) {
+        if (token.kind === "space") {
+            if (currentLine.length > 0) {
+                pendingSpace += token.value;
+            }
+            continue;
+        }
+        const chunks = splitWord(token.value, width);
+        for (let index = 0; index < chunks.length; index += 1) {
+            const chunk = chunks[index] ?? "";
+            const gap = index === 0 ? pendingSpace : "";
+            if (currentLine.length > 0 && currentLine.length + gap.length + chunk.length > width) {
+                flushLine();
+            }
+            if (currentLine.length > 0 && gap.length > 0) {
+                currentLine += gap;
+            }
+            currentLine += chunk;
+            pendingSpace = "";
+            if (index < chunks.length - 1) {
+                flushLine();
+            }
+        }
+    }
+    if (currentLine.length > 0 || lines.length === 0) {
+        lines.push(currentLine);
+    }
+    return lines;
+}
+function splitWord(value, width) {
+    if (value.length <= width) {
+        return [value];
+    }
+    const chunks = [];
+    for (let index = 0; index < value.length; index += width) {
+        chunks.push(value.slice(index, index + width));
+    }
+    return chunks;
+}
+function tokenize(value) {
+    const tokens = [];
+    let current = "";
+    let currentKind;
+    for (const ch of value) {
+        const nextKind = isWrappingSpace(ch) ? "space" : "word";
+        if (currentKind !== undefined && currentKind !== nextKind) {
+            tokens.push({ kind: currentKind, value: current });
+            current = "";
+        }
+        currentKind = nextKind;
+        current += ch;
+    }
+    if (currentKind !== undefined) {
+        tokens.push({ kind: currentKind, value: current });
+    }
+    return tokens;
+}
+function splitLogicalLines(value) {
+    const lines = [];
+    let currentLine = "";
+    for (const ch of value) {
+        if (ch === "\r") {
+            continue;
+        }
+        if (ch === "\n") {
+            lines.push(currentLine);
+            currentLine = "";
+            continue;
+        }
+        currentLine += ch;
+    }
+    lines.push(currentLine);
+    return lines;
+}
+function isWrappingSpace(ch) {
+    return ch === " " || ch === "\t";
+}

package/node_modules/@poe-code/design-system/dist/dashboard/components/stats-pane.d.ts

@@ -0,0 +1,7 @@
+import { ScreenBuffer } from "../buffer.js";
+import type { DashboardStats, Rect } from "../types.js";
+import type { VisualLine } from "./output-pane.js";
+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;
+export declare function statsToLines(stats: DashboardStats, width: number): VisualLine[];