toolcraft-openapi 0.0.17 → 0.0.19

package/node_modules/@poe-code/design-system/dist/explorer/runtime.js

@@ -0,0 +1,282 @@
+import { ScreenBuffer, cellToAnsi, diff } from "../dashboard/buffer.js";
+import { createTerminalDriver } from "../dashboard/terminal.js";
+import { createDetailJobs } from "./jobs.js";
+import { computeExplorerLayout } from "./layout.js";
+import { renderExplorer } from "./render/index.js";
+import { step } from "./reducer.js";
+import { createInitialState, REGION_ALL, REGION_MODAL, REGION_TOAST } from "./state.js";
+const TOAST_MS = 2500;
+export async function runExplorer(config) {
+    if (process.stdout.isTTY !== true) {
+        throw new Error("explorer requires a TTY");
+    }
+    const driver = createTerminalDriver();
+    const runtime = new ExplorerRuntime(config, driver);
+    return runtime.run();
+}
+class ExplorerRuntime {
+    config;
+    driver;
+    state;
+    previousBuffer = new ScreenBuffer(0, 0);
+    detailJobs;
+    runtimeHandles;
+    pendingEffects = new Set();
+    unsubscribeKeypress;
+    unsubscribeResize;
+    toastTimer;
+    stopped = false;
+    settle;
+    constructor(config, driver) {
+        this.config = config;
+        this.driver = driver;
+        this.state = createInitialState(config, driver.getSize());
+        this.detailJobs = createDetailJobs((event) => {
+            this.dispatch(event);
+        });
+        this.runtimeHandles = {
+            refresh: async () => {
+                await this.refreshRows();
+            },
+            suspendAnd: async (fn) => this.suspendAnd(fn),
+            toast: (msg, tone) => {
+                this.showToast(msg, tone);
+            },
+            confirm: async (prompt) => this.confirm(prompt),
+            exit: (after) => {
+                this.exit(null, after);
+            }
+        };
+    }
+    run() {
+        return new Promise((resolve, reject) => {
+            this.settle = { resolve, reject };
+            try {
+                this.startTerminal();
+                this.render();
+                this.refreshRows().catch((error) => {
+                    this.fail(error);
+                });
+            }
+            catch (error) {
+                this.fail(error);
+            }
+        });
+    }
+    startTerminal() {
+        this.driver.enterRawMode();
+        this.driver.enterAltScreen();
+        this.driver.disableLineWrap();
+        this.driver.hideCursor();
+        this.unsubscribeKeypress = this.driver.onKeypress((key) => {
+            this.dispatch({ type: "key", key });
+        });
+        this.unsubscribeResize = this.driver.onResize(() => {
+            const size = this.driver.getSize();
+            this.dispatch({ type: "resize", cols: size.cols, rows: size.rows });
+        });
+    }
+    async refreshRows() {
+        const rows = await this.config.rows();
+        this.dispatch({ type: "rowsLoaded", rows });
+    }
+    dispatch(event) {
+        if (this.stopped) {
+            return;
+        }
+        const previousState = this.state;
+        const next = step(this.state, event, this.runtimeHandles);
+        this.state = next.state;
+        this.render();
+        this.applyEffects(next.effects, previousState);
+    }
+    applyEffects(effects, previousState) {
+        for (const effect of effects) {
+            if (effect.type === "renderDetail") {
+                this.renderDetail(effect.rowId);
+                continue;
+            }
+            if (effect.type === "persistOrder") {
+                this.track(this.persistOrder(effect.orderedIds, previousState.rows));
+                continue;
+            }
+            if (effect.type === "suspend") {
+                this.track(this.runActionEffect(effect));
+                continue;
+            }
+            if (effect.type === "exit") {
+                this.exit(effect.result, effect.after);
+            }
+        }
+    }
+    renderDetail(rowId) {
+        const row = this.state.rows.find((candidate) => candidate.id === rowId);
+        if (row === undefined) {
+            return;
+        }
+        const layout = computeExplorerLayout({
+            cols: this.state.size.cols,
+            rows: this.state.size.rows,
+            detailHidden: this.state.layout === "narrow-list-only" || this.state.layout === "too-narrow"
+        });
+        void this.detailJobs.schedule(rowId, (ctx) => this.config.detail.items(row, ctx), {
+            width: layout.detail.width,
+            height: layout.detail.height,
+            row,
+            signal: new AbortController().signal
+        });
+    }
+    async persistOrder(orderedIds, previousRows) {
+        try {
+            await this.config.reorder?.onReorder(orderedIds);
+        }
+        catch (error) {
+            this.showToast(error instanceof Error ? error.message : "Could not persist order", "error");
+            this.dispatch({ type: "rowsLoaded", rows: previousRows });
+        }
+    }
+    async runActionEffect(effect) {
+        try {
+            const value = await effect.fn();
+            this.dispatch(effect.resumeWith(value));
+        }
+        catch (error) {
+            this.showToast(error instanceof Error ? error.message : "Action failed", "error");
+            this.dispatch(effect.resumeWith(error));
+        }
+    }
+    async suspendAnd(fn) {
+        this.driver.exitAltScreen();
+        this.driver.enableLineWrap();
+        this.driver.showCursor();
+        this.driver.exitRawMode();
+        try {
+            return await fn();
+        }
+        finally {
+            if (!this.stopped) {
+                this.driver.enterRawMode();
+                this.driver.enterAltScreen();
+                this.driver.disableLineWrap();
+                this.driver.hideCursor();
+                const size = this.driver.getSize();
+                this.dispatch({
+                    type: "suspendResumed",
+                    value: null,
+                    emit: { type: "resize", cols: size.cols, rows: size.rows }
+                });
+            }
+        }
+    }
+    confirm(prompt) {
+        return new Promise((resolve) => {
+            const action = {
+                id: "__confirm__",
+                label: prompt,
+                handler: () => undefined
+            };
+            const row = this.currentRow();
+            this.state = {
+                ...this.state,
+                modal: {
+                    kind: "confirm",
+                    action,
+                    rows: row === undefined ? [] : [row],
+                    resolver: resolve
+                },
+                dirty: REGION_MODAL
+            };
+            this.render();
+        });
+    }
+    showToast(message, tone = "info") {
+        if (this.stopped) {
+            return;
+        }
+        if (this.toastTimer !== undefined) {
+            clearTimeout(this.toastTimer);
+        }
+        this.state = {
+            ...this.state,
+            toast: { message, tone, expiresAt: Date.now() + TOAST_MS },
+            dirty: REGION_TOAST
+        };
+        this.render();
+        this.toastTimer = setTimeout(() => {
+            this.dispatch({ type: "toastExpired" });
+        }, TOAST_MS);
+    }
+    currentRow() {
+        return this.state.rows[this.state.filtered[this.state.cursor] ?? -1];
+    }
+    render() {
+        if (this.stopped) {
+            return;
+        }
+        const size = this.driver.getSize();
+        if (size.cols !== this.state.size.cols || size.rows !== this.state.size.rows) {
+            this.state = step(this.state, { type: "resize", cols: size.cols, rows: size.rows }, this.runtimeHandles).state;
+        }
+        const nextBuffer = this.state.dirty === REGION_ALL
+            ? new ScreenBuffer(this.state.size.cols, this.state.size.rows)
+            : cloneBuffer(this.previousBuffer);
+        renderExplorer(this.state, nextBuffer);
+        this.driver.write(changesToAnsi(diff(this.previousBuffer, nextBuffer)));
+        this.previousBuffer = nextBuffer;
+        this.state = { ...this.state, dirty: 0 };
+    }
+    track(promise) {
+        this.pendingEffects.add(promise);
+        promise.finally(() => {
+            this.pendingEffects.delete(promise);
+        });
+    }
+    exit(result, after) {
+        if (this.stopped) {
+            return;
+        }
+        this.stopped = true;
+        this.unsubscribeKeypress?.();
+        this.unsubscribeResize?.();
+        this.detailJobs.abort();
+        if (this.toastTimer !== undefined) {
+            clearTimeout(this.toastTimer);
+        }
+        this.driver.destroy();
+        Promise.resolve()
+            .then(() => after?.())
+            .then(() => {
+            this.settle?.resolve(result);
+        })
+            .catch((error) => {
+            this.settle?.reject(error);
+        });
+    }
+    fail(error) {
+        if (!this.stopped) {
+            this.stopped = true;
+            this.driver.destroy();
+        }
+        this.settle?.reject(error);
+    }
+}
+function cloneBuffer(buffer) {
+    const next = new ScreenBuffer(buffer.width, buffer.height);
+    for (let y = 0; y < buffer.height; y += 1) {
+        for (let x = 0; x < buffer.width; x += 1) {
+            const cell = buffer.get(x, y);
+            next.put(x, y, cell.ch, cell.style);
+        }
+    }
+    return next;
+}
+function changesToAnsi(changes) {
+    let output = "";
+    for (const change of changes) {
+        output += `${cursorPositionAnsi(change.x, change.y)}${cellToAnsi(change.cell)}`;
+    }
+    return output;
+}
+function cursorPositionAnsi(x, y) {
+    return `\u001b[${Math.max(1, y + 1)};${Math.max(1, x + 1)}H`;
+}

package/node_modules/@poe-code/design-system/dist/explorer/runtime.test-helpers.d.ts

@@ -0,0 +1,50 @@
+import type { Cell } from "../dashboard/types.js";
+import type { KeypressEvent, TerminalDriver } from "../dashboard/terminal.js";
+export declare class FakeTerminalDriver implements TerminalDriver {
+    private cols;
+    private rows;
+    readonly keyQueue: KeypressEvent[];
+    readonly writes: string[];
+    readonly flushes: Array<Array<{
+        x: number;
+        y: number;
+        cell: Cell;
+    }>>;
+    rawMode: boolean;
+    altScreen: boolean;
+    lineWrap: boolean;
+    cursorVisible: boolean;
+    destroyed: boolean;
+    enterAltScreenCount: number;
+    exitAltScreenCount: number;
+    enterRawModeCount: number;
+    exitRawModeCount: number;
+    private readonly keypressHandlers;
+    private readonly resizeHandlers;
+    constructor(cols?: number, rows?: number);
+    get output(): string;
+    enterRawMode(): void;
+    exitRawMode(): void;
+    enterAltScreen(): void;
+    exitAltScreen(): void;
+    disableLineWrap(): void;
+    enableLineWrap(): 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;
+    };
+    resize(cols: number, rows: number): void;
+    onResize(handler: () => void): () => void;
+    onKeypress(handler: (key: KeypressEvent) => void): () => void;
+    press(key: KeypressEvent): void;
+    destroy(): void;
+}

package/node_modules/@poe-code/design-system/dist/explorer/runtime.test-helpers.js

@@ -0,0 +1,101 @@
+export class FakeTerminalDriver {
+    cols;
+    rows;
+    keyQueue = [];
+    writes = [];
+    flushes = [];
+    rawMode = false;
+    altScreen = false;
+    lineWrap = true;
+    cursorVisible = true;
+    destroyed = false;
+    enterAltScreenCount = 0;
+    exitAltScreenCount = 0;
+    enterRawModeCount = 0;
+    exitRawModeCount = 0;
+    keypressHandlers = new Set();
+    resizeHandlers = new Set();
+    constructor(cols = 120, rows = 24) {
+        this.cols = cols;
+        this.rows = rows;
+    }
+    get output() {
+        return this.writes.join("");
+    }
+    enterRawMode() {
+        this.rawMode = true;
+        this.enterRawModeCount += 1;
+    }
+    exitRawMode() {
+        this.rawMode = false;
+        this.exitRawModeCount += 1;
+    }
+    enterAltScreen() {
+        this.altScreen = true;
+        this.enterAltScreenCount += 1;
+    }
+    exitAltScreen() {
+        this.altScreen = false;
+        this.exitAltScreenCount += 1;
+    }
+    disableLineWrap() {
+        this.lineWrap = false;
+    }
+    enableLineWrap() {
+        this.lineWrap = true;
+    }
+    hideCursor() {
+        this.cursorVisible = false;
+    }
+    showCursor() {
+        this.cursorVisible = true;
+    }
+    moveTo(x, y) {
+        this.write(`\u001b[${Math.max(1, y + 1)};${Math.max(1, x + 1)}H`);
+    }
+    write(text) {
+        if (!this.destroyed) {
+            this.writes.push(text);
+        }
+    }
+    flush(changes) {
+        this.flushes.push(changes);
+    }
+    getSize() {
+        return { cols: this.cols, rows: this.rows };
+    }
+    resize(cols, rows) {
+        this.cols = cols;
+        this.rows = rows;
+        for (const handler of this.resizeHandlers) {
+            handler();
+        }
+    }
+    onResize(handler) {
+        this.resizeHandlers.add(handler);
+        return () => {
+            this.resizeHandlers.delete(handler);
+        };
+    }
+    onKeypress(handler) {
+        this.keypressHandlers.add(handler);
+        return () => {
+            this.keypressHandlers.delete(handler);
+        };
+    }
+    press(key) {
+        this.keyQueue.push(key);
+        for (const handler of this.keypressHandlers) {
+            handler(key);
+        }
+    }
+    destroy() {
+        this.destroyed = true;
+        this.rawMode = false;
+        this.lineWrap = true;
+        this.altScreen = false;
+        this.cursorVisible = true;
+        this.keypressHandlers.clear();
+        this.resizeHandlers.clear();
+    }
+}

package/node_modules/@poe-code/design-system/dist/explorer/state.d.ts

@@ -0,0 +1,130 @@
+import { type ResolvedBindings } from "./keymap.js";
+export type Tone = "success" | "warning" | "error" | "info" | "muted";
+export interface Row {
+    id: string;
+    title: string;
+    subtitle?: string;
+    badge?: {
+        text: string;
+        tone?: Tone;
+    };
+    group?: string;
+}
+export interface DetailItem {
+    id: string;
+    title?: string;
+    subtitle?: string;
+    badge?: {
+        text: string;
+        tone?: Tone;
+    };
+    render: (ctx: DetailCtx) => string | Promise<string>;
+}
+export interface Detail<R> {
+    items: (row: Row, ctx: DetailCtx) => Promise<DetailItem[]>;
+    actions?: Action<R>[];
+}
+export interface DetailCtx {
+    width: number;
+    height: number;
+    signal: AbortSignal;
+    row: Row;
+}
+export interface Action<R> {
+    id: string;
+    label: string | (() => string);
+    key?: string | string[];
+    predicate?: (ctx: ActionContext<R>) => boolean;
+    handler: (ctx: ActionContext<R>) => void | Promise<void>;
+    destructive?: boolean;
+    primary?: boolean;
+    showInFooter?: boolean;
+}
+export interface ActionContext<R> {
+    row: Row;
+    rows: Row[];
+    item?: DetailItem;
+    filter: string;
+    refresh: () => Promise<void>;
+    suspendAnd: <T>(fn: () => Promise<T>) => Promise<T>;
+    toast: (msg: string, tone?: Tone) => void;
+    confirm: (prompt: string) => Promise<boolean>;
+    exit: (after?: () => void | Promise<void>) => void;
+}
+export interface ExplorerConfig<R> {
+    title: string;
+    rows: () => Promise<Row[]>;
+    detail: Detail<R>;
+    actions: Action<R>[];
+    reorder?: {
+        onReorder: (orderedIds: string[]) => void | Promise<void>;
+    };
+    multiSelect?: boolean;
+    keybindOverrides?: Record<string, string | string[]>;
+    emptyHint?: string;
+    initialFilter?: string;
+}
+export declare const REGION_HEADER: number;
+export declare const REGION_LIST: number;
+export declare const REGION_DETAIL: number;
+export declare const REGION_FOOTER: number;
+export declare const REGION_MODAL: number;
+export declare const REGION_TOAST: number;
+export declare const REGION_ALL: number;
+export type Dirty = number;
+export type ExplorerLayoutMode = "wide" | "medium" | "narrow-vertical" | "narrow-list-only" | "too-narrow";
+export interface ExplorerSize {
+    cols: number;
+    rows: number;
+}
+export interface ExplorerState {
+    title: string;
+    emptyHint: string;
+    rows: Row[];
+    filtered: number[];
+    matchPositions: Map<number, number[]>;
+    cursor: number;
+    filter: string;
+    filterFocused: boolean;
+    focused: "list" | "detail";
+    detail: {
+        rowId: string | null;
+        items: DetailItem[] | null;
+        cursor: number;
+        scroll: number;
+        token: number;
+        loading: boolean;
+    };
+    selected: Set<string>;
+    modal: null | {
+        kind: "help";
+    } | {
+        kind: "confirm";
+        action: Action<unknown>;
+        rows: Row[];
+        resolver: (ok: boolean) => void;
+    } | {
+        kind: "palette";
+        query: string;
+        cursor: number;
+    };
+    toast: {
+        message: string;
+        tone: Tone;
+        expiresAt: number;
+    } | null;
+    dirty: Dirty;
+    size: ExplorerSize;
+    layout: ExplorerLayoutMode;
+    bindings: ResolvedBindings;
+    actionState: Map<string, ActionStateEntry>;
+}
+export interface ActionStateEntry {
+    available: boolean;
+    label: string;
+    running?: boolean;
+    action?: Action<unknown>;
+    source?: "row" | "detail";
+}
+export declare function createInitialState<R>(config: ExplorerConfig<R>, size: ExplorerSize): ExplorerState;
+export declare function resolveExplorerLayoutMode(cols: number): ExplorerLayoutMode;

package/node_modules/@poe-code/design-system/dist/explorer/state.js

@@ -0,0 +1,87 @@
+import { resolveBindings } from "./keymap.js";
+export const REGION_HEADER = 1 << 0;
+export const REGION_LIST = 1 << 1;
+export const REGION_DETAIL = 1 << 2;
+export const REGION_FOOTER = 1 << 3;
+export const REGION_MODAL = 1 << 4;
+export const REGION_TOAST = 1 << 5;
+export const REGION_ALL = REGION_HEADER |
+    REGION_LIST |
+    REGION_DETAIL |
+    REGION_FOOTER |
+    REGION_MODAL |
+    REGION_TOAST;
+export function createInitialState(config, size) {
+    const normalizedSize = {
+        cols: normalizeSize(size.cols),
+        rows: normalizeSize(size.rows)
+    };
+    return {
+        title: config.title,
+        emptyHint: config.emptyHint ?? "No detail",
+        rows: [],
+        filtered: [],
+        matchPositions: new Map(),
+        cursor: 0,
+        filter: config.initialFilter ?? "",
+        filterFocused: false,
+        focused: "list",
+        detail: {
+            rowId: null,
+            items: null,
+            cursor: 0,
+            scroll: 0,
+            token: 0,
+            loading: false
+        },
+        selected: new Set(),
+        modal: null,
+        toast: null,
+        dirty: REGION_ALL,
+        size: normalizedSize,
+        layout: resolveExplorerLayoutMode(normalizedSize.cols),
+        bindings: resolveBindings(config),
+        actionState: createInitialActionState(config)
+    };
+}
+function createInitialActionState(config) {
+    const state = new Map();
+    for (const action of config.actions) {
+        state.set(action.id, {
+            available: true,
+            label: typeof action.label === "function" ? action.id : action.label,
+            action: action,
+            source: "row"
+        });
+    }
+    for (const action of config.detail.actions ?? []) {
+        state.set(action.id, {
+            available: true,
+            label: typeof action.label === "function" ? action.id : action.label,
+            action: action,
+            source: "detail"
+        });
+    }
+    return state;
+}
+export function resolveExplorerLayoutMode(cols) {
+    if (cols < 40) {
+        return "too-narrow";
+    }
+    if (cols < 80) {
+        return "narrow-list-only";
+    }
+    if (cols < 100) {
+        return "narrow-vertical";
+    }
+    if (cols < 120) {
+        return "medium";
+    }
+    return "wide";
+}
+function normalizeSize(value) {
+    if (!Number.isFinite(value)) {
+        return 0;
+    }
+    return Math.max(0, Math.floor(value));
+}

package/node_modules/@poe-code/design-system/dist/explorer/theme.d.ts

@@ -0,0 +1,27 @@
+import type { Tone } from "./state.js";
+type CellStyle = {
+    fg?: string;
+    bg?: string;
+    bold?: boolean;
+    dim?: boolean;
+    underline?: boolean;
+};
+export interface ExplorerTheme {
+    accent: (text: string) => string;
+    muted: (text: string) => string;
+    border: (text: string) => string;
+    borderFocused: (text: string) => string;
+    badge: (text: string, tone: Tone) => string;
+    matchHighlight: (text: string) => string;
+}
+export interface ExplorerStyles {
+    accent: CellStyle;
+    muted: CellStyle;
+    border: CellStyle;
+    borderFocused: CellStyle;
+    matchHighlight: CellStyle;
+    tones: Record<Tone, CellStyle>;
+}
+export declare function getExplorerTheme(): ExplorerTheme;
+export declare function getExplorerStyles(): ExplorerStyles;
+export {};