poe-code 3.0.177 → 3.0.179

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

@@ -0,0 +1,132 @@
+import chalk from "chalk";
+import * as clack from "@clack/prompts";
+import { resolveOutputFormat } from "../internal/output-format.js";
+import { stripAnsi } from "../internal/strip-ansi.js";
+import { cancel, isCancel } from "./primitives/cancel.js";
+import { intro } from "./primitives/intro.js";
+import { log } from "./primitives/log.js";
+import { note } from "./primitives/note.js";
+import { outro } from "./primitives/outro.js";
+import { spinner } from "./primitives/spinner.js";
+export { isCancel, cancel, log };
+export { intro, outro, note, spinner };
+export function introPlain(title) {
+    const format = resolveOutputFormat();
+    if (format === "markdown") {
+        process.stdout.write(`# ${stripAnsi(title)}\n\n`);
+        return;
+    }
+    if (format === "json") {
+        return;
+    }
+    process.stdout.write(`${chalk.gray("┌")}  ${title}\n`);
+}
+export async function select(opts) {
+    return clack.select(opts);
+}
+/**
+ * Prompts the user to select one or more values from a list.
+ *
+ * Returns the selected values as an array, or a cancellation symbol if the
+ * user cancels. Use `isCancel` to check for cancellation.
+ *
+ * @example
+ * const result = await multiselect({
+ *   message: "Pick workflows to run",
+ *   options: [{ label: "Fix Vulnerabilities", value: "fix-vulnerabilities" }],
+ *   required: true
+ * });
+ * if (!isCancel(result)) {
+ *   // result is Value[]
+ * }
+ */
+export async function multiselect(opts) {
+    return clack.multiselect(opts);
+}
+export async function text(opts) {
+    return clack.text(opts);
+}
+export async function confirm(opts) {
+    return clack.confirm(opts);
+}
+export class PromptCancelledError extends Error {
+    constructor(message = "Operation cancelled.") {
+        super(message);
+        this.name = "PromptCancelledError";
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+}
+export async function confirmOrCancel(opts) {
+    const result = await confirm(opts);
+    if (isCancel(result)) {
+        cancel("Operation cancelled.");
+        throw new PromptCancelledError();
+    }
+    return result === true;
+}
+export async function password(opts) {
+    return clack.password(opts);
+}
+function formatElapsed(ms) {
+    const totalSeconds = Math.floor(ms / 1000);
+    if (totalSeconds < 60) {
+        return `${totalSeconds}s`;
+    }
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    return `${minutes}m ${seconds}s`;
+}
+export async function withSpinner(options) {
+    const { message, fn, stopMessage, subtext } = options;
+    if (resolveOutputFormat() === "json") {
+        const result = await fn();
+        const sub = subtext ? subtext(result) : undefined;
+        if (sub) {
+            process.stdout.write(sub + "\n");
+        }
+        return result;
+    }
+    const noSpinner = process.env.POE_NO_SPINNER === "1";
+    const isTTY = process.stdout.isTTY;
+    if (noSpinner || !isTTY) {
+        const result = await fn();
+        const msg = stopMessage ? stopMessage(result) : undefined;
+        if (msg) {
+            process.stdout.write(`\x1b[32m◆\x1b[0m  ${msg}\n`);
+        }
+        const sub = subtext ? subtext(result) : undefined;
+        if (sub) {
+            for (const line of sub.split("\n")) {
+                process.stdout.write(`\x1b[90m│\x1b[0m     ${line}\n`);
+            }
+        }
+        return result;
+    }
+    const s = spinner();
+    const start = Date.now();
+    s.start(message);
+    const timer = setInterval(() => {
+        s.message(`${message} [${formatElapsed(Date.now() - start)}]`);
+    }, 1000);
+    try {
+        const result = await fn();
+        clearInterval(timer);
+        const elapsed = formatElapsed(Date.now() - start);
+        const msg = stopMessage ? stopMessage(result) : undefined;
+        s.stop(msg ? `${msg} [${elapsed}]` : `Done [${elapsed}]`);
+        const sub = subtext ? subtext(result) : undefined;
+        if (sub) {
+            for (const line of sub.split("\n")) {
+                process.stdout.write(`\x1b[90m│\x1b[0m     ${line}\n`);
+            }
+        }
+        return result;
+    }
+    catch (error) {
+        clearInterval(timer);
+        s.stop("", 1);
+        throw error;
+    }
+}

package/packages/design-system/dist/prompts/primitives/cancel.d.ts

@@ -0,0 +1,2 @@
+export { isCancel } from "@clack/core";
+export declare function cancel(msg?: string): void;

package/packages/design-system/dist/prompts/primitives/cancel.js

@@ -0,0 +1,9 @@
+import chalk from "chalk";
+export { isCancel } from "@clack/core";
+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`);
+}

package/packages/design-system/dist/prompts/primitives/intro.d.ts

@@ -0,0 +1 @@
+export declare function intro(title: string): void;

package/packages/design-system/dist/prompts/primitives/intro.js

@@ -0,0 +1,15 @@
+import chalk from "chalk";
+import { text } from "../../components/text.js";
+import { resolveOutputFormat } from "../../internal/output-format.js";
+import { stripAnsi } from "../../internal/strip-ansi.js";
+export function intro(title) {
+    const format = resolveOutputFormat();
+    if (format === "json") {
+        return;
+    }
+    if (format === "markdown") {
+        process.stdout.write(`# ${stripAnsi(title)}\n\n`);
+        return;
+    }
+    process.stdout.write(`${chalk.gray("┌")}  ${text.intro(title)}\n`);
+}

package/packages/design-system/dist/prompts/primitives/log.d.ts

@@ -0,0 +1,18 @@
+export interface LogMessageOptions {
+    symbol?: string;
+    secondarySymbol?: string;
+    spacing?: number;
+    withGuide?: boolean;
+}
+export declare function message(msg: string, options?: LogMessageOptions): void;
+export declare function info(msg: string): void;
+export declare function success(msg: string): void;
+export declare function warn(msg: string): void;
+export declare function error(msg: string): void;
+export declare const log: {
+    info: typeof info;
+    success: typeof success;
+    message: typeof message;
+    warn: typeof warn;
+    error: typeof error;
+};

package/packages/design-system/dist/prompts/primitives/log.js

@@ -0,0 +1,101 @@
+import chalk from "chalk";
+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 } = {}) {
+    const lines = [];
+    const showGuide = withGuide !== false;
+    const contentLines = msg.split("\n");
+    const prefix = showGuide ? `${symbol}  ` : "";
+    const continuationPrefix = showGuide ? `${secondarySymbol}  ` : "";
+    const emptyGuide = showGuide ? secondarySymbol : "";
+    for (let index = 0; index < spacing; index += 1) {
+        lines.push(emptyGuide);
+    }
+    if (contentLines.length === 0) {
+        process.stdout.write("\n");
+        return;
+    }
+    const [firstLine = "", ...continuationLines] = contentLines;
+    if (firstLine.length > 0) {
+        lines.push(`${prefix}${firstLine}`);
+    }
+    else {
+        lines.push(showGuide ? symbol : "");
+    }
+    for (const line of continuationLines) {
+        if (line.length > 0) {
+            lines.push(`${continuationPrefix}${line}`);
+            continue;
+        }
+        lines.push(emptyGuide);
+    }
+    process.stdout.write(`${lines.join("\n")}\n`);
+}
+export function message(msg, options) {
+    const format = resolveOutputFormat();
+    if (format === "markdown") {
+        process.stdout.write(`- ${stripAnsi(msg)}\n`);
+        return;
+    }
+    if (format === "json") {
+        process.stdout.write(`${JSON.stringify({ level: "message", message: stripAnsi(msg) })}\n`);
+        return;
+    }
+    writeTerminalMessage(msg, options);
+}
+export function info(msg) {
+    const format = resolveOutputFormat();
+    if (format === "markdown") {
+        process.stdout.write(`- **info:** ${stripAnsi(msg)}\n`);
+        return;
+    }
+    if (format === "json") {
+        process.stdout.write(`${JSON.stringify({ level: "info", message: stripAnsi(msg) })}\n`);
+        return;
+    }
+    message(msg, { symbol: symbols.info });
+}
+export function success(msg) {
+    const format = resolveOutputFormat();
+    if (format === "markdown") {
+        process.stdout.write(`- **success:** ${stripAnsi(msg)}\n`);
+        return;
+    }
+    if (format === "json") {
+        process.stdout.write(`${JSON.stringify({ level: "success", message: stripAnsi(msg) })}\n`);
+        return;
+    }
+    message(msg, { symbol: symbols.success });
+}
+export function warn(msg) {
+    const format = resolveOutputFormat();
+    if (format === "markdown") {
+        process.stdout.write(`- **warning:** ${stripAnsi(msg)}\n`);
+        return;
+    }
+    if (format === "json") {
+        process.stdout.write(`${JSON.stringify({ level: "warn", message: stripAnsi(msg) })}\n`);
+        return;
+    }
+    message(msg, { symbol: chalk.yellow("▲") });
+}
+export function error(msg) {
+    const format = resolveOutputFormat();
+    if (format === "markdown") {
+        process.stdout.write(`- **error:** ${stripAnsi(msg)}\n`);
+        return;
+    }
+    if (format === "json") {
+        process.stdout.write(`${JSON.stringify({ level: "error", message: stripAnsi(msg) })}\n`);
+        return;
+    }
+    message(msg, { symbol: chalk.red("■") });
+}
+export const log = {
+    info,
+    success,
+    message,
+    warn,
+    error
+};

package/packages/design-system/dist/prompts/primitives/note.d.ts

@@ -0,0 +1 @@
+export declare function note(message: string, title?: string): void;

package/packages/design-system/dist/prompts/primitives/note.js

@@ -0,0 +1,39 @@
+import chalk from "chalk";
+import { resolveOutputFormat } from "../../internal/output-format.js";
+import { stripAnsi } from "../../internal/strip-ansi.js";
+function getVisibleWidth(value) {
+    return stripAnsi(value).length;
+}
+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 content = contentLines.map((line) => {
+        const padding = " ".repeat(contentWidth - getVisibleWidth(line));
+        return `${chalk.gray("│")}  ${line}${padding}${chalk.gray("│")}`;
+    });
+    const bottom = chalk.gray(`├${"─".repeat(contentWidth + 2)}╯`);
+    return [chalk.gray("│"), titleLine, ...content, bottom].join("\n");
+}
+export function note(message, title) {
+    const format = resolveOutputFormat();
+    const strippedMessage = stripAnsi(message);
+    const strippedTitle = stripAnsi(title ?? "");
+    if (format === "markdown") {
+        const lines = strippedMessage.split("\n");
+        const heading = strippedTitle ? `> **${strippedTitle}**\n` : "";
+        const body = lines.map((line) => `> ${line}`).join("\n");
+        process.stdout.write(`${heading}${body}\n`);
+        return;
+    }
+    if (format === "json") {
+        process.stdout.write(`${JSON.stringify({
+            type: "note",
+            title: strippedTitle,
+            message: strippedMessage
+        })}\n`);
+        return;
+    }
+    process.stdout.write(`${renderTerminalNote(message, title)}\n`);
+}

package/packages/design-system/dist/prompts/primitives/outro.d.ts

@@ -0,0 +1 @@
+export declare function outro(message: string): void;

package/packages/design-system/dist/prompts/primitives/outro.js

@@ -0,0 +1,16 @@
+import chalk from "chalk";
+import { resolveOutputFormat } from "../../internal/output-format.js";
+import { stripAnsi } from "../../internal/strip-ansi.js";
+export function outro(message) {
+    const format = resolveOutputFormat();
+    const stripped = stripAnsi(message);
+    if (format === "markdown") {
+        process.stdout.write(`---\n${stripped}\n`);
+        return;
+    }
+    if (format === "json") {
+        process.stdout.write(`${JSON.stringify({ type: "outro", message: stripped })}\n`);
+        return;
+    }
+    process.stdout.write(`${chalk.gray("│")}\n${chalk.gray("└")}  ${message}\n\n`);
+}

package/packages/design-system/dist/prompts/primitives/spinner.d.ts

@@ -0,0 +1,6 @@
+export interface SpinnerOptions {
+    start: (message?: string) => void;
+    stop: (message?: string, code?: number) => void;
+    message: (message?: string) => void;
+}
+export declare function spinner(): SpinnerOptions;

package/packages/design-system/dist/prompts/primitives/spinner.js

@@ -0,0 +1,74 @@
+import chalk from "chalk";
+import { resolveOutputFormat } from "../../internal/output-format.js";
+import { stripAnsi } from "../../internal/strip-ansi.js";
+import { SPINNER_FRAMES } from "../../static/spinner.js";
+function writeTerminalFrame(frame, message) {
+    process.stdout.write(`\r\x1b[K${frame}  ${message}`);
+}
+export function spinner() {
+    let currentMessage = "";
+    let frameIndex = 0;
+    let timer;
+    let fallback = false;
+    const format = resolveOutputFormat();
+    const renderFrame = () => {
+        writeTerminalFrame(SPINNER_FRAMES[frameIndex % SPINNER_FRAMES.length], currentMessage);
+    };
+    const clearTimer = () => {
+        if (!timer) {
+            return;
+        }
+        clearInterval(timer);
+        timer = undefined;
+    };
+    return {
+        start(message = "") {
+            currentMessage = stripAnsi(message);
+            if (format === "json") {
+                return;
+            }
+            if (format === "markdown") {
+                process.stdout.write(`- ${currentMessage}...\n`);
+                return;
+            }
+            fallback = process.env.POE_NO_SPINNER === "1" || !process.stdout.isTTY;
+            if (fallback) {
+                process.stdout.write(`${currentMessage}\n`);
+                return;
+            }
+            frameIndex = 0;
+            renderFrame();
+            timer = setInterval(() => {
+                frameIndex += 1;
+                renderFrame();
+            }, 16);
+        },
+        message(message = "") {
+            currentMessage = stripAnsi(message);
+            if (format !== "terminal" || fallback || !timer) {
+                return;
+            }
+            renderFrame();
+        },
+        stop(message = currentMessage, code) {
+            currentMessage = stripAnsi(message);
+            if (format === "json") {
+                process.stdout.write(`${JSON.stringify({ type: "spinner", state: "stopped", message: currentMessage })}\n`);
+                return;
+            }
+            if (format === "markdown") {
+                process.stdout.write(`- ${currentMessage}\n`);
+                return;
+            }
+            clearTimer();
+            const symbol = code === undefined || code === 0
+                ? chalk.green("◆")
+                : chalk.red("■");
+            if (fallback) {
+                process.stdout.write(`${symbol}  ${currentMessage}\n`);
+                return;
+            }
+            process.stdout.write(`\r\x1b[K${symbol}  ${currentMessage}\n`);
+        }
+    };
+}

package/packages/design-system/dist/prompts/theme.d.ts

@@ -0,0 +1,11 @@
+export declare const promptTheme: {
+    readonly symbols: {
+        readonly initial: "◆";
+        readonly active: "◆";
+        readonly inactive: "○";
+        readonly success: "◇";
+    };
+    readonly style: {
+        readonly accentColor: "#a200ff";
+    };
+};

package/packages/design-system/dist/prompts/theme.js

@@ -0,0 +1,12 @@
+import { brand } from "../tokens/colors.js";
+export const promptTheme = {
+    symbols: {
+        initial: "◆",
+        active: "◆",
+        inactive: "○",
+        success: "◇"
+    },
+    style: {
+        accentColor: brand
+    }
+};

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

@@ -0,0 +1,4 @@
+export { SPINNER_FRAMES, renderSpinnerFrame, renderSpinnerStopped } from "./spinner.js";
+export type { SpinnerFrameOptions, SpinnerStoppedOptions } from "./spinner.js";
+export { renderMenu } from "./menu.js";
+export type { MenuOption, RenderMenuOptions } from "./menu.js";

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

@@ -0,0 +1,2 @@
+export { SPINNER_FRAMES, renderSpinnerFrame, renderSpinnerStopped } from "./spinner.js";
+export { renderMenu } from "./menu.js";

package/packages/design-system/dist/static/menu.d.ts

@@ -0,0 +1,11 @@
+export interface MenuOption {
+    label: string;
+    value: string;
+    hint?: string;
+}
+export interface RenderMenuOptions {
+    message: string;
+    options: MenuOption[];
+    selectedIndex?: number;
+}
+export declare function renderMenu(opts: RenderMenuOptions): string;

package/packages/design-system/dist/static/menu.js

@@ -0,0 +1,36 @@
+import chalk from "chalk";
+import { symbols } from "../components/symbols.js";
+import { resolveOutputFormat } from "../internal/output-format.js";
+import { getTheme } from "../internal/theme-detect.js";
+export function renderMenu(opts) {
+    const format = resolveOutputFormat();
+    const selectedIndex = opts.selectedIndex ?? 0;
+    if (format === "markdown") {
+        return [
+            `**${opts.message}**`,
+            ...opts.options.map((option, index) => `- [${index === selectedIndex ? "x" : " "}] ${option.label}`)
+        ].join("\n");
+    }
+    if (format === "json") {
+        return JSON.stringify({
+            type: "menu",
+            message: opts.message,
+            options: opts.options,
+            selected: selectedIndex
+        });
+    }
+    const theme = getTheme();
+    const bar = chalk.gray(symbols.bar);
+    const lines = [];
+    lines.push(`${chalk.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 label = isSelected ? theme.accent(option.label) : option.label;
+        const hint = option.hint ? chalk.dim(` (${option.hint})`) : "";
+        lines.push(`${bar}  ${prefix} ${label}${hint}`);
+    });
+    lines.push(`${bar}`);
+    return lines.join("\n");
+}

package/packages/design-system/dist/static/spinner.d.ts

@@ -0,0 +1,14 @@
+export declare const SPINNER_FRAMES: readonly ["◒", "◐", "◓", "◑"];
+export interface SpinnerFrameOptions {
+    frame?: number;
+    message: string;
+    timer?: string;
+}
+export declare function renderSpinnerFrame(options: SpinnerFrameOptions): string;
+export interface SpinnerStoppedOptions {
+    message: string;
+    code?: number;
+    timer?: string;
+    subtext?: string;
+}
+export declare function renderSpinnerStopped(options: SpinnerStoppedOptions): string;

package/packages/design-system/dist/static/spinner.js

@@ -0,0 +1,46 @@
+import chalk from "chalk";
+import { symbols } from "../components/symbols.js";
+import { resolveOutputFormat } from "../internal/output-format.js";
+export const SPINNER_FRAMES = ["◒", "◐", "◓", "◑"];
+export function renderSpinnerFrame(options) {
+    const format = resolveOutputFormat();
+    if (format === "markdown") {
+        return `- ${options.message}${options.timer ? ` [${options.timer}]` : ""}...\n`;
+    }
+    if (format === "json") {
+        return `${JSON.stringify({
+            type: "spinner",
+            state: "running",
+            message: options.message,
+            ...(options.timer ? { timer: options.timer } : {})
+        })}\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);
+    return `${spinnerChar}  ${options.message}${timerSuffix}\n${bar}`;
+}
+export function renderSpinnerStopped(options) {
+    const format = resolveOutputFormat();
+    if (format === "markdown") {
+        return `- ${options.message}${options.timer ? ` [${options.timer}]` : ""}\n`;
+    }
+    if (format === "json") {
+        return `${JSON.stringify({
+            type: "spinner",
+            state: "stopped",
+            message: options.message,
+            ...(options.timer ? { timer: options.timer } : {})
+        })}\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);
+    let output = `${symbol}  ${options.message}${timerSuffix}`;
+    if (options.subtext) {
+        output += `\n${bar}     ${chalk.dim(options.subtext)}`;
+    }
+    return output;
+}

package/packages/design-system/dist/terminal-markdown/ast.d.ts

@@ -0,0 +1,84 @@
+export type MdNode = {
+    type: "root";
+    children: MdNode[];
+} | {
+    type: "heading";
+    depth: 1 | 2 | 3 | 4 | 5 | 6;
+    children: MdNode[];
+} | {
+    type: "paragraph";
+    children: MdNode[];
+} | {
+    type: "blockquote";
+    children: MdNode[];
+} | {
+    type: "code";
+    lang?: string;
+    meta?: string;
+    value: string;
+} | {
+    type: "list";
+    ordered: boolean;
+    start?: number;
+    children: MdNode[];
+} | {
+    type: "listItem";
+    checked?: boolean;
+    children: MdNode[];
+} | {
+    type: "thematicBreak";
+} | {
+    type: "table";
+    align: Array<"left" | "center" | "right" | null>;
+    children: MdNode[];
+} | {
+    type: "tableRow";
+    children: MdNode[];
+} | {
+    type: "tableCell";
+    children: MdNode[];
+} | {
+    type: "html";
+    value: string;
+} | {
+    type: "text";
+    value: string;
+} | {
+    type: "emphasis";
+    children: MdNode[];
+} | {
+    type: "strong";
+    children: MdNode[];
+} | {
+    type: "strikethrough";
+    children: MdNode[];
+} | {
+    type: "inlineCode";
+    value: string;
+} | {
+    type: "link";
+    url: string;
+    title?: string;
+    children: MdNode[];
+} | {
+    type: "image";
+    url: string;
+    alt: string;
+    title?: string;
+} | {
+    type: "break";
+} | {
+    type: "frontmatter";
+    data: Record<string, unknown>;
+} | {
+    type: "alert";
+    kind: "NOTE" | "TIP" | "IMPORTANT" | "WARNING" | "CAUTION";
+    children: MdNode[];
+} | {
+    type: "footnoteDefinition";
+    label: string;
+    children: MdNode[];
+} | {
+    type: "footnoteReference";
+    label: string;
+};

package/packages/design-system/dist/terminal-markdown/ast.js

@@ -0,0 +1 @@
+export {};

package/packages/design-system/dist/terminal-markdown/demo-content.d.ts

@@ -0,0 +1,2 @@
+export type MarkdownDemoName = "default" | "minimal" | "code-blocks" | "blockquotes" | "lists" | "tables" | "alerts";
+export declare function getMarkdownDemo(name?: MarkdownDemoName): string;