toolcraft-openapi 0.0.64 → 0.0.66

package/node_modules/toolcraft-design/dist/explorer/two-pane.js

@@ -0,0 +1,446 @@
+import { ScreenBuffer, cellToAnsi } from "../dashboard/buffer.js";
+import { createTerminalDriver } from "../dashboard/terminal.js";
+const TOAST_MS = 2500;
+export async function runTwoPaneExplorer(config) {
+    if (process.stdout.isTTY !== true) {
+        throw new Error("two-pane explorer requires a TTY");
+    }
+    return new TwoPaneExplorerRuntime(config, createTerminalDriver()).run();
+}
+export class TwoPaneExplorerRuntime {
+    config;
+    driver;
+    state;
+    unsubscribeKeypress;
+    unsubscribeResize;
+    toastTimer;
+    stopped = false;
+    rowsRequestToken = 0;
+    settle;
+    constructor(config, driver) {
+        this.config = config;
+        this.driver = driver;
+        const size = normalizeSize(driver.getSize());
+        this.state = {
+            title: config.title,
+            panes: [
+                initialPaneState(config.panes[0]),
+                initialPaneState(config.panes[1])
+            ],
+            activePaneIndex: 0,
+            filterFocused: false,
+            toast: null,
+            size
+        };
+    }
+    run() {
+        return new Promise((resolve, reject) => {
+            this.settle = { resolve, reject };
+            try {
+                this.startTerminal();
+                this.render();
+                this.loadRows().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.dispatchKey(key);
+        });
+        this.unsubscribeResize = this.driver.onResize(() => {
+            this.state = { ...this.state, size: normalizeSize(this.driver.getSize()) };
+            this.render();
+        });
+    }
+    async loadRows(requestToken = ++this.rowsRequestToken) {
+        const [leftRows, rightRows] = await Promise.all([
+            this.config.panes[0].rows(),
+            this.config.panes[1].rows()
+        ]);
+        if (requestToken !== this.rowsRequestToken) {
+            return;
+        }
+        this.state = {
+            ...this.state,
+            panes: [
+                rowsLoaded(this.state.panes[0], leftRows),
+                rowsLoaded(this.state.panes[1], rightRows)
+            ]
+        };
+        this.render();
+    }
+    async refresh() {
+        await this.config.refresh?.();
+        await this.loadRows(++this.rowsRequestToken);
+    }
+    dispatchKey(key) {
+        if (this.stopped) {
+            return;
+        }
+        if (this.state.filterFocused) {
+            this.dispatchFilterKey(key);
+            return;
+        }
+        if (isQuitKey(key)) {
+            this.exit(null);
+            return;
+        }
+        if (key.name === "tab") {
+            this.state = {
+                ...this.state,
+                activePaneIndex: this.state.activePaneIndex === 0 ? 1 : 0
+            };
+            this.render();
+            return;
+        }
+        if (key.name === "up" || key.name === "down") {
+            this.moveCursor(key.name === "up" ? -1 : 1);
+            return;
+        }
+        if (key.name === "home") {
+            this.setCursor(0);
+            return;
+        }
+        if (key.name === "end") {
+            this.setCursor(filteredRows(this.activePane()).length - 1);
+            return;
+        }
+        if (key.ch === " ") {
+            this.toggleSelection();
+            return;
+        }
+        if (key.ch === "/") {
+            this.state = {
+                ...this.state,
+                filterFocused: true,
+                panes: updateActivePane(this.state, (pane) => ({ ...pane, filter: "", cursor: 0 }))
+            };
+            this.render();
+            return;
+        }
+        const action = this.config.actions.find((candidate) => actionMatchesKey(candidate, key));
+        if (action !== undefined) {
+            this.runAction(action);
+        }
+    }
+    dispatchFilterKey(key) {
+        if (key.name === "escape" || key.name === "return") {
+            this.state = { ...this.state, filterFocused: false };
+            this.render();
+            return;
+        }
+        if (key.name === "backspace") {
+            this.state = {
+                ...this.state,
+                panes: updateActivePane(this.state, (pane) => ({
+                    ...pane,
+                    filter: Array.from(pane.filter).slice(0, -1).join(""),
+                    cursor: 0
+                }))
+            };
+            this.render();
+            return;
+        }
+        if (key.ch !== undefined && key.ch.length > 0 && key.ch !== "/") {
+            this.state = {
+                ...this.state,
+                panes: updateActivePane(this.state, (pane) => ({
+                    ...pane,
+                    filter: `${pane.filter}${key.ch}`,
+                    cursor: 0
+                }))
+            };
+            this.render();
+        }
+    }
+    moveCursor(delta) {
+        const pane = this.activePane();
+        const rows = filteredRows(pane);
+        if (rows.length === 0) {
+            return;
+        }
+        this.setCursor(Math.max(0, Math.min(rows.length - 1, pane.cursor + delta)));
+    }
+    setCursor(cursor) {
+        this.state = {
+            ...this.state,
+            panes: updateActivePane(this.state, (pane) => ({
+                ...pane,
+                cursor: Math.max(0, cursor)
+            }))
+        };
+        this.render();
+    }
+    toggleSelection() {
+        const pane = this.activePane();
+        const row = currentRow(pane);
+        if (row === undefined) {
+            return;
+        }
+        const selected = new Set(pane.selected);
+        if (selected.has(row.id)) {
+            selected.delete(row.id);
+        }
+        else {
+            selected.add(row.id);
+        }
+        this.state = {
+            ...this.state,
+            panes: updateActivePane(this.state, (candidate) => ({ ...candidate, selected }))
+        };
+        this.render();
+    }
+    runAction(action) {
+        const activePane = this.activePane();
+        const inactivePane = this.inactivePane();
+        const row = currentRow(activePane);
+        if (row === undefined) {
+            this.showToast("Select an item first", "warning");
+            return;
+        }
+        const selectedRows = activePane.rows.filter((candidate) => activePane.selected.has(candidate.id));
+        const context = {
+            activePane,
+            inactivePane,
+            row,
+            rows: selectedRows.length > 0 ? selectedRows : [row],
+            refresh: async () => this.refresh(),
+            suspendAnd: async (fn) => this.suspendAnd(fn),
+            toast: (message, tone) => this.showToast(message, tone),
+            exit: (result) => this.exit(result ?? null)
+        };
+        Promise.resolve()
+            .then(() => action.handler(context))
+            .catch((error) => {
+            this.showToast(error instanceof Error ? error.message : "Action failed", "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();
+                this.state = { ...this.state, size: normalizeSize(this.driver.getSize()) };
+                this.render();
+            }
+        }
+    }
+    showToast(message, tone = "info") {
+        if (this.toastTimer !== undefined) {
+            clearTimeout(this.toastTimer);
+        }
+        this.state = { ...this.state, toast: { message, tone } };
+        this.render();
+        this.toastTimer = setTimeout(() => {
+            this.state = { ...this.state, toast: null };
+            this.render();
+        }, TOAST_MS);
+    }
+    activePane() {
+        return this.state.panes[this.state.activePaneIndex];
+    }
+    inactivePane() {
+        return this.state.panes[this.state.activePaneIndex === 0 ? 1 : 0];
+    }
+    render() {
+        if (this.stopped) {
+            return;
+        }
+        const size = normalizeSize(this.driver.getSize());
+        if (size.cols !== this.state.size.cols || size.rows !== this.state.size.rows) {
+            this.state = { ...this.state, size };
+        }
+        const next = new ScreenBuffer(this.state.size.cols, this.state.size.rows);
+        renderTwoPaneExplorer(this.state, this.config.actions, next);
+        this.driver.write(screenToAnsi(next));
+    }
+    exit(result) {
+        if (this.stopped) {
+            return;
+        }
+        this.stopped = true;
+        this.unsubscribeKeypress?.();
+        this.unsubscribeResize?.();
+        if (this.toastTimer !== undefined) {
+            clearTimeout(this.toastTimer);
+        }
+        this.driver.destroy();
+        this.settle?.resolve(result);
+    }
+    fail(error) {
+        if (!this.stopped) {
+            this.stopped = true;
+            this.driver.destroy();
+        }
+        this.settle?.reject(error);
+    }
+}
+export function renderTwoPaneExplorer(state, actions, screen) {
+    screen.clear();
+    if (state.size.cols < 60 || state.size.rows < 8) {
+        screen.put(0, 0, fit(` ${state.title} `, state.size.cols), { bold: true });
+        screen.put(0, 2, fit("Terminal is too small for two-pane view.", state.size.cols));
+        screen.put(0, state.size.rows - 1, fit("q quit", state.size.cols), { dim: true });
+        return;
+    }
+    const gap = 1;
+    const paneWidth = Math.floor((state.size.cols - gap) / 2);
+    const rightWidth = state.size.cols - paneWidth - gap;
+    const paneHeight = Math.max(5, state.size.rows - 2);
+    renderPane(screen, state.panes[0], {
+        x: 0,
+        y: 0,
+        width: paneWidth,
+        height: paneHeight,
+        active: state.activePaneIndex === 0
+    });
+    renderPane(screen, state.panes[1], {
+        x: paneWidth + gap,
+        y: 0,
+        width: rightWidth,
+        height: paneHeight,
+        active: state.activePaneIndex === 1
+    });
+    renderFooter(screen, state, actions, state.size.rows - 2);
+    if (state.toast !== null) {
+        screen.put(0, state.size.rows - 1, fit(` ${state.toast.message} `, state.size.cols), toneStyle(state.toast.tone));
+    }
+}
+function renderPane(screen, pane, layout) {
+    const borderStyle = layout.active ? { bold: true, fg: "cyan" } : { dim: true };
+    const title = `${layout.active ? ">" : " "} ${pane.title}`;
+    screen.put(layout.x, layout.y, `+${fit(title, layout.width - 2, "-")}+`, borderStyle);
+    for (let y = 1; y < layout.height - 1; y += 1) {
+        screen.put(layout.x, layout.y + y, "|", borderStyle);
+        screen.put(layout.x + layout.width - 1, layout.y + y, "|", borderStyle);
+    }
+    const filterLabel = pane.filter.length > 0 ? ` /${pane.filter}` : "";
+    screen.put(layout.x, layout.y + layout.height - 1, `+${fit(`${pane.selected.size} selected${filterLabel}`, layout.width - 2, "-")}+`, borderStyle);
+    const visibleRows = filteredRows(pane);
+    const bodyHeight = layout.height - 2;
+    if (visibleRows.length === 0) {
+        screen.put(layout.x + 2, layout.y + 2, fit(pane.emptyHint, Math.max(0, layout.width - 4)), { dim: true });
+        return;
+    }
+    const start = Math.max(0, Math.min(pane.cursor - Math.floor(bodyHeight / 2), visibleRows.length - bodyHeight));
+    for (let index = 0; index < bodyHeight; index += 1) {
+        const row = visibleRows[start + index];
+        if (row === undefined) {
+            continue;
+        }
+        const selected = pane.selected.has(row.id);
+        const cursor = start + index === pane.cursor;
+        const marker = selected ? "*" : " ";
+        const pointer = cursor && layout.active ? ">" : " ";
+        const badge = row.badge ? ` [${row.badge.text}]` : "";
+        const subtitle = row.subtitle ? ` ${row.subtitle}` : "";
+        const style = cursor && layout.active ? { inverse: true } : {};
+        screen.put(layout.x + 1, layout.y + 1 + index, fit(`${pointer}${marker} ${row.title}${badge}${subtitle}`, layout.width - 2), style);
+    }
+}
+function renderFooter(screen, state, actions, y) {
+    const actionHelp = actions.map((action) => `${firstKey(action.key)} ${action.label}`).join("   ");
+    const filter = state.filterFocused ? "search: typing, enter done" : "/ search";
+    const text = `tab pane   ${filter}   space select   ${actionHelp}   q quit`;
+    screen.put(0, y, fit(text, state.size.cols), { dim: true });
+}
+function initialPaneState(definition) {
+    return {
+        id: definition.id,
+        title: definition.title,
+        rows: [],
+        cursor: 0,
+        selected: new Set(),
+        filter: "",
+        emptyHint: definition.emptyHint ?? "No items"
+    };
+}
+function rowsLoaded(pane, rows) {
+    const ids = new Set(rows.map((row) => row.id));
+    return {
+        ...pane,
+        rows,
+        selected: new Set([...pane.selected].filter((id) => ids.has(id))),
+        cursor: Math.max(0, Math.min(pane.cursor, Math.max(0, filteredRows({ ...pane, rows }).length - 1)))
+    };
+}
+function filteredRows(pane) {
+    const query = pane.filter.trim().toLowerCase();
+    if (query.length === 0) {
+        return pane.rows;
+    }
+    return pane.rows.filter((row) => {
+        const haystack = `${row.title} ${row.subtitle ?? ""} ${row.badge?.text ?? ""}`.toLowerCase();
+        return haystack.includes(query);
+    });
+}
+function currentRow(pane) {
+    return filteredRows(pane)[pane.cursor];
+}
+function updateActivePane(state, update) {
+    return state.activePaneIndex === 0
+        ? [update(state.panes[0]), state.panes[1]]
+        : [state.panes[0], update(state.panes[1])];
+}
+function actionMatchesKey(action, key) {
+    const keys = Array.isArray(action.key) ? action.key : [action.key];
+    return keys.some((candidate) => key.ch === candidate || key.name === candidate);
+}
+function firstKey(key) {
+    return Array.isArray(key) ? key[0] ?? "" : key;
+}
+function isQuitKey(key) {
+    return key.ch === "q" || (key.name === "c" && key.ctrl);
+}
+function normalizeSize(size) {
+    return {
+        cols: Math.max(0, Math.floor(size.cols)),
+        rows: Math.max(0, Math.floor(size.rows))
+    };
+}
+function fit(text, width, pad = " ") {
+    if (width <= 0) {
+        return "";
+    }
+    const normalized = text.length > width ? text.slice(0, width) : text;
+    return normalized.padEnd(width, pad);
+}
+function toneStyle(tone) {
+    if (tone === "success") {
+        return { fg: "green", bold: true };
+    }
+    if (tone === "warning") {
+        return { fg: "yellow", bold: true };
+    }
+    if (tone === "error") {
+        return { fg: "red", bold: true };
+    }
+    return tone === "muted" ? { dim: true } : { fg: "cyan", bold: true };
+}
+function screenToAnsi(screen) {
+    let output = "";
+    for (let y = 0; y < screen.height; y += 1) {
+        output += `\u001b[${y + 1};1H`;
+        for (let x = 0; x < screen.width; x += 1) {
+            const cell = screen.get(x, y);
+            output += cellToAnsi(cell);
+        }
+    }
+    return output;
+}

package/node_modules/toolcraft-design/dist/index.d.ts

@@ -23,6 +23,10 @@ export { renderCatalog } from "./components/catalog.js";
 export type { CatalogGroup, CatalogItem, CatalogMetric, CatalogTone, RenderCatalogOptions } from "./components/catalog.js";
 export { renderDetailCard } from "./components/detail-card.js";
 export type { DetailCardRow, DetailCardSection, RenderDetailCardOptions } from "./components/detail-card.js";
+export { renderInspectorCard } from "./components/inspector-card.js";
+export type { InspectorField, InspectorSection, RenderInspectorCardOptions } from "./components/inspector-card.js";
+export { renderResourceBrowser } from "./components/resource-browser.js";
+export type { RenderResourceBrowserOptions, ResourceBrowserGroup, ResourceBrowserItem } from "./components/resource-browser.js";
 export { getTemplatePartialNames, renderTemplate, resolveTemplatePartials } from "./components/template.js";
 export type { RenderTemplateOptions, TemplateEscape } from "./components/template.js";
 export { openExternal } from "./components/browser.js";
@@ -31,8 +35,8 @@ export * as dashboard from "./dashboard/index.js";
 export { createDashboard, shouldUseInteractiveDashboard } from "./dashboard/index.js";
 export type { Dashboard, DashboardOptions } from "./dashboard/index.js";
 export * as explorer from "./explorer/index.js";
-export { runExplorer, singleDetail } from "./explorer/index.js";
-export type { Row, DetailItem, Detail, DetailCtx, Action, ActionContext, ExplorerConfig, ReorderContext, Tone } from "./explorer/index.js";
+export { runExplorer, runTwoPaneExplorer, singleDetail } from "./explorer/index.js";
+export type { Row, DetailItem, Detail, DetailCtx, Action, ActionContext, TwoPaneAction, TwoPaneActionContext, TwoPaneDefinition, TwoPaneExplorerConfig, TwoPanePaneState, TwoPaneRow, ExplorerConfig, ReorderContext, Tone } from "./explorer/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";

package/node_modules/toolcraft-design/dist/index.js

@@ -17,6 +17,8 @@ export { formatCommandNotFoundPanel } from "./components/command-errors.js";
 export { renderTable } from "./components/table.js";
 export { renderCatalog } from "./components/catalog.js";
 export { renderDetailCard } from "./components/detail-card.js";
+export { renderInspectorCard } from "./components/inspector-card.js";
+export { renderResourceBrowser } from "./components/resource-browser.js";
 export { getTemplatePartialNames, renderTemplate, resolveTemplatePartials } from "./components/template.js";
 export { openExternal } from "./components/browser.js";
 // ACP rendering
@@ -26,7 +28,7 @@ export * as dashboard from "./dashboard/index.js";
 export { createDashboard, shouldUseInteractiveDashboard } from "./dashboard/index.js";
 // Explorer
 export * as explorer from "./explorer/index.js";
-export { runExplorer, singleDetail } from "./explorer/index.js";
+export { runExplorer, runTwoPaneExplorer, singleDetail } from "./explorer/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";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft-openapi",
-  "version": "0.0.64",
+  "version": "0.0.66",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -28,7 +28,7 @@
     "toolcraft-openapi-generate": "dist/bin/generate.js"
   },
   "dependencies": {
-    "toolcraft": "0.0.64",
+    "toolcraft": "0.0.66",
     "auth-store": "^0.0.1",
     "fast-string-width": "^3.0.2",
     "fast-wrap-ansi": "^0.2.0",