terminal-pilot 0.0.30 → 0.0.32

package/node_modules/toolcraft-design/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/toolcraft-design/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/toolcraft-design/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/toolcraft-design/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/toolcraft-design/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/toolcraft-design/dist/dashboard/terminal-width.d.ts

@@ -0,0 +1,4 @@
+export declare function graphemes(value: string): string[];
+export declare function displayWidth(value: string, startColumn?: number): number;
+export declare function expandTabs(value: string, startColumn?: number): string;
+export declare function graphemeWidth(segment: string): number;

package/node_modules/toolcraft-design/dist/dashboard/terminal-width.js

@@ -0,0 +1,71 @@
+const graphemeSegmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+export function graphemes(value) {
+    return Array.from(graphemeSegmenter.segment(value), ({ segment }) => segment);
+}
+export function displayWidth(value, startColumn = 0) {
+    let column = startColumn;
+    for (const segment of graphemes(value)) {
+        if (segment === "\t") {
+            column += 8 - (column % 8);
+            continue;
+        }
+        column += graphemeWidth(segment);
+    }
+    return column - startColumn;
+}
+export function expandTabs(value, startColumn = 0) {
+    let column = startColumn;
+    let expanded = "";
+    for (const segment of graphemes(value)) {
+        if (segment === "\t") {
+            const spaces = 8 - (column % 8);
+            expanded += " ".repeat(spaces);
+            column += spaces;
+            continue;
+        }
+        expanded += segment;
+        column += graphemeWidth(segment);
+    }
+    return expanded;
+}
+export function graphemeWidth(segment) {
+    const codePoint = segment.codePointAt(0);
+    if (codePoint === undefined || isZeroWidthCodePoint(codePoint)) {
+        return 0;
+    }
+    return isWideCodePoint(codePoint) || isFlagSegment(segment) ? 2 : 1;
+}
+function isZeroWidthCodePoint(codePoint) {
+    return (codePoint >= 0x0300 && codePoint <= 0x036f)
+        || (codePoint >= 0x1ab0 && codePoint <= 0x1aff)
+        || (codePoint >= 0x1dc0 && codePoint <= 0x1dff)
+        || (codePoint >= 0x20d0 && codePoint <= 0x20ff)
+        || (codePoint >= 0xfe20 && codePoint <= 0xfe2f);
+}
+function isFlagSegment(segment) {
+    const codePoints = [...segment].map((character) => character.codePointAt(0));
+    return codePoints.length === 2
+        && codePoints.every((codePoint) => codePoint !== undefined && codePoint >= 0x1f1e6 && codePoint <= 0x1f1ff);
+}
+function isWideCodePoint(codePoint) {
+    return ((codePoint >= 0x1100 && codePoint <= 0x115f)
+        || codePoint === 0x2329
+        || codePoint === 0x232a
+        || (codePoint >= 0x2e80 && codePoint <= 0x303e)
+        || (codePoint >= 0x3041 && codePoint <= 0x33bf)
+        || (codePoint >= 0x3400 && codePoint <= 0x4dbf)
+        || (codePoint >= 0x4e00 && codePoint <= 0xa4cf)
+        || (codePoint >= 0xa960 && codePoint <= 0xa97f)
+        || (codePoint >= 0xac00 && codePoint <= 0xd7af)
+        || (codePoint >= 0xf900 && codePoint <= 0xfaff)
+        || (codePoint >= 0xfe10 && codePoint <= 0xfe19)
+        || (codePoint >= 0xfe30 && codePoint <= 0xfe6f)
+        || (codePoint >= 0xff00 && codePoint <= 0xff60)
+        || (codePoint >= 0xffe0 && codePoint <= 0xffe6)
+        || (codePoint >= 0x1b000 && codePoint <= 0x1b0ff)
+        || codePoint === 0x1f004
+        || codePoint === 0x1f0cf
+        || (codePoint >= 0x1f200 && codePoint <= 0x1fffd)
+        || (codePoint >= 0x20000 && codePoint <= 0x2fffd)
+        || (codePoint >= 0x30000 && codePoint <= 0x3fffd));
+}

package/node_modules/toolcraft-design/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;

package/node_modules/toolcraft-design/dist/dashboard/terminal.js

@@ -0,0 +1,264 @@
+import readline from "node:readline";
+import { PassThrough } from "node:stream";
+import { cellToAnsi } from "./buffer.js";
+export function createTerminalDriver(opts) {
+    const stdin = (opts?.stdin ?? process.stdin);
+    const stdout = (opts?.stdout ?? process.stdout);
+    const resizeListeners = new Set();
+    const keypressListeners = new Set();
+    let rawMode = false;
+    let altScreen = false;
+    let lineWrapEnabled = true;
+    let cursorHidden = false;
+    let destroyed = false;
+    readline.emitKeypressEvents(stdin);
+    function enterRawMode() {
+        if (destroyed || rawMode) {
+            return;
+        }
+        stdin.setRawMode?.(true);
+        stdin.resume();
+        rawMode = true;
+    }
+    function exitRawMode() {
+        if (destroyed || !rawMode) {
+            return;
+        }
+        stdin.setRawMode?.(false);
+        stdin.pause();
+        rawMode = false;
+    }
+    function enterAltScreen() {
+        if (destroyed || altScreen) {
+            return;
+        }
+        write("\u001b[?1049h");
+        altScreen = true;
+    }
+    function exitAltScreen() {
+        if (destroyed || !altScreen) {
+            return;
+        }
+        write("\u001b[?1049l");
+        altScreen = false;
+    }
+    function disableLineWrap() {
+        if (destroyed || !lineWrapEnabled) {
+            return;
+        }
+        write("\u001b[?7l");
+        lineWrapEnabled = false;
+    }
+    function enableLineWrap() {
+        if (destroyed || lineWrapEnabled) {
+            return;
+        }
+        write("\u001b[?7h");
+        lineWrapEnabled = true;
+    }
+    function hideCursor() {
+        if (destroyed || cursorHidden) {
+            return;
+        }
+        write("\u001b[?25l");
+        cursorHidden = true;
+    }
+    function showCursor() {
+        if (destroyed || !cursorHidden) {
+            return;
+        }
+        write("\u001b[?25h");
+        cursorHidden = false;
+    }
+    function moveTo(x, y) {
+        if (destroyed) {
+            return;
+        }
+        write(cursorPositionAnsi(x, y));
+    }
+    function write(text) {
+        if (destroyed || text.length === 0) {
+            return;
+        }
+        stdout.write(text);
+    }
+    function flush(changes) {
+        if (destroyed || changes.length === 0) {
+            return;
+        }
+        let output = "";
+        for (const change of changes) {
+            output += `${cursorPositionAnsi(change.x, change.y)}${cellToAnsi(change.cell)}`;
+        }
+        write(output);
+    }
+    function getSize() {
+        return {
+            cols: normalizeSize(stdout.columns),
+            rows: normalizeSize(stdout.rows)
+        };
+    }
+    function onResize(handler) {
+        if (destroyed) {
+            return () => { };
+        }
+        const listener = () => {
+            handler();
+        };
+        resizeListeners.add(listener);
+        stdout.on("resize", listener);
+        return () => {
+            if (!resizeListeners.delete(listener)) {
+                return;
+            }
+            stdout.off("resize", listener);
+        };
+    }
+    function onKeypress(handler) {
+        if (destroyed) {
+            return () => { };
+        }
+        const listener = (str, key) => {
+            const event = toKeypressEvent(str, key);
+            if (event !== undefined) {
+                handler(event);
+            }
+        };
+        keypressListeners.add(listener);
+        stdin.on("keypress", listener);
+        return () => {
+            if (!keypressListeners.delete(listener)) {
+                return;
+            }
+            stdin.off("keypress", listener);
+        };
+    }
+    function destroy() {
+        if (destroyed) {
+            return;
+        }
+        for (const listener of keypressListeners) {
+            stdin.off("keypress", listener);
+        }
+        keypressListeners.clear();
+        for (const listener of resizeListeners) {
+            stdout.off("resize", listener);
+        }
+        resizeListeners.clear();
+        exitRawMode();
+        enableLineWrap();
+        exitAltScreen();
+        showCursor();
+        destroyed = true;
+    }
+    return {
+        enterRawMode,
+        exitRawMode,
+        enterAltScreen,
+        exitAltScreen,
+        disableLineWrap,
+        enableLineWrap,
+        hideCursor,
+        showCursor,
+        moveTo,
+        write,
+        flush,
+        getSize,
+        onResize,
+        onKeypress,
+        destroy
+    };
+}
+export function parseKeypress(data) {
+    if (data.length === 0) {
+        return undefined;
+    }
+    const stream = new PassThrough();
+    const stdin = stream;
+    let event;
+    readline.emitKeypressEvents(stdin);
+    stdin.on("keypress", (str, key) => {
+        event = toKeypressEvent(str, key);
+    });
+    stream.emit("data", data);
+    stream.destroy();
+    return event;
+}
+function toKeypressEvent(str, key) {
+    const controlCharacter = controlCharacterToKeypress(key?.sequence);
+    if (controlCharacter !== undefined) {
+        return controlCharacter;
+    }
+    const ctrl = key?.ctrl ?? false;
+    const meta = key?.meta ?? false;
+    const shift = key?.shift ?? false;
+    const ch = extractPrintableCharacter(str, key?.sequence);
+    if (ch !== undefined) {
+        return { ch, ctrl, meta, shift };
+    }
+    if (key?.name === undefined) {
+        return undefined;
+    }
+    return {
+        name: key.name,
+        ctrl,
+        meta,
+        shift
+    };
+}
+function extractPrintableCharacter(str, sequence) {
+    if (isPrintableCharacter(str)) {
+        return str;
+    }
+    if (isSinglePrintableSequence(sequence)) {
+        return sequence;
+    }
+    if (sequence === undefined || sequence.length <= 1 || sequence[0] !== "\u001b") {
+        return undefined;
+    }
+    const candidate = sequence.slice(1);
+    return isPrintableCharacter(candidate) ? candidate : undefined;
+}
+function isSinglePrintableSequence(value) {
+    if (value === undefined || Array.from(value).length !== 1) {
+        return false;
+    }
+    const codePoint = value.codePointAt(0);
+    return codePoint !== undefined && codePoint >= 0x20 && codePoint !== 0x7f;
+}
+function isPrintableCharacter(value) {
+    if (value === undefined || Array.from(value).length !== 1) {
+        return false;
+    }
+    const codePoint = value.codePointAt(0);
+    return codePoint !== undefined && codePoint >= 0x20 && codePoint !== 0x7f;
+}
+function controlCharacterToKeypress(sequence) {
+    if (sequence === "\u001f") {
+        return { ch: "/", ctrl: true, meta: false, shift: false };
+    }
+    if (sequence !== undefined && sequence.length === 1) {
+        const code = sequence.charCodeAt(0);
+        if (code >= 1 && code <= 26 && code !== 9 && code !== 10 && code !== 13) {
+            return {
+                name: String.fromCharCode(code + 96),
+                ctrl: true,
+                meta: false,
+                shift: false
+            };
+        }
+    }
+    return undefined;
+}
+function cursorPositionAnsi(x, y) {
+    return `\u001b[${normalizeCoordinate(y) + 1};${normalizeCoordinate(x) + 1}H`;
+}
+function normalizeCoordinate(value) {
+    return Math.max(0, Math.floor(value));
+}
+function normalizeSize(value) {
+    if (value === undefined || !Number.isFinite(value)) {
+        return 0;
+    }
+    return Math.max(0, Math.floor(value));
+}

package/node_modules/toolcraft-design/dist/dashboard/types.d.ts

@@ -0,0 +1,38 @@
+export type OutputItemKind = "info" | "success" | "error" | "tool" | "status";
+export type OutputItem = {
+    kind: OutputItemKind;
+    text: string;
+    ts: number;
+};
+export type DashboardStats = {
+    status: "idle" | "running" | "paused" | "done" | "error";
+    iterations: number;
+    iterationsLabel?: string;
+    tokensIn: number;
+    tokensOut: number;
+    elapsedMs: number;
+    currentAction?: string;
+};
+export type Command = "quit" | "forceQuit" | "edit" | "pause" | "retry" | "view-log";
+export type DashboardState = {
+    output: OutputItem[];
+    stats: DashboardStats;
+};
+export type CellStyle = {
+    fg?: string;
+    bg?: string;
+    bold?: boolean;
+    dim?: boolean;
+    inverse?: boolean;
+    underline?: boolean;
+};
+export type Cell = {
+    ch: string;
+    style: CellStyle;
+};
+export type Rect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};

package/node_modules/toolcraft-design/dist/dashboard/types.js

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

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

@@ -0,0 +1,16 @@
+import type { ExplorerEvent } from "./events.js";
+import type { Action, ActionContext, ExplorerState, Row, Tone } from "./state.js";
+export type ActionSource = "row" | "detail";
+type ExplorerKeypressEvent = Extract<ExplorerEvent, {
+    type: "key";
+}>["key"];
+export type ActionRuntimeHandles = {
+    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 declare function resolveAction<R>(state: ExplorerState, keyEvent: ExplorerKeypressEvent): Action<R> | null;
+export declare function buildActionContext<R>(state: ExplorerState, _action: Action<R>, source: ActionSource, runtimeHandles: ActionRuntimeHandles, rowsOverride?: Row[]): ActionContext<R>;
+export {};

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

@@ -0,0 +1,39 @@
+export function resolveAction(state, keyEvent) {
+    const target = state.bindings.resolve(keyEvent);
+    if (target?.type !== "action") {
+        return null;
+    }
+    const actionState = state.actionState.get(target.id);
+    if (actionState?.available !== true ||
+        actionState.running === true ||
+        actionState.action === undefined) {
+        return null;
+    }
+    return actionState.action;
+}
+export function buildActionContext(state, _action, source, runtimeHandles, rowsOverride) {
+    const row = rowsOverride?.[0] ?? currentRow(state) ?? { id: "", title: "" };
+    return {
+        row,
+        rows: rowsOverride ?? selectedRows(state, row),
+        item: source === "detail" ? currentDetailItem(state) : undefined,
+        filter: state.filter,
+        refresh: runtimeHandles.refresh,
+        suspendAnd: runtimeHandles.suspendAnd,
+        toast: runtimeHandles.toast,
+        confirm: runtimeHandles.confirm,
+        exit: runtimeHandles.exit
+    };
+}
+function currentRow(state) {
+    return state.rows[state.filtered[state.cursor] ?? -1];
+}
+function currentDetailItem(state) {
+    return state.detail.items?.[state.detail.cursor];
+}
+function selectedRows(state, fallback) {
+    if (!state.multiSelect || state.selected.size === 0) {
+        return fallback.id === "" ? [] : [fallback];
+    }
+    return state.rows.filter((row) => state.selected.has(row.id));
+}

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

@@ -0,0 +1,13 @@
+import type { ExplorerConfig } from "./state.js";
+type ExplorerDemoMode = "single-detail-mode" | "list-detail-mode";
+export interface ExplorerDemoOptions {
+    mode: ExplorerDemoMode;
+    slowDetail: boolean;
+}
+export interface BuildExplorerDemoConfigOptions extends ExplorerDemoOptions {
+    onReorder?: (orderedIds: string[]) => void | Promise<void>;
+}
+export declare function parseExplorerDemoOptions(argv?: string[], env?: NodeJS.ProcessEnv): ExplorerDemoOptions;
+export declare function buildExplorerDemoConfig(options: BuildExplorerDemoConfigOptions): ExplorerConfig<void>;
+export declare function main(): Promise<void>;
+export {};