pi-jar 0.1.3 → 0.1.4

package/src/compact-tools.ts

@@ -14,18 +14,31 @@ type ToolResult = { content: Array<{ type: string; text?: string }>; details?: u
 
 const SUMMARY_SCAN_CHARS = 32 * 1024;
 const DIFF_SCAN_CHARS = 64 * 1024;
-const resultSummaryCache = new WeakMap<object, { sample: string; lines: number; truncated: boolean }>();
+interface Summary { sample: string; lines: number; truncated: boolean; preview?: string }
+/**
+ * Pi hands renderResult a fresh `{ content, details }` wrapper on every display update, and Ctrl+O or a
+ * theme change re-renders every tool of the session, so these caches key on the stable content/details.
+ */
+const resultSummaryCache = new WeakMap<object, Summary>();
 const writeCountCache = new WeakMap<object, { lines: number; truncated: boolean }>();
+const diffCountCache = new WeakMap<object, { diff: string; additions: number; removals: number }>();
 
-function summarizeResult(result: ToolResult): { sample: string; lines: number; truncated: boolean } {
-  if (result && typeof result === "object") {
-    const cached = resultSummaryCache.get(result as object);
-    if (cached) return cached;
-  }
+/** Line count without splitting the text into an array. */
+function lineCount(text: string): number {
+  if (!text) return 0;
+  let lines = 1;
+  for (let at = text.indexOf("\n"); at >= 0; at = text.indexOf("\n", at + 1)) lines++;
+  return lines;
+}
+
+function summarizeResult(result: ToolResult): Summary {
+  const content = result.content;
+  const cached = resultSummaryCache.get(content);
+  if (cached) return cached;
   let sample = "";
   let truncated = false;
   let textParts = 0;
-  for (const item of result.content) {
+  for (const item of content) {
     if (item.type !== "text" || typeof item.text !== "string") continue;
     if (textParts++ && sample.length < SUMMARY_SCAN_CHARS) sample += "\n";
     const room = SUMMARY_SCAN_CHARS - sample.length;
@@ -33,26 +46,41 @@ function summarizeResult(result: ToolResult): { sample: string; lines: number; t
     sample += item.text.slice(0, room);
     if (item.text.length > room) { truncated = true; break; }
   }
-  const value = { sample, lines: sample ? sample.split("\n").length : 0, truncated };
-  if (result && typeof result === "object") resultSummaryCache.set(result as object, value);
+  const value: Summary = { sample, lines: lineCount(sample), truncated };
+  if (content && typeof content === "object") resultSummaryCache.set(content, value);
   return value;
 }
 
 function firstNonEmpty(text: string): string {
-  for (const line of text.split("\n")) if (line.trim()) return line;
-  return "";
+  for (let start = 0; ;) {
+    const end = text.indexOf("\n", start);
+    const line = text.slice(start, end < 0 ? text.length : end);
+    if (line.trim()) return line;
+    if (end < 0) return "";
+    start = end + 1;
+  }
 }
 
 function boundedLineCount(text: string, limit = SUMMARY_SCAN_CHARS): { lines: number; truncated: boolean } {
-  const sample = text.slice(0, limit);
-  return { lines: sample ? sample.split("\n").length : 0, truncated: text.length > limit };
+  return { lines: lineCount(text.slice(0, limit)), truncated: text.length > limit };
 }
 
 const expandHint = " · [ expand ] Ctrl+O";
 
+/**
+ * Whitespace-collapsed, trimmed text cut to `max` characters. Only a bounded prefix is scanned: a call
+ * card re-renders on every streamed argument delta, so collapsing a whole heredoc each time was O(n²).
+ */
 function compactText(text: string, max = 72): string {
-  const clean = text.replace(/\s+/g, " ").trim();
-  return clean.length <= max ? clean : clean.slice(0, Math.max(0, max - 1)) + "…";
+  for (let end = Math.min(text.length, 2 * max + 64); ; end = Math.min(text.length, end * 4)) {
+    const clean = text.slice(0, end).replace(/\s+/g, " ").trimStart();
+    if (end >= text.length) {
+      const full = clean.trimEnd();
+      return full.length <= max ? full : full.slice(0, Math.max(0, max - 1)) + "…";
+    }
+    // The collapsed prefix is a prefix of the whole; past max + 1 characters only one trailing space could still be trimmed.
+    if (clean.length > max + 1) return clean.slice(0, Math.max(0, max - 1)) + "…";
+  }
 }
 
 const bashCache = new WeakMap<object, { cwd: string; trusted: boolean; tool: ReturnType<typeof createBashToolDefinition> }>();
@@ -112,8 +140,11 @@ export function installCompactBuiltinTools(pi: ExtensionAPI): void {
     renderResult(result, options, theme, context) {
       if (options.expanded && bash.renderResult) return bash.renderResult(result as Parameters<NonNullable<typeof bash.renderResult>>[0], options, theme, context);
       const summary = summarizeResult(result);
-      const first = firstNonEmpty(summary.sample);
-      const preview = first ? ` · ${compactText(first, 56)}` : "";
+      if (summary.preview === undefined) {
+        const first = firstNonEmpty(summary.sample);
+        summary.preview = first ? ` · ${compactText(first, 56)}` : "";
+      }
+      const preview = summary.preview;
       const count = `${summary.lines}${summary.truncated ? "+" : ""}`;
       const label = options.isPartial ? "running" : "done";
       return new Text(theme.fg(options.isPartial ? "warning" : "muted",
@@ -138,14 +169,17 @@ export function installCompactBuiltinTools(pi: ExtensionAPI): void {
         return new Text(theme.fg(text.startsWith("Error") ? "error" : "success", compactText(text || "applied", 96)), 0, 0);
       }
       if (diff.length > DIFF_SCAN_CHARS) return new Text(theme.fg("muted", `large diff${expandHint}`), 0, 0);
-      let additions = 0;
-      let removals = 0;
-      for (const line of diff.split("\n")) {
-        if (line.startsWith("+") && !line.startsWith("+++")) additions++;
-        else if (line.startsWith("-") && !line.startsWith("---")) removals++;
+      let counts = diffCountCache.get(details!);
+      if (counts?.diff !== diff) {
+        counts = { diff, additions: 0, removals: 0 };
+        for (const line of diff.split("\n")) {
+          if (line.startsWith("+") && !line.startsWith("+++")) counts.additions++;
+          else if (line.startsWith("-") && !line.startsWith("---")) counts.removals++;
+        }
+        diffCountCache.set(details!, counts);
       }
-      return new Text(theme.fg("success", `+${additions}`) + theme.fg("dim", " / ")
-        + theme.fg("error", `-${removals}`) + theme.fg("dim", expandHint), 0, 0);
+      return new Text(theme.fg("success", `+${counts.additions}`) + theme.fg("dim", " / ")
+        + theme.fg("error", `-${counts.removals}`) + theme.fg("dim", expandHint), 0, 0);
     }
   });
 

package/src/composer.ts

@@ -4,6 +4,7 @@ import { Mascot, MASCOT_FACE_WIDTH, mascotFace, paintFace, paintTip, type Mascot
 import type { SuggestionState } from "./suggest.ts";
 import type { WorkingPhase } from "./working.ts";
 import { imageChip, imageInfo, imagePaths } from "./attachments.ts";
+import { RowCache } from "./row-cache.ts";
 // Aliased: roundedInput has a parameter named `icon`.
 import { icon as glyph, type IconKey } from "./icons.ts";
 
@@ -77,12 +78,27 @@ export interface RoundedInputOptions {
   dim?: (text: string) => string;
 }
 
+/** The last framed editor: Pi repaints the composer on every render (each streamed token) while the draft sits still. */
+let lastFrame: { lines: string[]; key: string; border: (text: string) => string; dim?: (text: string) => string; framed: string[] } | undefined;
+/** While typing only the edited row changes; the rest of a long draft is reused. */
+const framedRows = new RowCache();
+const fittedLines = new RowCache();
+const sameLines = (a: readonly string[], b: readonly string[]) => {
+  if (a.length !== b.length) return false;
+  for (let index = 0; index < a.length; index++) if (a[index] !== b[index]) return false;
+  return true;
+};
+
 /** Frame a real editor without changing its keyboard, history or autocomplete implementation. */
 export function roundedInput(lines: string[], width: number, focused: boolean, theme: EditorTheme, focusPaint?: (text: string) => string,
   icon = composerIcon("idle"), session = "", options: RoundedInputOptions = {}): string[] {
   if (width < 8 || lines.length < 2) return lines.map((line) => truncateToWidth(line, Math.max(0, width)));
   const border = focused && focusPaint ? focusPaint : theme.borderColor;
   const dim = options.dim ?? ((text: string) => text);
+  // Painter samples catch a theme change behind the same function.
+  const key = [width, icon, session, options.ghost ?? "", options.hint ?? "", options.paintedIcon ?? "", options.visibleRows ?? "",
+    options.below ?? "", glyph("tab"), border("─"), dim("─")].join("\0");
+  if (lastFrame?.key === key && lastFrame.border === border && lastFrame.dim === options.dim && sameLines(lastFrame.lines, lines)) return lastFrame.framed.slice();
   const bottom = bottomBorderIndex(lines, options.visibleRows);
   const inner = width - 2;
   const meta = session ? `${icon} · session ${session}` : icon;
@@ -97,6 +113,10 @@ export function roundedInput(lines: string[], width: number, focused: boolean, t
   const left = below ? `─ ${below} ` : "";
   const fill = Math.max(0, width - 2 - visibleWidth(left) - visibleWidth(hint) - 1);
   const bottomLine = border("╰" + left + "─".repeat(fill)) + (hint ? dim(hint) : "") + border((hint ? "─" : "─") + "╯");
+  const side = border("│");
+  framedRows.begin(`${inner}\0${side}`);
+  fittedLines.begin(String(width));
+  const fit = (text: string) => fittedLines.get(text, (value) => truncateToWidth(value, width));
   const content = lines.slice(1, bottom).map((line, index) => {
     let row = line;
     if (index === 0 && options.ghost && row.includes(CURSOR)) {
@@ -106,13 +126,13 @@ export function roundedInput(lines: string[], width: number, focused: boolean, t
       const tab = glyph("tab") === "tab" ? "tab" : keyHint("tab", "tab");
       if (room > 2) row = base + dim(truncateToWidth(options.ghost + "   " + tab, room, "…"));
     }
-    const fitted = truncateToWidth(row, inner);
-    return border("│") + fitted + " ".repeat(Math.max(0, inner - visibleWidth(fitted))) + border("│");
+    return framedRows.get(row, (value) => side + truncateToWidth(value, inner, "...", true) + side);
   });
   // Autocomplete rows stay below the frame, indented to line up with the text.
-  const trailing = lines.slice(bottom + 1).map((line) => truncateToWidth(" " + line, width));
-  return [truncateToWidth(top, width), ...content, truncateToWidth(bottomLine, width),
-    ...(options.below ? [truncateToWidth(" " + options.below, width)] : []), ...trailing];
+  const trailing = lines.slice(bottom + 1).map((line) => fit(" " + line));
+  const framed = [fit(top), ...content, fit(bottomLine), ...(options.below ? [fit(" " + options.below)] : []), ...trailing];
+  lastFrame = { lines: lines.slice(), key, border, ...(options.dim ? { dim: options.dim } : {}), framed };
+  return framed.slice();
 }
 
 export interface ComposerDecor {
@@ -174,15 +194,19 @@ class RoundedEditor extends CustomEditor {
     const ghost = empty && !this.isShowingAutocomplete() ? this.decor.ghost() : undefined;
     this.ghostShown = !!ghost;
     const visibleRows = (this as unknown as { renderedVisibleLineCount?: number }).renderedVisibleLineCount;
-    const framed = roundedInput(inner, width, this.focused, this.colors, this.paint, this.decor.icon(), this.decor.session(), {
-      ...(ghost ? { ghost } : {}), ...(this.decor.hint() ? { hint: this.decor.hint()! } : {}),
-      ...(this.decor.paintedIcon() ? { paintedIcon: this.decor.paintedIcon()! } : {}),
+    const icon = this.decor.icon();
+    const session = this.decor.session();
+    const hint = this.decor.hint();
+    const paintedIcon = this.decor.paintedIcon();
+    const framed = roundedInput(inner, width, this.focused, this.colors, this.paint, icon, session, {
+      ...(ghost ? { ghost } : {}), ...(hint ? { hint } : {}), ...(paintedIcon ? { paintedIcon } : {}),
       ...(visibleRows != null ? { visibleRows } : {}), dim: this.decor.dim,
       ...(below ? { below } : {})
     });
     const tip = width >= 8 ? this.decor.tip(width) : undefined;
     this.tipRows = tip ? 1 : 0;
-    return tip ? [truncateToWidth(tip, width), ...framed] : framed;
+    // The tip is a few painted cells; measuring (cached) skips re-segmenting it on every frame.
+    return tip ? [visibleWidth(tip) <= width ? tip : truncateToWidth(tip, width), ...framed] : framed;
   }
 
   override handleInput(data: string): void {
@@ -244,13 +268,16 @@ class ThemedEditor implements EditorComponent {
     const text = this.base.getText();
     const ghost = text === "" ? this.decor.ghost() : undefined;
     const below = this.decor.attachments(text);
-    const framed = roundedInput(this.base.render(width < 8 ? width : width - 2), width, this.focused, this.theme, this.paint, this.decor.icon(), this.decor.session(), {
-      ...(ghost ? { ghost } : {}), ...(this.decor.paintedIcon() ? { paintedIcon: this.decor.paintedIcon()! } : {}), dim: this.decor.dim,
+    const icon = this.decor.icon();
+    const session = this.decor.session();
+    const paintedIcon = this.decor.paintedIcon();
+    const framed = roundedInput(this.base.render(width < 8 ? width : width - 2), width, this.focused, this.theme, this.paint, icon, session, {
+      ...(ghost ? { ghost } : {}), ...(paintedIcon ? { paintedIcon } : {}), dim: this.decor.dim,
       ...(below ? { below } : {})
     });
     const tip = width >= 8 ? this.decor.tip(width) : undefined;
     this.tipRows = tip ? 1 : 0;
-    return tip ? [truncateToWidth(tip, width), ...framed] : framed;
+    return tip ? [visibleWidth(tip) <= width ? tip : truncateToWidth(tip, width), ...framed] : framed;
   }
   addToHistory(text: string) { this.base.addToHistory?.(text); }
   insertTextAtCursor(text: string) { this.base.insertTextAtCursor?.(text); }