poe-code 3.0.178 → 3.0.180

package/packages/design-system/dist/dashboard/store.js

@@ -0,0 +1,107 @@
+import { scrollDown, scrollToBottom, scrollToTop, scrollUp } from "./components/output-pane.js";
+export function createStore() {
+    let state = {
+        output: [],
+        outputScroll: 0,
+        autoFollow: true,
+        stats: {
+            status: "idle",
+            iterations: 0,
+            tokensIn: 0,
+            tokensOut: 0,
+            elapsedMs: 0
+        },
+        paused: false,
+        activeDialog: { kind: "none" }
+    };
+    const listeners = new Set();
+    function notify() {
+        for (const listener of listeners) {
+            listener();
+        }
+    }
+    function getState() {
+        return state;
+    }
+    function appendOutput(item) {
+        const output = [...state.output, item];
+        state = {
+            ...state,
+            output,
+            outputScroll: state.autoFollow ? Math.max(0, output.length - 1) : state.outputScroll
+        };
+        notify();
+    }
+    function updateStats(partial) {
+        state = {
+            ...state,
+            stats: {
+                ...state.stats,
+                ...partial
+            }
+        };
+        notify();
+    }
+    function dispatch(command, paneHeight) {
+        const totalVisualLines = state.output.length;
+        const currentPaneState = state.autoFollow
+            ? toStateFromPane(state, scrollToBottom(toPaneState(state), totalVisualLines, paneHeight))
+            : state;
+        if (command === "scrollUp") {
+            state = toStateFromPane(currentPaneState, scrollUp(toPaneState(currentPaneState), 1));
+            notify();
+            return;
+        }
+        if (command === "scrollDown") {
+            state = toStateFromPane(currentPaneState, scrollDown(toPaneState(currentPaneState), 1, totalVisualLines));
+            notify();
+            return;
+        }
+        if (command === "pageUp") {
+            state = toStateFromPane(currentPaneState, scrollUp(toPaneState(currentPaneState), paneHeight));
+            notify();
+            return;
+        }
+        if (command === "pageDown") {
+            state = toStateFromPane(currentPaneState, scrollDown(toPaneState(currentPaneState), paneHeight, totalVisualLines));
+            notify();
+            return;
+        }
+        if (command === "scrollToTop") {
+            state = toStateFromPane(currentPaneState, scrollToTop(toPaneState(currentPaneState)));
+            notify();
+            return;
+        }
+        if (command === "scrollToBottom") {
+            state = toStateFromPane(currentPaneState, scrollToBottom(toPaneState(currentPaneState), totalVisualLines, paneHeight));
+            notify();
+        }
+    }
+    function onChange(handler) {
+        listeners.add(handler);
+        return () => {
+            listeners.delete(handler);
+        };
+    }
+    return {
+        getState,
+        appendOutput,
+        updateStats,
+        dispatch,
+        onChange
+    };
+}
+function toPaneState(state) {
+    return {
+        items: state.output,
+        scrollOffset: state.outputScroll,
+        autoFollow: state.autoFollow
+    };
+}
+function toStateFromPane(state, paneState) {
+    return {
+        ...state,
+        outputScroll: paneState.scrollOffset,
+        autoFollow: paneState.autoFollow
+    };
+}

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

@@ -0,0 +1,35 @@
+import type { Cell } from "./types.js";
+export type KeypressEvent = {
+    name?: string;
+    ch?: string;
+    ctrl: boolean;
+    meta: boolean;
+    shift: boolean;
+};
+export type TerminalDriver = {
+    enterRawMode(): void;
+    exitRawMode(): void;
+    enterAltScreen(): void;
+    exitAltScreen(): void;
+    hideCursor(): void;
+    showCursor(): void;
+    moveTo(x: number, y: number): void;
+    write(text: string): void;
+    flush(changes: Array<{
+        x: number;
+        y: number;
+        cell: Cell;
+    }>): void;
+    getSize(): {
+        cols: number;
+        rows: number;
+    };
+    onResize(handler: () => void): () => void;
+    onKeypress(handler: (key: KeypressEvent) => void): () => void;
+    destroy(): void;
+};
+export declare function createTerminalDriver(opts?: {
+    stdin?: NodeJS.ReadStream;
+    stdout?: NodeJS.WriteStream;
+}): TerminalDriver;
+export declare function parseKeypress(data: Buffer): KeypressEvent | undefined;

package/packages/design-system/dist/dashboard/terminal.js

@@ -0,0 +1,215 @@
+import readline from "node:readline";
+import { PassThrough } from "node:stream";
+import { cellToAnsi } from "./buffer.js";
+export function createTerminalDriver(opts) {
+    const stdin = (opts?.stdin ?? process.stdin);
+    const stdout = (opts?.stdout ?? process.stdout);
+    const resizeListeners = new Set();
+    const keypressListeners = new Set();
+    let rawMode = false;
+    let altScreen = false;
+    let cursorHidden = false;
+    let destroyed = false;
+    readline.emitKeypressEvents(stdin);
+    function enterRawMode() {
+        if (destroyed || rawMode) {
+            return;
+        }
+        stdin.setRawMode?.(true);
+        stdin.resume();
+        rawMode = true;
+    }
+    function exitRawMode() {
+        if (destroyed || !rawMode) {
+            return;
+        }
+        stdin.setRawMode?.(false);
+        stdin.pause();
+        rawMode = false;
+    }
+    function enterAltScreen() {
+        if (destroyed || altScreen) {
+            return;
+        }
+        write("\u001b[?1049h");
+        altScreen = true;
+    }
+    function exitAltScreen() {
+        if (destroyed || !altScreen) {
+            return;
+        }
+        write("\u001b[?1049l");
+        altScreen = false;
+    }
+    function hideCursor() {
+        if (destroyed || cursorHidden) {
+            return;
+        }
+        write("\u001b[?25l");
+        cursorHidden = true;
+    }
+    function showCursor() {
+        if (destroyed || !cursorHidden) {
+            return;
+        }
+        write("\u001b[?25h");
+        cursorHidden = false;
+    }
+    function moveTo(x, y) {
+        if (destroyed) {
+            return;
+        }
+        write(cursorPositionAnsi(x, y));
+    }
+    function write(text) {
+        if (destroyed || text.length === 0) {
+            return;
+        }
+        stdout.write(text);
+    }
+    function flush(changes) {
+        if (destroyed || changes.length === 0) {
+            return;
+        }
+        let output = "";
+        for (const change of changes) {
+            output += `${cursorPositionAnsi(change.x, change.y)}${cellToAnsi(change.cell)}`;
+        }
+        write(output);
+    }
+    function getSize() {
+        return {
+            cols: normalizeSize(stdout.columns),
+            rows: normalizeSize(stdout.rows)
+        };
+    }
+    function onResize(handler) {
+        if (destroyed) {
+            return () => { };
+        }
+        const listener = () => {
+            handler();
+        };
+        resizeListeners.add(listener);
+        stdout.on("resize", listener);
+        return () => {
+            if (!resizeListeners.delete(listener)) {
+                return;
+            }
+            stdout.off("resize", listener);
+        };
+    }
+    function onKeypress(handler) {
+        if (destroyed) {
+            return () => { };
+        }
+        const listener = (str, key) => {
+            const event = toKeypressEvent(str, key);
+            if (event !== undefined) {
+                handler(event);
+            }
+        };
+        keypressListeners.add(listener);
+        stdin.on("keypress", listener);
+        return () => {
+            if (!keypressListeners.delete(listener)) {
+                return;
+            }
+            stdin.off("keypress", listener);
+        };
+    }
+    function destroy() {
+        if (destroyed) {
+            return;
+        }
+        for (const listener of keypressListeners) {
+            stdin.off("keypress", listener);
+        }
+        keypressListeners.clear();
+        for (const listener of resizeListeners) {
+            stdout.off("resize", listener);
+        }
+        resizeListeners.clear();
+        exitRawMode();
+        exitAltScreen();
+        showCursor();
+        destroyed = true;
+    }
+    return {
+        enterRawMode,
+        exitRawMode,
+        enterAltScreen,
+        exitAltScreen,
+        hideCursor,
+        showCursor,
+        moveTo,
+        write,
+        flush,
+        getSize,
+        onResize,
+        onKeypress,
+        destroy
+    };
+}
+export function parseKeypress(data) {
+    if (data.length === 0) {
+        return undefined;
+    }
+    const stream = new PassThrough();
+    const stdin = stream;
+    let event;
+    readline.emitKeypressEvents(stdin);
+    stdin.on("keypress", (str, key) => {
+        event = toKeypressEvent(str, key);
+    });
+    stream.emit("data", data);
+    stream.destroy();
+    return event;
+}
+function toKeypressEvent(str, key) {
+    const ctrl = key?.ctrl ?? false;
+    const meta = key?.meta ?? false;
+    const shift = key?.shift ?? false;
+    const ch = extractPrintableCharacter(str, key?.sequence);
+    if (ch !== undefined) {
+        return { ch, ctrl, meta, shift };
+    }
+    if (key?.name === undefined) {
+        return undefined;
+    }
+    return {
+        name: key.name,
+        ctrl,
+        meta,
+        shift
+    };
+}
+function extractPrintableCharacter(str, sequence) {
+    if (isPrintableCharacter(str)) {
+        return str;
+    }
+    if (sequence === undefined || sequence.length <= 1 || sequence[0] !== "\u001b") {
+        return undefined;
+    }
+    const candidate = sequence.slice(1);
+    return isPrintableCharacter(candidate) ? candidate : undefined;
+}
+function isPrintableCharacter(value) {
+    if (value === undefined || Array.from(value).length !== 1) {
+        return false;
+    }
+    const codePoint = value.codePointAt(0);
+    return codePoint !== undefined && codePoint >= 0x20 && codePoint !== 0x7f;
+}
+function cursorPositionAnsi(x, y) {
+    return `\u001b[${normalizeCoordinate(y) + 1};${normalizeCoordinate(x) + 1}H`;
+}
+function normalizeCoordinate(value) {
+    return Math.max(0, Math.floor(value));
+}
+function normalizeSize(value) {
+    if (value === undefined || !Number.isFinite(value)) {
+        return 0;
+    }
+    return Math.max(0, Math.floor(value));
+}

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

@@ -0,0 +1,45 @@
+export type OutputItemKind = "info" | "success" | "error" | "tool" | "status";
+export type OutputItem = {
+    kind: OutputItemKind;
+    text: string;
+    ts: number;
+};
+export type DashboardStats = {
+    status: "idle" | "running" | "paused" | "done" | "error";
+    iterations: number;
+    tokensIn: number;
+    tokensOut: number;
+    elapsedMs: number;
+    currentAction?: string;
+};
+export type Command = "quit" | "edit" | "pause" | "retry" | "scrollUp" | "scrollDown" | "pageUp" | "pageDown" | "scrollToTop" | "scrollToBottom";
+export type DialogState = {
+    kind: "none";
+} | {
+    kind: "edit";
+    initialValue: string;
+};
+export type DashboardState = {
+    output: OutputItem[];
+    outputScroll: number;
+    autoFollow: boolean;
+    stats: DashboardStats;
+    paused: boolean;
+    activeDialog: DialogState;
+};
+export type CellStyle = {
+    fg?: string;
+    bg?: string;
+    bold?: boolean;
+    dim?: boolean;
+};
+export type Cell = {
+    ch: string;
+    style: CellStyle;
+};
+export type Rect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};

package/packages/design-system/dist/dashboard/types.js

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

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

@@ -0,0 +1,33 @@
+export * as tokens from "./tokens/index.js";
+export { brand, dark, light } from "./tokens/colors.js";
+export type { ThemeName, ThemePalette } from "./tokens/colors.js";
+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 { symbols } from "./components/symbols.js";
+export { createLogger, logger } from "./components/logger.js";
+export type { LoggerOutput } from "./components/logger.js";
+export { helpFormatter, formatCommand, formatUsage, formatOption, formatCommandList, formatOptionList } from "./components/help-formatter.js";
+export type { CommandInfo, OptionInfo } from "./components/help-formatter.js";
+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 * as acp from "./acp/index.js";
+export * as dashboard from "./dashboard/index.js";
+export { createDashboard } from "./dashboard/index.js";
+export type { Dashboard, DashboardOptions } from "./dashboard/index.js";
+export * as prompts from "./prompts/index.js";
+export { intro, introPlain, outro, note, select, multiselect, text as promptText, confirm, confirmOrCancel, password, spinner, withSpinner, isCancel, cancel, log, PromptCancelledError } from "./prompts/index.js";
+export type { SelectOptions, MultiselectOptions, TextOptions, ConfirmOptions, PasswordOptions, SpinnerOptions, WithSpinnerOptions } from "./prompts/index.js";
+export { promptTheme } from "./prompts/theme.js";
+export * as staticRender from "./static/index.js";
+export { SPINNER_FRAMES, renderSpinnerFrame, renderSpinnerStopped, renderMenu } from "./static/index.js";
+export type { SpinnerFrameOptions, SpinnerStoppedOptions, MenuOption, RenderMenuOptions } from "./static/index.js";
+export { parse, render, renderMarkdown } from "./terminal-markdown/index.js";
+export type { MdNode, RenderOptions } from "./terminal-markdown/index.js";
+export { getTheme, resolveThemeName, resetThemeCache } from "./internal/theme-detect.js";
+export type { ThemeEnv } from "./internal/theme-detect.js";
+export { resolveOutputFormat, resetOutputFormatCache, withOutputFormat } from "./internal/output-format.js";
+export type { OutputFormat } from "./internal/output-format.js";

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

@@ -0,0 +1,31 @@
+// Tokens
+export * as tokens from "./tokens/index.js";
+export { brand, dark, light } from "./tokens/colors.js";
+export { spacing } from "./tokens/spacing.js";
+export { typography } from "./tokens/typography.js";
+export { widths } from "./tokens/widths.js";
+// Components
+export { text } from "./components/text.js";
+export { symbols } from "./components/symbols.js";
+export { createLogger, logger } from "./components/logger.js";
+export { helpFormatter, formatCommand, formatUsage, formatOption, formatCommandList, formatOptionList } from "./components/help-formatter.js";
+export { formatCommandNotFound } from "./components/command-errors.js";
+export { formatCommandNotFoundPanel } from "./components/command-errors.js";
+export { renderTable } from "./components/table.js";
+// ACP rendering
+export * as acp from "./acp/index.js";
+// Dashboard
+export * as dashboard from "./dashboard/index.js";
+export { createDashboard } from "./dashboard/index.js";
+// Prompts
+export * as prompts from "./prompts/index.js";
+export { intro, introPlain, outro, note, select, multiselect, text as promptText, confirm, confirmOrCancel, password, spinner, withSpinner, isCancel, cancel, log, PromptCancelledError } from "./prompts/index.js";
+export { promptTheme } from "./prompts/theme.js";
+// Static rendering
+export * as staticRender from "./static/index.js";
+export { SPINNER_FRAMES, renderSpinnerFrame, renderSpinnerStopped, renderMenu } from "./static/index.js";
+// Terminal markdown
+export { parse, render, renderMarkdown } from "./terminal-markdown/index.js";
+// Internal utilities (for advanced use)
+export { getTheme, resolveThemeName, resetThemeCache } from "./internal/theme-detect.js";
+export { resolveOutputFormat, resetOutputFormatCache, withOutputFormat } from "./internal/output-format.js";

package/packages/design-system/dist/internal/output-format.d.ts

@@ -0,0 +1,6 @@
+export type OutputFormat = "terminal" | "markdown" | "json";
+export declare function resolveOutputFormat(env?: {
+    OUTPUT_FORMAT?: string;
+}): OutputFormat;
+export declare function withOutputFormat<T>(format: OutputFormat, fn: () => T): T;
+export declare function resetOutputFormatCache(): void;

package/packages/design-system/dist/internal/output-format.js

@@ -0,0 +1,22 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+const VALID_FORMATS = new Set(["terminal", "markdown", "json"]);
+const formatStorage = new AsyncLocalStorage();
+let cached;
+export function resolveOutputFormat(env = process.env) {
+    const scoped = formatStorage.getStore();
+    if (scoped) {
+        return scoped;
+    }
+    if (cached) {
+        return cached;
+    }
+    const raw = env.OUTPUT_FORMAT?.toLowerCase();
+    cached = VALID_FORMATS.has(raw) ? raw : "terminal";
+    return cached;
+}
+export function withOutputFormat(format, fn) {
+    return formatStorage.run(format, fn);
+}
+export function resetOutputFormatCache() {
+    cached = undefined;
+}

package/packages/design-system/dist/internal/strip-ansi.d.ts

@@ -0,0 +1 @@
+export declare function stripAnsi(value: string): string;

package/packages/design-system/dist/internal/strip-ansi.js

@@ -0,0 +1,3 @@
+export function stripAnsi(value) {
+    return value.replace(/\u001b\[[0-9;]*m/g, "");
+}

package/packages/design-system/dist/internal/theme-detect.d.ts

@@ -0,0 +1,11 @@
+import { type ThemeName, type ThemePalette } from "../tokens/colors.js";
+export interface ThemeEnv {
+    POE_CODE_THEME?: string;
+    POE_THEME?: string;
+    APPLE_INTERFACE_STYLE?: string;
+    VSCODE_COLOR_THEME_KIND?: string;
+    COLORFGBG?: string;
+}
+export declare function resolveThemeName(env?: ThemeEnv): ThemeName;
+export declare function getTheme(env?: ThemeEnv): ThemePalette;
+export declare function resetThemeCache(): void;

package/packages/design-system/dist/internal/theme-detect.js

@@ -0,0 +1,49 @@
+import { dark, light } from "../tokens/colors.js";
+function detectThemeFromEnv(env) {
+    const apple = env.APPLE_INTERFACE_STYLE;
+    if (typeof apple === "string") {
+        return apple.toLowerCase() === "dark" ? "dark" : "light";
+    }
+    const vscodeKind = env.VSCODE_COLOR_THEME_KIND;
+    if (typeof vscodeKind === "string") {
+        const normalized = vscodeKind.toLowerCase();
+        if (normalized.includes("light")) {
+            return "light";
+        }
+        if (normalized.includes("dark")) {
+            return "dark";
+        }
+    }
+    const colorFGBG = env.COLORFGBG;
+    if (typeof colorFGBG === "string") {
+        const parts = colorFGBG.split(";").map((part) => Number.parseInt(part, 10));
+        const background = parts.at(-1);
+        if (Number.isFinite(background)) {
+            return background >= 8 ? "light" : "dark";
+        }
+    }
+    return undefined;
+}
+export function resolveThemeName(env = process.env) {
+    const raw = (env.POE_CODE_THEME ?? env.POE_THEME)?.toLowerCase();
+    if (raw === "light" || raw === "dark") {
+        return raw;
+    }
+    const detected = detectThemeFromEnv(env);
+    if (detected) {
+        return detected;
+    }
+    return "dark";
+}
+let cachedTheme;
+export function getTheme(env) {
+    if (cachedTheme) {
+        return cachedTheme;
+    }
+    const themeName = resolveThemeName(env);
+    cachedTheme = themeName === "light" ? light : dark;
+    return cachedTheme;
+}
+export function resetThemeCache() {
+    cachedTheme = undefined;
+}

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

@@ -0,0 +1,66 @@
+import * as clack from "@clack/prompts";
+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 declare function introPlain(title: string): void;
+export interface SelectOptions<Value> {
+    message: string;
+    options: Array<{
+        value: Value;
+        label: string;
+        hint?: string;
+    }>;
+    initialValue?: Value;
+}
+export declare function select<Value>(opts: SelectOptions<Value>): Promise<Value | symbol>;
+export type MultiselectOptions<Value> = Parameters<typeof clack.multiselect<Value>>[0];
+/**
+ * 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 declare function multiselect<Value>(opts: MultiselectOptions<Value>): Promise<Value[] | symbol>;
+export type TextOptions = Parameters<typeof clack.text>[0];
+export declare function text(opts: TextOptions): Promise<string | symbol>;
+export interface ConfirmOptions {
+    message: string;
+    initialValue?: boolean;
+}
+export declare function confirm(opts: ConfirmOptions): Promise<boolean | symbol>;
+export declare class PromptCancelledError extends Error {
+    constructor(message?: string);
+}
+export declare function confirmOrCancel(opts: ConfirmOptions): Promise<boolean>;
+export interface PasswordOptions {
+    message: string;
+    validate?: (value: string) => string | undefined;
+}
+export declare function password(opts: PasswordOptions): Promise<string | symbol>;
+export type SpinnerOptions = {
+    start: (message?: string) => void;
+    stop: (message?: string, code?: number) => void;
+    message: (message?: string) => void;
+};
+export interface WithSpinnerOptions<T> {
+    message: string;
+    fn: () => Promise<T>;
+    stopMessage?: (result: T) => string;
+    subtext?: (result: T) => string | undefined;
+}
+export declare function withSpinner<T>(options: WithSpinnerOptions<T>): Promise<T>;