toolcraft-openapi 0.0.1

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

@@ -0,0 +1,145 @@
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { createDashboard } from "./dashboard.js";
+const OUTPUT_INTERVAL_MS = 500;
+const STATS_INTERVAL_MS = 1_000;
+const DEMO_DURATION_MS = 30_000;
+const TOKENS_IN_PER_ITERATION = 137;
+const TOKENS_OUT_PER_ITERATION = 89;
+const OUTPUT_KINDS = ["info", "success", "error", "tool", "status"];
+const OUTPUT_MESSAGES = {
+    info: [
+        "Analyzing repository state",
+        "Inspecting agent configuration",
+        "Collecting recent command output"
+    ],
+    success: [
+        "Generated provider config",
+        "Updated dashboard layout",
+        "Saved session checkpoint"
+    ],
+    error: [
+        "Retrying transient network request",
+        "Tool execution returned a non-zero exit code",
+        "Encountered a recoverable validation error"
+    ],
+    tool: [
+        "Running npm test -- --runInBand",
+        "Executing npm run lint:types",
+        "Opening task plan documentation"
+    ],
+    status: [
+        "Waiting for follow-up task",
+        "Streaming model response",
+        "Syncing derived metrics"
+    ]
+};
+const RUNNING_ACTIONS = [
+    "Planning next step",
+    "Executing tool call",
+    "Reviewing tool results",
+    "Updating working memory",
+    "Preparing final response"
+];
+const INITIAL_ACTION = "Connecting to provider";
+const COMPLETED_ACTION = "Completed";
+export function startDashboardDemo(dashboard, runtime = {}) {
+    const setIntervalFn = runtime.setInterval ?? globalThis.setInterval.bind(globalThis);
+    const clearIntervalFn = runtime.clearInterval ?? globalThis.clearInterval.bind(globalThis);
+    const setTimeoutFn = runtime.setTimeout ?? globalThis.setTimeout.bind(globalThis);
+    const clearTimeoutFn = runtime.clearTimeout ?? globalThis.clearTimeout.bind(globalThis);
+    const now = runtime.now ?? Date.now;
+    const random = runtime.random ?? Math.random;
+    let outputCount = 0;
+    let iterations = 0;
+    let cleanedUp = false;
+    dashboard.updateStats({
+        status: "running",
+        currentAction: INITIAL_ACTION
+    });
+    const outputTimer = setIntervalFn(() => {
+        const kind = OUTPUT_KINDS[outputCount % OUTPUT_KINDS.length] ?? "info";
+        dashboard.appendOutput({
+            kind,
+            text: pickOutputMessage(kind, random),
+            ts: now()
+        });
+        outputCount += 1;
+    }, OUTPUT_INTERVAL_MS);
+    const statsTimer = setIntervalFn(() => {
+        iterations += 1;
+        dashboard.updateStats({
+            status: "running",
+            iterations,
+            tokensIn: iterations * TOKENS_IN_PER_ITERATION,
+            tokensOut: iterations * TOKENS_OUT_PER_ITERATION,
+            elapsedMs: iterations * STATS_INTERVAL_MS,
+            currentAction: RUNNING_ACTIONS[(iterations - 1) % RUNNING_ACTIONS.length] ?? INITIAL_ACTION
+        });
+    }, STATS_INTERVAL_MS);
+    const finishTimeout = setTimeoutFn(() => {
+        cleanup();
+        dashboard.updateStats({
+            status: "done",
+            iterations,
+            tokensIn: iterations * TOKENS_IN_PER_ITERATION,
+            tokensOut: iterations * TOKENS_OUT_PER_ITERATION,
+            elapsedMs: DEMO_DURATION_MS,
+            currentAction: COMPLETED_ACTION
+        });
+    }, DEMO_DURATION_MS);
+    function cleanup() {
+        if (cleanedUp) {
+            return;
+        }
+        cleanedUp = true;
+        clearTimeoutFn(finishTimeout);
+        clearIntervalFn(outputTimer);
+        clearIntervalFn(statsTimer);
+    }
+    return cleanup;
+}
+function pickOutputMessage(kind, random) {
+    const options = OUTPUT_MESSAGES[kind];
+    const cappedRandom = Math.max(0, Math.min(0.999_999, random()));
+    const index = Math.floor(cappedRandom * options.length);
+    return options[index] ?? options[0] ?? kind;
+}
+export async function main() {
+    const dashboard = createDashboard({ title: "Agent Output", statsTitle: "Stats" });
+    const stopDemo = startDashboardDemo(dashboard);
+    let shutDown = false;
+    const shutdown = (exitCode) => {
+        if (shutDown) {
+            return;
+        }
+        shutDown = true;
+        stopDemo();
+        dashboard.destroy();
+        if (exitCode !== undefined) {
+            process.exit(exitCode);
+        }
+    };
+    dashboard.onCommand((command) => {
+        if (command === "quit") {
+            shutdown(0);
+        }
+    });
+    process.once("SIGINT", () => {
+        shutdown(0);
+    });
+    process.once("SIGTERM", () => {
+        shutdown(0);
+    });
+    dashboard.start();
+}
+const entry = process.argv[1];
+const isMain = typeof entry === "string" && path.resolve(entry) === fileURLToPath(import.meta.url);
+if (isMain) {
+    main().catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`${message}\n`);
+        process.exitCode = 1;
+    });
+}

package/node_modules/@poe-code/design-system/dist/dashboard/index.d.ts

@@ -0,0 +1,8 @@
+export { createDashboard } from "./dashboard.js";
+export { shouldUseInteractiveDashboard } from "./should-use-dashboard.js";
+export type { Dashboard, DashboardOptions } from "./dashboard.js";
+export { renderDashboardSnapshot } from "./snapshot.js";
+export type { SnapshotOptions } from "./snapshot.js";
+export type { OutputItem, OutputItemKind, DashboardStats, Command, DashboardState } from "./types.js";
+export { defaultHints } from "./components/footer.js";
+export type { FooterHint } from "./components/footer.js";

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

@@ -0,0 +1,4 @@
+export { createDashboard } from "./dashboard.js";
+export { shouldUseInteractiveDashboard } from "./should-use-dashboard.js";
+export { renderDashboardSnapshot } from "./snapshot.js";
+export { defaultHints } from "./components/footer.js";

package/node_modules/@poe-code/design-system/dist/dashboard/keymap.d.ts

@@ -0,0 +1,3 @@
+import type { KeypressEvent } from "./terminal.js";
+import type { Command } from "./types.js";
+export declare function createKeymap(overrides?: Partial<Record<Command, string[]>>): (event: KeypressEvent) => Command | undefined;

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

@@ -0,0 +1,99 @@
+const commands = ["forceQuit", "quit", "edit", "pause", "retry", "view-log"];
+const defaultBindings = {
+    forceQuit: ["Ctrl+C"],
+    quit: ["q"],
+    edit: ["e"],
+    pause: ["p"],
+    retry: ["r"],
+    "view-log": ["l"]
+};
+export function createKeymap(overrides) {
+    const bindings = new Map();
+    for (const command of commands) {
+        const keys = overrides?.[command] ?? defaultBindings[command];
+        bindings.set(command, keys
+            .map(parseBinding)
+            .filter((binding) => binding !== undefined));
+    }
+    return (event) => {
+        for (const command of commands) {
+            const commandBindings = bindings.get(command);
+            if (commandBindings?.some((binding) => matches(binding, event))) {
+                return command;
+            }
+        }
+        return undefined;
+    };
+}
+function parseBinding(binding) {
+    const value = binding.trim();
+    if (value.length === 0) {
+        return undefined;
+    }
+    const parts = value.split("+").map((part) => part.trim()).filter(Boolean);
+    if (parts.length === 0) {
+        return undefined;
+    }
+    let ctrl = false;
+    let meta = false;
+    let shift = false;
+    const key = parts.at(-1);
+    if (key === undefined) {
+        return undefined;
+    }
+    for (const modifier of parts.slice(0, -1)) {
+        const normalized = modifier.toLowerCase();
+        if (normalized === "ctrl" || normalized === "control") {
+            ctrl = true;
+            continue;
+        }
+        if (normalized === "meta" || normalized === "alt") {
+            meta = true;
+            continue;
+        }
+        if (normalized === "shift") {
+            shift = true;
+            continue;
+        }
+    }
+    if (parts.length === 1 && isShiftedCharacter(key)) {
+        shift = true;
+    }
+    if (key.length === 1) {
+        return {
+            ch: normalizeBindingCharacter(key, shift),
+            ctrl,
+            meta,
+            shift
+        };
+    }
+    return {
+        name: key.toLowerCase(),
+        ctrl,
+        meta,
+        shift
+    };
+}
+function matches(binding, event) {
+    if (binding.ctrl !== event.ctrl ||
+        binding.meta !== event.meta ||
+        binding.shift !== event.shift) {
+        return false;
+    }
+    if (binding.ch !== undefined) {
+        return event.ch === binding.ch || event.name === binding.ch.toLowerCase();
+    }
+    if (binding.name !== undefined) {
+        return event.name === binding.name;
+    }
+    return false;
+}
+function isShiftedCharacter(value) {
+    return value.length === 1 && value.toLowerCase() !== value && value.toUpperCase() === value;
+}
+function normalizeBindingCharacter(value, shift) {
+    if (!shift || value.toLowerCase() === value.toUpperCase()) {
+        return value;
+    }
+    return value.toUpperCase();
+}

package/node_modules/@poe-code/design-system/dist/dashboard/layout.d.ts

@@ -0,0 +1,25 @@
+import type { Rect } from "./types.js";
+export type LayoutOptions = {
+    totalWidth: number;
+    totalHeight: number;
+    rightPaneWidth?: number;
+    footerHeight?: number;
+    borderWidth?: number;
+};
+export type DashboardLayout = {
+    outerBorder: Rect;
+    leftPane: Rect;
+    rightPane: Rect;
+    divider: {
+        x: number;
+        top: number;
+        bottom: number;
+    };
+    footer: Rect;
+    footerDivider: {
+        y: number;
+        left: number;
+        right: number;
+    };
+};
+export declare function computeDashboardLayout(opts: LayoutOptions): DashboardLayout;

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

@@ -0,0 +1,79 @@
+const DEFAULT_RIGHT_PANE_WIDTH = 25;
+const DEFAULT_FOOTER_HEIGHT = 1;
+const DEFAULT_BORDER_WIDTH = 1;
+const MIN_LEFT_PANE_WIDTH = 20;
+export function computeDashboardLayout(opts) {
+    const totalWidth = normalizeSize(opts.totalWidth);
+    const totalHeight = normalizeSize(opts.totalHeight);
+    const borderWidth = normalizeSize(opts.borderWidth ?? DEFAULT_BORDER_WIDTH);
+    const footerHeight = normalizeSize(opts.footerHeight ?? DEFAULT_FOOTER_HEIGHT);
+    const requestedRightPaneWidth = normalizeSize(opts.rightPaneWidth ?? DEFAULT_RIGHT_PANE_WIDTH);
+    const maxX = Math.max(0, totalWidth - 1);
+    const maxY = Math.max(0, totalHeight - 1);
+    const outerBorder = { x: 0, y: 0, width: totalWidth, height: totalHeight };
+    const innerWidth = Math.max(0, totalWidth - (borderWidth * 2));
+    const innerHeight = Math.max(0, totalHeight - (borderWidth * 2));
+    const innerX = clampCoordinate(borderWidth, maxX);
+    const innerY = clampCoordinate(borderWidth, maxY);
+    const dividerWidth = innerWidth > 0 ? 1 : 0;
+    const availablePaneWidth = Math.max(0, innerWidth - dividerWidth);
+    const leftPaneWidth = computeLeftPaneWidth(availablePaneWidth, requestedRightPaneWidth);
+    const rightPaneWidth = Math.max(0, availablePaneWidth - leftPaneWidth);
+    const actualFooterHeight = Math.min(footerHeight, innerHeight);
+    const footerDividerHeight = innerHeight > actualFooterHeight ? 1 : 0;
+    const contentHeight = Math.max(0, innerHeight - actualFooterHeight - footerDividerHeight);
+    const leftPane = {
+        x: innerX,
+        y: innerY,
+        width: leftPaneWidth,
+        height: contentHeight
+    };
+    const dividerX = clampCoordinate(leftPane.x + leftPane.width, maxX);
+    const rightPane = {
+        x: clampCoordinate(dividerX + dividerWidth, maxX),
+        y: innerY,
+        width: rightPaneWidth,
+        height: contentHeight
+    };
+    const dividerTop = innerY;
+    const dividerBottom = clampCoordinate(dividerTop + Math.max(contentHeight - 1, 0), maxY);
+    const footerDividerY = clampCoordinate(innerY + contentHeight, maxY);
+    const footerY = clampCoordinate(footerDividerY + footerDividerHeight, maxY);
+    const footerDividerLeft = innerX;
+    const footerDividerRight = clampCoordinate(Math.max(innerX, totalWidth - borderWidth - 1), maxX);
+    return {
+        outerBorder,
+        leftPane,
+        rightPane,
+        divider: {
+            x: dividerX,
+            top: dividerTop,
+            bottom: dividerBottom
+        },
+        footer: {
+            x: innerX,
+            y: footerY,
+            width: innerWidth,
+            height: actualFooterHeight
+        },
+        footerDivider: {
+            y: footerDividerY,
+            left: footerDividerLeft,
+            right: footerDividerRight
+        }
+    };
+}
+function computeLeftPaneWidth(availablePaneWidth, requestedRightPaneWidth) {
+    if (availablePaneWidth <= 0) {
+        return 0;
+    }
+    const maxRightPaneWidth = Math.max(0, availablePaneWidth - MIN_LEFT_PANE_WIDTH);
+    const rightPaneWidth = Math.min(requestedRightPaneWidth, maxRightPaneWidth);
+    return Math.max(0, availablePaneWidth - rightPaneWidth);
+}
+function normalizeSize(value) {
+    return Math.max(0, Math.floor(value));
+}
+function clampCoordinate(value, max) {
+    return Math.max(0, Math.min(value, max));
+}

package/node_modules/@poe-code/design-system/dist/dashboard/should-use-dashboard.d.ts

@@ -0,0 +1,10 @@
+type DashboardIo = {
+    stdin: {
+        isTTY?: boolean | undefined;
+    };
+    stdout: {
+        isTTY?: boolean | undefined;
+    };
+};
+export declare function shouldUseInteractiveDashboard(enabled: boolean | undefined, io?: DashboardIo): boolean;
+export {};

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

@@ -0,0 +1,7 @@
+import { resolveOutputFormat } from "../internal/output-format.js";
+export function shouldUseInteractiveDashboard(enabled, io = process) {
+    return enabled === true
+        && resolveOutputFormat() === "terminal"
+        && Boolean(io.stdin.isTTY)
+        && Boolean(io.stdout.isTTY);
+}

package/node_modules/@poe-code/design-system/dist/dashboard/snapshot.d.ts

@@ -0,0 +1,10 @@
+import type { DashboardStats, OutputItem } from "./types.js";
+export type SnapshotOptions = {
+    width?: number;
+    height?: number;
+    title?: string;
+    statsTitle?: string;
+    items?: OutputItem[];
+    stats?: DashboardStats;
+};
+export declare function renderDashboardSnapshot(opts?: SnapshotOptions): string;

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

@@ -0,0 +1,68 @@
+import { ScreenBuffer, cellToAnsi } from "./buffer.js";
+import { renderBorder } from "./components/border.js";
+import { defaultHints, renderFooter } from "./components/footer.js";
+import { renderOutputPane } from "./components/output-pane.js";
+import { renderStatsPane } from "./components/stats-pane.js";
+import { computeDashboardLayout } from "./layout.js";
+const SNAPSHOT_WIDTH = 80;
+const SNAPSHOT_HEIGHT = 20;
+const RIGHT_PANE_WIDTH = 25;
+export function renderDashboardSnapshot(opts = {}) {
+    const width = opts.width ?? SNAPSHOT_WIDTH;
+    const height = opts.height ?? SNAPSHOT_HEIGHT;
+    const title = opts.title ?? "Agent Output";
+    const statsTitle = opts.statsTitle ?? "Stats";
+    const items = opts.items ?? defaultItems();
+    const stats = opts.stats ?? defaultStats();
+    const layout = computeDashboardLayout({
+        totalWidth: width,
+        totalHeight: height,
+        rightPaneWidth: RIGHT_PANE_WIDTH
+    });
+    const buffer = new ScreenBuffer(width, height);
+    renderBorder(buffer, layout, {
+        leftTitle: title,
+        rightTitle: statsTitle,
+        style: { dim: true }
+    });
+    renderOutputPane(buffer, layout.leftPane, items);
+    renderStatsPane(buffer, layout.rightPane, stats);
+    renderFooter(buffer, layout.footer, defaultHints());
+    return bufferToAnsi(buffer);
+}
+function bufferToAnsi(buffer) {
+    const lines = [];
+    for (let y = 0; y < buffer.height; y += 1) {
+        let line = "";
+        for (let x = 0; x < buffer.width; x += 1) {
+            line += cellToAnsi(buffer.get(x, y));
+        }
+        lines.push(line);
+    }
+    return lines.join("\n");
+}
+function defaultItems() {
+    const now = Date.now();
+    return [
+        { kind: "info", text: "Analyzing repository state", ts: now },
+        { kind: "tool", text: "Running npm test -- --runInBand", ts: now + 500 },
+        { kind: "success", text: "Generated provider config", ts: now + 1000 },
+        { kind: "status", text: "Streaming model response", ts: now + 1500 },
+        { kind: "info", text: "Inspecting agent configuration", ts: now + 2000 },
+        { kind: "tool", text: "Executing npm run lint:types", ts: now + 2500 },
+        { kind: "error", text: "Retrying transient network request", ts: now + 3000 },
+        { kind: "success", text: "Updated dashboard layout", ts: now + 3500 },
+        { kind: "info", text: "Collecting recent command output", ts: now + 4000 },
+        { kind: "status", text: "Waiting for follow-up task", ts: now + 4500 }
+    ];
+}
+function defaultStats() {
+    return {
+        status: "running",
+        iterations: 5,
+        tokensIn: 685,
+        tokensOut: 445,
+        elapsedMs: 5000,
+        currentAction: "Executing tool call"
+    };
+}

package/node_modules/@poe-code/design-system/dist/dashboard/store.d.ts

@@ -0,0 +1,8 @@
+import type { DashboardState, DashboardStats, OutputItem } from "./types.js";
+export type DashboardStore = {
+    getState(): DashboardState;
+    appendOutput(item: OutputItem): void;
+    updateStats(partial: Partial<DashboardStats>): void;
+    onChange(handler: () => void): () => void;
+};
+export declare function createStore(): DashboardStore;

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

@@ -0,0 +1,51 @@
+const MAX_RETAINED_OUTPUT = 256;
+export function createStore() {
+    let state = {
+        output: [],
+        stats: {
+            status: "idle",
+            iterations: 0,
+            tokensIn: 0,
+            tokensOut: 0,
+            elapsedMs: 0
+        }
+    };
+    const listeners = new Set();
+    function notify() {
+        for (const listener of listeners) {
+            listener();
+        }
+    }
+    function getState() {
+        return state;
+    }
+    function appendOutput(item) {
+        const next = state.output.length >= MAX_RETAINED_OUTPUT
+            ? [...state.output.slice(state.output.length - MAX_RETAINED_OUTPUT + 1), item]
+            : [...state.output, item];
+        state = { ...state, output: next };
+        notify();
+    }
+    function updateStats(partial) {
+        state = {
+            ...state,
+            stats: {
+                ...state.stats,
+                ...partial
+            }
+        };
+        notify();
+    }
+    function onChange(handler) {
+        listeners.add(handler);
+        return () => {
+            listeners.delete(handler);
+        };
+    }
+    return {
+        getState,
+        appendOutput,
+        updateStats,
+        onChange
+    };
+}

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

@@ -0,0 +1,37 @@
+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;
+    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;
+    };
+    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;