toolcraft-openapi 0.0.1

package/node_modules/@poe-code/design-system/dist/dashboard/terminal.js

@@ -0,0 +1,233 @@
+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 lineWrapEnabled = true;
+    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 disableLineWrap() {
+        if (destroyed || !lineWrapEnabled) {
+            return;
+        }
+        write("\u001b[?7l");
+        lineWrapEnabled = false;
+    }
+    function enableLineWrap() {
+        if (destroyed || lineWrapEnabled) {
+            return;
+        }
+        write("\u001b[?7h");
+        lineWrapEnabled = true;
+    }
+    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();
+        enableLineWrap();
+        exitAltScreen();
+        showCursor();
+        destroyed = true;
+    }
+    return {
+        enterRawMode,
+        exitRawMode,
+        enterAltScreen,
+        exitAltScreen,
+        disableLineWrap,
+        enableLineWrap,
+        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/node_modules/@poe-code/design-system/dist/dashboard/types.d.ts

@@ -0,0 +1,36 @@
+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;
+    iterationsLabel?: string;
+    tokensIn: number;
+    tokensOut: number;
+    elapsedMs: number;
+    currentAction?: string;
+};
+export type Command = "quit" | "forceQuit" | "edit" | "pause" | "retry" | "view-log";
+export type DashboardState = {
+    output: OutputItem[];
+    stats: DashboardStats;
+};
+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/node_modules/@poe-code/design-system/dist/dashboard/types.js

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

package/node_modules/@poe-code/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, shouldUseInteractiveDashboard } 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/node_modules/@poe-code/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, shouldUseInteractiveDashboard } 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/node_modules/@poe-code/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/node_modules/@poe-code/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/node_modules/@poe-code/design-system/dist/internal/strip-ansi.d.ts

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

package/node_modules/@poe-code/design-system/dist/internal/strip-ansi.js

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

package/node_modules/@poe-code/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/node_modules/@poe-code/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/node_modules/@poe-code/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>;

package/node_modules/@poe-code/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/node_modules/@poe-code/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/node_modules/@poe-code/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/node_modules/@poe-code/design-system/dist/prompts/primitives/intro.d.ts

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

package/node_modules/@poe-code/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`);
+}