@north-light/crouter 0.3.170 → 0.3.172

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

@@ -4,9 +4,10 @@ export declare class ContextMessageComponent implements Component {
     private readonly label;
     private readonly labelText;
     private readonly collapsedHint;
+    private readonly expandsWithTools;
     private expanded;
     private readonly expandedBody;
-    constructor(body: string, expanded: boolean, dim: (s: string) => string, label: (s: string) => string, labelText?: string, collapsedHint?: string);
+    constructor(body: string, expanded: boolean, dim: (s: string) => string, label: (s: string) => string, labelText?: string, collapsedHint?: string, expandsWithTools?: boolean);
     /** Ctrl+O global tool-output toggle (ChatView.isExpandable duck-type). */
     setExpanded(expanded: boolean): void;
     render(width: number): string[];

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

@@ -1,12 +1,13 @@
 // render/context-message.ts — the terminal viewer's foldable renderer for
-// crouter-generated context. Session bearings, situational updates, fresh-revive
-// kickoffs, context-size nudges, and node inbox digests retain their full model-visible body and
-// runtime role, while this display-only component presents them consistently:
-// collapsed → one dim line; expanded (Ctrl+O) → the ordinary user-message
-// surface, regardless of the message's runtime role. It implements
-// `setExpanded`, so the global tool-display cycle folds these blocks alongside
-// tool output. Classification lives in shared/generated-context.ts; this
-// component only renders the presentation it is handed.
+// 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 renders the disclosure body it
+// receives: collapsed → a padded dim line; expanded (Ctrl+O) → the ordinary
+// user-message surface, regardless of the message's runtime role. Selected
+// cards implement `setExpanded` for the global tool-display cycle; other cards
+// remain folded while tool output is shown. Classification and disclosure
+// selection live in shared/generated-context.ts; this component only renders
+// the presentation it is handed.
 import { UserMessageComponent } from '@earendil-works/pi-coding-agent';
 import { truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
 import { attachMarkdownTheme } from '../config.js';
@@ -19,19 +20,22 @@ export class ContextMessageComponent {
     label;
     labelText;
     collapsedHint;
+    expandsWithTools;
     expanded;
     expandedBody;
-    constructor(body, expanded, dim, label, labelText = LABEL, collapsedHint = COLLAPSED_HINT) {
+    constructor(body, expanded, dim, label, labelText = LABEL, collapsedHint = COLLAPSED_HINT, expandsWithTools = true) {
         this.dim = dim;
         this.label = label;
         this.labelText = labelText;
         this.collapsedHint = collapsedHint;
-        this.expanded = expanded;
+        this.expandsWithTools = expandsWithTools;
+        this.expanded = expandsWithTools && expanded;
         this.expandedBody = new UserMessageComponent(styleAttachMarkdownHeadings(body), attachMarkdownTheme());
     }
     /** Ctrl+O global tool-output toggle (ChatView.isExpandable duck-type). */
     setExpanded(expanded) {
-        this.expanded = expanded;
+        if (this.expandsWithTools)
+            this.expanded = expanded;
     }
     render(width) {
         const w = width > 0 ? width : 80;
@@ -44,8 +48,8 @@ export class ContextMessageComponent {
             const rest = this.collapsedHint;
             const labelW = visibleWidth(labelTag);
             if (labelW >= w)
-                return [this.label(truncateToWidth(labelTag, w, '…'))];
-            return [this.label(labelTag) + this.dim(truncateToWidth(rest, w - labelW, '…'))];
+                return ['', this.label(truncateToWidth(labelTag, w, '…')), ''];
+            return ['', this.label(labelTag) + this.dim(truncateToWidth(rest, w - labelW, '…')), ''];
         }
         const lines = this.expandedBody.render(w);
         if (lines.at(-1) !== '')

package/dist/clients/attach/render/crtr-output.js

@@ -651,9 +651,7 @@ class CrtrResultComponent {
         }
         return clampRenderedLines(['', ...statusLines, ...generic.lines], width);
     }
-    invalidate() {
-        this.context.invalidate?.();
-    }
+    invalidate() { }
 }
 /** First-line convention from crtr-commands/index.ts's pi.sendMessage:
  *  `$ crtr <argv>\n\n<output>`. Help-only here, never suppressOutput: this

package/dist/clients/attach/render/diagram.js

@@ -11,14 +11,14 @@
 //     byte-identical to `--color off`). So the rendered lines are safe to splice
 //     back into markdown inside a plain ``` code fence — pi's Markdown then shows
 //     them verbatim in monospace, no escape-code leakage, no re-wrapping.
-//   • `renderMarkdown` (humanloop — the sole org-wide termrender caller) is
+//   • `renderMarkdown` (crouter's sole org-wide termrender binding) is
 //     synchronous and memoized, so this is a plain string→string transform with
 //     no async swap or component lifecycle.
 //
 // Scope: Mermaid and a single-line `text`/`plain`/untagged Unicode-arrow chain.
 // The wider termrender directive vocabulary remains out of scope — see the base
 // prompt's Diagrams note.
-import { ensureRenderer, isRendererReady, renderMarkdown } from '@crouton-kit/humanloop';
+import { ensureRenderer, isRendererReady, renderMarkdown } from '../../../core/termrender/termrender.js';
 /** A complete Mermaid fence, including normal Markdown's optional three-space
  *  indentation. Line-anchored (m flag), non-greedy body (captured). An unclosed
  *  fence (still streaming) does not match, so mid-stream text is left raw and

package/dist/clients/attach/render/edit-diff.d.ts

@@ -1,4 +1,4 @@
-import { FoldedToolCallController } from './tool-calls.js';
+import { FoldedToolCallController, type FileLineChanges } from './tool-calls.js';
 type ToolResultLike = {
     content?: Array<{
         type?: unknown;
@@ -14,6 +14,9 @@ export type CrtrEditToolView = {
     definition: unknown;
     observeResult: EditResultObserver;
 };
+/** Count only changed rows in pi's display diff; context and ellipsis rows do
+ *  not contribute to the folded file summary. */
+export declare function countDisplayDiffLines(diff: string): FileLineChanges;
 /** Crouter owns edit presentation while the imported tool owns execution. The
  *  card has two explicit phases: streamed argument diff, then executed result
  *  diff. No asynchronous preview can write after settlement. */

package/dist/clients/attach/render/edit-diff.js

@@ -84,11 +84,7 @@ function themeBgRgb(theme, name, fallback) {
         return fallback;
     }
 }
-// ---------------------------------------------------------------------------
-// Diff body rendering
-// ---------------------------------------------------------------------------
-/** pi's display-diff line format: "+123 content" / "-123 content" / " 123 content". */
-function parseDiffLine(line) {
+function parseDisplayDiffLine(line) {
     const match = line.match(/^([+-\s])(\s*\d*)\s(.*)$/);
     if (!match)
         return null;
@@ -96,11 +92,11 @@ function parseDiffLine(line) {
 }
 /** Count only changed rows in pi's display diff; context and ellipsis rows do
  *  not contribute to the folded file summary. */
-function countDiffLines(diff) {
+export function countDisplayDiffLines(diff) {
     let added = 0;
     let removed = 0;
     for (const line of diff.split('\n')) {
-        const parsed = parseDiffLine(line);
+        const parsed = parseDisplayDiffLine(line);
         if (parsed?.prefix === '+')
             added++;
         if (parsed?.prefix === '-')
@@ -185,7 +181,7 @@ function buildDiffBody(diffText, theme, restoreBg) {
     const lines = diffText.split('\n');
     let i = 0;
     while (i < lines.length) {
-        const parsed = parseDiffLine(lines[i]);
+        const parsed = parseDisplayDiffLine(lines[i]);
         if (!parsed) {
             pushLine(theme.fg('toolDiffContext', lines[i]));
             i++;
@@ -194,7 +190,7 @@ function buildDiffBody(diffText, theme, restoreBg) {
         if (parsed.prefix === '-') {
             const removed = [];
             while (i < lines.length) {
-                const p = parseDiffLine(lines[i]);
+                const p = parseDisplayDiffLine(lines[i]);
                 if (!p || p.prefix !== '-')
                     break;
                 removed.push({ lineNum: p.lineNum, content: replaceTabs(p.content) });
@@ -202,7 +198,7 @@ function buildDiffBody(diffText, theme, restoreBg) {
             }
             const added = [];
             while (i < lines.length) {
-                const p = parseDiffLine(lines[i]);
+                const p = parseDisplayDiffLine(lines[i]);
                 if (!p || p.prefix !== '+')
                     break;
                 added.push({ lineNum: p.lineNum, content: replaceTabs(p.content) });
@@ -281,7 +277,7 @@ export function createCrtrEditToolDefinition(cwd, fold = new FoldedToolCallContr
         renderShell: 'self',
         renderCall(args, theme, context) {
             const diff = state.settled ? state.diff : streamedArgumentDiff(args);
-            const changes = state.settled && !state.isError && state.diff ? countDiffLines(state.diff) : undefined;
+            const changes = state.settled && !state.isError && state.diff ? countDisplayDiffLines(state.diff) : undefined;
             const header = foldedFileCallLine('edit', editPath(args), theme, context.cwd ?? cwd, changes);
             if (fold.folded)
                 return fold.capture(new Text(header, 0, 0));

package/dist/clients/attach/render/group-activity.d.ts

@@ -0,0 +1,32 @@
+export type FileActivity = {
+    key: string;
+    displayPath: string;
+    kind: 'edit' | 'write';
+    added: number;
+    removed: number;
+    hasKnownCounts: boolean;
+    countsIncomplete: boolean;
+};
+export type MemoryActivity = {
+    name: string;
+    path?: string;
+};
+export type GroupActivity = {
+    files: readonly FileActivity[];
+    memories: readonly MemoryActivity[];
+};
+/** Per-group recorder. Calls retain only their current transcript references
+ * until they settle; the settled activity is plain immutable evidence. */
+export declare class GroupActivityRecorder {
+    private readonly cwd;
+    private readonly calls;
+    private readonly files;
+    private readonly memories;
+    private readonly memorySet;
+    constructor(cwd: string);
+    noteCall(id: string, name: string, args: unknown): void;
+    settle(id: string, result: unknown, isError: boolean): void;
+    resolveWithoutResult(id: string): void;
+    activity(): GroupActivity;
+    private extract;
+}

package/dist/clients/attach/render/group-activity.js

@@ -0,0 +1,206 @@
+// Deterministic, transcript-derived activity evidence for one folded tool group.
+// This deliberately knows no rendering or broker state: it reduces completed
+// calls into the exact evidence already present in the session transcript.
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { countDisplayDiffLines } from './edit-diff.js';
+const EMPTY_ACTIVITY = Object.freeze({
+    files: Object.freeze([]),
+    memories: Object.freeze([]),
+});
+function object(value) {
+    return typeof value === 'object' && value !== null ? value : undefined;
+}
+function filePath(args) {
+    const value = object(args);
+    const path = value?.file_path ?? value?.path;
+    return typeof path === 'string' && path !== '' ? path : undefined;
+}
+function resultText(result) {
+    const content = object(result)?.content;
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .flatMap((part) => {
+        const value = object(part);
+        return value?.type === 'text' && typeof value.text === 'string' ? [value.text] : [];
+    })
+        .join('');
+}
+function lineCount(content) {
+    if (content.length === 0)
+        return 0;
+    return (content.match(/\n/g)?.length ?? 0) + (content.endsWith('\n') ? 0 : 1);
+}
+/** Shell-level command segments only: a quoted `crtr memory read` is data, not
+ * an invocation. This intentionally handles the same separators the viewer's
+ * command preview treats as command boundaries. */
+function shellSegments(command) {
+    const segments = [];
+    let segment = '';
+    let quote;
+    for (let i = 0; i < command.length; i++) {
+        const char = command[i];
+        if (char === '\\' && quote !== "'") {
+            segment += char + (command[++i] ?? '');
+            continue;
+        }
+        if (quote !== undefined) {
+            if (char === quote)
+                quote = undefined;
+            segment += char;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            segment += char;
+            continue;
+        }
+        if (char === '\n' || char === ';' || char === '|' || char === '&' || char === '(' || char === ')') {
+            if (segment.trim())
+                segments.push(segment);
+            segment = '';
+            continue;
+        }
+        segment += char;
+    }
+    if (segment.trim())
+        segments.push(segment);
+    return segments;
+}
+function shellTokens(segment) {
+    return segment.match(/"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\S+/g)?.map((token) => token.length >= 2 && ((token.startsWith('"') && token.endsWith('"')) || (token.startsWith("'") && token.endsWith("'")))
+        ? token.slice(1, -1)
+        : token) ?? [];
+}
+/** Deliberately match an executable token, not a result-shaped string or a
+ * quoted command fragment. */
+function invokesMemoryRead(args) {
+    const command = object(args)?.command;
+    if (typeof command !== 'string')
+        return false;
+    return shellSegments(command).some((segment) => {
+        const tokens = shellTokens(segment);
+        while (/^[A-Za-z_][A-Za-z0-9_]*=\S+$/.test(tokens[0] ?? ''))
+            tokens.shift();
+        const executable = tokens[0]?.split('/').at(-1);
+        return (executable === 'crtr' || executable === 'crouter') && tokens[1] === 'memory' && tokens[2] === 'read';
+    });
+}
+/** A resolved read starts with the complete three-line identity emitted by
+ * `memory read`; its source path follows as optional display metadata. Links and
+ * discovery output intentionally do not satisfy this shape. */
+function resolvedMemories(result) {
+    const memories = [];
+    const identity = /^- name:\s*([^\r\n]+)\r?\n- kind:\s*[^\r\n]+\r?\n- scope:\s*[^\r\n]+(?:\r?\n- path:\s*([^\r\n]+)|\r?\n\r?\n\*\*path:\*\*\s*([^\r\n]+))?/gm;
+    for (const match of resultText(result).matchAll(identity)) {
+        const name = match[1]?.trim();
+        const path = (match[2] ?? match[3])?.trim();
+        if (name)
+            memories.push(path ? { name, path } : { name });
+    }
+    return memories;
+}
+/** Local mirror of pi's `resolveToCwd`: file tools expand `~` before resolving
+ * against the node cwd, and the recap must key the exact same file identically. */
+function canonicalPath(rawPath, cwd) {
+    const normalized = rawPath === '~'
+        ? homedir()
+        : rawPath.startsWith('~/') ? join(homedir(), rawPath.slice(2)) : rawPath;
+    return resolve(cwd, normalized);
+}
+function fileChange(name, args, result) {
+    if (name === 'edit') {
+        const diff = object(object(result)?.details)?.diff;
+        return typeof diff === 'string'
+            ? { kind: 'edit', ...countDisplayDiffLines(diff), known: true }
+            : { kind: 'edit', added: 0, removed: 0, known: false };
+    }
+    if (name === 'write') {
+        const content = object(args)?.content;
+        return typeof content === 'string'
+            ? { kind: 'write', added: lineCount(content), removed: 0, known: true }
+            : { kind: 'write', added: 0, removed: 0, known: false };
+    }
+    return undefined;
+}
+/** Per-group recorder. Calls retain only their current transcript references
+ * until they settle; the settled activity is plain immutable evidence. */
+export class GroupActivityRecorder {
+    cwd;
+    calls = new Map();
+    files = new Map();
+    memories = [];
+    memorySet = new Set();
+    constructor(cwd) {
+        this.cwd = cwd;
+    }
+    noteCall(id, name, args) {
+        const existing = this.calls.get(id);
+        if (existing?.settled)
+            return;
+        this.calls.set(id, { name, args, settled: false });
+    }
+    settle(id, result, isError) {
+        const entry = this.calls.get(id);
+        if (!entry || entry.settled)
+            return;
+        entry.settled = true;
+        if (!isError && object(result)?.isError !== true)
+            this.extract(entry, result);
+        // Release message-owned references after the operation is reduced.
+        entry.args = undefined;
+    }
+    resolveWithoutResult(id) {
+        const entry = this.calls.get(id);
+        if (!entry || entry.settled)
+            return;
+        entry.settled = true;
+        entry.args = undefined;
+    }
+    activity() {
+        if (this.files.size === 0 && this.memories.length === 0)
+            return EMPTY_ACTIVITY;
+        const files = [...this.files.values()].map((file) => Object.freeze({ ...file }));
+        const memories = this.memories.map((memory) => Object.freeze({ ...memory }));
+        return Object.freeze({ files: Object.freeze(files), memories: Object.freeze(memories) });
+    }
+    extract(entry, result) {
+        if (entry.name === 'bash' && invokesMemoryRead(entry.args)) {
+            for (const memory of resolvedMemories(result)) {
+                if (!this.memorySet.has(memory.name)) {
+                    this.memorySet.add(memory.name);
+                    this.memories.push(memory);
+                }
+            }
+            return;
+        }
+        const rawPath = filePath(entry.args);
+        const change = fileChange(entry.name, entry.args, result);
+        if (!rawPath || !change)
+            return;
+        const pathKey = canonicalPath(rawPath, this.cwd);
+        // Keep edits and writes distinct: a write is its own durable action even
+        // when it touches a path already changed by an edit in this group.
+        const key = `${change.kind}:${pathKey}`;
+        let file = this.files.get(key);
+        if (!file) {
+            file = {
+                key: pathKey,
+                displayPath: rawPath,
+                kind: change.kind,
+                added: 0,
+                removed: 0,
+                hasKnownCounts: false,
+                countsIncomplete: false,
+            };
+            this.files.set(key, file);
+        }
+        file.added += change.added;
+        file.removed += change.removed;
+        file.hasKnownCounts ||= change.known;
+        file.countsIncomplete ||= !change.known;
+    }
+}

package/dist/clients/attach/render/group-recap.d.ts

@@ -0,0 +1,10 @@
+import { Container } from '@earendil-works/pi-tui';
+import type { AttachPalette } from '../config.js';
+import type { ToolGroupSummary } from '../../../shared/tool-groups.js';
+import type { GroupActivity } from './group-activity.js';
+/** Direct history child for a folded group. It is empty (zero rows) unless the
+ * group is eligible to collapse, preserving the member rows for Ctrl+O. */
+export declare class GroupRecapComponent extends Container {
+    setRecap(summary: ToolGroupSummary | undefined, toolCount: number, activity: GroupActivity, detailed: boolean, palette: AttachPalette): void;
+    private addFile;
+}

package/dist/clients/attach/render/group-recap.js

@@ -0,0 +1,93 @@
+// Folded visual recap for one broker-summarized tool group. All evidence arrives
+// pre-reduced from GroupActivityRecorder; this component owns only layout/color.
+import { Container, Spacer, Text, getCapabilities, hyperlink, truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
+import { homedir } from 'node:os';
+import { pathToFileURL } from 'node:url';
+import { ICON } from '../../../core/inspector/model.js';
+import { TOOL_ICON } from '../../../core/preview-registry.js';
+const MEMORY_ICON = String.fromCodePoint(0xf02d);
+function count(value, singular, plural) {
+    return `${value} ${value === 1 ? singular : plural}`;
+}
+function shortened(path) {
+    const home = homedir();
+    return path.startsWith(home) ? `~${path.slice(home.length)}` : path;
+}
+function filePath(file) {
+    const path = shortened(file.displayPath);
+    return getCapabilities().hyperlinks ? hyperlink(path, pathToFileURL(file.key).href) : path;
+}
+function memoryName(memory, palette) {
+    const name = palette.muted(memory.name);
+    return memory.path && getCapabilities().hyperlinks
+        ? hyperlink(name, pathToFileURL(memory.path).href)
+        : name;
+}
+function distinctFileCount(files) {
+    return new Set(files.map((file) => file.key)).size;
+}
+class RecapDetailLine {
+    prefix;
+    path;
+    suffix;
+    constructor(prefix, path, suffix) {
+        this.prefix = prefix;
+        this.path = path;
+        this.suffix = suffix;
+    }
+    invalidate() { }
+    render(width) {
+        const pathWidth = Math.max(1, width - visibleWidth(this.prefix) - visibleWidth(this.suffix));
+        const path = truncateToWidth(this.path, pathWidth, '…');
+        return [truncateToWidth(`${this.prefix}${path}${this.suffix}`, width, '')];
+    }
+}
+/** Direct history child for a folded group. It is empty (zero rows) unless the
+ * group is eligible to collapse, preserving the member rows for Ctrl+O. */
+export class GroupRecapComponent extends Container {
+    setRecap(summary, toolCount, activity, detailed, palette) {
+        this.clear();
+        if (!summary)
+            return;
+        this.addChild(new Spacer(1));
+        if (detailed) {
+            for (const memory of activity.memories) {
+                this.addChild(new RecapDetailLine(`${palette.info(MEMORY_ICON)} `, memoryName(memory, palette), ''));
+            }
+            for (const file of activity.files)
+                this.addFile(file, palette);
+        }
+        const toolCallCount = `${palette.active(TOOL_ICON.bash)} ${palette.muted(count(toolCount, 'tool call', 'tool calls'))}`;
+        if (detailed) {
+            this.addChild(new Text(toolCallCount, 0, 0));
+        }
+        else {
+            const stats = [toolCallCount];
+            if (summary.nodesSpawned >= 1) {
+                stats.push(`${palette.accent(ICON.graph)} ${palette.muted(count(summary.nodesSpawned, 'node spawned', 'nodes spawned'))}`);
+            }
+            const changedFiles = distinctFileCount(activity.files);
+            if (changedFiles >= 1) {
+                stats.push(`${palette.warning(TOOL_ICON.edit)} ${palette.muted(count(changedFiles, 'file changed', 'files changed'))}`);
+            }
+            if (activity.memories.length >= 1) {
+                stats.push(`${palette.info(MEMORY_ICON)} ${palette.muted(count(activity.memories.length, 'memory read', 'memory reads'))}`);
+            }
+            this.addChild(new Text(stats.join(palette.muted(' · ')), 0, 0));
+        }
+        for (const bullet of summary.bullets)
+            this.addChild(new Text(palette.muted(`  • ${bullet.trim()}`), 0, 0));
+        this.addChild(new Spacer(1));
+    }
+    addFile(file, palette) {
+        const counts = file.hasKnownCounts
+            ? `${palette.diffAdded(`+${file.added}`)}${file.kind === 'edit' ? ` ${palette.diffRemoved(`-${file.removed}`)}` : ''}`
+            : '';
+        const availability = file.countsIncomplete
+            ? palette.muted(file.hasKnownCounts ? ' · counts incomplete' : 'counts unavailable')
+            : '';
+        const suffix = counts || availability ? ` ${counts}${availability}` : '';
+        const icon = file.kind === 'write' ? TOOL_ICON.write : TOOL_ICON.edit;
+        this.addChild(new RecapDetailLine(`${palette.warning(icon)} `, filePath(file), suffix));
+    }
+}

package/dist/clients/attach/render/html-markdown.d.ts

@@ -0,0 +1,17 @@
+export interface HtmlMarkdownStyles {
+    kbd: (text: string) => string;
+    mark: (text: string) => string;
+    hint: (text: string) => string;
+}
+export interface HtmlMarkdownOptions {
+    /** Undefined honors each block's `open` attribute. A boolean is the viewer's
+     * global Ctrl+O override. */
+    detailsExpanded: boolean | undefined;
+    styles: HtmlMarkdownStyles;
+}
+/** Transform the strict supported HTML subset in one Markdown string. */
+export declare function transformHtmlMarkdown(source: string, options: HtmlMarkdownOptions): string;
+/** Copy an assistant message for terminal rendering, enhancing only text parts. */
+export declare function transformMessageHtml<T extends {
+    content?: unknown;
+}>(message: T, options: HtmlMarkdownOptions): T;