@north-light/crouter 0.3.163 → 0.3.164

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

@@ -19,14 +19,22 @@ 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;
+/** Per-tool fold state owned by the attach viewer. Tool definitions capture the
+ *  call component they render while folded, so the viewer never reaches into
+ *  `ToolExecutionComponent`'s private renderer fields to recover it. */
+export class FoldedToolCallController {
+    folded = false;
+    component;
+    setFolded(folded) {
+        this.folded = folded;
+    }
+    capture(component) {
+        this.component = component;
+        return component;
+    }
+    callComponent() {
+        return this.component;
+    }
 }
 /** Count file lines the way a diff does: a trailing newline terminates the last
  *  line instead of creating an extra empty one. */
@@ -36,7 +44,7 @@ function countFileLines(content) {
     const newlines = content.match(/\n/g)?.length ?? 0;
     return newlines + (content.endsWith('\n') ? 0 : 1);
 }
-/** The green/red line-count suffix shown after a folded write/edit path. */
+/** The green/red changed-line suffix shown after a folded edit path. */
 function lineChangesDisplay(changes, theme) {
     if (!changes)
         return '';
@@ -47,6 +55,12 @@ function lineChangesDisplay(changes, theme) {
         counts.push(theme.fg('toolDiffRemoved', `-${changes.removed}`));
     return counts.length > 0 ? ` ${counts.join(' ')}` : '';
 }
+/** A write has no before/after diff, so report its output size neutrally. */
+function lineCountDisplay(lines, theme) {
+    if (lines === undefined)
+        return '';
+    return ` ${theme.fg('muted', `${lines} ${lines === 1 ? 'line' : 'lines'}`)}`;
+}
 /** The one-line folded form of a file tool's call: `<icon> <label> <path>`,
  *  optionally followed by its green/red changed-line counts. */
 export function foldedFileCallLine(tool, rawPath, theme, cwd, changes) {
@@ -72,18 +86,29 @@ function pathDisplay(rawPath, theme, cwd) {
 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}`);
+/** Add an icon to a tool call without mutating the imported renderer's private
+ *  text storage. The imported component remains responsible for its own body. */
+class IconPrefixedToolCall {
+    child;
+    prefix;
+    constructor(child, prefix) {
+        this.child = child;
+        this.prefix = prefix;
+    }
+    update(child, prefix) {
+        this.child = child;
+        this.prefix = prefix;
+    }
+    invalidate() {
+        this.child.invalidate();
+    }
+    render(width) {
+        const prefixWidth = visibleWidth(this.prefix);
+        const lines = this.child.render(Math.max(1, width - prefixWidth));
+        if (lines.length === 0)
+            return [truncateToWidth(this.prefix.trimEnd(), width, '')];
+        return lines.map((line, index) => index === 0 ? truncateToWidth(`${this.prefix}${line}`, width, '') : line);
+    }
 }
 // ---------------------------------------------------------------------------
 // read
@@ -91,7 +116,7 @@ export function prefixToolText(component, prefix) {
 /** 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) {
+export function createCrtrReadToolDefinition(cwd, fold = new FoldedToolCallController()) {
     const builtin = createReadToolDefinition(cwd);
     return {
         name: 'read',
@@ -110,7 +135,7 @@ export function createCrtrReadToolDefinition(cwd) {
             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;
+            return fold.capture(component);
         },
         renderResult(result, options, theme, context) {
             return builtin.renderResult(result, options, theme, context);
@@ -123,30 +148,30 @@ export function createCrtrReadToolDefinition(cwd) {
 /** 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) {
+export function createCrtrWriteToolDefinition(cwd, fold = new FoldedToolCallController()) {
     const builtin = createWriteToolDefinition(cwd);
+    let builtinCall;
+    let decoratedCall;
     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)) {
+            if (fold.folded) {
                 const a = args;
-                const changes = context.isError ? undefined : { added: countFileLines(str(a?.content)), removed: 0 };
-                const line = foldedFileCallLine('write', str(a?.file_path ?? a?.path), theme, context.cwd ?? cwd, changes);
-                // 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 lines = context.isError ? undefined : countFileLines(str(a?.content));
+                const line = foldedFileCallLine('write', str(a?.file_path ?? a?.path), theme, context.cwd ?? cwd) +
+                    lineCountDisplay(lines, theme);
+                return fold.capture(new Text(line, 0, 0));
             }
-            const component = builtin.renderCall(args, theme, context);
-            prefixToolText(component, `${theme.fg('accent', TOOL_ICON.write)} `);
-            return component;
+            builtinCall = builtin.renderCall(args, theme, { ...context, lastComponent: builtinCall });
+            const prefix = `${theme.fg('accent', TOOL_ICON.write)} `;
+            if (decoratedCall)
+                decoratedCall.update(builtinCall, prefix);
+            else
+                decoratedCall = new IconPrefixedToolCall(builtinCall, prefix);
+            return fold.capture(decoratedCall);
         },
         renderResult(result, options, theme, context) {
             return builtin.renderResult(result, options, theme, context);
@@ -242,7 +267,7 @@ class BashCallComponent {
     }
 }
 /** Attach-viewer `bash` for anything that is not a `crtr` invocation. */
-export function createCrtrPlainBashToolDefinition(cwd) {
+export function createCrtrPlainBashToolDefinition(cwd, fold = new FoldedToolCallController()) {
     const builtin = createBashToolDefinition(cwd);
     return {
         name: 'bash',
@@ -262,8 +287,8 @@ export function createCrtrPlainBashToolDefinition(cwd) {
             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;
+            Boolean(context.expanded) && !fold.folded, typeof a?.timeout === 'number' ? a.timeout : undefined);
+            return fold.capture(component);
         },
         renderResult(result, options, theme, context) {
             return builtin.renderResult(result, options, theme, context);