@north-light/crouter 0.3.170 → 0.3.171

package/dist/clients/attach/overlays/help.js

@@ -0,0 +1,204 @@
+import { matchesKey, truncateToWidth, visibleWidth, } from '@earendil-works/pi-tui';
+import { ATTACH_CONTROL_BINDINGS, BINDING_CATALOG, formatBinding, matchesPiTuiInput, } from '../../../core/keybindings/index.js';
+const HEIGHT_PCT = 0.72;
+const OVERLAY_OPTIONS = { anchor: 'center', width: '72%', minWidth: 48, maxHeight: '72%', margin: 1 };
+/** A bounded, focused reference for the attach viewer's viewport controls. */
+export class HelpOverlay {
+    tui;
+    pal;
+    handle;
+    bindings;
+    scrollTop = 0;
+    lastContentRows = 1;
+    constructor(tui, pal) {
+        this.tui = tui;
+        this.pal = pal;
+    }
+    /** Re-resolve key spellings after `/reload` (mirrors GraphOverlay.setBindings). */
+    setBindings(bindings) {
+        this.bindings = bindings;
+        if (this.handle !== undefined)
+            this.tui.requestRender();
+    }
+    toggle() {
+        if (this.handle === undefined)
+            this.open();
+        else
+            this.close();
+    }
+    close() {
+        if (this.handle === undefined)
+            return;
+        this.handle.hide();
+        this.handle = undefined;
+        this.tui.requestRender();
+    }
+    isOpen() {
+        return this.handle !== undefined;
+    }
+    invalidate() {
+        if (this.handle !== undefined)
+            this.tui.requestRender();
+    }
+    render(width) {
+        const panelWidth = Math.max(1, width);
+        if (panelWidth < 5)
+            return this.renderNarrow(panelWidth);
+        const innerWidth = panelWidth - 4;
+        const allLines = this.body(innerWidth);
+        const terminalRows = Math.max(1, this.tui.terminal.rows);
+        const maxPanelHeight = Math.max(3, Math.min(Math.floor(terminalRows * HEIGHT_PCT), Math.max(3, terminalRows - 2)));
+        const bodyRows = Math.max(1, maxPanelHeight - 2);
+        const overflow = allLines.length > bodyRows;
+        const contentRows = overflow && bodyRows >= 3 ? bodyRows - 2 : 1;
+        this.lastContentRows = contentRows;
+        this.scrollTop = Math.max(0, Math.min(this.scrollTop, Math.max(0, allLines.length - contentRows)));
+        const end = Math.min(allLines.length, this.scrollTop + contentRows);
+        const body = [];
+        if (overflow && bodyRows >= 3) {
+            body.push(this.scrollTop > 0 ? this.pal.muted(`↑ ${this.scrollTop} more`) : '');
+        }
+        body.push(...allLines.slice(this.scrollTop, end));
+        if (overflow && bodyRows >= 3) {
+            body.push(end < allLines.length ? this.pal.muted(`↓ ${allLines.length - end} more`) : '');
+        }
+        else if (overflow && bodyRows === 2) {
+            body.push(end < allLines.length ? this.pal.muted(`↓ ${allLines.length - end} more`) : '');
+        }
+        while (body.length < bodyRows)
+            body.push('');
+        const title = this.pal.bold(this.pal.accent('⌨ attach help'));
+        const hint = this.pal.muted('esc dismiss · ↑↓ scroll');
+        return [
+            this.borderRow('╭', '╮', title, panelWidth),
+            ...body.map((line) => this.boxRow(line, panelWidth)),
+            this.borderRow('╰', '╯', hint, panelWidth),
+        ].map(this.pal.surface);
+    }
+    handleInput(data) {
+        if (matchesKey(data, 'escape') || matchesKey(data, 'q')) {
+            this.close();
+            return true;
+        }
+        if (matchesKey(data, 'up') || this.matchesBinding('crtr.attach.scroll.up', data))
+            return this.scrollBy(-1);
+        if (matchesKey(data, 'down') || this.matchesBinding('crtr.attach.scroll.down', data))
+            return this.scrollBy(1);
+        if (matchesKey(data, 'pageUp') || this.matchesBinding('crtr.attach.scroll.page-up', data))
+            return this.scrollBy(-this.pageSize());
+        if (matchesKey(data, 'pageDown') || this.matchesBinding('crtr.attach.scroll.page-down', data))
+            return this.scrollBy(this.pageSize());
+        return true;
+    }
+    open() {
+        this.scrollTop = 0;
+        this.handle = this.tui.showOverlay(this, OVERLAY_OPTIONS);
+    }
+    matchesBinding(id, data) {
+        return this.bindings !== undefined && matchesPiTuiInput(this.bindings, id, data, (input, gesture) => matchesKey(input, gesture));
+    }
+    scrollBy(lines) {
+        const lineCount = this.body(Math.max(1, this.tui.terminal.columns - 4)).length;
+        const maxTop = Math.max(0, lineCount - this.lastContentRows);
+        const next = Math.max(0, Math.min(maxTop, this.scrollTop + lines));
+        if (next !== this.scrollTop) {
+            this.scrollTop = next;
+            this.tui.requestRender();
+        }
+        return true;
+    }
+    pageSize() {
+        return Math.max(1, this.lastContentRows - 1);
+    }
+    body(width) {
+        return this.lines().flatMap((line) => this.wrap(line.text, width).map((text) => this.style(text, line.style)));
+    }
+    lines() {
+        const binding = (id, description) => ({
+            text: `${this.binding(id)}  ${description}`,
+            style: 'plain',
+        });
+        const heading = (text) => ({ text, style: 'heading' });
+        const muted = (text) => ({ text, style: 'muted' });
+        const blank = { text: '', style: 'plain' };
+        const otherKeys = ATTACH_CONTROL_BINDINGS.map(({ actionId }) => {
+            const name = BINDING_CATALOG.find((definition) => definition.id === actionId)?.name ?? actionId;
+            return binding(actionId, name);
+        });
+        return [
+            heading('Scrolling'),
+            binding('crtr.attach.scroll.up', 'scroll one line up'),
+            binding('crtr.attach.scroll.down', 'scroll one line down'),
+            binding('crtr.attach.scroll.page-up', 'scroll one page up'),
+            binding('crtr.attach.scroll.page-down', 'scroll one page down'),
+            binding('crtr.attach.scroll.live', 'return to the live bottom'),
+            muted('mouse wheel (when reporting is on)'),
+            blank,
+            heading('Selection and copy'),
+            { text: 'prefix + [  tmux copy-mode selects and copies the visible screenful; it works even while mouse reporting is on.', style: 'plain' },
+            { text: 'Option-drag (iTerm2, Terminal.app) or Shift-drag (Ghostty, Alacritty, xterm) makes a true terminal selection that bypasses mouse reporting.', style: 'plain' },
+            { text: 'Block-copy commands copy transcript content and are not capped at one screenful.', style: 'plain' },
+            blank,
+            heading('Copy commands'),
+            { text: '/copy  last assistant message.', style: 'plain' },
+            { text: `/copy-message (${this.binding('crtr.attach.copy.message')})  newest copyable block entirely visible in the viewport; otherwise the newest one that intersects it.`, style: 'plain' },
+            { text: "/copy-tool  newest tool call's result text.", style: 'plain' },
+            { text: "/copy-transcript  every copyable block's text, oldest to newest, joined by blank lines.", style: 'plain' },
+            blank,
+            heading('Mouse'),
+            { text: `/mouse or ${this.binding('crtr.attach.mouse.toggle')}  toggle mouse wheel scrolling. Turning it off restores tmux drag-select and copy-mode mouse.`, style: 'plain' },
+            blank,
+            heading('Other attach keys'),
+            ...otherKeys,
+        ];
+    }
+    binding(id) {
+        return this.bindings === undefined ? 'Loading…' : formatBinding(this.bindings, id);
+    }
+    wrap(text, width) {
+        if (text === '')
+            return [''];
+        const limit = Math.max(1, width);
+        const words = text.split(/\s+/);
+        const lines = [];
+        let current = '';
+        for (const word of words) {
+            const candidate = current === '' ? word : `${current} ${word}`;
+            if (current !== '' && visibleWidth(candidate) > limit) {
+                lines.push(truncateToWidth(current, limit, '', true));
+                current = `  ${word}`;
+            }
+            else {
+                current = candidate;
+            }
+        }
+        if (current !== '')
+            lines.push(truncateToWidth(current, limit, '', true));
+        return lines;
+    }
+    style(text, style) {
+        switch (style) {
+            case 'heading': return this.pal.bold(this.pal.accent(text));
+            case 'muted': return this.pal.muted(text);
+            case 'plain': return text;
+        }
+    }
+    boxRow(content, width) {
+        const innerWidth = width - 4;
+        const clipped = truncateToWidth(content, innerWidth, '', true);
+        const padding = ' '.repeat(Math.max(0, innerWidth - visibleWidth(clipped)));
+        return `${this.pal.border('│')} ${clipped}${padding} ${this.pal.border('│')}`;
+    }
+    borderRow(left, right, label, width) {
+        if (width < 6)
+            return truncateToWidth(`${this.pal.border(left)}${label}${this.pal.border(right)}`, width, '', true);
+        const span = width - 5;
+        const clipped = truncateToWidth(label, span, '…');
+        const fill = Math.max(0, width - 5 - visibleWidth(clipped));
+        return `${this.pal.border(`${left}─`)} ${clipped} ${this.pal.border('─'.repeat(fill) + right)}`;
+    }
+    renderNarrow(width) {
+        const title = truncateToWidth(this.pal.bold(this.pal.accent('help')), width, '', true);
+        return [this.pal.surface(title)];
+    }
+}

package/dist/clients/attach/render/chat-view.d.ts

@@ -1,8 +1,24 @@
-import { Container, type TUI } from '@earendil-works/pi-tui';
+import { Container, type Component, type TUI } from '@earendil-works/pi-tui';
 import { type AgentSessionEvent } from '@earendil-works/pi-coding-agent';
 import type { BrokerSnapshot } from '../../../core/runtime/broker-protocol.js';
 import { type AttachPalette } from '../config.js';
+import { type ToolGroupSummary } from '../../../shared/tool-groups.js';
+import { type ViewportSource } from './measured-container.js';
 import type { CondensedHistoryMode } from '../../../types.js';
+export type ToolDisplayToggle = {
+    kind: 'summaries';
+    shown: boolean;
+} | {
+    kind: 'output';
+    expanded: boolean;
+};
+export type CopyBlockKind = 'user' | 'assistant' | 'tool' | 'condensed';
+/** One copyable unit, bound to the exact top-level component the viewport addresses. */
+export interface CopyBlock {
+    block: Component;
+    kind: CopyBlockKind;
+    text: string;
+}
 export interface ChatViewOptions {
     /** Working dir used by `ToolExecutionComponent` for path/diff display. Defaults
      *  to the viewer's cwd; T7 may pass the node's working dir for nicer paths. */
@@ -46,6 +62,9 @@ export declare class ChatView {
     private readonly historyContainer;
     /** Activity/status area below history. Holds working/compaction/retry loaders. */
     private readonly statusContainer;
+    /** Optional banner, above history and status in the viewport's flat source. */
+    private readonly bannerContainer;
+    private readonly transcript;
     /** Where `append()` puts a component. Normally `historyContainer`; retargeted to
      *  a nested container while condensed history is being built, so the same
      *  message-rendering path serves both regions. */
@@ -65,6 +84,14 @@ export declare class ChatView {
      *  call line. Independent of `toolOutputExpanded` — it survives an expand/collapse
      *  and only ever applies to tool calls that are done. */
     private foldSettledTools;
+    /** Summary mode only changes Ctrl+O when both persistent settings are on. */
+    private readonly summarizeToolCalls;
+    private showGroupSummaries;
+    /** Groups exist only while building/rendering the full-fidelity live region. */
+    private readonly groups;
+    private openGroup;
+    private readonly groupSummaries;
+    private streamingWasGroupMember;
     private readonly onFooterEvent;
     /** Theme-derived colorizers for the activity/status area. */
     private readonly spinnerStyle;
@@ -106,7 +133,15 @@ export declare class ChatView {
     private readonly transcriptTexts;
     /** Existing file paths found anywhere in the rendered transcript, newest first. */
     private readonly transcriptFilePaths;
+    /** Canonical copyable transcript blocks, in their rendered visual order. */
+    private readonly copyBlockRecords;
+    private readonly copyIndex;
+    /** Registrations made while building condensed history are collapsed onto its
+     * outer container once that container becomes a top-level viewport block. */
+    private readonly condensedCopyBlocks;
     constructor(tui: TUI, container: Container, opts?: ChatViewOptions);
+    /** The transcript as one flat ordered block list for the viewport. */
+    transcriptSource(): ViewportSource;
     /** Render the full message history from a `welcome` snapshot. Ports pi's
      *  `renderSessionContext` (interactive-mode.js:2553): assistant messages spawn
      *  tool-execution components matched to their toolResult messages; everything
@@ -139,17 +174,15 @@ export declare class ChatView {
      *  timers die with the process, but if T7 reuses a ChatView across reconnects in
      *  one process it should call this on detach to avoid a leaked interval. */
     dispose(): void;
-    /** Ctrl+O / app.tools.expand — flip global tool-output expansion and apply it to
-     *  every rendered component that supports it. Returns the new expanded state so
-     *  the caller can surface a notice. Condensed cycles hold no tool components, so
-     *  they are unaffected by design. */
-    toggleToolsExpanded(): boolean;
+    /** Ctrl+O prefers summaries when the user enabled both folding and summary
+     * generation. Otherwise it remains pi's global output expansion toggle. */
+    toggleToolsExpanded(): ToolDisplayToggle;
     /** The `fold finished tool calls` view setting (`/fold-tools`, Alt+C → w → f).
      *  Returns the new state so the caller can surface a notice. */
     toggleFoldSettledTools(): boolean;
     /** Push both display settings onto every rendered component. A tool call still in
-     *  `pendingTools` is in flight, so it is never folded — you keep watching live
-     *  output, and it folds on its own once `tool_execution_end` settles it. */
+     *  flight is never hidden or minimized. Only a settled group with a broker-known
+     *  summary collapses; incomplete/failed generation leaves its folded call lines. */
     private applyToolDisplay;
     /** Ctrl+T / app.thinking.toggle — flip thinking-block visibility and apply it to
      *  every assistant message (the in-flight streaming bubble is itself a child of
@@ -169,7 +202,33 @@ export declare class ChatView {
     private appendAssistantMessage;
     /** Add a separator in transcript order now; it renders only after a following
      * tool settles in the folded view. */
-    private appendFoldedToolSeparator;
+    private appendAssistantSeparator;
+    private appendAssistantPart;
+    private appendUserPart;
+    /** Only the full-fidelity trailing region gets summary groups. Condensed
+     * history intentionally drops tool traffic, so grouping there would create
+     * phantom summary rows and cross the live/condensed boundary. */
+    private isLiveGroupRegion;
+    private ensureGroup;
+    private closeOpenGroup;
+    private appendGroupMember;
+    /** Used for context that may join an existing run but must not create one. */
+    private appendExistingGroupMember;
+    private removeGroupMember;
+    /** Add one tool as a group member, moving the assistant's boundary separator
+     * behind the new summary row without changing the separator's identity. */
+    private appendToolComponent;
+    private settleGroupTool;
+    /** An assistant starts as a non-boundary while its text is empty. The first
+     * visible prose turns it into the boundary without recreating either pi-owned
+     * component (their direct-child cache identities remain intact). */
+    private promoteStreamingAssistantToBoundary;
+    private seedToolGroupSummaries;
+    /** Broker frames can arrive before or after their group's events, and snapshot
+     * rebuilding defers them through the single-writer gate, so this stores first
+     * and applies to every currently-rendered matching group. */
+    applyToolGroupSummary(key: string, summary: ToolGroupSummary): void;
+    private applyGroupDisplay;
     /** Make each separator visible only if its immediately-following tool call is
      * actually folded; in-flight calls remain flush with their live output. */
     private updateFoldedToolSeparators;
@@ -207,6 +266,19 @@ export declare class ChatView {
     /** The text of the most recent assistant message, for `/copy`. Undefined when
      *  no assistant message has been seen (or it had no text content). */
     getLastAssistantText(): string | undefined;
+    /** Copyable source text for a transcript block, if it has any. */
+    blockText(block: Component): string | undefined;
+    /** The canonical ordered copy record, oldest → newest. */
+    copyBlocks(): readonly CopyBlock[];
+    /** Newest tool call's result text (`/copy-tool`). */
+    getLastToolOutputText(): string | undefined;
+    /** Every copyable block's text, oldest → newest, joined by blank lines. */
+    getTranscriptPlainText(): string;
+    private registerCopyBlock;
+    private unregisterCopyBlock;
+    private appendCondensedBlock;
+    /** Flatten arbitrary tool result payloads into the visible text copy target. */
+    private toolResultText;
     private pushTranscriptText;
     private pushTranscriptValue;
     /** Concatenate the text blocks of a user message (string or content array). */