toolcraft 0.0.18 → 0.0.19

package/node_modules/@poe-code/config-mutations/dist/execution/apply-mutation.js

@@ -1,4 +1,4 @@
-import Mustache from "mustache";
+import { renderTemplate } from "@poe-code/design-system";
 import { getConfigFormat, detectFormat } from "../formats/index.js";
 import { resolvePath } from "./path-utils.js";
 import { isNotFound, readFileIfExists, pathExists, createTimestamp } from "../fs-utils.js";
@@ -481,7 +481,7 @@ async function applyTemplateWrite(mutation, context, options) {
     const templateContext = mutation.context
         ? resolveValue(mutation.context, options)
         : {};
-    const rendered = Mustache.render(template, templateContext);
+    const rendered = renderTemplate(template, templateContext);
     const existed = await pathExists(context.fs, targetPath);
     if (!context.dryRun) {
         await context.fs.writeFile(targetPath, rendered, { encoding: "utf8" });
@@ -513,7 +513,7 @@ async function applyTemplateMerge(mutation, context, options, formatName) {
     const templateContext = mutation.context
         ? resolveValue(mutation.context, options)
         : {};
-    const rendered = Mustache.render(template, templateContext);
+    const rendered = renderTemplate(template, templateContext);
     // Parse rendered template
     let templateDoc;
     try {

package/node_modules/@poe-code/config-mutations/dist/mutations/template-mutation.d.ts

@@ -4,7 +4,7 @@ export interface WriteOptions {
     target: ValueResolver<string>;
     /** Template ID to load via template loader */
     templateId: string;
-    /** Context to pass to Mustache.render() */
+    /** Context to pass to renderTemplate() */
     context?: ValueResolver<ConfigObject>;
     /** Optional human-readable label for logging */
     label?: string;
@@ -14,7 +14,7 @@ export interface MergeTomlOptions {
     target: ValueResolver<string>;
     /** Template ID to load via template loader */
     templateId: string;
-    /** Context to pass to Mustache.render() */
+    /** Context to pass to renderTemplate() */
     context?: ValueResolver<ConfigObject>;
     /** Optional human-readable label for logging */
     label?: string;
@@ -24,7 +24,7 @@ export interface MergeJsonOptions {
     target: ValueResolver<string>;
     /** Template ID to load via template loader */
     templateId: string;
-    /** Context to pass to Mustache.render() */
+    /** Context to pass to renderTemplate() */
     context?: ValueResolver<ConfigObject>;
     /** Optional human-readable label for logging */
     label?: string;

package/node_modules/@poe-code/config-mutations/dist/template/render.d.ts

@@ -1,7 +1,6 @@
 export type TemplateVariables = Record<string, string | number | boolean | string[]>;
 /**
  * Render a mustache template with the given variables.
- * Arrays are automatically joined with newlines.
  * HTML escaping is disabled.
  */
 export declare function renderTemplate(template: string, variables: TemplateVariables): string;

package/node_modules/@poe-code/config-mutations/dist/template/render.js

@@ -1,28 +1,8 @@
-import Mustache from "mustache";
-// Disable HTML escaping - we're rendering prompts, not HTML
-const originalEscape = Mustache.escape;
+import { renderTemplate as renderDesignTemplate } from "@poe-code/design-system";
 /**
  * Render a mustache template with the given variables.
- * Arrays are automatically joined with newlines.
  * HTML escaping is disabled.
  */
 export function renderTemplate(template, variables) {
-    // Pre-process variables to handle arrays
-    const processed = {};
-    for (const [key, value] of Object.entries(variables)) {
-        if (Array.isArray(value)) {
-            processed[key] = value.join("\n");
-        }
-        else {
-            processed[key] = value;
-        }
-    }
-    // Temporarily disable HTML escaping
-    Mustache.escape = (text) => text;
-    try {
-        return Mustache.render(template, processed);
-    }
-    finally {
-        Mustache.escape = originalEscape;
-    }
+    return renderDesignTemplate(template, variables, { escape: "none" });
 }

package/node_modules/@poe-code/config-mutations/package.json

@@ -22,12 +22,9 @@
     "dist"
   ],
   "dependencies": {
+    "@poe-code/design-system": "*",
     "jsonc-parser": "^3.3.1",
-    "mustache": "^4.2.0",
     "smol-toml": "^1.3.0",
     "yaml": "^2.8.1"
-  },
-  "devDependencies": {
-    "@types/mustache": "^4.2.6"
   }
 }

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;