pi-jar 0.1.3 → 0.1.5

package/src/changes.ts

@@ -104,7 +104,8 @@ export class ChangeTracker {
   private readonly cwd: () => string;
   constructor(cwd: () => string) { this.cwd = cwd; }
 
-  private absolute(path: string): string { return isAbsolute(path) ? resolve(path) : resolve(this.cwd(), path); }
+  /** Resolve like every other tracker method; baselines are keyed by this absolute path. */
+  absolute(path: string): string { return isAbsolute(path) ? resolve(path) : resolve(this.cwd(), path); }
   private bytes(content: string | null): number { return content === null ? 0 : Buffer.byteLength(content, "utf8"); }
   private drop(target: string): void {
     if (this.baselines.has(target)) this.baselineBytes = Math.max(0, this.baselineBytes - this.bytes(this.baselines.get(target)!));
@@ -112,23 +113,46 @@ export class ChangeTracker {
     this.dirty.delete(target);
   }
 
-  /** Record the pre-change content once; returns false when the file cannot be tracked. */
-  capture(path: string): boolean {
-    const target = this.absolute(path);
-    if (this.baselines.has(target)) return true;
-    // Only project files: plan files and scratch space elsewhere are not part of the review.
+  /**
+   * Store a baseline when the file is inside the project (plan files and scratch space elsewhere are
+   * not reviewed) and within the file/byte caps. `content` is lazy so outside files are never read.
+   */
+  private admit(target: string, content: () => string | null | undefined): boolean {
     const rel = relative(this.cwd(), target);
     if (!rel || rel.startsWith("..") || isAbsolute(rel)) return false;
     if (this.baselines.size >= MAX_TRACKED_FILES) return false;
-    const content = readText(target);
-    if (content === undefined) return false;
-    const bytes = this.bytes(content);
-    if (this.baselineBytes + bytes > MAX_TRACKED_TOTAL_BYTES) return false;
-    this.baselines.set(target, content);
+    const before = content();
+    if (before === undefined) return false;
+    const bytes = this.bytes(before);
+    if (bytes > MAX_TRACKED_BYTES || this.baselineBytes + bytes > MAX_TRACKED_TOTAL_BYTES) return false;
+    this.baselines.set(target, before);
     this.baselineBytes += bytes;
     return true;
   }
 
+  /** Record the pre-change content once; returns false when the file cannot be tracked. */
+  capture(path: string): boolean {
+    const target = this.absolute(path);
+    return this.baselines.has(target) || this.admit(target, () => readText(target));
+  }
+
+  /** Captured pre-change content (`null` = file did not exist), or `undefined` when untracked. */
+  baseline(path: string): string | null | undefined {
+    const target = this.absolute(path);
+    return this.baselines.has(target) ? this.baselines.get(target)! : undefined;
+  }
+
+  /**
+   * Take over a baseline captured elsewhere (a subagent's first-edit content) and mark the file
+   * dirty. An existing baseline is older and wins, so each absolute path counts once.
+   */
+  adopt(path: string, baseline: string | null): boolean {
+    const target = this.absolute(path);
+    if (!this.baselines.has(target) && !this.admit(target, () => baseline)) return false;
+    this.dirty.add(target);
+    return true;
+  }
+
   /**
    * Mark one captured file after a successful edit/write. Do not synchronously re-read the file on
    * every tool result; the review UI reconciles content lazily when /diff is actually opened.

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,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); }