pi-extension-utils 0.5.1 → 0.6.0

package/dist/src/client/index.js

@@ -1,11 +1,12 @@
 import { createRemindersClient } from "../reminders/client.js";
-import { createUiClient } from "../ui/client.js";
+import { createTuiModeCapture, createUiClient } from "../ui/client.js";
 import { connectWidgetCoordinator } from "../widgets/client.js";
 let nextClientId = 1;
 export function connect(pi, opts) {
     const clientId = opts.clientId ?? `client-${process.pid}-${Date.now()}-${nextClientId++}`;
     let disposed = false;
-    const coordinator = connectWidgetCoordinator(pi, { ctx: opts.ctx, clientId });
+    const tuiCapture = createTuiModeCapture();
+    const coordinator = connectWidgetCoordinator(pi, { ctx: opts.ctx, clientId, tui: tuiCapture });
     return {
         clientId,
         get mode() {
@@ -13,7 +14,7 @@ export function connect(pi, opts) {
         },
         widgets: coordinator.widgets,
         fullscreen: coordinator.fullscreen,
-        ui: createUiClient(coordinator.fullscreen, opts.ctx),
+        ui: createUiClient(coordinator.fullscreen, opts.ctx, tuiCapture),
         reminders: createRemindersClient(pi, () => disposed),
         dispose() {
             if (disposed)

package/dist/src/pane/overlay.d.ts

@@ -72,7 +72,12 @@ export interface PaneOverlaySplitOptions {
 export interface PaneCollapseOptions {
     key?: string;
     collapsedWidth?: number;
-    label?: string;
+    /**
+     * Legend/divider label for the collapse toggle. A function receives the
+     * current collapsed state so the hint can read e.g. "hide sidebar" when open
+     * and "open sidebar" when collapsed.
+     */
+    label?: string | ((collapsed: boolean) => string);
 }
 export interface PaneOverlayOptions<T = unknown, Row = unknown> {
     primary: PrimaryPaneOptions<Row>;

package/dist/src/pane/overlay.js

@@ -89,6 +89,10 @@ export function paneOverlay(options) {
         let finished = false;
         let focus = "primary";
         let collapsed = false;
+        const collapseLabel = (fallback) => {
+            const label = collapse?.label;
+            return typeof label === "function" ? label(collapsed) : (label ?? fallback);
+        };
         let leftFraction = split.initialFraction ?? 0.5;
         let lastRenderWidth = 80;
         let lastSelectedKey;
@@ -339,7 +343,7 @@ export function paneOverlay(options) {
             if (!collapsed)
                 entries.push({ key: "[/]", label: "resize" });
             if (collapse)
-                entries.push({ key: collapseKey, label: collapse.label ?? "collapse" });
+                entries.push({ key: collapseKey, label: collapseLabel("collapse") });
             for (const action of customActions) {
                 if (action.showInLegend === false)
                     continue;
@@ -453,10 +457,16 @@ export function paneOverlay(options) {
                         : primaryRows.length > primaryHeight
                             ? formatScrollInfo(primaryState.scrollOffset, Math.max(0, primaryRows.length - primaryHeight), { style: "position" })
                             : "");
-                const detailFooterText = resolveValue(options.detail.footer, ctx)
-                    ?? (detailRows.length > detailHeight
+                const detailFooterBase = resolveValue(options.detail.footer, ctx) ??
+                    (detailRows.length > detailHeight
                         ? formatScrollInfo(detailState.scrollOffset, Math.max(0, detailRows.length - detailHeight), { style: "position" })
                         : "");
+                // When the primary pane is collapsed its legend (and the collapse hint with
+                // it) disappears, so the user can't see how to reopen it. Surface the
+                // reopen hint in the always-visible detail footer instead.
+                const detailFooterText = collapsed && collapse
+                    ? [`${collapseKey} ${collapseLabel("expand")}`, detailFooterBase].filter(Boolean).join(" \u00b7 ")
+                    : detailFooterBase;
                 const bottomPrimary = titledBottomSegment(chromeTheme, primaryWidth, primaryFooterText, focus === "primary");
                 const bottomDetail = titledBottomSegment(chromeTheme, detailWidth, detailFooterText, focus === "detail");
                 const bottomBorder = primaryWidth === 0
@@ -474,7 +484,7 @@ export function paneOverlay(options) {
                         primaryCell = infoLines[row - infoStart - 1] ?? "";
                     }
                     else if (legendPlacement === "primary" && row === legendStart && legendLines.length > 0) {
-                        primaryCell = flatRule(chromeTheme, collapse?.label ?? "actions", primaryWidth);
+                        primaryCell = flatRule(chromeTheme, collapse ? collapseLabel("actions") : "actions", primaryWidth);
                     }
                     if (legendPlacement === "primary" && row > legendStart) {
                         const legendIndex = row - legendStart - 1;

package/dist/src/ui/client.d.ts

@@ -4,6 +4,17 @@ export interface FullscreenLeaseLike {
 export interface FullscreenController {
     acquire(): FullscreenLeaseLike;
 }
+/**
+ * Lazily-captured TUI reference used to detect the fullscreen TUI mode.
+ * Populated whenever pi invokes any wrapped UI factory (widget, footer,
+ * editor, custom component). Structural on purpose: the helper must not
+ * depend on pi-tui types directly.
+ */
+export interface TuiModeCapture {
+    noteTui(tui: unknown): void;
+    isFullscreenTui(): boolean;
+}
+export declare function createTuiModeCapture(): TuiModeCapture;
 /**
  * Factory signature accepted by `ctx.ui.custom`. Typed structurally so the
  * helper does not depend on pi-tui types directly.
@@ -19,4 +30,4 @@ export interface UiClient {
 }
 export declare function createUiClient(fullscreen: FullscreenController, ctx: {
     ui: unknown;
-}): UiClient;
+}, capture?: TuiModeCapture): UiClient;

package/dist/src/ui/client.js

@@ -1,4 +1,17 @@
-export function createUiClient(fullscreen, ctx) {
+export function createTuiModeCapture() {
+    let mode;
+    return {
+        noteTui(tui) {
+            const value = tui?.mode;
+            if (typeof value === "string")
+                mode = value;
+        },
+        isFullscreenTui() {
+            return mode === "fullscreen";
+        },
+    };
+}
+export function createUiClient(fullscreen, ctx, capture = createTuiModeCapture()) {
     return {
         async fullscreen(factory) {
             const ui = ctx.ui;
@@ -7,7 +20,22 @@ export function createUiClient(fullscreen, ctx) {
             }
             const lease = fullscreen.acquire();
             try {
-                return await ui.custom(factory);
+                const wrapped = (tui, theme, keybindings, done) => {
+                    capture.noteTui(tui);
+                    return factory(tui, theme, keybindings, done);
+                };
+                // In the fullscreen TUI a plain custom component mounts inside the
+                // bottom dock (the editor slot), where the dock layout shrinks and
+                // clips it while the transcript tail renders above it. Mount it as a
+                // full-screen overlay instead so the component owns the whole screen,
+                // matching the regular-TUI behavior it was designed for.
+                const options = capture.isFullscreenTui()
+                    ? {
+                        overlay: true,
+                        overlayOptions: { anchor: "top-left", width: "100%", maxHeight: "100%" },
+                    }
+                    : undefined;
+                return await ui.custom(wrapped, options);
             }
             finally {
                 lease.release();

package/dist/src/widgets/client.d.ts

@@ -1,4 +1,5 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { type TuiModeCapture } from "../ui/client.ts";
 import { type WidgetFactory, type WidgetPlacement } from "./protocol.ts";
 export interface WidgetSetOptions {
     order?: number;
@@ -22,6 +23,8 @@ export interface WidgetCoordinatorClient {
 interface WidgetCoordinatorClientOptions {
     ctx: ExtensionContext;
     clientId: string;
+    /** Optional shared TUI-mode capture fed by every widget factory invocation. */
+    tui?: TuiModeCapture;
 }
 export declare function connectWidgetCoordinator(pi: ExtensionAPI, opts: WidgetCoordinatorClientOptions): WidgetCoordinatorClient;
 export {};

package/dist/src/widgets/client.js

@@ -1,5 +1,11 @@
 import { basePayload, EVENTS, PROTOCOL_VERSION } from "./protocol.js";
 let nextLeaseId = 1;
+function withTuiCapture(factory, capture) {
+    return (tui, theme) => {
+        capture.noteTui(tui);
+        return factory(tui, theme);
+    };
+}
 export function connectWidgetCoordinator(pi, opts) {
     const { clientId } = opts;
     const widgets = new Map();
@@ -78,13 +84,18 @@ export function connectWidgetCoordinator(pi, opts) {
             set(placement, key, factory, setOpts = {}) {
                 if (disposed)
                     return;
-                const record = { placement, key, factory, order: setOpts.order ?? 0 };
+                const record = {
+                    placement,
+                    key,
+                    factory: opts.tui ? withTuiCapture(factory, opts.tui) : factory,
+                    order: setOpts.order ?? 0,
+                };
                 widgets.set(widgetId(placement, key), record);
                 if (coordinated) {
                     emitRegister(record);
                 }
                 else if (leases.size === 0) {
-                    opts.ctx.ui.setWidget(key, factory, { placement });
+                    opts.ctx.ui.setWidget(key, record.factory, { placement });
                 }
             },
             remove(placement, key) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-extension-utils",
-	"version": "0.5.1",
+	"version": "0.6.0",
 	"description": "Shared Pi extension utilities for coordinated widgets, fullscreen leases, and logging.",
 	"type": "module",
 	"main": "./dist/src/index.js",