@north-light/api 0.3.579 → 0.3.587

package/dist/clients/attach/render/condensed-history.d.ts

@@ -0,0 +1,21 @@
+import type { CondensedHistoryMode } from '../../../types.js';
+/** A message from the broker snapshot, structurally. */
+type Message = {
+    role?: string;
+    customType?: string;
+};
+export declare function isCycleDivider(message: Message): boolean;
+/** Does this message survive into the condensed region? */
+export declare function keepWhenCondensed(message: Message, mode: CondensedHistoryMode): boolean;
+/**
+ * Index into `messages` at which the LIVE (fully rendered) region begins.
+ *
+ * The snapshot is `[cycle 0][divider][cycle 1][divider]…[current cycle]`, so a
+ * transcript with D dividers holds D+1 cycles. Keeping the trailing
+ * `liveCycles` of them means everything up to and including divider
+ * `D - liveCycles` is condensed. Returns 0 — condense nothing — when the node
+ * has not yielded often enough to have older cycles, so a fresh or
+ * single-yield node renders exactly as it always did.
+ */
+export declare function liveRegionStart(messages: readonly Message[], liveCycles: number): number;
+export {};

package/dist/clients/attach/render/condensed-history.js

@@ -0,0 +1,60 @@
+// condensed-history.ts — lightweight rendering of a node's OLD cycles.
+//
+// A node that has yielded several times carries every prior cycle in its welcome
+// snapshot (cycleAwareMessages, session-cycles.ts). Cycles older than the trailing
+// `live_cycles` (config, default 2) are condensed to cycle dividers plus whichever
+// messages `condensed_history` (config, default `none`) admits. Tool calls and
+// results are excluded; across six measured sessions they accounted for 62.9% of
+// rendered lines and 69% of transcript build time.
+//
+// Retained messages stay as components inside one nested container. Settled lines
+// are cached at a stable pane width, while a width change rerenders the nested
+// content so old prose wraps with the rest of the transcript.
+//
+// The full detail of a condensed cycle remains in the node's session file, and
+// `/tree` navigates the real branches.
+import { CRTR_CYCLE_DIVIDER_CUSTOM_TYPE } from '../../../core/runtime/session-cycles.js';
+/** Roles admitted by each `condensed_history` mode. `toolResult`,
+ *  `bashExecution`, and every non-divider `custom` message (crtr output,
+ *  injected context blocks) are never kept, nor are the tool-call components an
+ *  assistant message would otherwise spawn — only its prose. The cycle dividers
+ *  survive every mode, so `none` leaves the seams and nothing else. */
+const ROLES_BY_MODE = {
+    none: new Set(),
+    user: new Set(['user']),
+    agent: new Set(['assistant', 'compactionSummary', 'branchSummary']),
+    both: new Set(['user', 'assistant', 'compactionSummary', 'branchSummary']),
+};
+export function isCycleDivider(message) {
+    return message.role === 'custom' && message.customType === CRTR_CYCLE_DIVIDER_CUSTOM_TYPE;
+}
+/** Does this message survive into the condensed region? */
+export function keepWhenCondensed(message, mode) {
+    if (isCycleDivider(message))
+        return true;
+    return (ROLES_BY_MODE[mode] ?? ROLES_BY_MODE.none).has(message.role ?? '');
+}
+/**
+ * Index into `messages` at which the LIVE (fully rendered) region begins.
+ *
+ * The snapshot is `[cycle 0][divider][cycle 1][divider]…[current cycle]`, so a
+ * transcript with D dividers holds D+1 cycles. Keeping the trailing
+ * `liveCycles` of them means everything up to and including divider
+ * `D - liveCycles` is condensed. Returns 0 — condense nothing — when the node
+ * has not yielded often enough to have older cycles, so a fresh or
+ * single-yield node renders exactly as it always did.
+ */
+export function liveRegionStart(messages, liveCycles) {
+    const keep = Math.max(1, Math.floor(liveCycles));
+    const dividers = [];
+    for (let i = 0; i < messages.length; i++) {
+        if (isCycleDivider(messages[i]))
+            dividers.push(i);
+    }
+    const cycles = dividers.length + 1;
+    if (cycles <= keep)
+        return 0;
+    // The last divider that closes a condensed cycle; the live region opens just
+    // after it (the divider itself stays in the condensed region as the seam).
+    return dividers[cycles - keep - 1] + 1;
+}

package/dist/clients/attach/render/context-message.d.ts

@@ -0,0 +1,22 @@
+import { type Component } from '@earendil-works/pi-tui';
+import { type CardPresentation } from './card-presentation.js';
+import type { GeneratedCard } from '../../../shared/generated-context.js';
+export declare class ContextMessageComponent implements Component {
+    private readonly dim;
+    private readonly label;
+    private expanded;
+    private readonly expandable;
+    private readonly labelTag;
+    private readonly summaryText;
+    private readonly collapsedHint;
+    private readonly expandedBody;
+    constructor(card: GeneratedCard, presentation: CardPresentation, expanded: boolean, dim: (s: string) => string, label: (s: string) => string);
+    /** Ctrl+O global tool-output toggle (ChatView.isExpandable duck-type). */
+    setExpanded(expanded: boolean): void;
+    /** Paint the [label] tag in the accent color and the rest dim. Truncate
+     *  BEFORE painting so the ANSI wrappers never inflate the measured width — an
+     *  over-wide line aborts the whole TUI render. */
+    private headerRow;
+    render(width: number): string[];
+    invalidate(): void;
+}

package/dist/clients/attach/render/context-message.js

@@ -0,0 +1,63 @@
+// render/context-message.ts — the terminal viewer's foldable renderer for
+// crouter-generated context. Session bearings, situational updates, lifecycle
+// steering, recovery prompts, and inbox digests retain their model-visible body
+// and runtime role. This display-only component paints one parsed card through
+// its presentation: collapsed → a padded dim line; expanded (Ctrl+O) → the
+// ordinary user-message surface, regardless of the message's runtime role.
+// Classification lives in shared/generated-context.ts and every per-kind
+// decision in ./card-presentation.ts; this module owns only the painting.
+import { UserMessageComponent } from '@earendil-works/pi-coding-agent';
+import { truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
+import { attachMarkdownTheme } from '../config.js';
+import { cardDisclosure, cardIsExpandable, cardLabel, } from './card-presentation.js';
+import { styleAttachMarkdownSource } from './markdown-source.js';
+export class ContextMessageComponent {
+    dim;
+    label;
+    expanded;
+    expandable;
+    labelTag;
+    summaryText;
+    collapsedHint;
+    expandedBody;
+    constructor(card, presentation, expanded, dim, label) {
+        this.dim = dim;
+        this.label = label;
+        this.expandable = cardIsExpandable(presentation, card);
+        this.expanded = this.expandable && expanded;
+        this.labelTag = `[${cardLabel(presentation.subject)}]`;
+        this.summaryText = ` ${presentation.summary(card)}`;
+        // A card with nothing to disclose must not advertise the toggle.
+        this.collapsedHint = `${this.summaryText}${this.expandable ? ' — ctrl+o to expand' : ''}`;
+        this.expandedBody = new UserMessageComponent(styleAttachMarkdownSource(cardDisclosure(presentation, card)), attachMarkdownTheme());
+    }
+    /** Ctrl+O global tool-output toggle (ChatView.isExpandable duck-type). */
+    setExpanded(expanded) {
+        if (this.expandable)
+            this.expanded = expanded;
+    }
+    /** Paint the [label] tag in the accent color and the rest dim. Truncate
+     *  BEFORE painting so the ANSI wrappers never inflate the measured width — an
+     *  over-wide line aborts the whole TUI render. */
+    headerRow(w, hint) {
+        const labelW = visibleWidth(this.labelTag);
+        if (labelW >= w)
+            return this.label(truncateToWidth(this.labelTag, w, '…'));
+        return this.label(this.labelTag) + this.dim(truncateToWidth(hint, w - labelW, '…'));
+    }
+    render(width) {
+        const w = width > 0 ? width : 80;
+        // The header stays in BOTH states: expanding replaces the card's body, not
+        // its identity, and consecutive disclosed cards are otherwise a run of
+        // unattributed bubbles.
+        if (!this.expanded)
+            return ['', this.headerRow(w, this.collapsedHint), ''];
+        const lines = this.expandedBody.render(w);
+        if (lines.at(-1) !== '')
+            lines.push('');
+        return ['', this.headerRow(w, this.summaryText), ...lines];
+    }
+    invalidate() {
+        /* stateless — nothing to clear */
+    }
+}

package/dist/clients/attach/render/crtr-output.d.ts

@@ -0,0 +1,52 @@
+import { Box } from '@earendil-works/pi-tui';
+import { FoldedToolCallController } from './tool-calls.js';
+type Theme = {
+    fg: (name: string, text: string) => string;
+    bg: (name: string, text: string) => string;
+    bold: (text: string) => string;
+};
+export declare const CRTR_OUTPUT_CUSTOM_TYPE = "crtr-output";
+export declare function stripHeredocBodies(command: string): string;
+export declare function isCrtrBashCommand(command: unknown): boolean;
+/** True when a crtr bash invocation's OWN argv carries a bare -h/--help
+ *  token — the dispatcher renders the leaf's schema, not a result, so it is
+ *  never useful to preview like a normal command's output (see
+ *  src/core/help.ts renderLeafArgv: schema text, not agent-facing result
+ *  text). Checked against extractCrtrInvocationTokens' tokens (scoped to the
+ *  crtr segment only, quote-aware), never the raw command string — a `-h`
+ *  appearing before the crtr segment (`echo -h && crtr canvas snapshot`),
+ *  after it (`crtr canvas snapshot && echo --help`), or inside a quoted
+ *  argument (`crtr node new "write about -h flags"`) must never count. This is
+ *  structural (every leaf's -h has the same shape), so it needs no per-leaf
+ *  metadata — unlike suppressOutput below, which is command-owned. */
+export declare function isCrtrHelpInvocation(command: unknown): boolean;
+/** Per-render preview state for a crtr bash invocation. Both fields are
+ *  synchronous and structural: isHelp from the invocation's own argv (above),
+ *  suppressOutput from the bundle-safe static registry (preview-registry.ts —
+ *  a hand-maintained mirror of the leaf's own `help.preview.suppressOutput`).
+ *  Neither needs an async
+ *  cross-process command-tree lookup, so there is no cache/resolver/invalidate
+ *  machinery here, and no path from the attach bundle into the command tree.
+ *  Command-owned computed summaries (canvas read, doc lint, ...) are a
+ *  separate lookup entirely — render() below gives summarizePath
+ *  (preview-registry.ts) the private structured CLI result attached by the
+ *  canvas preview extension. Invocation tokens provide only static chrome. */
+export interface CrtrPreviewState {
+    isHelp: boolean;
+    suppressOutput: boolean;
+}
+export declare function commandPreviewMeta(command: string): CrtrPreviewState;
+export declare function renderCrtrOutputText(text: string, theme: Theme, preserveSyntax?: boolean): string;
+export declare class CrtrOutputMessageComponent extends Box {
+    private readonly content;
+    private readonly theme;
+    private body;
+    private expanded;
+    constructor(content: string, expanded: boolean, theme: Theme);
+    setExpanded(expanded: boolean): void;
+}
+export type CrtrBashToolView = {
+    definition: unknown;
+};
+export declare function createCrtrBashToolDefinition(args: unknown, fold?: FoldedToolCallController): CrtrBashToolView | undefined;
+export {};