@north-light/crouter 0.3.159 → 0.3.161

package/dist/clients/attach/render/tool-calls.js

@@ -0,0 +1,251 @@
+// render/tool-calls.ts — attach-viewer call headers for the plain agent tools.
+//
+// pi's builtin renderers name a tool with a bold word (`read <path>`,
+// `$ <the entire command line>`). In the crtr viewer a tool call is a card the
+// human scans, not a shell echo (inline-ui-placement rule 12): each tool gets
+// its own Nerd Font glyph, and `bash` gets a compact, syntax-colored ONE-LINE
+// summary instead of dumping a multi-line command into the transcript. The
+// full command is still one ctrl+o away (rule 10: terse by default, reveal on
+// demand).
+//
+// Only the CALL is re-skinned here; every result renderer stays pi's builtin,
+// so output, truncation, timing and error chrome are untouched.
+import { createBashToolDefinition, createReadToolDefinition, createWriteToolDefinition } from '@earendil-works/pi-coding-agent';
+import { Text, getCapabilities, hyperlink, truncateToWidth, visibleWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
+import { homedir } from 'node:os';
+import { isAbsolute, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { TOOL_ICON } from '../../../core/preview-registry.js';
+function str(value) {
+    return typeof value === 'string' ? value : '';
+}
+/** Key in a tool's shared render-state bag (`context.state`) carrying the
+ *  viewer's fold. `MinimizableToolComponent` sets it; the fold-aware renderCalls
+ *  below read it and emit ONLY their one-line header while it is true, which is
+ *  what makes a folded card exactly `<icon> <tool> <path>` with no body — the
+ *  renderer owns its folded form, no post-hoc slicing of rendered rows. */
+export const FOLDED_STATE_KEY = 'crtrFolded';
+export function isFoldedContext(context) {
+    return context.state?.[FOLDED_STATE_KEY] === true;
+}
+/** The one-line folded form of a file tool's call: `<icon> <label> <path>`. */
+export function foldedFileCallLine(tool, rawPath, theme, cwd) {
+    return `${header(TOOL_ICON[tool], tool, theme)} ${pathDisplay(rawPath, theme, cwd)}`;
+}
+/** `~`-shorten an absolute path the way pi's renderToolPath does (its
+ *  render-utils module is not exported from the package root). */
+function shortenPath(path) {
+    const home = homedir();
+    return path.startsWith(home) ? `~${path.slice(home.length)}` : path;
+}
+/** Accent-colored, OSC-8-linked path — the same affordance pi gives file tools. */
+function pathDisplay(rawPath, theme, cwd) {
+    if (!rawPath)
+        return theme.fg('toolOutput', '...');
+    const styled = theme.fg('accent', shortenPath(rawPath));
+    if (!getCapabilities().hyperlinks)
+        return styled;
+    const absolute = isAbsolute(rawPath) ? rawPath : resolve(cwd, rawPath);
+    return hyperlink(styled, pathToFileURL(absolute).href);
+}
+/** `<icon> <label>` — the glyph in accent, the tool name in pi's tool title style. */
+function header(icon, label, theme) {
+    return `${theme.fg('accent', icon)} ${theme.fg('toolTitle', theme.bold(label))}`;
+}
+/** Prefix a pi-built `Text` in place (its `text` field is TS-private but a plain
+ *  runtime property). Used where the header line is baked into the same string as
+ *  a body we want to keep verbatim — write's syntax-highlighted content preview,
+ *  edit's header inside its own card. Silently no-ops if pi's Text ever stops
+ *  looking like this, so the worst case is a missing glyph, never a crash. */
+export function prefixToolText(component, prefix) {
+    const text = component;
+    if (typeof text.text !== 'string' || typeof text.setText !== 'function')
+        return;
+    if (text.text.startsWith(prefix))
+        return;
+    text.setText(`${prefix}${text.text}`);
+}
+// ---------------------------------------------------------------------------
+// read
+// ---------------------------------------------------------------------------
+/** Attach-viewer `read`: an icon + the path (plus any `:offset-limit` range).
+ *  The call is a single line by construction, so a folded read shows exactly
+ *  what it read and nothing else. */
+export function createCrtrReadToolDefinition(cwd) {
+    const builtin = createReadToolDefinition(cwd);
+    return {
+        name: 'read',
+        label: 'read',
+        description: 'Render read calls with a crtr icon header in the attach viewer.',
+        parameters: {},
+        renderCall(args, theme, context) {
+            const a = args;
+            const raw = str(a?.file_path ?? a?.path);
+            let range = '';
+            if (a?.offset !== undefined || a?.limit !== undefined) {
+                const start = typeof a?.offset === 'number' ? a.offset : 1;
+                const end = typeof a?.limit === 'number' ? start + a.limit - 1 : undefined;
+                range = theme.fg('warning', `:${start}${end !== undefined ? `-${end}` : ''}`);
+            }
+            const line = `${header(TOOL_ICON.read, 'read', theme)} ${pathDisplay(raw, theme, context.cwd ?? cwd)}${range}`;
+            const component = context.lastComponent ?? new Text('', 0, 0);
+            component.setText(line);
+            return component;
+        },
+        renderResult(result, options, theme, context) {
+            return builtin.renderResult(result, options, theme, context);
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// write
+// ---------------------------------------------------------------------------
+/** Attach-viewer `write`: pi's builtin call renderer (it owns the
+ *  syntax-highlighted content preview and its expand hint) with the icon
+ *  prefixed onto its header line. Folded, only that header survives. */
+export function createCrtrWriteToolDefinition(cwd) {
+    const builtin = createWriteToolDefinition(cwd);
+    return {
+        name: 'write',
+        label: 'write',
+        description: 'Render write calls with a crtr icon header in the attach viewer.',
+        parameters: {},
+        renderCall(args, theme, context) {
+            if (isFoldedContext(context)) {
+                const a = args;
+                const line = foldedFileCallLine('write', str(a?.file_path ?? a?.path), theme, context.cwd ?? cwd);
+                // Reuse the previous component when it is Text-like (the builtin's is a
+                // Text subclass), so fold toggles don't churn component identity.
+                const last = context.lastComponent;
+                if (last && typeof last.setText === 'function') {
+                    last.setText(line);
+                    return last;
+                }
+                return new Text(line, 0, 0);
+            }
+            const component = builtin.renderCall(args, theme, context);
+            prefixToolText(component, `${theme.fg('accent', TOOL_ICON.write)} `);
+            return component;
+        },
+        renderResult(result, options, theme, context) {
+            return builtin.renderResult(result, options, theme, context);
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// bash (non-crtr commands; `crtr ...` invocations get the command card in
+// render/crtr-output.ts)
+// ---------------------------------------------------------------------------
+const OPERATOR_RE = /^(&&|\|\||\||;|>>|>|<|2>&1|&)$/;
+/** Split a command into shell-ish tokens, keeping quoted spans whole. */
+function tokenize(line) {
+    return line.match(/"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\S+/g) ?? [];
+}
+/** Color a single command line so it reads at a glance: program name first,
+ *  operators marking the pipeline joints, flags and quoted strings toned to
+ *  their own hues, everything else plain tool output. */
+function styleCommandLine(line, theme) {
+    const tokens = tokenize(line);
+    let atSegmentStart = true;
+    const styled = tokens.map((token) => {
+        if (OPERATOR_RE.test(token)) {
+            atSegmentStart = true;
+            return theme.fg('syntaxOperator', token);
+        }
+        if (atSegmentStart && !token.includes('=')) {
+            atSegmentStart = false;
+            return theme.fg('syntaxFunction', theme.bold(token));
+        }
+        atSegmentStart = false;
+        if (token.startsWith('-'))
+            return theme.fg('muted', token);
+        if (/^["']/.test(token))
+            return theme.fg('syntaxString', token);
+        return theme.fg('toolOutput', token);
+    });
+    return styled.join(' ');
+}
+/** The bash call header. Collapsed it is exactly ONE line — icon, the command's
+ *  first line styled, truncated to the pane with a muted `+N lines` count when
+ *  there is more. Expanded (ctrl+o) it prints every line of the command, wrapped
+ *  (never clipped — expanded is the raw truth) into the pane with continuations
+ *  hanging under the icon. A line wider than the pane would desync pi-tui's line
+ *  accounting against the terminal's own wrapping and garble the frame. */
+class BashCallComponent {
+    command = '';
+    expanded = false;
+    timeout;
+    theme;
+    /** Nothing is cached across paints (render recomputes from the fields), so
+     *  pi's cache-drop hook has nothing to do here. */
+    invalidate() { }
+    update(theme, command, expanded, timeout) {
+        this.theme = theme;
+        this.command = command;
+        this.expanded = expanded;
+        this.timeout = timeout;
+    }
+    render(width) {
+        const theme = this.theme;
+        if (!theme)
+            return [];
+        const icon = theme.fg('accent', TOOL_ICON.bash);
+        const lines = this.command.split('\n').map((line) => line.trim()).filter((line) => line.length > 0);
+        const suffix = this.timeout ? theme.fg('muted', ` (timeout ${this.timeout}s)`) : '';
+        if (lines.length === 0)
+            return [`${icon} ${theme.fg('toolOutput', '...')}`];
+        if (this.expanded) {
+            const prefixWidth = visibleWidth(`${icon} `);
+            const indent = ' '.repeat(prefixWidth);
+            const inner = Math.max(1, width - prefixWidth);
+            const body = [];
+            for (let i = 0; i < lines.length; i++) {
+                let styled = styleCommandLine(lines[i], theme);
+                if (i === lines.length - 1)
+                    styled += suffix;
+                const wrapped = wrapTextWithAnsi(styled, inner);
+                for (let j = 0; j < wrapped.length; j++) {
+                    body.push(`${i === 0 && j === 0 ? `${icon} ` : indent}${wrapped[j]}`);
+                }
+            }
+            // Final backstop: at a pane narrower than the prefix itself the wrap
+            // budget bottoms out at 1 and a wrapped line can still overhang.
+            return body.map((line) => truncateToWidth(line, width, ''));
+        }
+        const more = lines.length > 1 ? theme.fg('muted', ` +${lines.length - 1} lines`) : '';
+        const fixed = visibleWidth(`${icon} `) + visibleWidth(more) + visibleWidth(suffix);
+        const budget = Math.max(8, width - fixed);
+        const first = lines[0];
+        const shown = first.length > budget ? `${first.slice(0, Math.max(1, budget - 1))}…` : first;
+        return [truncateToWidth(`${icon} ${styleCommandLine(shown, theme)}${more}${suffix}`, width)];
+    }
+}
+/** Attach-viewer `bash` for anything that is not a `crtr` invocation. */
+export function createCrtrPlainBashToolDefinition(cwd) {
+    const builtin = createBashToolDefinition(cwd);
+    return {
+        name: 'bash',
+        label: 'bash',
+        description: 'Render plain bash calls as a compact styled command line in the attach viewer.',
+        parameters: {},
+        renderCall(args, theme, context) {
+            const a = args;
+            // pi's builtin bash result renderer reads the elapsed clock off this shared
+            // state, which its own renderCall would have started — keep stamping it so a
+            // running command still shows its duration.
+            const state = context.state;
+            if (state && context.executionStarted && state.startedAt === undefined) {
+                state.startedAt = Date.now();
+                state.endedAt = undefined;
+            }
+            const component = context.lastComponent instanceof BashCallComponent ? context.lastComponent : new BashCallComponent();
+            component.update(theme, str(a?.command), 
+            // Folded wins over ctrl+o expansion: a folded bash is always its one-line form.
+            Boolean(context.expanded) && !isFoldedContext(context), typeof a?.timeout === 'number' ? a.timeout : undefined);
+            return component;
+        },
+        renderResult(result, options, theme, context) {
+            return builtin.renderResult(result, options, theme, context);
+        },
+    };
+}

package/dist/clients/attach/session/input-wiring.d.ts

@@ -15,6 +15,9 @@ export interface InputWiringHooks {
     lastAssistantText: () => string | undefined;
     /** Ctrl+O — flip global tool-output expansion; returns the new state. */
     toggleToolsExpanded: () => boolean;
+    /** `/fold-tools` — flip the fold-finished-tool-calls view setting; returns the
+     *  new state. */
+    toggleFoldTools: () => boolean;
     /** Ctrl+T — flip thinking-block visibility; returns true when now HIDDEN. */
     toggleThinking: () => boolean;
     /** `/graph` and the graph keybinding. */

package/dist/clients/attach/session/input-wiring.js

@@ -80,6 +80,9 @@ export function createInputController(ctx, km, hooks) {
         // state owned by ChatView, surfaced as a footer notice mirroring pi's
         // status line.
         onToggleToolsExpand: () => setNotice(hooks.toggleToolsExpanded() ? 'Tool output: expanded' : 'Tool output: collapsed'),
+        onFoldTools: () => setNotice(hooks.toggleFoldTools()
+            ? 'Finished tool calls: folded to one line'
+            : 'Finished tool calls: shown in full'),
         onToggleThinking: () => setNotice(hooks.toggleThinking() ? 'Thinking blocks: hidden' : 'Thinking blocks: visible'),
         // The correlated read-op channel the native pickers (/model, /resume,
         // /fork, /tree, /settings, /scoped-models) fetch their payloads over.

package/dist/clients/attach/slash/dispatch.d.ts

@@ -71,6 +71,10 @@ export interface SlashContext {
     onColor?: (color: string | null) => void;
     /** Open the focused node's progressively disclosed metadata dossier. */
     onNodeMetadata?: () => void;
+    /** `/fold-tools` — flip the "fold finished tool calls" view setting. Pure
+     *  viewer-local render state (ChatView owns it), so it is safe for an observer
+     *  and for a remote attach. Absent → the command notifies it is unwired. */
+    onFoldTools?: () => void;
 }
 /** Canvas slash-commands — implemented NATIVE in the viewer, the ONLY live host:
  *  the broker binds mode:'rpc', so broker pi-extensions never run their

package/dist/clients/attach/slash/dispatch.js

@@ -42,6 +42,7 @@ export const CANVAS_SLASH_COMMANDS = [
     { name: 'mcp', description: 'MCP servers — status from the adapter’s config/cache; Enter (or /mcp <server>) connects, reconnects, or re-auths' },
     { name: 'rename', description: 'Rename this node everywhere — node row, viewer window, session chip, tmux pane: /rename <name>' },
     { name: 'color', description: 'Color this node — tmux pane outline + name chip: /color <color> (red, blue, #rrggbb, …) or /color none' },
+    { name: 'fold-tools', description: 'View setting — fold every FINISHED tool call to its single call line (Alt+C → w → f)' },
 ];
 const CANVAS_NAMES = new Set(CANVAS_SLASH_COMMANDS.map((c) => c.name));
 /** Native canvas commands that shell a LOCAL `crtr` mutation or read against
@@ -394,6 +395,13 @@ function dispatchCanvasCommand(name, arg, ctx) {
             return true;
         case 'color':
             return colorNode(arg, ctx);
+        case 'fold-tools':
+            // Viewer-local render state only — no frame, no CLI, no node mutation.
+            if (ctx.onFoldTools)
+                ctx.onFoldTools();
+            else
+                ctx.notify('The fold-tools view setting is not wired into this viewer');
+            return true;
         default:
             ctx.notify(`/${name} is not available in attach`);
             return true;