toolcraft 0.0.65 → 0.0.67

package/dist/renderer.js

@@ -46,6 +46,9 @@ function unwrapMcpEnvelope(result) {
 function isArrayOfObjects(value) {
     return Array.isArray(value) && value.every((entry) => isObject(entry));
 }
+function isNonEmptyArrayOfObjects(value) {
+    return Array.isArray(value) && value.length > 0 && value.every((entry) => isObject(entry));
+}
 function stringifyValue(value) {
     if (value === undefined) {
         return "";
@@ -97,10 +100,26 @@ function detailRows(result, depth = 0) {
             rows.push(...detailRows(value, depth + 1));
             continue;
         }
+        if (isNonEmptyArrayOfObjects(value)) {
+            rows.push({ label, value: "" });
+            rows.push(...arrayObjectDetailRows(value, depth + 1));
+            continue;
+        }
         rows.push({ label, value: displayScalar(value) });
     }
     return rows;
 }
+function arrayObjectDetailRows(value, depth) {
+    return value.flatMap((entry, index) => {
+        if (value.length === 1) {
+            return detailRows(entry, depth);
+        }
+        return [
+            { label: `${"  ".repeat(depth)}${index + 1}`, value: "" },
+            ...detailRows(entry, depth + 1)
+        ];
+    });
+}
 function displayScalar(value) {
     if (typeof value === "boolean") {
         return value ? "Yes" : "No";
@@ -137,11 +156,26 @@ function directObjectSections(result) {
         .map(([key, value]) => ({ title: humanizeKey(key), rows: detailRows(value) }))
         .filter((section) => section.rows.length > 0);
 }
+function directArrayObjectSections(result) {
+    return Object.entries(result).flatMap(([key, value]) => {
+        if (!isNonEmptyArrayOfObjects(value)) {
+            return [];
+        }
+        const title = humanizeKey(key);
+        return value
+            .map((entry, index) => ({
+            title: value.length === 1 ? title : `${title} ${index + 1}`,
+            rows: detailRows(entry)
+        }))
+            .filter((section) => section.rows.length > 0);
+    });
+}
 function renderObjectCard(result, primitives, title) {
     const scalarRows = directScalarRows(result);
     const nestedSections = directObjectSections(result);
+    const arrayObjectSections = directArrayObjectSections(result);
     const listRows = Object.entries(result)
-        .filter(([, value]) => Array.isArray(value))
+        .filter(([, value]) => Array.isArray(value) && !isNonEmptyArrayOfObjects(value))
         .map(([key, value]) => ({ label: humanizeKey(key), value: displayScalar(value) }));
     return renderDetailCard({
         theme: primitives.getTheme(),
@@ -149,7 +183,8 @@ function renderObjectCard(result, primitives, title) {
         sections: [
             { rows: scalarRows },
             ...nestedSections,
-            { title: "Lists", rows: listRows }
+            { title: "Lists", rows: listRows },
+            ...arrayObjectSections
         ]
     });
 }

package/node_modules/toolcraft-design/dist/components/inspector-card.d.ts

@@ -0,0 +1,21 @@
+import type { ThemePalette } from "../tokens/colors.js";
+export interface InspectorField {
+    label: string;
+    value: string;
+}
+export interface InspectorSection {
+    title?: string;
+    fields: InspectorField[];
+}
+export interface RenderInspectorCardOptions {
+    theme: ThemePalette;
+    title: string;
+    subtitle?: string;
+    badges?: string[];
+    preview?: string;
+    previewTitle?: string;
+    sections?: InspectorSection[];
+    width?: number;
+    maxPreviewLines?: number;
+}
+export declare function renderInspectorCard(options: RenderInspectorCardOptions): string;

package/node_modules/toolcraft-design/dist/components/inspector-card.js

@@ -0,0 +1,42 @@
+import { renderDetailCard } from "./detail-card.js";
+export function renderInspectorCard(options) {
+    const preview = truncatePreview(options.preview, options.maxPreviewLines ?? 8);
+    const sections = (options.sections ?? [])
+        .filter((section) => section.fields.length > 0)
+        .map((section) => ({
+        title: section.title,
+        rows: section.fields.map((field) => ({ label: field.label, value: field.value }))
+    }));
+    return renderDetailCard({
+        theme: options.theme,
+        title: options.title,
+        subtitle: options.subtitle,
+        badges: options.badges,
+        prose: preview === undefined
+            ? undefined
+            : [{
+                    title: options.previewTitle ?? "Preview",
+                    value: preview
+                }],
+        sections,
+        width: options.width
+    });
+}
+function truncatePreview(value, maxLines) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const lines = splitLines(value).map((line) => line.trimEnd());
+    const firstContent = lines.findIndex((line) => line.trim().length > 0);
+    const contentLines = firstContent === -1 ? [] : lines.slice(firstContent);
+    if (contentLines.length === 0) {
+        return undefined;
+    }
+    if (contentLines.length <= maxLines) {
+        return contentLines.join("\n");
+    }
+    return [...contentLines.slice(0, maxLines), `... ${contentLines.length - maxLines} more line(s)`].join("\n");
+}
+function splitLines(content) {
+    return content.split("\n").map((line) => line.endsWith("\r") ? line.slice(0, -1) : line);
+}

package/node_modules/toolcraft-design/dist/components/resource-browser.d.ts

@@ -0,0 +1,21 @@
+import type { ThemePalette } from "../tokens/colors.js";
+export interface ResourceBrowserItem {
+    label: string;
+    meta?: string[];
+    preview?: string;
+    badge?: string;
+}
+export interface ResourceBrowserGroup {
+    title: string;
+    description?: string;
+    emptyHint?: string;
+    items: ResourceBrowserItem[];
+}
+export interface RenderResourceBrowserOptions {
+    theme: ThemePalette;
+    title: string;
+    subtitle?: string;
+    groups: ResourceBrowserGroup[];
+    footer?: string;
+}
+export declare function renderResourceBrowser(options: RenderResourceBrowserOptions): string;

package/node_modules/toolcraft-design/dist/components/resource-browser.js

@@ -0,0 +1,98 @@
+import { resolveOutputFormat } from "../internal/output-format.js";
+import { stripAnsi } from "../internal/strip-ansi.js";
+export function renderResourceBrowser(options) {
+    switch (resolveOutputFormat()) {
+        case "markdown":
+            return renderMarkdown(options);
+        case "json":
+            return renderJson(options);
+        default:
+            return renderTerminal(options);
+    }
+}
+function renderTerminal(options) {
+    const blocks = [renderTitle(options)];
+    for (const group of options.groups) {
+        blocks.push(renderTerminalGroup(options.theme, group));
+    }
+    if (options.footer !== undefined) {
+        blocks.push(options.theme.muted(options.footer));
+    }
+    return blocks.join("\n\n");
+}
+function renderTitle(options) {
+    return [
+        options.theme.header(options.title),
+        options.subtitle === undefined ? undefined : options.theme.muted(options.subtitle)
+    ].filter((value) => value !== undefined).join("  ");
+}
+function renderTerminalGroup(theme, group) {
+    const lines = [
+        `${theme.header(group.title)}  ${theme.muted(String(group.items.length))}`,
+        ...(group.description === undefined ? [] : [theme.muted(group.description)])
+    ];
+    if (group.items.length === 0) {
+        lines.push(theme.muted(group.emptyHint ?? "No items"));
+        return lines.join("\n");
+    }
+    for (const [index, item] of group.items.entries()) {
+        lines.push(...renderTerminalItem(theme, item));
+        if (index < group.items.length - 1) {
+            lines.push("");
+        }
+    }
+    return lines.join("\n");
+}
+function renderTerminalItem(theme, item) {
+    return [
+        `${theme.accent(">")} ${theme.header(item.label)}${item.badge === undefined ? "" : `  ${theme.info(item.badge)}`}`,
+        ...(item.meta === undefined || item.meta.length === 0 ? [] : [`  ${theme.muted(item.meta.join(" · "))}`]),
+        ...(item.preview === undefined || item.preview.length === 0 ? [] : [`  ${theme.muted(item.preview)}`])
+    ];
+}
+function renderMarkdown(options) {
+    const blocks = [`# ${stripAnsi(options.title)}`];
+    if (options.subtitle !== undefined) {
+        blocks.push(stripAnsi(options.subtitle));
+    }
+    for (const group of options.groups) {
+        const lines = [`## ${stripAnsi(group.title)} (${group.items.length})`];
+        if (group.description !== undefined) {
+            lines.push(stripAnsi(group.description));
+        }
+        if (group.items.length === 0) {
+            lines.push(stripAnsi(group.emptyHint ?? "No items"));
+        }
+        else {
+            lines.push(...group.items.map((item) => renderMarkdownItem(item)));
+        }
+        blocks.push(lines.join("\n\n"));
+    }
+    if (options.footer !== undefined) {
+        blocks.push(stripAnsi(options.footer));
+    }
+    return blocks.join("\n\n");
+}
+function renderMarkdownItem(item) {
+    const meta = item.meta === undefined || item.meta.length === 0 ? "" : ` — ${item.meta.map(stripAnsi).join(" · ")}`;
+    const preview = item.preview === undefined || item.preview.length === 0 ? "" : `: ${stripAnsi(item.preview)}`;
+    return `- **${stripAnsi(item.label)}**${meta}${preview}`;
+}
+function renderJson(options) {
+    return JSON.stringify({
+        title: stripAnsi(options.title),
+        ...(options.subtitle === undefined ? {} : { subtitle: stripAnsi(options.subtitle) }),
+        groups: options.groups.map((group) => ({
+            title: stripAnsi(group.title),
+            ...(group.description === undefined ? {} : { description: stripAnsi(group.description) }),
+            ...(group.emptyHint === undefined ? {} : { emptyHint: stripAnsi(group.emptyHint) }),
+            items: group.items.map((item) => ({
+                label: stripAnsi(item.label),
+                ...(item.meta === undefined ? {} : { meta: item.meta.map(stripAnsi) }),
+                ...(item.preview === undefined ? {} : { preview: stripAnsi(item.preview) }),
+                ...(item.badge === undefined ? {} : { badge: stripAnsi(item.badge) })
+            }))
+        })),
+        ...(options.footer === undefined ? {} : { footer: stripAnsi(options.footer) })
+    }, null, 2);
+}

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

@@ -1,8 +1,10 @@
 import type { Detail, DetailCtx, Row } from "./state.js";
 export { runExplorer } from "./runtime.js";
+export { runTwoPaneExplorer, renderTwoPaneExplorer, TwoPaneExplorerRuntime } from "./two-pane.js";
 export { createInitialState } from "./state.js";
 export { resolveBindings } from "./keymap.js";
 export type { Effect, ExplorerEvent } from "./events.js";
 export type { BindingTarget, ExplorerBindingDefaults, ExplorerBuiltinCommand, ResolvedBindings } from "./keymap.js";
 export type { Action, ActionContext, Detail, DetailCtx, DetailItem, Dirty, ExplorerConfig, ExplorerLayoutMode, ExplorerSize, ExplorerState, ReorderContext, Row, Tone } from "./state.js";
+export type { TwoPaneAction, TwoPaneActionContext, TwoPaneDefinition, TwoPaneExplorerConfig, TwoPaneExplorerState, TwoPanePaneState, TwoPaneRow } from "./two-pane.js";
 export declare function singleDetail<R>(fn: (row: Row, ctx: DetailCtx) => string | Promise<string>): Detail<R>;

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

@@ -1,4 +1,5 @@
 export { runExplorer } from "./runtime.js";
+export { runTwoPaneExplorer, renderTwoPaneExplorer, TwoPaneExplorerRuntime } from "./two-pane.js";
 export { createInitialState } from "./state.js";
 export { resolveBindings } from "./keymap.js";
 export function singleDetail(fn) {

package/node_modules/toolcraft-design/dist/explorer/two-pane.d.ts

@@ -0,0 +1,94 @@
+import { ScreenBuffer } from "../dashboard/buffer.js";
+import { type TerminalDriver } from "../dashboard/terminal.js";
+import type { Tone } from "./state.js";
+export interface TwoPaneRow {
+    id: string;
+    title: string;
+    subtitle?: string;
+    badge?: {
+        text: string;
+        tone?: Tone;
+    };
+}
+export interface TwoPaneDefinition {
+    id: string;
+    title: string;
+    rows: () => Promise<TwoPaneRow[]>;
+    emptyHint?: string;
+}
+export interface TwoPaneActionContext<R> {
+    activePane: TwoPanePaneState;
+    inactivePane: TwoPanePaneState;
+    row: TwoPaneRow;
+    rows: TwoPaneRow[];
+    refresh: () => Promise<void>;
+    suspendAnd: <T>(fn: () => Promise<T>) => Promise<T>;
+    toast: (message: string, tone?: Tone) => void;
+    exit: (result?: R | null) => void;
+}
+export interface TwoPaneAction<R> {
+    id: string;
+    label: string;
+    key: string | string[];
+    handler: (ctx: TwoPaneActionContext<R>) => void | Promise<void>;
+}
+export interface TwoPaneExplorerConfig<R> {
+    title: string;
+    panes: [TwoPaneDefinition, TwoPaneDefinition];
+    actions: TwoPaneAction<R>[];
+    refresh?: () => void | Promise<void>;
+}
+export interface TwoPanePaneState {
+    id: string;
+    title: string;
+    rows: TwoPaneRow[];
+    cursor: number;
+    selected: Set<string>;
+    filter: string;
+    emptyHint: string;
+}
+export interface TwoPaneExplorerState {
+    title: string;
+    panes: [TwoPanePaneState, TwoPanePaneState];
+    activePaneIndex: 0 | 1;
+    filterFocused: boolean;
+    toast: {
+        message: string;
+        tone: Tone;
+    } | null;
+    size: {
+        cols: number;
+        rows: number;
+    };
+}
+export declare function runTwoPaneExplorer<R = void>(config: TwoPaneExplorerConfig<R>): Promise<R | null>;
+export declare class TwoPaneExplorerRuntime<R> {
+    private readonly config;
+    private readonly driver;
+    private state;
+    private unsubscribeKeypress;
+    private unsubscribeResize;
+    private toastTimer;
+    private stopped;
+    private rowsRequestToken;
+    private settle;
+    constructor(config: TwoPaneExplorerConfig<R>, driver: TerminalDriver);
+    run(): Promise<R | null>;
+    private startTerminal;
+    private loadRows;
+    private refresh;
+    private dispatchKey;
+    private dispatchFilterKey;
+    private moveCursor;
+    private setCursor;
+    private toggleSelection;
+    private runAction;
+    private suspendAnd;
+    private showToast;
+    private activePane;
+    private inactivePane;
+    private render;
+    private exit;
+    private fail;
+}
+export declare function renderTwoPaneExplorer<R>(state: TwoPaneExplorerState, actions: TwoPaneAction<R>[], screen: ScreenBuffer): void;

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",
-  "version": "0.0.65",
+  "version": "0.0.67",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -47,7 +47,7 @@
     "postpack": "node ../../scripts/manage-bundled-workspace-deps.mjs cleanup . toolcraft-design @poe-code/frontmatter @poe-code/agent-mcp-config @poe-code/agent-human-in-loop @poe-code/task-list @poe-code/agent-defs @poe-code/config-mutations @poe-code/process-runner tiny-mcp-client mcp-oauth auth-store"
   },
   "dependencies": {
-    "toolcraft-schema": "0.0.65",
+    "toolcraft-schema": "0.0.67",
     "commander": "^14.0.3",
     "fast-string-width": "^3.0.2",
     "fast-wrap-ansi": "^0.2.0",