@north-light/crouter 0.3.198 → 0.3.200

package/dist/clients/attach/render/page-block.d.ts

@@ -0,0 +1,34 @@
+import type { Component } from '@earendil-works/pi-tui';
+export interface InlinePageRef {
+    pageId: string;
+    dir: string;
+}
+/**
+ * The inline page a `human send` tool result announces, or undefined for every
+ * other result. Read from the structured CLI record the canvas-preview extension
+ * attaches (`details.crtrPreview`), which is present on both live tool events and
+ * rebuilt snapshot messages — never from the rendered bash text.
+ */
+export declare function detectInlinePageResult(result: unknown): InlinePageRef | undefined;
+export declare class PageBlockComponent implements Component {
+    readonly pageId: string;
+    private readonly dir;
+    private readonly openHint;
+    private expanded;
+    private generation;
+    private stamp;
+    private snapshot;
+    private cache;
+    constructor(pageId: string, dir: string, openHint: () => string);
+    /** Re-read the ticket when its request or its result changed on disk. */
+    refresh(): boolean;
+    /** Ctrl+O global expansion (ChatView.isExpandable duck-type). */
+    setExpanded(expanded: boolean): void;
+    render(width: number): string[];
+    invalidate(): void;
+    private diskStamp;
+    private reload;
+    private compose;
+    private bodyLines;
+    private footerLine;
+}

package/dist/clients/attach/render/page-block.js

@@ -0,0 +1,226 @@
+// render/page-block.ts — the transcript home for an inline page.
+//
+// `crtr human send --placement inline` puts a page in THIS conversation, and in
+// crouter the conversation is the attach viewer's transcript. So the page gets a
+// durable block anchored where it was sent, exactly as the assistant's prose is
+// anchored: the inbox stays purely the queue (a page sent `--no-inbox` has no
+// queue entry at all and would otherwise be invisible here), while this block is
+// what the person actually reads.
+//
+// The block renders from the ticket directory on disk, never from the tool
+// result text, so `--replace` revisions and the answer that settles a page both
+// land on the already-placed block when `refresh()` is driven by the viewer's
+// inbox-activity watcher.
+import { statSync } from 'node:fs';
+import { parsePage } from '../../../core/human/page.js';
+import { pageManifestPath, responsePath } from '../../../core/human/convention.js';
+import { pageTicketState, readTicketResult } from '../../../core/human/tickets.js';
+import { renderMarkdownBlockAwareLines } from '../../../core/termrender/termrender.js';
+import { describeSlot, tableMarkdown, terminalAnswerable } from '../../inbox/tui/slots.js';
+import { BOLD, CYAN, DIM, GREEN, RESET, YELLOW, sanitize, singleLine, truncate, wrap } from '../../inbox/tui/ansi.js';
+/** Rows of page body shown while the block is folded; Ctrl+O expands it. */
+const FOLDED_BODY_LINES = 16;
+/**
+ * The inline page a `human send` tool result announces, or undefined for every
+ * other result. Read from the structured CLI record the canvas-preview extension
+ * attaches (`details.crtrPreview`), which is present on both live tool events and
+ * rebuilt snapshot messages — never from the rendered bash text.
+ */
+export function detectInlinePageResult(result) {
+    if (result === null || typeof result !== 'object')
+        return undefined;
+    const details = result['details'];
+    if (details === null || typeof details !== 'object')
+        return undefined;
+    const preview = details['crtrPreview'];
+    if (preview === null || typeof preview !== 'object')
+        return undefined;
+    const record = preview;
+    if (record['path'] !== 'human send')
+        return undefined;
+    const payload = record['result'];
+    if (payload === null || typeof payload !== 'object')
+        return undefined;
+    const fields = payload;
+    const pageId = fields['page_id'];
+    const dir = fields['dir'];
+    if (typeof pageId !== 'string' || typeof dir !== 'string')
+        return undefined;
+    if (fields['placement'] !== 'inline')
+        return undefined;
+    return { pageId, dir };
+}
+function mtimeOf(path) {
+    try {
+        return String(statSync(path).mtimeMs);
+    }
+    catch {
+        return '-';
+    }
+}
+export class PageBlockComponent {
+    pageId;
+    dir;
+    openHint;
+    expanded = false;
+    generation = 0;
+    stamp = '';
+    snapshot;
+    cache;
+    constructor(pageId, dir, openHint) {
+        this.pageId = pageId;
+        this.dir = dir;
+        this.openHint = openHint;
+        this.reload();
+    }
+    /** Re-read the ticket when its request or its result changed on disk. */
+    refresh() {
+        if (this.diskStamp() === this.stamp)
+            return false;
+        this.reload();
+        return true;
+    }
+    /** Ctrl+O global expansion (ChatView.isExpandable duck-type). */
+    setExpanded(expanded) {
+        if (expanded === this.expanded)
+            return;
+        this.expanded = expanded;
+        this.cache = undefined;
+    }
+    render(width) {
+        const w = width > 0 ? width : 80;
+        const cached = this.cache;
+        if (cached !== undefined && cached.width === w && cached.generation === this.generation && cached.expanded === this.expanded) {
+            return cached.lines;
+        }
+        const lines = this.compose(w);
+        this.cache = { width: w, generation: this.generation, expanded: this.expanded, lines };
+        return lines;
+    }
+    invalidate() {
+        this.cache = undefined;
+    }
+    diskStamp() {
+        return `${mtimeOf(pageManifestPath(this.dir))}|${mtimeOf(responsePath(this.dir))}`;
+    }
+    reload() {
+        this.stamp = this.diskStamp();
+        this.generation++;
+        this.cache = undefined;
+        try {
+            const manifest = parsePage(this.dir);
+            const state = pageTicketState(this.dir);
+            const digest = state === 'resolved' ? readTicketResult(this.dir) : null;
+            this.snapshot = {
+                manifest,
+                state,
+                ...(digest?.kind === 'page' ? { answerDigest: digest.summary.replace(/\s+/g, ' ').trim() } : {}),
+            };
+        }
+        catch {
+            // A removed or half-written ticket keeps whatever was last read; a block
+            // that never read one renders its unavailable line instead.
+            if (this.snapshot === undefined)
+                this.snapshot = undefined;
+        }
+    }
+    compose(width) {
+        const snapshot = this.snapshot;
+        if (snapshot === undefined)
+            return ['', `  ${DIM}[page] no longer available${RESET}`, ''];
+        const maxW = Math.min(Math.max(20, width - 4), 100);
+        const out = ['', `  ${BOLD}${CYAN}${truncate(sanitize(singleLine(snapshot.manifest.title)), maxW)}${RESET}`];
+        if (snapshot.manifest.subtitle) {
+            for (const line of wrap(sanitize(snapshot.manifest.subtitle), maxW))
+                out.push(`  ${DIM}${line}${RESET}`);
+        }
+        const body = this.bodyLines(snapshot.manifest, maxW, Math.max(20, width - 4));
+        if (body.length > 0) {
+            out.push('');
+            const shown = this.expanded || body.length <= FOLDED_BODY_LINES ? body : body.slice(0, FOLDED_BODY_LINES);
+            for (const line of shown)
+                out.push(`  ${line}`);
+            if (shown.length < body.length)
+                out.push(`  ${DIM}… +${body.length - shown.length} lines — ctrl+o to expand${RESET}`);
+        }
+        const footer = this.footerLine(snapshot, maxW);
+        if (footer !== undefined)
+            out.push('', `  ${footer}`);
+        out.push('');
+        return out;
+    }
+    bodyLines(manifest, maxW, paneW) {
+        const md = (text) => renderMarkdownBlockAwareLines(text, maxW, paneW);
+        if (manifest.dialect === 'html')
+            return [`${DIM}HTML page — opens in a browser surface${RESET}`];
+        // Display components (Card, Alert, the rest of the shadcn set) are page markup,
+        // not manifest slots, so a page built only from them keeps nothing here a
+        // terminal could draw. Say so rather than paint a title over an empty body.
+        if (manifest.slots.length === 0)
+            return [`${DIM}display-only page — its content renders in Northlight${RESET}`];
+        const lines = [];
+        let priorStep = -1;
+        for (const slot of manifest.slots) {
+            if (manifest.steps > 1 && slot.step !== priorStep) {
+                if (lines.length > 0)
+                    lines.push('');
+                lines.push(`${BOLD}Step ${slot.step + 1}/${manifest.steps}${RESET}`);
+                priorStep = slot.step;
+            }
+            if (lines.length > 0)
+                lines.push('');
+            lines.push(`${BOLD}${truncate(sanitize(singleLine(describeSlot(slot))), maxW)}${RESET}`);
+            const body = slot.config.body;
+            if (typeof body === 'string' && body !== '')
+                lines.push(...md(body));
+            if (!terminalAnswerable(slot)) {
+                lines.push(`${DIM}${sanitize(slot.kind)} — open in Northlight to answer this${RESET}`);
+                continue;
+            }
+            if (slot.kind === 'text') {
+                lines.push(...md(slot.config.initialText));
+            }
+            else if (slot.kind === 'table') {
+                lines.push(...md(tableMarkdown(slot.config)));
+            }
+            else if (slot.kind === 'cards') {
+                for (const card of slot.config.cards ?? []) {
+                    lines.push(`  • ${truncate(sanitize(singleLine(card.subtitle === undefined ? card.title : `${card.title} — ${card.subtitle}`)), Math.max(10, maxW - 4))}`);
+                    if (card.body !== undefined)
+                        for (const line of wrap(sanitize(card.body), Math.max(10, maxW - 6)))
+                            lines.push(`    ${DIM}${line}${RESET}`);
+                }
+            }
+            else if (slot.kind === 'options') {
+                for (const option of slot.config.options) {
+                    lines.push(`  • ${truncate(sanitize(singleLine(option.label)), Math.max(10, maxW - 4))}`);
+                    if (option.description !== undefined)
+                        for (const line of wrap(sanitize(option.description), Math.max(10, maxW - 6)))
+                            lines.push(`    ${DIM}${line}${RESET}`);
+                }
+            }
+            else if (slot.kind === 'chart') {
+                const config = slot.config;
+                const title = config.title ?? `${config.x ?? ''} vs ${(config.y ?? []).map((y) => y.label ?? y.field).join(', ')}`;
+                lines.push(`${DIM}chart — ${sanitize(config.kind ?? 'chart')}: ${sanitize(title)}${RESET}`);
+            }
+        }
+        return lines;
+    }
+    footerLine(snapshot, maxW) {
+        switch (snapshot.state) {
+            case 'pending':
+                return snapshot.manifest.delivery.reply
+                    ? `${YELLOW}▸ awaiting your answer${RESET} ${DIM}— ${sanitize(this.openHint())}${RESET}`
+                    : `${DIM}◦ queued in your inbox — ${sanitize(this.openHint())}${RESET}`;
+            case 'resolved':
+                return snapshot.answerDigest === undefined
+                    ? `${GREEN}✓ answered${RESET}`
+                    : `${GREEN}✓ answered${RESET} ${DIM}— ${truncate(sanitize(snapshot.answerDigest), Math.max(10, maxW - 12))}${RESET}`;
+            case 'canceled':
+                return `${DIM}⊘ canceled${RESET}`;
+            case 'passive':
+                return undefined;
+        }
+    }
+}

package/dist/clients/attach/session/whip.d.ts

@@ -1,5 +1,7 @@
 import { type Component, type TUI } from '@earendil-works/pi-tui';
 import type { AttachPalette } from '../config.js';
+/** The fixed line the plain whip sends — not drawn from `whip_messages`. */
+export declare const GO_FASTER_WHIP_MESSAGE = "Go faster";
 /** A random line, never the one the previous whip used. */
 export declare function randomWhipMessage(messages: readonly string[]): string;
 /** A 20-frame, 12-row header animation that gives the focused agent a playful nudge. */

package/dist/clients/attach/session/whip.js

@@ -306,6 +306,8 @@ const WHIP_FRAMES = [
         ""
     ]
 ];
+/** The fixed line the plain whip sends — not drawn from `whip_messages`. */
+export const GO_FASTER_WHIP_MESSAGE = 'Go faster';
 let lastMessage;
 /** A random line, never the one the previous whip used. */
 export function randomWhipMessage(messages) {