toolcraft-openapi 0.0.18 → 0.0.20

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

@@ -1,4 +1,4 @@
-import chalk from "chalk";
+import { color } from "../components/color.js";
 import { resolveOutputFormat } from "../internal/output-format.js";
 import { renderMarkdown } from "../terminal-markdown/index.js";
 import { getAcpWriter } from "./writer.js";
@@ -10,20 +10,22 @@ function truncate(text, maxLength) {
     return `${text.slice(0, maxLength - 3)}...`;
 }
 const KIND_COLORS = {
-    exec: (text) => chalk.yellow(text),
-    edit: (text) => chalk.magenta(text),
-    read: (text) => chalk.cyan(text),
-    search: (text) => chalk.blue(text),
-    think: (text) => chalk.dim(text),
-    other: (text) => chalk.dim(text)
+    exec: (text) => color.yellow(text),
+    edit: (text) => color.magenta(text),
+    read: (text) => color.cyan(text),
+    search: (text) => color.blue(text),
+    think: (text) => color.dim(text),
+    other: (text) => color.dim(text)
 };
 function colorForKind(kind) {
-    return KIND_COLORS[kind] ?? ((text) => chalk.dim(text));
+    return KIND_COLORS[kind] ?? ((text) => color.dim(text));
 }
 function writeLine(line) {
     getAcpWriter()(line);
 }
-const AGENT_PREFIX = `${chalk.green.bold("✓")} agent: `;
+function agentPrefix() {
+    return `${color.green.bold("✓")} agent: `;
+}
 function formatCost(costUsd) {
     return new Intl.NumberFormat("en-US", {
         style: "currency",
@@ -43,7 +45,7 @@ export function renderAgentMessage(text) {
         return;
     }
     const rendered = renderMarkdown(text).trimEnd();
-    writeLine(`${AGENT_PREFIX}${rendered}`);
+    writeLine(`${agentPrefix()}${rendered}`);
 }
 export function renderToolStart(kind, title) {
     const format = resolveOutputFormat();
@@ -81,7 +83,7 @@ export function renderReasoning(text) {
         writeLine(JSON.stringify({ event: "reasoning", text }));
         return;
     }
-    writeLine(chalk.dim(`  ✓ ${truncate(text, 80)}`));
+    writeLine(color.dim(`  ✓ ${truncate(text, 80)}`));
 }
 export function renderUsage(tokens) {
     const format = resolveOutputFormat();
@@ -105,7 +107,7 @@ export function renderUsage(tokens) {
         return;
     }
     writeLine("");
-    writeLine(chalk.green(`✓ tokens: ${tokens.input} in${cached} → ${tokens.output} out${cost}`));
+    writeLine(color.green(`✓ tokens: ${tokens.input} in${cached} → ${tokens.output} out${cost}`));
 }
 export function renderError(message) {
     const format = resolveOutputFormat();
@@ -117,5 +119,5 @@ export function renderError(message) {
         writeLine(JSON.stringify({ event: "error", message }));
         return;
     }
-    writeLine(chalk.red(`✗ ${message}`));
+    writeLine(color.red(`✗ ${message}`));
 }

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

@@ -0,0 +1,31 @@
+export interface Color {
+    (text: string): string;
+    reset: Color;
+    bold: Color;
+    dim: Color;
+    italic: Color;
+    underline: Color;
+    inverse: Color;
+    strikethrough: Color;
+    black: Color;
+    red: Color;
+    green: Color;
+    yellow: Color;
+    blue: Color;
+    magenta: Color;
+    cyan: Color;
+    white: Color;
+    gray: Color;
+    magentaBright: Color;
+    cyanBright: Color;
+    bgRed: Color;
+    bgGreen: Color;
+    bgYellow: Color;
+    bgBlue: Color;
+    bgMagenta: Color;
+    hex: (value: string) => Color;
+    rgb: (red: number, green: number, blue: number) => Color;
+    bgHex: (value: string) => Color;
+    bgRgb: (red: number, green: number, blue: number) => Color;
+}
+export declare const color: Color;

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

@@ -0,0 +1,101 @@
+import { supportsColor } from "../internal/color-support.js";
+const reset = "\x1b[0m";
+const ansiStyles = {
+    reset: { open: reset },
+    bold: { open: "\x1b[1m" },
+    dim: { open: "\x1b[2m" },
+    italic: { open: "\x1b[3m" },
+    underline: { open: "\x1b[4m" },
+    inverse: { open: "\x1b[7m" },
+    strikethrough: { open: "\x1b[9m" },
+    black: { open: "\x1b[30m" },
+    red: { open: "\x1b[31m" },
+    green: { open: "\x1b[32m" },
+    yellow: { open: "\x1b[33m" },
+    blue: { open: "\x1b[34m" },
+    magenta: { open: "\x1b[35m" },
+    cyan: { open: "\x1b[36m" },
+    white: { open: "\x1b[37m" },
+    gray: { open: "\x1b[90m" },
+    magentaBright: { open: "\x1b[95m" },
+    cyanBright: { open: "\x1b[96m" },
+    bgRed: { open: "\x1b[41m" },
+    bgGreen: { open: "\x1b[42m" },
+    bgYellow: { open: "\x1b[43m" },
+    bgBlue: { open: "\x1b[44m" },
+    bgMagenta: { open: "\x1b[45m" }
+};
+const styleNames = Object.keys(ansiStyles);
+function replaceAll(value, search, replacement) {
+    return value.split(search).join(replacement);
+}
+function applyStyles(text, styles) {
+    if (!supportsColor() || styles.length === 0) {
+        return text;
+    }
+    const open = styles.map((style) => style.open).join("");
+    const output = text.includes(reset) ? replaceAll(text, reset, `${reset}${open}`) : text;
+    return `${open}${output}${reset}`;
+}
+function clampRgb(value) {
+    if (Number.isNaN(value)) {
+        return 0;
+    }
+    return Math.min(255, Math.max(0, Math.round(value)));
+}
+function hexChannel(value, offset) {
+    return Number.parseInt(value.slice(offset, offset + 2), 16);
+}
+function normalizeHex(value) {
+    const normalized = value.startsWith("#") ? value.slice(1) : value;
+    if (normalized.length === 3) {
+        const red = normalized[0];
+        const green = normalized[1];
+        const blue = normalized[2];
+        return [
+            Number.parseInt(`${red}${red}`, 16),
+            Number.parseInt(`${green}${green}`, 16),
+            Number.parseInt(`${blue}${blue}`, 16)
+        ];
+    }
+    if (normalized.length === 6) {
+        return [
+            hexChannel(normalized, 0),
+            hexChannel(normalized, 2),
+            hexChannel(normalized, 4)
+        ];
+    }
+    return [0, 0, 0];
+}
+function rgbStyle(red, green, blue) {
+    return {
+        open: `\x1b[38;2;${clampRgb(red)};${clampRgb(green)};${clampRgb(blue)}m`
+    };
+}
+function bgRgbStyle(red, green, blue) {
+    return {
+        open: `\x1b[48;2;${clampRgb(red)};${clampRgb(green)};${clampRgb(blue)}m`
+    };
+}
+function createColor(styles = []) {
+    const builder = ((text) => applyStyles(String(text), styles));
+    for (const name of styleNames) {
+        Object.defineProperty(builder, name, {
+            configurable: true,
+            enumerable: true,
+            get: () => createColor([...styles, ansiStyles[name]])
+        });
+    }
+    builder.hex = (value) => {
+        const [red, green, blue] = normalizeHex(value);
+        return createColor([...styles, rgbStyle(red, green, blue)]);
+    };
+    builder.rgb = (red, green, blue) => createColor([...styles, rgbStyle(red, green, blue)]);
+    builder.bgHex = (value) => {
+        const [red, green, blue] = normalizeHex(value);
+        return createColor([...styles, bgRgbStyle(red, green, blue)]);
+    };
+    builder.bgRgb = (red, green, blue) => createColor([...styles, bgRgbStyle(red, green, blue)]);
+    return builder;
+}
+export const color = createColor();

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

@@ -1,4 +1,6 @@
 export { text } from "./text.js";
+export { color } from "./color.js";
+export type { Color } from "./color.js";
 export { symbols } from "./symbols.js";
 export { createLogger, logger } from "./logger.js";
 export type { LoggerOutput } from "./logger.js";
@@ -8,3 +10,5 @@ export { formatCommandNotFound } from "./command-errors.js";
 export { formatCommandNotFoundPanel } from "./command-errors.js";
 export { renderTable } from "./table.js";
 export type { TableColumn, RenderTableOptions } from "./table.js";
+export { renderTemplate } from "./template.js";
+export type { RenderTemplateOptions, TemplateEscape } from "./template.js";

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

@@ -1,7 +1,9 @@
 export { text } from "./text.js";
+export { color } from "./color.js";
 export { symbols } from "./symbols.js";
 export { createLogger, logger } from "./logger.js";
 export { helpFormatter, formatColumns, formatCommand, formatUsage, formatOption, formatCommandList, formatOptionList } from "./help-formatter.js";
 export { formatCommandNotFound } from "./command-errors.js";
 export { formatCommandNotFoundPanel } from "./command-errors.js";
 export { renderTable } from "./table.js";
+export { renderTemplate } from "./template.js";

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

@@ -1,4 +1,4 @@
-import chalk from "chalk";
+import { color } from "./color.js";
 import { log } from "../prompts/primitives/log.js";
 import { symbols } from "./symbols.js";
 export function createLogger(emitter) {
@@ -53,7 +53,7 @@ export function createLogger(emitter) {
                 emitter(message);
                 return;
             }
-            log.message(message, { symbol: symbol ?? chalk.gray("│") });
+            log.message(message, { symbol: symbol ?? color.gray("│") });
         }
     };
 }

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

@@ -1,4 +1,4 @@
-import chalk from "chalk";
+import { color } from "./color.js";
 import { resolveOutputFormat } from "../internal/output-format.js";
 import { getTheme } from "../internal/theme-detect.js";
 export const symbols = {
@@ -8,7 +8,7 @@ export const symbols = {
             return "info";
         if (format === "markdown")
             return "(i)";
-        return chalk.magenta("●");
+        return color.magenta("●");
     },
     get success() {
         const format = resolveOutputFormat();
@@ -16,7 +16,7 @@ export const symbols = {
             return "success";
         if (format === "markdown")
             return "[ok]";
-        return chalk.magenta("◆");
+        return color.magenta("◆");
     },
     get resolved() {
         const format = resolveOutputFormat();

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

@@ -1,52 +1,203 @@
-import { Table } from "console-table-printer";
 import { resolveOutputFormat } from "../internal/output-format.js";
 import { stripAnsi } from "../internal/strip-ansi.js";
+const reset = "\x1b[0m";
+const ellipsis = "…";
+const graphemeSegmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+function isAnsiSequence(value, index) {
+    return value[index] === "\u001b" && value[index + 1] === "[";
+}
+function readAnsiSequence(value, index) {
+    let nextIndex = index + 2;
+    while (nextIndex < value.length && value[nextIndex] !== "m") {
+        nextIndex += 1;
+    }
+    if (nextIndex < value.length) {
+        nextIndex += 1;
+    }
+    return { sequence: value.slice(index, nextIndex), nextIndex };
+}
+function isCombiningCodePoint(codePoint) {
+    return ((codePoint >= 0x0300 && codePoint <= 0x036f) ||
+        (codePoint >= 0x1ab0 && codePoint <= 0x1aff) ||
+        (codePoint >= 0x1dc0 && codePoint <= 0x1dff) ||
+        (codePoint >= 0x20d0 && codePoint <= 0x20ff) ||
+        (codePoint >= 0xfe20 && codePoint <= 0xfe2f));
+}
+function isWideCodePoint(codePoint) {
+    return ((codePoint >= 0x1100 && codePoint <= 0x115f) ||
+        codePoint === 0x2329 ||
+        codePoint === 0x232a ||
+        (codePoint >= 0x2e80 && codePoint <= 0xa4cf && codePoint !== 0x303f) ||
+        (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+        (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+        (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
+        (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+        (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+        (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+        (codePoint >= 0x2600 && codePoint <= 0x27bf) ||
+        (codePoint >= 0x1f300 && codePoint <= 0x1faff) ||
+        (codePoint >= 0x20000 && codePoint <= 0x3fffd));
+}
+function isEmojiClusterCodePoint(codePoint) {
+    return ((codePoint >= 0x1f1e6 && codePoint <= 0x1f1ff) ||
+        (codePoint >= 0x1f300 && codePoint <= 0x1faff) ||
+        (codePoint >= 0x2600 && codePoint <= 0x27bf));
+}
+function codePointWidth(char) {
+    const codePoint = char.codePointAt(0) ?? 0;
+    if (codePoint === 0 || codePoint < 0x20 || (codePoint >= 0x7f && codePoint < 0xa0)) {
+        return 0;
+    }
+    if (codePoint === 0x200d ||
+        (codePoint >= 0xfe00 && codePoint <= 0xfe0f) ||
+        isCombiningCodePoint(codePoint)) {
+        return 0;
+    }
+    return isWideCodePoint(codePoint) ? 2 : 1;
+}
+function readPrintableCluster(value, index) {
+    const nextAnsiIndex = value.indexOf("\u001b[", index);
+    const plainText = value.slice(index, nextAnsiIndex === -1 ? undefined : nextAnsiIndex);
+    const firstSegment = graphemeSegmenter.segment(plainText)[Symbol.iterator]().next().value;
+    return firstSegment?.segment ?? Array.from(plainText)[0] ?? "";
+}
+function clusterWidth(cluster) {
+    const codePoints = Array.from(cluster).map((char) => char.codePointAt(0) ?? 0);
+    const isEmojiCluster = codePoints.length > 1 &&
+        codePoints.some((codePoint) => codePoint === 0x200d ||
+            (codePoint >= 0xfe00 && codePoint <= 0xfe0f) ||
+            isEmojiClusterCodePoint(codePoint));
+    if (isEmojiCluster) {
+        return 2;
+    }
+    return codePoints.reduce((width, codePoint) => width + codePointWidth(String.fromCodePoint(codePoint)), 0);
+}
+function displayWidth(value) {
+    let width = 0;
+    let index = 0;
+    while (index < value.length) {
+        if (isAnsiSequence(value, index)) {
+            index = readAnsiSequence(value, index).nextIndex;
+            continue;
+        }
+        const cluster = readPrintableCluster(value, index);
+        width += clusterWidth(cluster);
+        index += cluster.length;
+    }
+    return width;
+}
+function truncateToWidth(value, width) {
+    if (displayWidth(value) <= width) {
+        return value;
+    }
+    if (width <= 0) {
+        return "";
+    }
+    const targetWidth = width <= 1 ? 0 : width - displayWidth(ellipsis);
+    let output = "";
+    let currentWidth = 0;
+    let index = 0;
+    let sawAnsi = false;
+    while (index < value.length) {
+        if (isAnsiSequence(value, index)) {
+            const ansi = readAnsiSequence(value, index);
+            sawAnsi = true;
+            output += ansi.sequence;
+            index = ansi.nextIndex;
+            continue;
+        }
+        const cluster = readPrintableCluster(value, index);
+        const width = clusterWidth(cluster);
+        if (currentWidth + width > targetWidth) {
+            break;
+        }
+        output += cluster;
+        currentWidth += width;
+        index += cluster.length;
+    }
+    return `${output}${ellipsis}${sawAnsi ? reset : ""}`;
+}
+function padCell(value, width, alignment) {
+    const visibleWidth = displayWidth(value);
+    const padding = Math.max(0, width - visibleWidth);
+    if (alignment === "right") {
+        return `${" ".repeat(padding)}${value}`;
+    }
+    if (alignment === "center") {
+        const left = Math.floor(padding / 2);
+        const right = padding - left;
+        return `${" ".repeat(left)}${value}${" ".repeat(right)}`;
+    }
+    return `${value}${" ".repeat(padding)}`;
+}
+function getAlignment(column) {
+    const alignment = column.alignment;
+    return alignment === "right" || alignment === "center" ? alignment : "left";
+}
+function getColumnWidth(column) {
+    const configuredMin = column.minLen;
+    const minWidth = Math.max(1, configuredMin ?? 1);
+    return Math.max(minWidth, column.maxLen);
+}
+function computeColumns(columns) {
+    return columns.map((column) => ({
+        name: column.name,
+        title: column.title,
+        alignment: getAlignment(column),
+        width: getColumnWidth(column)
+    }));
+}
+function renderBorder(columns, theme, parts) {
+    const horizontal = theme.muted("─");
+    const segments = columns.map((column) => horizontal.repeat(column.width + 2));
+    return [
+        theme.muted(parts.left),
+        segments.join(theme.muted(parts.mid)),
+        theme.muted(parts.right)
+    ].join("");
+}
+function renderTerminalRow(values, columns, theme) {
+    const vertical = theme.muted("│");
+    const cells = values.map((value, index) => {
+        const column = columns[index];
+        const truncated = truncateToWidth(value, column.width);
+        return ` ${padCell(truncated, column.width, column.alignment)} `;
+    });
+    return `${vertical}${cells.join(vertical)}${vertical}`;
+}
 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);
+    const computedColumns = computeColumns(columns);
+    const separatorOptions = options;
+    const includeRowSeparators = separatorOptions.rowSeparator === true || separatorOptions.rowSeparators === true;
+    const top = renderBorder(computedColumns, theme, { left: "┌", mid: "┬", right: "┐" });
+    const header = renderTerminalRow(computedColumns.map((column) => theme.header(column.title)), computedColumns, theme);
+    const headerBottom = renderBorder(computedColumns, theme, { left: "├", mid: "┼", right: "┤" });
+    const bottom = renderBorder(computedColumns, theme, { left: "└", mid: "┴", right: "┘" });
+    const renderedRows = [];
+    for (const [index, row] of rows.entries()) {
+        if (includeRowSeparators && index > 0) {
+            renderedRows.push(headerBottom);
+        }
+        renderedRows.push(renderTerminalRow(computedColumns.map((column) => row[column.name] ?? ""), computedColumns, theme));
     }
-    return table.render();
+    return [top, header, headerBottom, ...renderedRows, bottom].join("\n");
 }
 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 separator = `| ${columns
+        .map((c) => {
+        const alignment = getAlignment(c);
+        if (alignment === "right") {
+            return "---:";
+        }
+        if (alignment === "center") {
+            return ":---:";
+        }
+        return ":---";
+    })
+        .join(" | ")} |`;
     const dataRows = rows.map((row) => `| ${columns.map((c) => stripAnsi(row[c.name] ?? "").replace(/\|/g, "\\|")).join(" | ")} |`);
     return [header, separator, ...dataRows].join("\n");
 }

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

@@ -0,0 +1,6 @@
+export type TemplateEscape = "html" | "none";
+export interface RenderTemplateOptions {
+    escape?: TemplateEscape;
+    yield?: string;
+}
+export declare function renderTemplate(template: string, view: Record<string, unknown>, options?: RenderTemplateOptions): string;

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

@@ -0,0 +1,271 @@
+const HTML_ESCAPE = {
+    "&": "&",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;",
+    "/": "&#x2F;",
+    "`": "&#x60;",
+    "=": "&#x3D;"
+};
+export function renderTemplate(template, view, options = {}) {
+    const prepared = options.yield === undefined
+        ? template
+        : template.split("{{yield}}").join(options.yield);
+    const tokens = parseTemplate(prepared);
+    const escape = options.escape === "none" ? String : escapeHtml;
+    const preserveMissing = options.yield !== undefined && options.escape === "none";
+    return renderTokens(tokens, { view }, prepared, escape, preserveMissing);
+}
+function renderTemplateInContext(template, context, escape, preserveMissing) {
+    return renderTokens(parseTemplate(template), context, template, escape, preserveMissing);
+}
+function parseTemplate(template) {
+    const root = [];
+    const stack = [];
+    let tokens = root;
+    let index = 0;
+    while (index < template.length) {
+        const open = template.indexOf("{{", index);
+        if (open === -1) {
+            appendText(tokens, template.slice(index), index);
+            break;
+        }
+        appendText(tokens, template.slice(index, open), index);
+        const parsed = parseTag(template, open);
+        const standalone = getStandalone(template, open, parsed.end, parsed.kind);
+        if (standalone !== undefined) {
+            trimTextAfter(tokens, standalone.lineStart);
+        }
+        if (parsed.kind === "comment") {
+            index = standalone?.nextIndex ?? parsed.end;
+            continue;
+        }
+        if (parsed.kind === "partial") {
+            throw new Error(`Partials are not supported: "${parsed.name}"`);
+        }
+        if (parsed.kind === "delimiter") {
+            throw new Error("Custom delimiters are not supported");
+        }
+        if (parsed.kind === "section" || parsed.kind === "inverted") {
+            const token = {
+                type: parsed.kind,
+                name: parsed.name,
+                children: [],
+                rawStart: parsed.end,
+                rawEnd: standalone?.lineStart ?? open
+            };
+            tokens.push(token);
+            stack.push({ token, parent: tokens });
+            tokens = token.children;
+            index = standalone?.nextIndex ?? parsed.end;
+            continue;
+        }
+        if (parsed.kind === "close") {
+            const frame = stack.pop();
+            if (frame === undefined) {
+                throw new Error(`Closing unopened section "${parsed.name}"`);
+            }
+            if (frame.token.name !== parsed.name) {
+                throw new Error(`Unclosed section "${frame.token.name}" before closing "${parsed.name}"`);
+            }
+            frame.token.rawEnd = open;
+            tokens = frame.parent;
+            index = standalone?.nextIndex ?? parsed.end;
+            continue;
+        }
+        tokens.push({ type: parsed.kind, name: parsed.name, raw: template.slice(open, parsed.end) });
+        index = parsed.end;
+    }
+    const frame = stack.pop();
+    if (frame !== undefined) {
+        throw new Error(`Unclosed section "${frame.token.name}"`);
+    }
+    return root;
+}
+function parseTag(template, open) {
+    if (template.startsWith("{{{", open)) {
+        const close = template.indexOf("}}}", open + 3);
+        if (close === -1) {
+            throw new Error("Unclosed unescaped tag");
+        }
+        return { kind: "unescaped", name: template.slice(open + 3, close).trim(), end: close + 3 };
+    }
+    const close = template.indexOf("}}", open + 2);
+    if (close === -1) {
+        throw new Error("Unclosed tag");
+    }
+    const raw = template.slice(open + 2, close).trim();
+    const sigil = raw[0];
+    const name = sigil === undefined ? "" : raw.slice(1).trim();
+    const end = close + 2;
+    if (sigil === "#")
+        return { kind: "section", name, end };
+    if (sigil === "^")
+        return { kind: "inverted", name, end };
+    if (sigil === "/")
+        return { kind: "close", name, end };
+    if (sigil === "!")
+        return { kind: "comment", name, end };
+    if (sigil === "&")
+        return { kind: "unescaped", name, end };
+    if (sigil === ">")
+        return { kind: "partial", name, end };
+    if (sigil === "=" && raw.endsWith("="))
+        return { kind: "delimiter", name, end };
+    return { kind: "name", name: raw, end };
+}
+function getStandalone(template, tagStart, tagEnd, kind) {
+    if (!["section", "inverted", "close", "comment", "partial", "delimiter"].includes(kind)) {
+        return undefined;
+    }
+    const lineStart = template.lastIndexOf("\n", tagStart - 1) + 1;
+    if (!isWhitespace(template.slice(lineStart, tagStart))) {
+        return undefined;
+    }
+    let cursor = tagEnd;
+    while (cursor < template.length && (template[cursor] === " " || template[cursor] === "\t")) {
+        cursor += 1;
+    }
+    if (template.startsWith("\r\n", cursor)) {
+        return { lineStart, nextIndex: cursor + 2 };
+    }
+    if (template[cursor] === "\n") {
+        return { lineStart, nextIndex: cursor + 1 };
+    }
+    if (cursor === template.length) {
+        return { lineStart, nextIndex: cursor };
+    }
+    return undefined;
+}
+function renderTokens(tokens, context, template, escape, preserveMissing) {
+    let output = "";
+    for (const token of tokens) {
+        switch (token.type) {
+            case "text":
+                output += token.value;
+                continue;
+            case "name":
+            case "unescaped": {
+                const value = lookup(context, token.name);
+                if (value == null) {
+                    if (preserveMissing) {
+                        output += token.raw;
+                    }
+                    continue;
+                }
+                const rendered = String(value);
+                output += token.type === "name" ? escape(rendered) : rendered;
+                continue;
+            }
+            case "inverted": {
+                const value = lookup(context, token.name);
+                if (!value || (Array.isArray(value) && value.length === 0)) {
+                    output += renderTokens(token.children, context, template, escape, preserveMissing);
+                }
+                continue;
+            }
+            case "section": {
+                const value = lookup(context, token.name);
+                if (!value) {
+                    continue;
+                }
+                if (Array.isArray(value)) {
+                    for (const item of value) {
+                        output += renderTokens(token.children, pushContext(context, item), template, escape, preserveMissing);
+                    }
+                    continue;
+                }
+                if (typeof value === "function") {
+                    const raw = template.slice(token.rawStart, token.rawEnd);
+                    const rendered = value.call(context.view, raw, (nextTemplate) => renderTemplateInContext(nextTemplate, context, escape, preserveMissing));
+                    if (rendered != null) {
+                        output += String(rendered);
+                    }
+                    continue;
+                }
+                if (typeof value === "object" || typeof value === "string" || typeof value === "number") {
+                    output += renderTokens(token.children, pushContext(context, value), template, escape, preserveMissing);
+                    continue;
+                }
+                output += renderTokens(token.children, context, template, escape, preserveMissing);
+            }
+        }
+    }
+    return output;
+}
+function lookup(context, name) {
+    if (name === ".") {
+        return callLambda(context.view, context.view);
+    }
+    let cursor = context;
+    while (cursor !== undefined) {
+        const result = name.includes(".")
+            ? lookupDotted(cursor.view, name)
+            : lookupName(cursor.view, name);
+        if (result.hit) {
+            return callLambda(result.value, cursor.view);
+        }
+        cursor = cursor.parent;
+    }
+    return undefined;
+}
+function lookupName(view, name) {
+    if (!isPropertyContainer(view) || !hasProperty(view, name)) {
+        return { hit: false, value: undefined };
+    }
+    return { hit: true, value: view[name] };
+}
+function lookupDotted(view, name) {
+    const parts = name.split(".");
+    let value = view;
+    let hit = false;
+    for (let index = 0; value != null && index < parts.length; index += 1) {
+        const part = parts[index] ?? "";
+        if (index === parts.length - 1) {
+            hit = hasProperty(Object(value), part);
+        }
+        value = Object(value)[part];
+    }
+    return { hit, value };
+}
+function callLambda(value, view) {
+    return typeof value === "function" ? value.call(view) : value;
+}
+function pushContext(parent, view) {
+    return { view, parent };
+}
+function appendText(tokens, value, start) {
+    if (value === "") {
+        return;
+    }
+    const previous = tokens[tokens.length - 1];
+    if (previous?.type === "text") {
+        previous.value += value;
+        return;
+    }
+    tokens.push({ type: "text", value, start });
+}
+function trimTextAfter(tokens, lineStart) {
+    const previous = tokens[tokens.length - 1];
+    if (previous?.type !== "text") {
+        return;
+    }
+    const keep = Math.max(0, lineStart - previous.start);
+    previous.value = previous.value.slice(0, keep);
+    if (previous.value === "") {
+        tokens.pop();
+    }
+}
+function escapeHtml(value) {
+    return value.replace(/[&<>"'`=/]/g, (char) => HTML_ESCAPE[char] ?? char);
+}
+function isWhitespace(value) {
+    return value.trim() === "";
+}
+function isPropertyContainer(value) {
+    return (typeof value === "object" && value !== null) || typeof value === "function";
+}
+function hasProperty(value, key) {
+    return key in value;
+}

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

@@ -1,4 +1,4 @@
-import chalk from "chalk";
+import { color } from "./color.js";
 import { resolveOutputFormat } from "../internal/output-format.js";
 import { getTheme } from "../internal/theme-detect.js";
 import { typography } from "../tokens/typography.js";
@@ -57,7 +57,7 @@ export const text = {
             return content;
         if (format === "markdown")
             return `\`${content}\``;
-        return chalk.yellow(content);
+        return color.yellow(content);
     },
     example(content) {
         const format = resolveOutputFormat();
@@ -73,7 +73,7 @@ export const text = {
             return content;
         if (format === "markdown")
             return `\`${content}\``;
-        return chalk.green(content);
+        return color.green(content);
     },
     link(content) {
         const format = resolveOutputFormat();

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

@@ -1,4 +1,4 @@
-import chalk from "chalk";
+import { color } from "../components/color.js";
 const EMPTY_CELL = { ch: " ", style: {} };
 export class ScreenBuffer {
     _width;
@@ -119,7 +119,7 @@ export function diff(prev, next) {
 }
 export function cellToAnsi(cell) {
     const style = cell.style ?? {};
-    let painter = chalk;
+    let painter = color;
     if (style.bold) {
         painter = painter.bold;
     }
@@ -177,20 +177,20 @@ function cellsEqual(left, right) {
         && left.style.dim === right.style.dim
         && left.style.underline === right.style.underline;
 }
-function applyForegroundColor(instance, color) {
-    if (color.startsWith("#")) {
-        return instance.hex(color);
+function applyForegroundColor(instance, ansiColor) {
+    if (ansiColor.startsWith("#")) {
+        return instance.hex(ansiColor);
     }
-    const painter = instance[color];
+    const painter = instance[ansiColor];
     return typeof painter === "function" ? painter : instance;
 }
-function applyBackgroundColor(instance, color) {
-    if (color.startsWith("#")) {
-        return instance.bgHex(color);
+function applyBackgroundColor(instance, ansiColor) {
+    if (ansiColor.startsWith("#")) {
+        return instance.bgHex(ansiColor);
     }
-    const methodName = color.startsWith("bg")
-        ? color
-        : `bg${color.charAt(0).toUpperCase()}${color.slice(1)}`;
+    const methodName = ansiColor.startsWith("bg")
+        ? ansiColor
+        : `bg${ansiColor.charAt(0).toUpperCase()}${ansiColor.slice(1)}`;
     const painter = instance[methodName];
     return typeof painter === "function" ? painter : instance;
 }

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

@@ -5,6 +5,8 @@ export { spacing } from "./tokens/spacing.js";
 export { typography } from "./tokens/typography.js";
 export { widths } from "./tokens/widths.js";
 export { text } from "./components/text.js";
+export { color } from "./components/color.js";
+export type { Color } from "./components/color.js";
 export { symbols } from "./components/symbols.js";
 export { createLogger, logger } from "./components/logger.js";
 export type { LoggerOutput } from "./components/logger.js";
@@ -15,6 +17,8 @@ export { formatCommandNotFound } from "./components/command-errors.js";
 export { formatCommandNotFoundPanel } from "./components/command-errors.js";
 export { renderTable } from "./components/table.js";
 export type { TableColumn, RenderTableOptions } from "./components/table.js";
+export { renderTemplate } from "./components/template.js";
+export type { RenderTemplateOptions, TemplateEscape } from "./components/template.js";
 export * as acp from "./acp/index.js";
 export * as dashboard from "./dashboard/index.js";
 export { createDashboard, shouldUseInteractiveDashboard } from "./dashboard/index.js";

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

@@ -6,6 +6,7 @@ export { typography } from "./tokens/typography.js";
 export { widths } from "./tokens/widths.js";
 // Components
 export { text } from "./components/text.js";
+export { color } from "./components/color.js";
 export { symbols } from "./components/symbols.js";
 export { createLogger, logger } from "./components/logger.js";
 export { helpFormatter, formatColumns, formatCommand, formatUsage, formatOption, formatCommandList, formatOptionList } from "./components/help-formatter.js";
@@ -13,6 +14,7 @@ export * as helpFormatterPlain from "./components/help-formatter-plain.js";
 export { formatCommandNotFound } from "./components/command-errors.js";
 export { formatCommandNotFoundPanel } from "./components/command-errors.js";
 export { renderTable } from "./components/table.js";
+export { renderTemplate } from "./components/template.js";
 // ACP rendering
 export * as acp from "./acp/index.js";
 // Dashboard

package/node_modules/@poe-code/design-system/dist/internal/color-support.d.ts

@@ -0,0 +1,9 @@
+export interface ColorSupportEnv {
+    NO_COLOR?: string;
+    FORCE_COLOR?: string;
+    TERM?: string;
+}
+export interface ColorSupportStream {
+    isTTY?: boolean;
+}
+export declare function supportsColor(env?: ColorSupportEnv, stream?: ColorSupportStream): boolean;

package/node_modules/@poe-code/design-system/dist/internal/color-support.js

@@ -0,0 +1,12 @@
+export function supportsColor(env = process.env, stream = process.stdout) {
+    if (env.FORCE_COLOR !== undefined && env.FORCE_COLOR !== "0") {
+        return true;
+    }
+    if (env.NO_COLOR !== undefined) {
+        return false;
+    }
+    if (stream.isTTY !== true) {
+        return false;
+    }
+    return typeof env.TERM === "string" && env.TERM.length > 0 && env.TERM !== "dumb";
+}

package/node_modules/@poe-code/design-system/dist/prompts/index.d.ts

@@ -58,7 +58,7 @@ export type SpinnerOptions = {
     message: (message?: string) => void;
 };
 export interface WithSpinnerOptions<T> {
-    message: string;
+    message: string | (() => string);
     fn: () => Promise<T>;
     stopMessage?: (result: T) => string;
     subtext?: (result: T) => string | undefined;

package/node_modules/@poe-code/design-system/dist/prompts/index.js

@@ -1,4 +1,4 @@
-import chalk from "chalk";
+import { color } from "../components/color.js";
 import * as clack from "@clack/prompts";
 import { resolveOutputFormat } from "../internal/output-format.js";
 import { stripAnsi } from "../internal/strip-ansi.js";
@@ -19,7 +19,7 @@ export function introPlain(title) {
     if (format === "json") {
         return;
     }
-    process.stdout.write(`${chalk.gray("┌")}  ${title}\n`);
+    process.stdout.write(`${color.gray("┌")}  ${title}\n`);
 }
 export async function select(opts) {
     return clack.select(opts);
@@ -80,6 +80,7 @@ function formatElapsed(ms) {
 }
 export async function withSpinner(options) {
     const { message, fn, stopMessage, subtext } = options;
+    const readMessage = () => (typeof message === "function" ? message() : message);
     if (resolveOutputFormat() === "json") {
         const result = await fn();
         const sub = subtext ? subtext(result) : undefined;
@@ -106,9 +107,9 @@ export async function withSpinner(options) {
     }
     const s = spinner();
     const start = Date.now();
-    s.start(message);
+    s.start(readMessage());
     const timer = setInterval(() => {
-        s.message(`${message} [${formatElapsed(Date.now() - start)}]`);
+        s.message(`${readMessage()} [${formatElapsed(Date.now() - start)}]`);
     }, 1000);
     try {
         const result = await fn();

package/node_modules/@poe-code/design-system/dist/prompts/primitives/cancel.js

@@ -1,9 +1,9 @@
-import chalk from "chalk";
+import { color } from "../../components/color.js";
 export { isCancel } from "@clack/prompts";
 import { resolveOutputFormat } from "../../internal/output-format.js";
 export function cancel(msg = "") {
     if (resolveOutputFormat() !== "terminal") {
         return;
     }
-    process.stdout.write(`${chalk.gray("└")}  ${chalk.red(msg)}\n\n`);
+    process.stdout.write(`${color.gray("└")}  ${color.red(msg)}\n\n`);
 }

package/node_modules/@poe-code/design-system/dist/prompts/primitives/intro.js

@@ -1,4 +1,4 @@
-import chalk from "chalk";
+import { color } from "../../components/color.js";
 import { text } from "../../components/text.js";
 import { resolveOutputFormat } from "../../internal/output-format.js";
 import { stripAnsi } from "../../internal/strip-ansi.js";
@@ -11,5 +11,5 @@ export function intro(title) {
         process.stdout.write(`# ${stripAnsi(title)}\n\n`);
         return;
     }
-    process.stdout.write(`${chalk.gray("┌")}  ${text.intro(title)}\n`);
+    process.stdout.write(`${color.gray("┌")}  ${text.intro(title)}\n`);
 }

package/node_modules/@poe-code/design-system/dist/prompts/primitives/log.js

@@ -1,8 +1,8 @@
-import chalk from "chalk";
+import { color } from "../../components/color.js";
 import { symbols } from "../../components/symbols.js";
 import { resolveOutputFormat } from "../../internal/output-format.js";
 import { stripAnsi } from "../../internal/strip-ansi.js";
-function writeTerminalMessage(msg, { symbol = chalk.gray("│"), secondarySymbol = chalk.gray("│"), spacing = 1, withGuide = true } = {}) {
+function writeTerminalMessage(msg, { symbol = color.gray("│"), secondarySymbol = color.gray("│"), spacing = 1, withGuide = true } = {}) {
     const lines = [];
     const showGuide = withGuide !== false;
     const contentLines = msg.split("\n");
@@ -78,7 +78,7 @@ export function warn(msg) {
         process.stdout.write(`${JSON.stringify({ level: "warn", message: stripAnsi(msg) })}\n`);
         return;
     }
-    message(msg, { symbol: chalk.yellow("▲") });
+    message(msg, { symbol: color.yellow("▲") });
 }
 export function error(msg) {
     const format = resolveOutputFormat();
@@ -90,7 +90,7 @@ export function error(msg) {
         process.stdout.write(`${JSON.stringify({ level: "error", message: stripAnsi(msg) })}\n`);
         return;
     }
-    message(msg, { symbol: chalk.red("■") });
+    message(msg, { symbol: color.red("■") });
 }
 export const log = {
     info,

package/node_modules/@poe-code/design-system/dist/prompts/primitives/note.js

@@ -1,4 +1,4 @@
-import chalk from "chalk";
+import { color } from "../../components/color.js";
 import { resolveOutputFormat } from "../../internal/output-format.js";
 import { stripAnsi } from "../../internal/strip-ansi.js";
 function getVisibleWidth(value) {
@@ -8,13 +8,13 @@ function renderTerminalNote(message, title) {
     const contentLines = ["", ...message.split("\n"), ""];
     const visibleTitle = stripAnsi(title ?? "");
     const contentWidth = Math.max(visibleTitle.length, ...contentLines.map((line) => getVisibleWidth(line))) + 2;
-    const titleLine = `${chalk.green("◇")}  ${chalk.reset(title ?? "")} ${chalk.gray(`${"─".repeat(Math.max(contentWidth - visibleTitle.length - 1, 1))}╮`)}`;
+    const titleLine = `${color.green("◇")}  ${color.reset(title ?? "")} ${color.gray(`${"─".repeat(Math.max(contentWidth - visibleTitle.length - 1, 1))}╮`)}`;
     const content = contentLines.map((line) => {
         const padding = " ".repeat(contentWidth - getVisibleWidth(line));
-        return `${chalk.gray("│")}  ${line}${padding}${chalk.gray("│")}`;
+        return `${color.gray("│")}  ${line}${padding}${color.gray("│")}`;
     });
-    const bottom = chalk.gray(`├${"─".repeat(contentWidth + 2)}╯`);
-    return [chalk.gray("│"), titleLine, ...content, bottom].join("\n");
+    const bottom = color.gray(`├${"─".repeat(contentWidth + 2)}╯`);
+    return [color.gray("│"), titleLine, ...content, bottom].join("\n");
 }
 export function note(message, title) {
     const format = resolveOutputFormat();

package/node_modules/@poe-code/design-system/dist/prompts/primitives/outro.js

@@ -1,4 +1,4 @@
-import chalk from "chalk";
+import { color } from "../../components/color.js";
 import { resolveOutputFormat } from "../../internal/output-format.js";
 import { stripAnsi } from "../../internal/strip-ansi.js";
 export function outro(message) {
@@ -12,5 +12,5 @@ export function outro(message) {
         process.stdout.write(`${JSON.stringify({ type: "outro", message: stripped })}\n`);
         return;
     }
-    process.stdout.write(`${chalk.gray("│")}\n${chalk.gray("└")}  ${message}\n\n`);
+    process.stdout.write(`${color.gray("│")}\n${color.gray("└")}  ${message}\n\n`);
 }

package/node_modules/@poe-code/design-system/dist/prompts/primitives/spinner.js

@@ -1,4 +1,4 @@
-import chalk from "chalk";
+import { color } from "../../components/color.js";
 import { resolveOutputFormat } from "../../internal/output-format.js";
 import { stripAnsi } from "../../internal/strip-ansi.js";
 import { SPINNER_FRAMES } from "../../static/spinner.js";
@@ -62,8 +62,8 @@ export function spinner() {
             }
             clearTimer();
             const symbol = code === undefined || code === 0
-                ? chalk.green("◆")
-                : chalk.red("■");
+                ? color.green("◆")
+                : color.red("■");
             if (fallback) {
                 process.stdout.write(`${symbol}  ${currentMessage}\n`);
                 return;

package/node_modules/@poe-code/design-system/dist/static/menu.js

@@ -1,4 +1,4 @@
-import chalk from "chalk";
+import { color } from "../components/color.js";
 import { symbols } from "../components/symbols.js";
 import { resolveOutputFormat } from "../internal/output-format.js";
 import { getTheme } from "../internal/theme-detect.js";
@@ -20,15 +20,15 @@ export function renderMenu(opts) {
         });
     }
     const theme = getTheme();
-    const bar = chalk.gray(symbols.bar);
+    const bar = color.gray(symbols.bar);
     const lines = [];
-    lines.push(`${chalk.cyan(symbols.active)}  ${opts.message}`);
+    lines.push(`${color.cyan(symbols.active)}  ${opts.message}`);
     lines.push(bar);
     opts.options.forEach((option, index) => {
         const isSelected = index === selectedIndex;
-        const prefix = isSelected ? chalk.cyan(symbols.active) : chalk.gray(symbols.inactive);
+        const prefix = isSelected ? color.cyan(symbols.active) : color.gray(symbols.inactive);
         const label = isSelected ? theme.accent(option.label) : option.label;
-        const hint = option.hint ? chalk.dim(` (${option.hint})`) : "";
+        const hint = option.hint ? color.dim(` (${option.hint})`) : "";
         lines.push(`${bar}  ${prefix} ${label}${hint}`);
     });
     lines.push(`${bar}`);

package/node_modules/@poe-code/design-system/dist/static/spinner.js

@@ -1,4 +1,4 @@
-import chalk from "chalk";
+import { color } from "../components/color.js";
 import { symbols } from "../components/symbols.js";
 import { resolveOutputFormat } from "../internal/output-format.js";
 export const SPINNER_FRAMES = ["◒", "◐", "◓", "◑"];
@@ -16,9 +16,9 @@ export function renderSpinnerFrame(options) {
         })}\n`;
     }
     const frame = options.frame ?? 0;
-    const spinnerChar = chalk.magenta(SPINNER_FRAMES[frame % SPINNER_FRAMES.length]);
-    const timerSuffix = options.timer ? chalk.dim(` [${options.timer}]`) : "";
-    const bar = chalk.gray(symbols.bar);
+    const spinnerChar = color.magenta(SPINNER_FRAMES[frame % SPINNER_FRAMES.length]);
+    const timerSuffix = options.timer ? color.dim(` [${options.timer}]`) : "";
+    const bar = color.gray(symbols.bar);
     return `${spinnerChar}  ${options.message}${timerSuffix}\n${bar}`;
 }
 export function renderSpinnerStopped(options) {
@@ -35,12 +35,12 @@ export function renderSpinnerStopped(options) {
         })}\n`;
     }
     const code = options.code ?? 0;
-    const symbol = code === 0 ? chalk.green("◆") : chalk.red("■");
-    const timerSuffix = options.timer ? chalk.dim(` [${options.timer}]`) : "";
-    const bar = chalk.gray(symbols.bar);
+    const symbol = code === 0 ? color.green("◆") : color.red("■");
+    const timerSuffix = options.timer ? color.dim(` [${options.timer}]`) : "";
+    const bar = color.gray(symbols.bar);
     let output = `${symbol}  ${options.message}${timerSuffix}`;
     if (options.subtext) {
-        output += `\n${bar}     ${chalk.dim(options.subtext)}`;
+        output += `\n${bar}     ${color.dim(options.subtext)}`;
     }
     return output;
 }

package/node_modules/@poe-code/design-system/dist/tokens/colors.js

@@ -1,34 +1,34 @@
-import chalk from "chalk";
+import { color } from "../components/color.js";
 export const brand = "#a200ff";
 export const dark = {
-    header: (text) => chalk.magentaBright.bold(text),
-    divider: (text) => chalk.dim(text),
-    prompt: (text) => chalk.cyan(text),
-    number: (text) => chalk.cyanBright(text),
-    intro: (text) => chalk.bgMagenta.white(` Poe - ${text} `),
-    resolvedSymbol: chalk.magenta("◇"),
-    errorSymbol: chalk.red("■"),
-    accent: (text) => chalk.cyan(text),
-    muted: (text) => chalk.dim(text),
-    success: (text) => chalk.green(text),
-    warning: (text) => chalk.yellow(text),
-    error: (text) => chalk.red(text),
-    info: (text) => chalk.magenta(text),
-    badge: (text) => chalk.bgYellow.black(` ${text} `)
+    header: (text) => color.magentaBright.bold(text),
+    divider: (text) => color.dim(text),
+    prompt: (text) => color.cyan(text),
+    number: (text) => color.cyanBright(text),
+    intro: (text) => color.bgMagenta.white(` Poe - ${text} `),
+    resolvedSymbol: color.magenta("◇"),
+    errorSymbol: color.red("■"),
+    accent: (text) => color.cyan(text),
+    muted: (text) => color.dim(text),
+    success: (text) => color.green(text),
+    warning: (text) => color.yellow(text),
+    error: (text) => color.red(text),
+    info: (text) => color.magenta(text),
+    badge: (text) => color.bgYellow.black(` ${text} `)
 };
 export const light = {
-    header: (text) => chalk.hex("#a200ff").bold(text),
-    divider: (text) => chalk.hex("#666666")(text),
-    prompt: (text) => chalk.hex("#006699").bold(text),
-    number: (text) => chalk.hex("#0077cc").bold(text),
-    intro: (text) => chalk.bgHex("#a200ff").white(` Poe - ${text} `),
-    resolvedSymbol: chalk.hex("#a200ff")("◇"),
-    errorSymbol: chalk.hex("#cc0000")("■"),
-    accent: (text) => chalk.hex("#006699").bold(text),
-    muted: (text) => chalk.hex("#666666")(text),
-    success: (text) => chalk.hex("#008800")(text),
-    warning: (text) => chalk.hex("#cc6600")(text),
-    error: (text) => chalk.hex("#cc0000")(text),
-    info: (text) => chalk.hex("#a200ff")(text),
-    badge: (text) => chalk.bgHex("#cc6600").white(` ${text} `)
+    header: (text) => color.hex("#a200ff").bold(text),
+    divider: (text) => color.hex("#666666")(text),
+    prompt: (text) => color.hex("#006699").bold(text),
+    number: (text) => color.hex("#0077cc").bold(text),
+    intro: (text) => color.bgHex("#a200ff").white(` Poe - ${text} `),
+    resolvedSymbol: color.hex("#a200ff")("◇"),
+    errorSymbol: color.hex("#cc0000")("■"),
+    accent: (text) => color.hex("#006699").bold(text),
+    muted: (text) => color.hex("#666666")(text),
+    success: (text) => color.hex("#008800")(text),
+    warning: (text) => color.hex("#cc6600")(text),
+    error: (text) => color.hex("#cc0000")(text),
+    info: (text) => color.hex("#a200ff")(text),
+    badge: (text) => color.bgHex("#cc6600").white(` ${text} `)
 };

package/node_modules/@poe-code/design-system/dist/tokens/typography.js

@@ -1,8 +1,8 @@
-import chalk from "chalk";
+import { color } from "../components/color.js";
 export const typography = {
-    bold: (text) => chalk.bold(text),
-    dim: (text) => chalk.dim(text),
-    italic: (text) => chalk.italic(text),
-    underline: (text) => chalk.underline(text),
-    strikethrough: (text) => chalk.strikethrough(text)
+    bold: (text) => color.bold(text),
+    dim: (text) => color.dim(text),
+    italic: (text) => color.italic(text),
+    underline: (text) => color.underline(text),
+    strikethrough: (text) => color.strikethrough(text)
 };

package/node_modules/@poe-code/design-system/package.json

@@ -19,8 +19,10 @@
     "dist"
   ],
   "peerDependencies": {
-    "@clack/prompts": "^1.0.0",
-    "chalk": "^5.3.0",
-    "console-table-printer": "^2.15.0"
+    "@clack/prompts": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/mustache": "^4.2.6",
+    "mustache": "^4.2.0"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft-openapi",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -32,9 +32,7 @@
     "@clack/prompts": "^1.0.0",
     "@poe-code/design-system": "^0.0.2",
     "auth-store": "^0.0.1",
-    "chalk": "^5.6.2",
-    "console-table-printer": "^2.15.0",
-    "toolcraft": "^0.0.18",
+    "toolcraft": "^0.0.20",
     "yaml": "^2.8.2"
   },
   "engines": {