toolcraft 0.0.1

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

@@ -0,0 +1,71 @@
+import chalk from "chalk";
+import { resolveOutputFormat } from "../internal/output-format.js";
+import { getTheme } from "../internal/theme-detect.js";
+export const symbols = {
+    get info() {
+        const format = resolveOutputFormat();
+        if (format === "json")
+            return "info";
+        if (format === "markdown")
+            return "(i)";
+        return chalk.magenta("●");
+    },
+    get success() {
+        const format = resolveOutputFormat();
+        if (format === "json")
+            return "success";
+        if (format === "markdown")
+            return "[ok]";
+        return chalk.magenta("◆");
+    },
+    get resolved() {
+        const format = resolveOutputFormat();
+        if (format === "json")
+            return "resolved";
+        if (format === "markdown")
+            return ">";
+        return getTheme().resolvedSymbol;
+    },
+    get errorResolved() {
+        const format = resolveOutputFormat();
+        if (format === "json")
+            return "error";
+        if (format === "markdown")
+            return "[!]";
+        return getTheme().errorSymbol;
+    },
+    get bar() {
+        const format = resolveOutputFormat();
+        if (format === "json")
+            return "";
+        if (format === "markdown")
+            return "|";
+        return "│";
+    },
+    cornerTopRight: "╮",
+    cornerBottomRight: "╯",
+    get warning() {
+        const format = resolveOutputFormat();
+        if (format === "json")
+            return "warning";
+        if (format === "markdown")
+            return "[!]";
+        return "▲";
+    },
+    get active() {
+        const format = resolveOutputFormat();
+        if (format === "json")
+            return "active";
+        if (format === "markdown")
+            return "[x]";
+        return "◆";
+    },
+    get inactive() {
+        const format = resolveOutputFormat();
+        if (format === "json")
+            return "inactive";
+        if (format === "markdown")
+            return "[ ]";
+        return "○";
+    }
+};

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

@@ -0,0 +1,13 @@
+import type { ThemePalette } from "../tokens/colors.js";
+export interface TableColumn {
+    name: string;
+    title: string;
+    alignment: "left" | "right";
+    maxLen: number;
+}
+export interface RenderTableOptions {
+    theme: ThemePalette;
+    columns: TableColumn[];
+    rows: Record<string, string>[];
+}
+export declare function renderTable(options: RenderTableOptions): string;

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

@@ -0,0 +1,74 @@
+import { Table } from "console-table-printer";
+import { resolveOutputFormat } from "../internal/output-format.js";
+import { stripAnsi } from "../internal/strip-ansi.js";
+function renderTableTerminal(options) {
+    const { theme, columns, rows } = options;
+    const table = new Table({
+        style: {
+            headerTop: {
+                left: theme.muted("┌"),
+                mid: theme.muted("┬"),
+                right: theme.muted("┐"),
+                other: theme.muted("─")
+            },
+            headerBottom: {
+                left: theme.muted("├"),
+                mid: theme.muted("┼"),
+                right: theme.muted("┤"),
+                other: theme.muted("─")
+            },
+            tableBottom: {
+                left: theme.muted("└"),
+                mid: theme.muted("┴"),
+                right: theme.muted("┘"),
+                other: theme.muted("─")
+            },
+            vertical: theme.muted("│"),
+            rowSeparator: {
+                left: theme.muted("├"),
+                mid: theme.muted("┼"),
+                right: theme.muted("┤"),
+                other: theme.muted("─")
+            }
+        },
+        columns: columns.map((col) => ({
+            name: col.name,
+            title: theme.header(col.title),
+            alignment: col.alignment,
+            maxLen: col.maxLen
+        }))
+    });
+    for (const row of rows) {
+        table.addRow(row);
+    }
+    return table.render();
+}
+function renderTableMarkdown(options) {
+    const { columns, rows } = options;
+    const header = `| ${columns.map((c) => c.title).join(" | ")} |`;
+    const separator = `| ${columns.map((c) => (c.alignment === "right" ? "---:" : ":---")).join(" | ")} |`;
+    const dataRows = rows.map((row) => `| ${columns.map((c) => stripAnsi(row[c.name] ?? "").replace(/\|/g, "\\|")).join(" | ")} |`);
+    return [header, separator, ...dataRows].join("\n");
+}
+function renderTableJson(options) {
+    const { columns, rows } = options;
+    const cleaned = rows.map((row) => {
+        const obj = {};
+        for (const col of columns) {
+            obj[col.name] = stripAnsi(row[col.name] ?? "");
+        }
+        return obj;
+    });
+    return JSON.stringify(cleaned, null, 2);
+}
+export function renderTable(options) {
+    const format = resolveOutputFormat();
+    switch (format) {
+        case "markdown":
+            return renderTableMarkdown(options);
+        case "json":
+            return renderTableJson(options);
+        default:
+            return renderTableTerminal(options);
+    }
+}

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

@@ -0,0 +1,14 @@
+export declare const text: {
+    readonly intro: (content: string) => string;
+    readonly heading: (content: string) => string;
+    readonly section: (content: string) => string;
+    readonly command: (content: string) => string;
+    readonly argument: (content: string) => string;
+    readonly option: (content: string) => string;
+    readonly example: (content: string) => string;
+    readonly usageCommand: (content: string) => string;
+    readonly link: (content: string) => string;
+    readonly muted: (content: string) => string;
+    readonly badge: (content: string) => string;
+    readonly selectLabel: (label: string, detail?: string) => string;
+};

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

@@ -0,0 +1,104 @@
+import chalk from "chalk";
+import { resolveOutputFormat } from "../internal/output-format.js";
+import { getTheme } from "../internal/theme-detect.js";
+import { typography } from "../tokens/typography.js";
+export const text = {
+    intro(content) {
+        const format = resolveOutputFormat();
+        if (format === "json")
+            return content;
+        if (format === "markdown")
+            return `**${content}**`;
+        return getTheme().intro(content);
+    },
+    heading(content) {
+        const format = resolveOutputFormat();
+        if (format === "json")
+            return content;
+        if (format === "markdown")
+            return `## ${content}`;
+        return getTheme().header(content);
+    },
+    section(content) {
+        const format = resolveOutputFormat();
+        if (format === "json")
+            return content;
+        if (format === "markdown")
+            return `**${content}**`;
+        return typography.bold(content);
+    },
+    command(content) {
+        const format = resolveOutputFormat();
+        if (format === "json")
+            return content;
+        if (format === "markdown")
+            return `\`${content}\``;
+        return getTheme().accent(content);
+    },
+    argument(content) {
+        const format = resolveOutputFormat();
+        if (format === "json")
+            return content;
+        if (format === "markdown")
+            return `<${content}>`;
+        return getTheme().muted(content);
+    },
+    option(content) {
+        const format = resolveOutputFormat();
+        if (format === "json")
+            return content;
+        if (format === "markdown")
+            return `\`${content}\``;
+        return chalk.yellow(content);
+    },
+    example(content) {
+        const format = resolveOutputFormat();
+        if (format === "json")
+            return content;
+        if (format === "markdown")
+            return `\`${content}\``;
+        return getTheme().muted(content);
+    },
+    usageCommand(content) {
+        const format = resolveOutputFormat();
+        if (format === "json")
+            return content;
+        if (format === "markdown")
+            return `\`${content}\``;
+        return chalk.green(content);
+    },
+    link(content) {
+        const format = resolveOutputFormat();
+        if (format === "json")
+            return content;
+        if (format === "markdown")
+            return `[${content}](${content})`;
+        return getTheme().accent(content);
+    },
+    muted(content) {
+        const format = resolveOutputFormat();
+        if (format === "json")
+            return content;
+        if (format === "markdown")
+            return `*${content}*`;
+        return getTheme().muted(content);
+    },
+    badge(content) {
+        const format = resolveOutputFormat();
+        if (format === "json")
+            return content;
+        if (format === "markdown")
+            return `[${content}]`;
+        return getTheme().badge(content);
+    },
+    selectLabel(label, detail) {
+        if (!detail) {
+            return label;
+        }
+        const format = resolveOutputFormat();
+        if (format !== "terminal") {
+            return `${label} — ${detail}`;
+        }
+        return `${label} ${typography.dim("—")} ${typography.dim(detail)}`;
+    }
+};

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

@@ -0,0 +1,18 @@
+import type { CellStyle } from "./types.js";
+export interface StyledSegment {
+    text: string;
+    style: CellStyle;
+}
+export interface StyledLine {
+    segments: StyledSegment[];
+}
+export declare function hasAnsi(text: string): boolean;
+/**
+ * Parse a block of text that may contain ANSI SGR escape codes into a sequence of
+ * logical lines split on "\n". Each line is a list of styled segments: contiguous
+ * printable runs of characters sharing the same style.
+ *
+ * Non-SGR CSI sequences and other control characters are discarded. `baseStyle` is
+ * used as the initial style and as the restore target for SGR reset / default color.
+ */
+export declare function parseAnsi(text: string, baseStyle?: CellStyle): StyledLine[];

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

@@ -0,0 +1,298 @@
+const ESC = "\u001b";
+export function hasAnsi(text) {
+    return text.includes(ESC);
+}
+/**
+ * Parse a block of text that may contain ANSI SGR escape codes into a sequence of
+ * logical lines split on "\n". Each line is a list of styled segments: contiguous
+ * printable runs of characters sharing the same style.
+ *
+ * Non-SGR CSI sequences and other control characters are discarded. `baseStyle` is
+ * used as the initial style and as the restore target for SGR reset / default color.
+ */
+export function parseAnsi(text, baseStyle) {
+    const base = normalizeStyle(baseStyle);
+    let style = { ...base };
+    const lines = [];
+    let segments = [];
+    let pending = "";
+    const flushSegment = () => {
+        if (pending.length === 0) {
+            return;
+        }
+        const last = segments[segments.length - 1];
+        if (last && stylesEqual(last.style, style)) {
+            last.text += pending;
+        }
+        else {
+            segments.push({ text: pending, style: { ...style } });
+        }
+        pending = "";
+    };
+    const finishLine = () => {
+        flushSegment();
+        lines.push({ segments });
+        segments = [];
+    };
+    let index = 0;
+    while (index < text.length) {
+        const ch = text[index];
+        if (ch === ESC && text[index + 1] === "[") {
+            flushSegment();
+            const paramsStart = index + 2;
+            let cursor = paramsStart;
+            while (cursor < text.length && !isCsiFinalByte(text[cursor])) {
+                cursor += 1;
+            }
+            if (cursor >= text.length) {
+                index = text.length;
+                break;
+            }
+            const params = text.slice(paramsStart, cursor);
+            const finalByte = text[cursor];
+            if (finalByte === "m") {
+                style = applySgr(style, parseParams(params), base);
+            }
+            index = cursor + 1;
+            continue;
+        }
+        if (ch === ESC) {
+            flushSegment();
+            const next = text[index + 1];
+            if (next === "]" || next === "P" || next === "X" || next === "^" || next === "_") {
+                index = skipStringTerminated(text, index + 2);
+                continue;
+            }
+            index += 2;
+            continue;
+        }
+        if (ch === "\r") {
+            index += 1;
+            continue;
+        }
+        if (ch === "\n") {
+            finishLine();
+            index += 1;
+            continue;
+        }
+        const code = ch.charCodeAt(0);
+        if (code < 0x20 && ch !== "\t") {
+            index += 1;
+            continue;
+        }
+        pending += ch;
+        index += 1;
+    }
+    finishLine();
+    return lines;
+}
+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];
+    }
+    return params.split(";").map((part) => {
+        if (part.length === 0) {
+            return 0;
+        }
+        const parsed = Number.parseInt(part, 10);
+        return Number.isFinite(parsed) ? parsed : 0;
+    });
+}
+const BASIC_COLORS = [
+    "black",
+    "red",
+    "green",
+    "yellow",
+    "blue",
+    "magenta",
+    "cyan",
+    "white"
+];
+const BRIGHT_COLORS = [
+    "gray",
+    "redBright",
+    "greenBright",
+    "yellowBright",
+    "blueBright",
+    "magentaBright",
+    "cyanBright",
+    "whiteBright"
+];
+function applySgr(style, params, base) {
+    let next = { ...style };
+    let index = 0;
+    while (index < params.length) {
+        const code = params[index];
+        if (code === 0) {
+            next = { ...base };
+            index += 1;
+            continue;
+        }
+        if (code === 1) {
+            next.bold = true;
+            index += 1;
+            continue;
+        }
+        if (code === 2) {
+            next.dim = true;
+            index += 1;
+            continue;
+        }
+        if (code === 22) {
+            delete next.bold;
+            delete next.dim;
+            index += 1;
+            continue;
+        }
+        if (code >= 30 && code <= 37) {
+            next.fg = BASIC_COLORS[code - 30];
+            index += 1;
+            continue;
+        }
+        if (code === 38) {
+            const mode = params[index + 1];
+            if (mode === 5) {
+                const palette = params[index + 2] ?? 0;
+                next.fg = convert256(palette);
+                index += 3;
+                continue;
+            }
+            if (mode === 2) {
+                const r = params[index + 2] ?? 0;
+                const g = params[index + 3] ?? 0;
+                const b = params[index + 4] ?? 0;
+                next.fg = rgbToHex(r, g, b);
+                index += 5;
+                continue;
+            }
+            index += 1;
+            continue;
+        }
+        if (code === 39) {
+            if (base.fg !== undefined) {
+                next.fg = base.fg;
+            }
+            else {
+                delete next.fg;
+            }
+            index += 1;
+            continue;
+        }
+        if (code >= 40 && code <= 47) {
+            next.bg = BASIC_COLORS[code - 40];
+            index += 1;
+            continue;
+        }
+        if (code === 48) {
+            const mode = params[index + 1];
+            if (mode === 5) {
+                const palette = params[index + 2] ?? 0;
+                next.bg = convert256(palette);
+                index += 3;
+                continue;
+            }
+            if (mode === 2) {
+                const r = params[index + 2] ?? 0;
+                const g = params[index + 3] ?? 0;
+                const b = params[index + 4] ?? 0;
+                next.bg = rgbToHex(r, g, b);
+                index += 5;
+                continue;
+            }
+            index += 1;
+            continue;
+        }
+        if (code === 49) {
+            if (base.bg !== undefined) {
+                next.bg = base.bg;
+            }
+            else {
+                delete next.bg;
+            }
+            index += 1;
+            continue;
+        }
+        if (code >= 90 && code <= 97) {
+            next.fg = BRIGHT_COLORS[code - 90];
+            index += 1;
+            continue;
+        }
+        if (code >= 100 && code <= 107) {
+            next.bg = BRIGHT_COLORS[code - 100];
+            index += 1;
+            continue;
+        }
+        index += 1;
+    }
+    return next;
+}
+function convert256(palette) {
+    if (palette < 0 || palette > 255) {
+        return "#000000";
+    }
+    if (palette < 8) {
+        return BASIC_COLORS[palette];
+    }
+    if (palette < 16) {
+        return BRIGHT_COLORS[palette - 8];
+    }
+    if (palette >= 232) {
+        const level = 8 + (palette - 232) * 10;
+        return rgbToHex(level, level, level);
+    }
+    const offset = palette - 16;
+    const r = Math.floor(offset / 36);
+    const g = Math.floor((offset % 36) / 6);
+    const b = offset % 6;
+    return rgbToHex(cubeLevel(r), cubeLevel(g), cubeLevel(b));
+}
+function cubeLevel(value) {
+    return value === 0 ? 0 : 55 + value * 40;
+}
+function rgbToHex(r, g, b) {
+    return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
+function toHex(value) {
+    const clamped = Math.max(0, Math.min(255, Math.floor(value)));
+    return clamped.toString(16).padStart(2, "0");
+}
+function stylesEqual(left, right) {
+    return left.fg === right.fg
+        && left.bg === right.bg
+        && left.bold === right.bold
+        && left.dim === right.dim;
+}
+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;
+}

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

@@ -0,0 +1,25 @@
+import type { Cell, CellStyle, Rect } from "./types.js";
+export declare class ScreenBuffer {
+    private _width;
+    private _height;
+    private _cells;
+    constructor(width: number, height: number);
+    get width(): number;
+    get height(): number;
+    put(x: number, y: number, text: string, style?: CellStyle): void;
+    get(x: number, y: number): Cell;
+    clear(style?: CellStyle): void;
+    clearRect(rect: Rect, style?: CellStyle): void;
+    resize(width: number, height: number): void;
+    putInRect(rect: Rect, row: number, text: string, style?: CellStyle): void;
+    private index;
+    private isInBounds;
+    private isInBoundsX;
+    private isInBoundsY;
+}
+export declare function diff(prev: ScreenBuffer, next: ScreenBuffer): Array<{
+    x: number;
+    y: number;
+    cell: Cell;
+}>;
+export declare function cellToAnsi(cell: Cell): string;