@kamilio/wire 0.1.0

package/node_modules/toolcraft/node_modules/toolcraft-design/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/toolcraft/node_modules/toolcraft-design/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/toolcraft/node_modules/toolcraft-design/dist/dashboard/components/footer.js

@@ -0,0 +1,56 @@
+import { getTheme } from "../../internal/theme-detect.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().styles.accent;
+}

package/node_modules/toolcraft/node_modules/toolcraft-design/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/toolcraft/node_modules/toolcraft-design/dist/dashboard/components/output-pane.js

@@ -0,0 +1,268 @@
+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) {
+    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 += displayWidth(segment.text, offsetX);
+            }
+            continue;
+        }
+        buffer.putInRect(textRect, row, line.text, line.style);
+    }
+}
+export function computeVisualLines(items, width) {
+    if (width <= 0) {
+        return [];
+    }
+    const mutedStyle = getTheme().styles.muted;
+    const textWidth = Math.max(width - TEXT_OFFSET, 0);
+    const visualLines = [];
+    for (const item of items) {
+        const itemStyle = getItemStyle(item.kind);
+        if (hasAnsi(item.text) || hasCursorControls(item.text)) {
+            const styledLines = parseAnsi(item.text, hasAnsi(item.text) ? {} : itemStyle);
+            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 hasCursorControls(text) {
+    return text.includes("\r") || text.includes("\b");
+}
+function hardWrapSegments(segments, width) {
+    if (width <= 0) {
+        return [[]];
+    }
+    const rows = [[]];
+    let rowWidth = 0;
+    for (const segment of segments) {
+        for (const grapheme of graphemes(expandTabs(segment.text, rowWidth))) {
+            const graphemeCells = graphemeWidth(grapheme);
+            if (rowWidth > 0 && rowWidth + graphemeCells > width) {
+                rows.push([]);
+                rowWidth = 0;
+            }
+            appendSegment(rows[rows.length - 1], grapheme, segment.style);
+            rowWidth += graphemeCells;
+        }
+    }
+    return rows;
+}
+function appendSegment(segments, text, style) {
+    const last = segments[segments.length - 1];
+    if (last && stylesEqual(last.style, style)) {
+        last.text += text;
+    }
+    else {
+        segments.push({ text, style: { ...style } });
+    }
+}
+function stylesEqual(left, right) {
+    return (left.fg === right.fg &&
+        left.bg === right.bg &&
+        left.bold === right.bold &&
+        left.dim === right.dim &&
+        left.inverse === right.inverse &&
+        left.underline === right.underline);
+}
+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) {
+    const styles = getTheme().styles;
+    if (kind === "success") {
+        return styles.success;
+    }
+    if (kind === "error") {
+        return styles.error;
+    }
+    if (kind === "tool") {
+        return styles.muted;
+    }
+    if (kind === "status") {
+        return styles.info;
+    }
+    return styles.info;
+}
+function wrapText(value, width) {
+    const logicalLines = splitLogicalLines(value);
+    if (logicalLines.length === 0) {
+        return [""];
+    }
+    if (width <= 0) {
+        return logicalLines.map(() => "");
+    }
+    return logicalLines.flatMap((line) => wrapParagraph(expandTabs(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 && displayWidth(`${currentLine}${gap}${chunk}`) > 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 (displayWidth(value) <= width) {
+        return [value];
+    }
+    const chunks = [];
+    let chunk = "";
+    let chunkWidth = 0;
+    for (const grapheme of graphemes(value)) {
+        const graphemeCells = graphemeWidth(grapheme);
+        if (chunk.length > 0 && chunkWidth + graphemeCells > width) {
+            chunks.push(chunk);
+            chunk = "";
+            chunkWidth = 0;
+        }
+        chunk += grapheme;
+        chunkWidth += graphemeCells;
+    }
+    if (chunk.length > 0) {
+        chunks.push(chunk);
+    }
+    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/toolcraft/node_modules/toolcraft-design/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[];

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

@@ -0,0 +1,107 @@
+import { getTheme } from "../../internal/theme-detect.js";
+export function renderStatsPane(buffer, rect, stats) {
+    buffer.clearRect(rect);
+    if (rect.width <= 0 || rect.height <= 0) {
+        return;
+    }
+    const lines = statsToLines(stats, rect.width);
+    for (let row = 0; row < rect.height; row += 1) {
+        const line = lines[row];
+        if (line === undefined) {
+            continue;
+        }
+        if (line.prefix.length > 0) {
+            buffer.putInRect(rect, row, line.prefix, line.prefixStyle);
+        }
+        if (line.text.length === 0) {
+            continue;
+        }
+        const textStart = Math.min(line.prefix.length, rect.width);
+        buffer.putInRect({ x: rect.x + textStart, y: rect.y + row, width: rect.width - textStart, height: 1 }, 0, line.text, line.style);
+    }
+}
+export function formatElapsed(ms) {
+    const safeMs = Number.isFinite(ms) ? ms : 0;
+    const totalSeconds = Math.max(0, Math.floor(safeMs / 1_000));
+    const hours = Math.floor(totalSeconds / 3_600);
+    const minutes = Math.floor((totalSeconds % 3_600) / 60);
+    const seconds = totalSeconds % 60;
+    return [hours, minutes, seconds].map((value) => value.toString().padStart(2, "0")).join(":");
+}
+export function formatNumber(n) {
+    return new Intl.NumberFormat("en-US").format(n);
+}
+export function statsToLines(stats, width) {
+    if (width <= 0) {
+        return [];
+    }
+    const mutedStyle = getToneStyle("muted");
+    const totalTokens = stats.tokensIn + stats.tokensOut;
+    const iterationsLabel = stats.iterationsLabel ?? "Iteration";
+    const lines = [
+        createKeyValueLine("Status", formatStatus(stats.status), width, getStatusStyle(stats.status)),
+        createKeyValueLine(iterationsLabel, formatNumber(stats.iterations), width),
+        createKeyValueLine("Elapsed", formatElapsed(stats.elapsedMs), width),
+        createBlankLine(),
+        createKeyValueLine("Tokens In", formatNumber(stats.tokensIn), width),
+        createKeyValueLine("Tokens Out", formatNumber(stats.tokensOut), width),
+        createKeyValueLine("Total", formatNumber(totalTokens), width)
+    ];
+    if (stats.currentAction !== undefined) {
+        lines.push(createBlankLine(), {
+            prefix: clipText("Current:", width),
+            prefixStyle: {},
+            style: {},
+            text: ""
+        }, {
+            prefix: width > 0 ? clipText("  ", width) : "",
+            prefixStyle: mutedStyle,
+            style: mutedStyle,
+            text: clipText(stats.currentAction, Math.max(width - 2, 0))
+        });
+    }
+    return lines;
+}
+function createBlankLine() {
+    return {
+        prefix: "",
+        prefixStyle: {},
+        style: {},
+        text: ""
+    };
+}
+function createKeyValueLine(label, value, width, valueStyle = {}) {
+    const clippedValue = clipText(value, width);
+    const availableBeforeValue = Math.max(width - clippedValue.length, 0);
+    const clippedLabel = clipText(label, Math.max(availableBeforeValue - 1, 0));
+    return {
+        prefix: clippedLabel + " ".repeat(Math.max(availableBeforeValue - clippedLabel.length, 0)),
+        prefixStyle: {},
+        style: valueStyle,
+        text: clippedValue
+    };
+}
+function clipText(value, width) {
+    return width <= 0 ? "" : value.slice(0, width);
+}
+function formatStatus(status) {
+    return `${status.slice(0, 1).toUpperCase()}${status.slice(1)}`;
+}
+function getStatusStyle(status) {
+    if (status === "running") {
+        return getToneStyle("info");
+    }
+    if (status === "paused") {
+        return getToneStyle("warning");
+    }
+    if (status === "error") {
+        return getToneStyle("error");
+    }
+    if (status === "done") {
+        return getToneStyle("success");
+    }
+    return getToneStyle("muted");
+}
+function getToneStyle(tone) {
+    return getTheme().styles[tone];
+}

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

@@ -0,0 +1,20 @@
+import type { FooterHint } from "./components/footer.js";
+import type { Command, DashboardStats, OutputItem } from "./types.js";
+export type DashboardOptions = {
+    title?: string;
+    statsTitle?: string;
+    keymap?: Partial<Record<Command, string[]>>;
+    rightPaneWidth?: number;
+    hints?: FooterHint[];
+    stdin?: NodeJS.ReadStream;
+    stdout?: NodeJS.WriteStream;
+};
+export type Dashboard = {
+    start(): void;
+    stop(): void;
+    appendOutput(item: OutputItem): void;
+    updateStats(stats: Partial<DashboardStats>): void;
+    onCommand(handler: (cmd: Command) => void): void;
+    destroy(): void;
+};
+export declare function createDashboard(opts?: DashboardOptions): Dashboard;