@crouton-kit/crouter 0.3.27 → 0.3.29

package/dist/clients/attach/graph-overlay.d.ts

@@ -0,0 +1,43 @@
+import { type Component, type TUI } from '@earendil-works/pi-tui';
+import type { AttachPalette } from './config-load.js';
+export declare class GraphOverlay implements Component {
+    private readonly tui;
+    private readonly self;
+    private readonly getAsks;
+    private readonly palette;
+    private handle;
+    /** Manual fold OVERRIDES (h collapses → userCollapsed, l expands → userExpanded);
+     *  both override the default activity-driven policy and survive open/close. */
+    private readonly userExpanded;
+    private readonly userCollapsed;
+    private readonly folds;
+    /** Cursor as a node id (indices shift as topology changes). */
+    private cursorId;
+    /** Viewport scroll offset (row index of the top visible tree row). */
+    private scrollTop;
+    /** Transient y/n confirm gate (kill). */
+    private pendingConfirm;
+    constructor(tui: TUI, self: string, getAsks: () => Record<string, number>, palette: AttachPalette);
+    isOpen(): boolean;
+    open(): void;
+    close(): void;
+    toggle(): void;
+    /** Repaint if shown (the low-rate ask poll calls this). */
+    refresh(): void;
+    invalidate(): void;
+    render(width: number): string[];
+    /** A top/bottom border row: `<lc>─ <label> ────<rc>`, frame in the theme border
+     *  color, the label keeping its own styling. The label is visible-truncated to
+     *  the available span so a long label (a narrow pane, or a long `kill <name>?`
+     *  confirm) never spills past the corner. */
+    private borderRow;
+    handleInput(data: string): void;
+    private dispatch;
+    /** Focus node `id` from the overlay by shelling `crtr node focus <id> --pane <here>`.
+     *  Under the one-viewer-per-node model `--pane` is the ANCHOR to open beside: if
+     *  `id` has no viewer yet a fresh one splits beside this pane; if it already has
+     *  one, that viewer is navigated in place (this pane is left as-is). We pass
+     *  TMUX_PANE explicitly so the anchor is THIS pane even if env resolution differs. */
+    private focusTarget;
+    private shellCrtr;
+}

package/dist/clients/attach/graph-overlay.js

@@ -0,0 +1,306 @@
+// graph-overlay.ts — the alt+g GRAPH navigator overlay for `crtr attach` (Unit Q).
+//
+// Native reimplementation of canvas-nav.ts's GRAPH modal as a pi-tui OVERLAY
+// (the viewer has no pi extension host). `tui.showOverlay(this, …)` mounts this
+// Component as a BOUNDED, centered modal (~72% of the terminal, themed frame) and
+// CAPTURES keyboard focus (mirrors extension-dialogs.ts);
+// `OverlayHandle.hide()` tears it down and restores focus to the editor. While
+// shown, every key routes to handleInput() — a fold-aware NERDTree of the local
+// subscription graph with the canvas-nav keymap:
+//   j/k move · h/l fold/ascend-descend · g/G top/bottom · ↵ focus (swap into
+//   this pane) · m focus manager · x kill (y/n confirm) · esc close.
+// `e` is a tmux-menu prefixBind, not a GRAPH key, so it is swallowed (per
+// canvas-nav). All model/render comes from the shared nav-model layer; keys are
+// decoded with pi-tui's canonical matchesKey (kitty/CSI-u aware).
+//
+// Enter/m/x SHELL `crtr` out-of-process (node focus / node close) — the viewer
+// itself never spawns pi or opens a session (the §0 one-writer invariant). It
+// passes its own pane as `crtr node focus --pane <anchor>`: under the
+// one-viewer-per-node model the target's existing viewer is navigated in place,
+// or a fresh viewer opens BESIDE this pane — never a second pane for the same node.
+import { execFile } from 'node:child_process';
+import { matchesKey, truncateToWidth } from '@earendil-works/pi-tui';
+import { fullName } from '../../core/canvas/index.js';
+import { beginFrame, cNode, managerOf, sortedChildIds, climbRoot, computeSubtreeActivity, buildGraphModel, renderGraphRow, focusedNodeIds, shortId, visibleWidth, VIEWPORT_FALLBACK_ROWS, DIM, RESET, BOLD, YELLOW, } from '../../core/canvas/nav-model.js';
+// A BOUNDED, centered modal (CTO ruling: not full-bleed). Width/height are capped
+// at ~72% of the terminal; the overlay clips our lines to maxHeight, and render()
+// budgets the panel to the SAME fraction (HEIGHT_PCT) so the framed box is never
+// clipped. margin keeps it off the screen edges.
+const HEIGHT_PCT = 0.72;
+const OVERLAY_OPTIONS = { anchor: 'center', width: '72%', minWidth: 48, maxHeight: '72%', margin: 1 };
+// Viewer-specific hint: nav-model's shared GRAPH_HINT advertises "e expand",
+// but that key is the tmux pane-expand prefix-bind canvas-nav installs in its
+// host pane — the attach overlay has no such bind and swallows `e`, so the key
+// would do nothing here. Drop it.
+const GRAPH_HINT = `${DIM}jk move · hl fold · ↵ focus · x kill · m mgr · esc${RESET}`;
+export class GraphOverlay {
+    tui;
+    self;
+    getAsks;
+    palette;
+    handle;
+    /** Manual fold OVERRIDES (h collapses → userCollapsed, l expands → userExpanded);
+     *  both override the default activity-driven policy and survive open/close. */
+    userExpanded = new Set();
+    userCollapsed = new Set();
+    folds = { userExpanded: this.userExpanded, userCollapsed: this.userCollapsed };
+    /** Cursor as a node id (indices shift as topology changes). */
+    cursorId;
+    /** Viewport scroll offset (row index of the top visible tree row). */
+    scrollTop = 0;
+    /** Transient y/n confirm gate (kill). */
+    pendingConfirm;
+    constructor(tui, self, getAsks, palette) {
+        this.tui = tui;
+        this.self = self;
+        this.getAsks = getAsks;
+        this.palette = palette;
+    }
+    isOpen() {
+        return this.handle !== undefined;
+    }
+    open() {
+        if (this.handle !== undefined)
+            return;
+        this.scrollTop = 0;
+        this.pendingConfirm = undefined;
+        if (this.cursorId === undefined || cNode(this.cursorId) === null)
+            this.cursorId = this.self;
+        this.handle = this.tui.showOverlay(this, OVERLAY_OPTIONS);
+        this.tui.requestRender();
+    }
+    close() {
+        if (this.handle === undefined)
+            return;
+        this.pendingConfirm = undefined;
+        this.handle.hide();
+        this.handle = undefined;
+        this.tui.requestRender();
+    }
+    toggle() {
+        if (this.handle === undefined)
+            this.open();
+        else
+            this.close();
+    }
+    /** Repaint if shown (the low-rate ask poll calls this). */
+    refresh() {
+        if (this.handle !== undefined)
+            this.tui.requestRender();
+    }
+    invalidate() {
+        /* no cached render state — rebuilt every render() */
+    }
+    // -------------------------------------------------------------------------
+    render(width) {
+        // Fresh snapshot per paint (mirror canvas-nav's per-frame cache).
+        beginFrame();
+        const asks = this.getAsks();
+        const activity = computeSubtreeActivity(climbRoot(this.self), this.self);
+        const rows = buildGraphModel(this.self, this.folds, activity.expand);
+        // Re-resolve the cursor id → row (it may have vanished under a fold/close).
+        let cursorIdx = rows.findIndex((r) => r.id === this.cursorId);
+        if (cursorIdx < 0) {
+            cursorIdx = rows.findIndex((r) => r.id === this.self);
+            if (cursorIdx < 0)
+                cursorIdx = 0;
+        }
+        this.cursorId = rows[cursorIdx]?.id ?? this.self;
+        // Bounded panel budget (centered modal, not full-bleed): the box height
+        // shrinks to content but is capped at HEIGHT_PCT of the terminal — matching
+        // the overlay's maxHeight so our framed lines are never clipped. 2 rows go to
+        // the top/bottom border, the rest to tree rows.
+        const term = process.stdout.rows ?? VIEWPORT_FALLBACK_ROWS;
+        // Never exceed the overlay's own maxHeight (term-2 after the margin), so the
+        // bottom border is never slice-clipped even on a very short terminal.
+        const maxPanelH = Math.max(3, Math.min(Math.floor(term * HEIGHT_PCT), term - 2));
+        const treeArea = Math.max(2, Math.min(rows.length, maxPanelH - 2));
+        // Track the cursor within treeArea, reserving ↑/↓ "more" indicators. Up to
+        // 4 passes converge the mutual dependency between window size and indicators
+        // (an indicator steals a tree row → can re-home scrollTop → toggles the other
+        // indicator); see canvas-nav.ts renderGraph for the rationale.
+        let viewportH = treeArea;
+        for (let pass = 0; pass < 4; pass++) {
+            if (cursorIdx < this.scrollTop)
+                this.scrollTop = cursorIdx;
+            if (cursorIdx >= this.scrollTop + viewportH)
+                this.scrollTop = cursorIdx - viewportH + 1;
+            this.scrollTop = Math.max(0, Math.min(this.scrollTop, Math.max(0, rows.length - viewportH)));
+            const fit = treeArea - (this.scrollTop > 0 ? 1 : 0) - (this.scrollTop + viewportH < rows.length ? 1 : 0);
+            if (fit === viewportH)
+                break;
+            viewportH = Math.max(1, fit);
+        }
+        const end = Math.min(rows.length, this.scrollTop + viewportH);
+        const focused = focusedNodeIds();
+        const body = [];
+        if (this.scrollTop > 0)
+            body.push(`${DIM}  ↑ ${this.scrollTop} more${RESET}`);
+        for (let i = this.scrollTop; i < end; i++) {
+            body.push(renderGraphRow(rows[i], i === cursorIdx, focused, activity.activeBelow, asks));
+        }
+        if (end < rows.length)
+            body.push(`${DIM}  ↓ ${rows.length - end} more${RESET}`);
+        while (body.length < treeArea)
+            body.push(''); // fill so the overlay is opaque
+        const title = `${BOLD}⌗ canvas graph${RESET} ${DIM}(${cursorIdx + 1}/${rows.length})${RESET}`;
+        const hint = this.pendingConfirm !== undefined
+            ? `${YELLOW}${this.pendingConfirm.label} ${BOLD}y/n${RESET}`
+            : GRAPH_HINT;
+        // Frame the panel: title in the top border, hint in the bottom border, tree
+        // rows boxed with themed side bars (truncate/pad to the inner width so the
+        // right edge stays flush and opaque).
+        const B = this.palette.border;
+        const innerW = Math.max(1, width - 4); // "│ " + content + " │"
+        // Hard-cut (empty ellipsis) + pad to innerW: ANSI-aware, so the cursor fill
+        // bar reaches the right border flush with no stray "…" and the box edge is
+        // opaque.
+        const boxed = body.map((line) => `${B('│')} ${truncateToWidth(line, innerW, '', true)} ${B('│')}`);
+        // Paint the WHOLE modal — border rows + boxed body + opaque space-fill — on
+        // the theme's distinct-surface background (selectedBg) so the float reads as
+        // a separate surface, not a hole in the viewer behind it (CTO ruling).
+        const S = this.palette.surface;
+        return [
+            this.borderRow('╭', '╮', title, width),
+            ...boxed,
+            this.borderRow('╰', '╯', hint, width),
+        ].map(S);
+    }
+    /** A top/bottom border row: `<lc>─ <label> ────<rc>`, frame in the theme border
+     *  color, the label keeping its own styling. The label is visible-truncated to
+     *  the available span so a long label (a narrow pane, or a long `kill <name>?`
+     *  confirm) never spills past the corner. */
+    borderRow(lc, rc, label, width) {
+        const B = this.palette.border;
+        const span = Math.max(1, width - 5); // lc ─ _ <span> _ ─… rc
+        const lbl = truncateToWidth(label, span, '…');
+        const fill = Math.max(0, width - 5 - visibleWidth(lbl));
+        return `${B(`${lc}─`)} ${lbl} ${B('─'.repeat(fill) + rc)}`;
+    }
+    // -------------------------------------------------------------------------
+    handleInput(data) {
+        try {
+            this.dispatch(data);
+        }
+        catch {
+            /* a key handler is best-effort; never throw out of the input pump */
+        }
+    }
+    dispatch(data) {
+        // y/n confirm gate takes precedence over everything.
+        if (this.pendingConfirm !== undefined) {
+            if (matchesKey(data, 'y')) {
+                const act = this.pendingConfirm.action;
+                this.pendingConfirm = undefined;
+                act();
+            }
+            else {
+                this.pendingConfirm = undefined; // any other key cancels
+            }
+            this.tui.requestRender();
+            return;
+        }
+        if (matchesKey(data, 'escape')) {
+            this.close();
+            return;
+        }
+        const rows = buildGraphModel(this.self, this.folds);
+        let idx = rows.findIndex((r) => r.id === this.cursorId);
+        if (idx < 0)
+            idx = Math.max(0, rows.findIndex((r) => r.id === this.self));
+        const cur = rows[idx];
+        if (matchesKey(data, 'j')) {
+            idx = Math.min(rows.length - 1, idx + 1);
+            this.cursorId = rows[idx]?.id ?? this.cursorId;
+            this.tui.requestRender();
+            return;
+        }
+        if (matchesKey(data, 'k')) {
+            idx = Math.max(0, idx - 1);
+            this.cursorId = rows[idx]?.id ?? this.cursorId;
+            this.tui.requestRender();
+            return;
+        }
+        if (matchesKey(data, 'g')) {
+            this.cursorId = rows[0]?.id ?? this.cursorId;
+            this.tui.requestRender();
+            return;
+        }
+        if (matchesKey(data, 'shift+g')) {
+            this.cursorId = rows[rows.length - 1]?.id ?? this.cursorId;
+            this.tui.requestRender();
+            return;
+        }
+        if (matchesKey(data, 'h')) {
+            if (cur !== undefined && cur.hasKids && !cur.collapsed) {
+                this.userCollapsed.add(cur.id);
+                this.userExpanded.delete(cur.id);
+            }
+            else {
+                const p = managerOf(this.cursorId ?? this.self);
+                if (p !== undefined && rows.some((r) => r.id === p))
+                    this.cursorId = p;
+            }
+            this.tui.requestRender();
+            return;
+        }
+        if (matchesKey(data, 'l')) {
+            if (cur !== undefined && cur.collapsed && cur.hasKids) {
+                this.userExpanded.add(cur.id);
+                this.userCollapsed.delete(cur.id);
+            }
+            else if (cur !== undefined && cur.hasKids) {
+                const c = sortedChildIds(cur.id)[0];
+                if (c !== undefined)
+                    this.cursorId = c;
+            }
+            this.tui.requestRender();
+            return;
+        }
+        if (matchesKey(data, 'enter')) {
+            if (this.cursorId !== undefined)
+                this.focusTarget(this.cursorId);
+            this.close();
+            return;
+        }
+        if (matchesKey(data, 'm')) {
+            const mgr = managerOf(this.self);
+            if (mgr !== undefined) {
+                this.focusTarget(mgr);
+                this.close();
+            }
+            return;
+        }
+        if (matchesKey(data, 'x')) {
+            const target = this.cursorId ?? this.self;
+            const n = cNode(target);
+            const nm = n !== null ? fullName(n) : shortId(target);
+            this.pendingConfirm = { label: `kill ${nm}?`, action: () => this.shellCrtr(['node', 'close', '--node', target]) };
+            this.tui.requestRender();
+            return;
+        }
+        // Modal: swallow everything else (incl. the `e` tmux-menu bind) so a stray
+        // key never reaches the editor underneath.
+    }
+    // -------------------------------------------------------------------------
+    /** Focus node `id` from the overlay by shelling `crtr node focus <id> --pane <here>`.
+     *  Under the one-viewer-per-node model `--pane` is the ANCHOR to open beside: if
+     *  `id` has no viewer yet a fresh one splits beside this pane; if it already has
+     *  one, that viewer is navigated in place (this pane is left as-is). We pass
+     *  TMUX_PANE explicitly so the anchor is THIS pane even if env resolution differs. */
+    focusTarget(id) {
+        const argv = ['node', 'focus', id];
+        const pane = process.env['TMUX_PANE'];
+        if (pane !== undefined && pane !== '')
+            argv.push('--pane', pane);
+        this.shellCrtr(argv);
+    }
+    shellCrtr(argv) {
+        try {
+            execFile('crtr', argv, () => { });
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+}

package/dist/clients/attach/input-controller.d.ts

@@ -1,6 +1,8 @@
 import type { CustomEditor } from '@earendil-works/pi-coding-agent';
-import type { KeybindingsManager, TUI } from '@earendil-works/pi-tui';
-import { type BrokerSnapshot, type ClientToBroker, type RpcExtensionUIRequest, type RpcExtensionUIResponse } from '../../core/runtime/broker-protocol.js';
+import type { Component, KeybindingsManager, TUI } from '@earendil-works/pi-tui';
+import { type BrokerDataFrame, type BrokerSnapshot, type ClientToBroker, type RpcExtensionUIRequest, type RpcExtensionUIResponse } from '../../core/runtime/broker-protocol.js';
+import type { ReadOpRequest } from './view-socket.js';
+import { type Picker, type PickerControls } from './pickers.js';
 export interface InputControllerHooks {
     /** Send a command frame to the broker. */
     onCommand: (frame: ClientToBroker) => void;
@@ -11,20 +13,56 @@ export interface InputControllerHooks {
      *  reports notices up the same way it reports commands. Absent → notices are
      *  dropped silently. */
     onNotice?: (message: string) => void;
+    /** OPTIONAL: the canvas node this viewer is attached to — forwarded to the
+     *  slash context so `/promote` targets it (Unit Q wires it from runAttach). */
+    nodeId?: string;
+    /** OPTIONAL: toggle the GRAPH overlay — forwarded to the slash context so
+     *  `/graph` opens/closes it (Unit Q wires it from runAttach). */
+    onGraph?: () => void;
+    /** OPTIONAL: detach the viewer — forwarded to the slash context so `/quit`
+     *  tears down the TUI/socket (the engine keeps running). Wired by attach-cmd. */
+    onQuit?: () => void;
+    /** OPTIONAL: copy the last assistant message to the clipboard — forwarded to
+     *  the slash context so `/copy` works. Wired by attach-cmd (it owns ChatView). */
+    onCopy?: () => void;
+    /** OPTIONAL: Ctrl+O / app.tools.expand — flip global tool-output expansion in
+     *  the render layer (ChatView owns the components). Absent → the key no-ops. */
+    onToggleToolsExpand?: () => void;
+    /** OPTIONAL: Ctrl+T / app.thinking.toggle — flip thinking-block visibility in
+     *  the render layer. Absent → the key no-ops. */
+    onToggleThinking?: () => void;
+    /** OPTIONAL: issue a correlated read-op and resolve with the broker's `data`
+     *  reply. MUST be wired by attach-cmd (`onRequest: (f) => socket.request(f)`)
+     *  for the native pickers to work; when absent every picker degrades to a
+     *  text-arg notice. */
+    onRequest?: (frame: ReadOpRequest) => Promise<BrokerDataFrame>;
+    /** OPTIONAL pair: mount/unmount a native picker INLINE in the viewer's layout
+     *  (attach-cmd slots it directly under the editor). When BOTH are wired,
+     *  showPicker uses them instead of a centered overlay; absent → overlay
+     *  fallback. The controller stays layout-agnostic either way (T5/T7 own it). */
+    onMountPicker?: (component: Component) => void;
+    onUnmountPicker?: () => void;
+    /** OPTIONAL: open the native /login provider picker (viewer-local auth flow). */
+    openLoginPicker?: () => void;
+    /** OPTIONAL: open the native /logout provider picker (viewer-local auth flow). */
+    openLogoutPicker?: () => void;
 }
 export declare class InputController {
     private readonly tui;
     private readonly editor;
     private readonly keybindings;
     private readonly hooks;
-    /** Images pasted since the last send, attached to the next prompt/follow-up. */
-    private pendingImages;
-    /** Running base64-byte total of `pendingImages` (review M2 aggregate budget). */
-    private pendingImageBytes;
     /** The currently-rendered blocking dialog, if any (for supersede/dismiss). */
     private dialog;
+    /** The currently-open native picker overlay, if any (for supersede/dismiss). */
+    private picker;
+    /** Monotonic open counter — a slow read-op reply whose `seq` is no longer the
+     *  latest is dropped, so an earlier picker never pops over a later request. */
+    private openSeq;
     /** Latest engine state from `welcome`/`session_info_changed` (for `/session`). */
     private state;
+    /** Timestamp of the last lone Esc, for double-tap → tree detection (0 = none). */
+    private lastEscapeAt;
     constructor(tui: TUI, editor: CustomEditor, keybindings: KeybindingsManager, hooks: InputControllerHooks);
     /** Render a blocking extension dialog and route its answer to the broker.
      *  Supersedes any dialog already on screen (e.g. a re-route on control
@@ -35,20 +73,50 @@ export declare class InputController {
     setState(state: BrokerSnapshot['state']): void;
     private wire;
     private slashContext;
+    /** Send a command frame to the broker (picker selection sink). */
+    private send;
+    /** Fetch a picker payload (narrowed on `kind`), then build + show its overlay
+     *  iff this open is still the latest (m4: a stale slow reply is dropped). Any
+     *  failure — unwired channel, wrong kind, request error, or a throwing builder
+     *  — surfaces a notice instead of an unhandled rejection (m5). */
+    private openPicker;
+    /** Show a picker built by `build` (given a `close` that tears it down).
+     *  Mounted INLINE under the editor when attach-cmd wires onMountPicker/
+     *  onUnmountPicker (the integrated chrome path); otherwise falls back to a
+     *  centered overlay. Supersedes any picker already on screen. Routes focus to
+     *  the builder's declared focus target (an inner list for fork/settings) and
+     *  ALWAYS restores editor focus on close — `OverlayHandle.hide()` only
+     *  auto-restores when the OUTER component held focus, which is not the case
+     *  once we focus an inner child. A throwing builder is caught into a notice (m5). */
+    private showPicker;
+    private openModelPicker;
+    private openSessionPicker;
+    private openTreePicker;
+    private openForkPicker;
+    private openSettingsPicker;
+    private openScopedModelsPicker;
+    /** Open a viewer-local auth picker (login/logout) — uses the same showPicker
+     *  machinery as read-op pickers, but with a locally-built component (no read-op
+     *  request; auth operations are viewer-local in tmux-local attach). */
+    openAuthPicker(build: (controls: PickerControls) => Picker): void;
     private handleSubmit;
     private handleFollowUp;
+    /** Ctrl+G / app.editor.external — open the current editor text in $VISUAL/$EDITOR
+     *  and load the saved result back. Ported from pi's `openExternalEditor`: stop
+     *  the TUI to release the terminal, run the editor with inherited stdio, and on
+     *  a clean exit (status 0) replace the editor text; the socket keeps running in
+     *  the background throughout. */
+    private openExternalEditor;
+    /** Alt+Up / app.message.dequeue — clear the broker's queued steering + follow-up
+     *  messages and restore them to the editor, prepended to any in-progress text
+     *  (pi's `restoreQueuedMessagesToEditor`: queued text first, joined by blank
+     *  lines). A read-AND-mutate op over the correlated request channel. */
+    private handleDequeue;
     /** Send a drive frame iff the WHOLE encoded frame fits under MAX_FRAME_BYTES
      *  (the broker destroys the socket on any line over its 24 MiB read cap). Over
      *  the ceiling → notify + refuse so the caller leaves the editor + pending
      *  images intact for the user to trim, never a socket-destroying overflow. */
     private emitDrive;
     private handlePaste;
-    /** Snapshot the pending images as an `images?` payload (undefined when none)
-     *  WITHOUT clearing — so a frame refused by `emitDrive` (too large) keeps them
-     *  for the user to trim. The caller clears via `clearPendingImages` only after a
-     *  successful send. */
-    private pendingImagesPayload;
-    /** Drop all pending images + reset the aggregate byte counter (after a send). */
-    private clearPendingImages;
     private notify;
 }