poe-code 3.0.178 → 3.0.179

package/packages/design-system/dist/acp/components.js

@@ -0,0 +1,121 @@
+import chalk from "chalk";
+import { resolveOutputFormat } from "../internal/output-format.js";
+import { renderMarkdown } from "../terminal-markdown/index.js";
+import { getAcpWriter } from "./writer.js";
+function truncate(text, maxLength) {
+    if (text.length <= maxLength)
+        return text;
+    if (maxLength <= 3)
+        return text.slice(0, 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)
+};
+function colorForKind(kind) {
+    return KIND_COLORS[kind] ?? ((text) => chalk.dim(text));
+}
+function writeLine(line) {
+    getAcpWriter()(line);
+}
+const AGENT_PREFIX = `${chalk.green.bold("✓")} agent: `;
+function formatCost(costUsd) {
+    return new Intl.NumberFormat("en-US", {
+        style: "currency",
+        currency: "USD",
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 6
+    }).format(costUsd);
+}
+export function renderAgentMessage(text) {
+    const format = resolveOutputFormat();
+    if (format === "markdown") {
+        writeLine(`- **agent:** ${text}`);
+        return;
+    }
+    if (format === "json") {
+        writeLine(JSON.stringify({ event: "agent_message", text }));
+        return;
+    }
+    const rendered = renderMarkdown(text).trimEnd();
+    writeLine(`${AGENT_PREFIX}${rendered}`);
+}
+export function renderToolStart(kind, title) {
+    const format = resolveOutputFormat();
+    if (format === "markdown") {
+        writeLine(`- *→ ${kind}: ${title}*`);
+        return;
+    }
+    if (format === "json") {
+        writeLine(JSON.stringify({ event: "tool_start", kind, title }));
+        return;
+    }
+    const color = colorForKind(kind);
+    writeLine(color(`  → ${kind}: ${title}`));
+}
+export function renderToolComplete(kind) {
+    const format = resolveOutputFormat();
+    if (format === "markdown") {
+        writeLine(`- *✓ ${kind}*`);
+        return;
+    }
+    if (format === "json") {
+        writeLine(JSON.stringify({ event: "tool_complete", kind }));
+        return;
+    }
+    const color = colorForKind(kind);
+    writeLine(color(`  ✓ ${kind}`));
+}
+export function renderReasoning(text) {
+    const format = resolveOutputFormat();
+    if (format === "markdown") {
+        writeLine(`- *thinking:* ${truncate(text, 80)}`);
+        return;
+    }
+    if (format === "json") {
+        writeLine(JSON.stringify({ event: "reasoning", text }));
+        return;
+    }
+    writeLine(chalk.dim(`  ✓ ${truncate(text, 80)}`));
+}
+export function renderUsage(tokens) {
+    const format = resolveOutputFormat();
+    const cached = typeof tokens.cached === "number" && tokens.cached > 0 ? ` (${tokens.cached} cached)` : "";
+    let cost = "";
+    if (typeof tokens.costUsd === "number") {
+        cost = ` (${formatCost(tokens.costUsd)})`;
+    }
+    if (format === "markdown") {
+        writeLine(`- **tokens:** ${tokens.input} in → ${tokens.output} out${cost}`);
+        return;
+    }
+    if (format === "json") {
+        writeLine(JSON.stringify({
+            event: "usage",
+            inputTokens: tokens.input,
+            outputTokens: tokens.output,
+            cachedTokens: tokens.cached ?? 0,
+            costUsd: tokens.costUsd ?? 0
+        }));
+        return;
+    }
+    writeLine("");
+    writeLine(chalk.green(`✓ tokens: ${tokens.input} in${cached} → ${tokens.output} out${cost}`));
+}
+export function renderError(message) {
+    const format = resolveOutputFormat();
+    if (format === "markdown") {
+        writeLine(`- **error:** ${message}`);
+        return;
+    }
+    if (format === "json") {
+        writeLine(JSON.stringify({ event: "error", message }));
+        return;
+    }
+    writeLine(chalk.red(`✗ ${message}`));
+}

package/packages/design-system/dist/acp/index.d.ts

@@ -0,0 +1,3 @@
+export { renderAgentMessage, renderToolStart, renderToolComplete, renderReasoning, renderUsage, renderError } from "./components.js";
+export { getAcpWriter, withAcpWriter } from "./writer.js";
+export type { AcpLineWriter } from "./writer.js";

package/packages/design-system/dist/acp/index.js

@@ -0,0 +1,2 @@
+export { renderAgentMessage, renderToolStart, renderToolComplete, renderReasoning, renderUsage, renderError } from "./components.js";
+export { getAcpWriter, withAcpWriter } from "./writer.js";

package/packages/design-system/dist/acp/writer.d.ts

@@ -0,0 +1,13 @@
+export type AcpLineWriter = (line: string) => void;
+/**
+ * Return the writer active in the current async context, or the default
+ * stdout writer if none is bound.
+ */
+export declare function getAcpWriter(): AcpLineWriter;
+/**
+ * Run `fn` with `writer` bound as the active ACP line writer. All calls to
+ * `renderAgentMessage`, `renderToolStart`, `renderAcpEvent`, etc. made inside
+ * `fn` (or async work awaited from `fn`) will go through `writer` instead of
+ * writing to `process.stdout`.
+ */
+export declare function withAcpWriter<T>(writer: AcpLineWriter, fn: () => Promise<T>): Promise<T>;

package/packages/design-system/dist/acp/writer.js

@@ -0,0 +1,21 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+const storage = new AsyncLocalStorage();
+const defaultWriter = (line) => {
+    process.stdout.write(`${line}\n`);
+};
+/**
+ * Return the writer active in the current async context, or the default
+ * stdout writer if none is bound.
+ */
+export function getAcpWriter() {
+    return storage.getStore() ?? defaultWriter;
+}
+/**
+ * Run `fn` with `writer` bound as the active ACP line writer. All calls to
+ * `renderAgentMessage`, `renderToolStart`, `renderAcpEvent`, etc. made inside
+ * `fn` (or async work awaited from `fn`) will go through `writer` instead of
+ * writing to `process.stdout`.
+ */
+export function withAcpWriter(writer, fn) {
+    return storage.run(writer, fn);
+}

package/packages/design-system/dist/components/command-errors.d.ts

@@ -0,0 +1,16 @@
+export declare function formatCommandNotFound(input: {
+    unknownCommand: string;
+    helpCommand: string;
+}): {
+    label: string;
+    hint: string;
+};
+export declare function formatCommandNotFoundPanel(input: {
+    unknownCommand: string;
+    helpCommand: string;
+    title?: string;
+}): {
+    title: string;
+    label: string;
+    footer: string;
+};

package/packages/design-system/dist/components/command-errors.js

@@ -0,0 +1,22 @@
+import { typography } from "../tokens/typography.js";
+import { text } from "./text.js";
+export function formatCommandNotFound(input) {
+    const unknown = input.unknownCommand.length > 0
+        ? input.unknownCommand
+        : "<command>";
+    return {
+        label: `${typography.bold("Unknown command:")} ${text.command(unknown)}`,
+        hint: `${text.muted("Run")} ${text.usageCommand(input.helpCommand)} ${text.muted("for available commands.")}`
+    };
+}
+export function formatCommandNotFoundPanel(input) {
+    const message = formatCommandNotFound({
+        unknownCommand: input.unknownCommand,
+        helpCommand: input.helpCommand
+    });
+    return {
+        title: input.title ?? "command not found",
+        label: message.label,
+        footer: message.hint
+    };
+}

package/packages/design-system/dist/components/help-formatter.d.ts

@@ -0,0 +1,20 @@
+export interface CommandInfo {
+    name: string;
+    description: string;
+}
+export interface OptionInfo {
+    flags: string;
+    description: string;
+}
+export declare function formatCommand(name: string, description: string): string;
+export declare function formatUsage(command: string, args?: string): string;
+export declare function formatOption(flags: string, description: string): string;
+export declare function formatCommandList(commands: CommandInfo[]): string;
+export declare function formatOptionList(options: OptionInfo[]): string;
+export declare const helpFormatter: {
+    readonly formatCommand: typeof formatCommand;
+    readonly formatUsage: typeof formatUsage;
+    readonly formatOption: typeof formatOption;
+    readonly formatCommandList: typeof formatCommandList;
+    readonly formatOptionList: typeof formatOptionList;
+};

package/packages/design-system/dist/components/help-formatter.js

@@ -0,0 +1,27 @@
+import { text } from "./text.js";
+import { widths } from "../tokens/widths.js";
+export function formatCommand(name, description) {
+    const paddedName = name.padEnd(widths.helpColumn);
+    return `  ${text.command(paddedName)}  ${description}`;
+}
+export function formatUsage(command, args) {
+    const argsStr = args ? ` ${text.argument(args)}` : "";
+    return `${text.usageCommand(command)}${argsStr}`;
+}
+export function formatOption(flags, description) {
+    const paddedFlags = flags.padEnd(widths.helpColumn);
+    return `  ${text.option(paddedFlags)}  ${description}`;
+}
+export function formatCommandList(commands) {
+    return commands.map((cmd) => formatCommand(cmd.name, cmd.description)).join("\n");
+}
+export function formatOptionList(options) {
+    return options.map((opt) => formatOption(opt.flags, opt.description)).join("\n");
+}
+export const helpFormatter = {
+    formatCommand,
+    formatUsage,
+    formatOption,
+    formatCommandList,
+    formatOptionList
+};

package/packages/design-system/dist/components/index.d.ts

@@ -0,0 +1,10 @@
+export { text } from "./text.js";
+export { symbols } from "./symbols.js";
+export { createLogger, logger } from "./logger.js";
+export type { LoggerOutput } from "./logger.js";
+export { helpFormatter, formatCommand, formatUsage, formatOption, formatCommandList, formatOptionList } from "./help-formatter.js";
+export type { CommandInfo, OptionInfo } from "./help-formatter.js";
+export { formatCommandNotFound } from "./command-errors.js";
+export { formatCommandNotFoundPanel } from "./command-errors.js";
+export { renderTable } from "./table.js";
+export type { TableColumn, RenderTableOptions } from "./table.js";

package/packages/design-system/dist/components/index.js

@@ -0,0 +1,7 @@
+export { text } from "./text.js";
+export { symbols } from "./symbols.js";
+export { createLogger, logger } from "./logger.js";
+export { helpFormatter, 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";

package/packages/design-system/dist/components/logger.d.ts

@@ -0,0 +1,11 @@
+export interface LoggerOutput {
+    info(message: string): void;
+    success(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    resolved(label: string, value: string): void;
+    errorResolved(label: string, value: string): void;
+    message(message: string, symbol?: string): void;
+}
+export declare function createLogger(emitter?: (message: string) => void): LoggerOutput;
+export declare const logger: LoggerOutput;

package/packages/design-system/dist/components/logger.js

@@ -0,0 +1,60 @@
+import chalk from "chalk";
+import { log } from "../prompts/primitives/log.js";
+import { symbols } from "./symbols.js";
+export function createLogger(emitter) {
+    const emit = (level, message) => {
+        if (emitter) {
+            emitter(message);
+            return;
+        }
+        if (level === "success") {
+            log.success(message);
+            return;
+        }
+        if (level === "warn") {
+            log.warn(message);
+            return;
+        }
+        if (level === "error") {
+            log.error(message);
+            return;
+        }
+        log.info(message);
+    };
+    return {
+        info(message) {
+            emit("info", message);
+        },
+        success(message) {
+            emit("success", message);
+        },
+        warn(message) {
+            emit("warn", message);
+        },
+        error(message) {
+            emit("error", message);
+        },
+        resolved(label, value) {
+            if (emitter) {
+                emitter(`${label}: ${value}`);
+                return;
+            }
+            log.message(`${label}\n   ${value}`, { symbol: symbols.resolved });
+        },
+        errorResolved(label, value) {
+            if (emitter) {
+                emitter(`${label}: ${value}`);
+                return;
+            }
+            log.message(`${label}\n   ${value}`, { symbol: symbols.errorResolved });
+        },
+        message(message, symbol) {
+            if (emitter) {
+                emitter(message);
+                return;
+            }
+            log.message(message, { symbol: symbol ?? chalk.gray("│") });
+        }
+    };
+}
+export const logger = createLogger();

package/packages/design-system/dist/components/symbols.d.ts

@@ -0,0 +1,12 @@
+export declare const symbols: {
+    readonly info: string;
+    readonly success: string;
+    readonly resolved: string;
+    readonly errorResolved: string;
+    readonly bar: string;
+    readonly cornerTopRight: "╮";
+    readonly cornerBottomRight: "╯";
+    readonly warning: string;
+    readonly active: string;
+    readonly inactive: string;
+};

package/packages/design-system/dist/components/symbols.js

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

package/packages/design-system/dist/components/table.d.ts

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

package/packages/design-system/dist/components/table.js

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

package/packages/design-system/dist/components/text.d.ts

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

package/packages/design-system/dist/components/text.js

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

package/packages/design-system/dist/dashboard/ansi.d.ts

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