pi-jar 0.1.2 → 0.1.4

package/src/child-baselines.ts

@@ -0,0 +1,42 @@
+import { createHash } from "node:crypto";
+import { existsSync, linkSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+/**
+ * Directory a parent hands to a subagent so the child can report each file's content before its
+ * first edit/write. The parent then adopts those baselines into its own `/diff` review.
+ */
+export const CHILD_BASELINE_ENV = "PI_JAR_BASELINE_DIR";
+
+type BaselineRecord = { path: string; content: string | null };
+
+/** Writer and reader must agree on the name: one JSON file per absolute path. */
+const fileFor = (dir: string, absPath: string) => join(dir, createHash("sha1").update(absPath).digest("hex") + ".json");
+
+/**
+ * Store the pre-change content (`null` = file did not exist) once per absolute path. The first
+ * write wins: the temp file is hard-linked into place, which fails instead of replacing an
+ * existing baseline, so readers never see a partial or newer record. Throws on I/O failure.
+ */
+export function writeChildBaseline(dir: string, absPath: string, content: string | null): void {
+  const target = fileFor(dir, absPath);
+  const temp = `${target}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  if (existsSync(target)) return;
+  mkdirSync(dir, { recursive: true });
+  try {
+    writeFileSync(temp, JSON.stringify({ path: absPath, content } satisfies BaselineRecord));
+    linkSync(temp, target);
+  } catch (error) { if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error; }
+  finally { rmSync(temp, { force: true }); }
+}
+
+/** The recorded baseline, or `undefined` when absent, unreadable or malformed. */
+export function readChildBaseline(dir: string, absPath: string): string | null | undefined {
+  let record: unknown;
+  try { record = JSON.parse(readFileSync(fileFor(dir, absPath), "utf8")); }
+  catch { return undefined; } // absent or corrupt: the parent simply does not adopt this file
+  if (!record || typeof record !== "object") return undefined;
+  const { path, content } = record as Partial<BaselineRecord>;
+  if (path !== absPath || (content !== null && typeof content !== "string")) return undefined;
+  return content;
+}

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,12 @@ 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";
+
+/** `⏎ send`; ascii spells the key out (`enter send`). */
+const keyHint = (key: IconKey, action: string) => glyph(key) + " " + action;
 
 type EditorFactory = NonNullable<ReturnType<ExtensionContext["ui"]["getEditorComponent"]>>;
 type MouseEvent = Parameters<NonNullable<EditorComponent["handleMouse"]>>[0];
@@ -12,6 +18,8 @@ const PHASE_MOODS: Record<WorkingPhase, readonly MascotMood[]> = {
   idle: ["idle"], generating: ["happy", "thinking"], tool: ["tool"], waiting: ["waiting"]
 };
 export const COMPOSER_ACTIVE_INTERVAL_MS = 600;
+/** How long composer image chips trust a previous filesystem check for the same draft. */
+const ATTACHMENT_RECHECK_MS = 1000;
 /** Plain one-line face for a phase; every phase has the same width. */
 export function composerIcon(phase: WorkingPhase, frame = 0): string {
   const moods = PHASE_MOODS[phase];
@@ -70,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;
@@ -90,20 +113,26 @@ 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)) {
       const base = row.replace(/ +$/, "");
       const room = inner - visibleWidth(base);
-      if (room > 2) row = base + dim(truncateToWidth(options.ghost + "   ⇥ tab", room, "…"));
+      // ascii's tab "icon" is already the word.
+      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 {
@@ -159,19 +188,25 @@ class RoundedEditor extends CustomEditor {
 
   override render(width: number): string[] {
     const inner = this.renderTall(width < 8 ? width : width - 2);
-    const empty = this.getText() === "";
+    const text = this.getText();
+    const empty = text === "";
+    const below = this.decor.attachments(text);
     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,
-      ...(this.decor.attachments(this.getText()) ? { below: this.decor.attachments(this.getText())! } : {})
+      ...(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 {
@@ -230,14 +265,19 @@ class ThemedEditor implements EditorComponent {
   }
   invalidate() { this.base.invalidate(); }
   render(width: number): string[] {
-    const ghost = this.base.getText() === "" ? this.decor.ghost() : undefined;
-    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,
-      ...(this.decor.attachments(this.base.getText()) ? { below: this.decor.attachments(this.base.getText())! } : {})
+    const text = this.base.getText();
+    const ghost = text === "" ? this.decor.ghost() : undefined;
+    const below = this.decor.attachments(text);
+    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); }
@@ -269,6 +309,8 @@ export class ComposerStyle {
   private suggestions?: SuggestionState;
   private unsubscribe?: () => void;
   private colors?: { fg(color: string, text: string): string };
+  /** Chips for the last draft; image paths hit the filesystem, so reuse them briefly across repaints. */
+  private chips?: { text: string; cwd: string; at: number; chips: string[] };
 
   private readonly decor: ComposerDecor = {
     icon: () => this.mascotOn ? mascotFace(this.animations ? this.mascot.mood() : "idle") : "pi",
@@ -286,7 +328,9 @@ export class ComposerStyle {
     },
     session: () => this.session,
     ghost: () => this.suggestions?.text,
-    hint: () => this.suggestions?.text ? "⇥ accept · ⏎ send · ⇧⏎ newline" : "⏎ send · ⇧⏎ newline · /plan · /goal",
+    hint: () => this.suggestions?.text
+      ? `${keyHint("tab", "accept")} · ${keyHint("enter", "send")} · ${keyHint("shiftEnter", "newline")}`
+      : `${keyHint("enter", "send")} · ${keyHint("shiftEnter", "newline")} · /plan · /goal`,
     accept: () => {
       const text = this.suggestions?.text;
       if (text) this.suggestions!.clear();
@@ -297,9 +341,13 @@ export class ComposerStyle {
     dim: (text) => this.colors?.fg("dim", text) ?? `\x1b[2m${text}\x1b[22m`,
     attachments: (text) => {
       if (!/\.(png|jpe?g|gif|webp)\b/i.test(text)) return undefined;
-      const chips = imagePaths(text, this.cwd).map(imageInfo).filter((info) => !!info).map((info) => imageChip(info!));
-      if (!chips.length) return undefined;
-      return chips.map((chip) => this.colors?.fg("accent", chip) ?? chip).join(this.colors?.fg("dim", "   ") ?? "   ");
+      const now = Date.now();
+      if (this.chips?.text !== text || this.chips.cwd !== this.cwd || now - this.chips.at >= ATTACHMENT_RECHECK_MS) {
+        const chips = imagePaths(text, this.cwd).map(imageInfo).filter((info) => !!info).map((info) => imageChip(info!));
+        this.chips = { text, cwd: this.cwd, at: now, chips };
+      }
+      if (!this.chips.chips.length) return undefined;
+      return this.chips.chips.map((chip) => this.colors?.fg("accent", chip) ?? chip).join(this.colors?.fg("dim", "   ") ?? "   ");
     }
   };