toolcraft 0.0.18 → 0.0.20

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;