pi-jar 0.1.0 → 0.1.1

package/extensions/index.ts

@@ -187,7 +187,7 @@ export default function piJar(pi: ExtensionAPI): void {
       ctx.ui.setWorkingMessage?.(view.message);
       const indicatorKey = `${working.phase}:${animations}`;
       if (indicatorKey !== workingIndicatorKey) {
-        ctx.ui.setWorkingIndicator({ frames: view.frames, intervalMs: 240 });
+        ctx.ui.setWorkingIndicator({ frames: view.frames, intervalMs: 600 });
         workingIndicatorKey = indicatorKey;
       }
       if (active && !workingClock) {
@@ -360,15 +360,16 @@ export default function piJar(pi: ExtensionAPI): void {
         let frame = 0;
         let memory = `ram ${Math.round(process.memoryUsage.rss() / 1048576)} MiB`;
         let memoryTimer: ReturnType<typeof setTimeout> | undefined;
+        const MEMORY_SAMPLE_MS = 10_000;
         const sampleMemory = () => {
           if (disposed) return;
-          memory = `ram ${Math.round(process.memoryUsage.rss() / 1048576)} MiB`;
-          tui.requestRender();
-          memoryTimer = setTimeout(sampleMemory, 3000);
+          const next = `ram ${Math.round(process.memoryUsage.rss() / 1048576)} MiB`;
+          if (next !== memory) { memory = next; tui.requestRender(); }
+          memoryTimer = setTimeout(sampleMemory, MEMORY_SAMPLE_MS);
           memoryTimer.unref?.();
         };
         if (footerSettings.memory) {
-          memoryTimer = setTimeout(sampleMemory, 3000);
+          memoryTimer = setTimeout(sampleMemory, MEMORY_SAMPLE_MS);
           memoryTimer.unref?.();
         }
         let timer: ReturnType<typeof setInterval> | undefined;
@@ -402,8 +403,10 @@ export default function piJar(pi: ExtensionAPI): void {
                 role.expiresAt != null ? Math.min(min ?? Infinity, role.expiresAt) : min, undefined);
               if (nearest != null) expiryTimer = setTimeout(() => tui.requestRender(), Math.max(1, nearest - now));
               const active = animations && footerSettings.roles && roles.some((role) => ACTIVE_STATES.has(role.state));
-              if (active && !timer) timer = setInterval(() => { frame += 1; tui.requestRender(); }, 240);
-              else if (!active && timer) { clearInterval(timer); timer = undefined; }
+              if (active && !timer) {
+                timer = setInterval(() => { frame += 1; tui.requestRender(); }, 600);
+                timer.unref?.();
+              } else if (!active && timer) { clearInterval(timer); timer = undefined; }
               const usage = ctx.getContextUsage();
               const context = usage?.percent == null || !Number.isFinite(usage.percent)
                 ? "ctx ?" : `ctx ${Math.round(usage.percent)}%`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-jar",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "A warm, role-aware Pi terminal workspace with animated UI, plan and goal workflows, tasks, change review, model roles, background shells and subagents.",
   "type": "module",
   "license": "MIT",

package/src/animations.ts

@@ -20,4 +20,4 @@ export function roleFrame(state: RoleState, frame: number, animations = true): s
 
 export const WORKING_FRAMES = ["◇", "◆", "◇", "◈"] as const;
 /** Pixel-fire tick for the welcome flame; frozen when motion is disabled. */
-export const WELCOME_INTERVAL_MS = 90;
+export const WELCOME_INTERVAL_MS = 150;

package/src/changes.ts

@@ -4,11 +4,14 @@ import { isAbsolute, relative, resolve } from "node:path";
 /** Files larger than this, or binary files, are not tracked for review. */
 export const MAX_TRACKED_BYTES = 1024 * 1024;
 export const MAX_TRACKED_FILES = 200;
-/** Above this many (old × new) changed lines the inline diff is replaced by a summary. */
-const MAX_DIFF_CELLS = 4_000_000;
+/** Bound total retained baselines so a long editing session cannot pin hundreds of MiB. */
+export const MAX_TRACKED_TOTAL_BYTES = 8 * 1024 * 1024;
+/** Keep the quadratic fallback small; larger edits render a summary instead of allocating a huge matrix. */
+const MAX_DIFF_CELLS = 500_000;
+const MAX_DIFF_MIDDLE_LINES = 4_000;
 
 export type ChangeStatus = "added" | "modified" | "deleted";
-export interface FileChange { path: string; rel: string; status: ChangeStatus; before: string; after: string; added: number; removed: number }
+export interface FileChange { path: string; rel: string; status: ChangeStatus; before: string; after: string; added: number; removed: number; diff?: DiffOp[] | null }
 export type DiffOp = { op: " " | "+" | "-"; text: string };
 export type DiffRow = { kind: "hunk" | "context" | "add" | "remove" | "note"; text: string; oldLine?: number; newLine?: number };
 
@@ -32,10 +35,11 @@ export function lineDiff(before: string, after: string): DiffOp[] | undefined {
   let endA = a.length, endB = b.length;
   while (endA > start && endB > start && a[endA - 1] === b[endB - 1]) { endA--; endB--; }
   const midA = a.slice(start, endA), midB = b.slice(start, endB);
-  if (midA.length * midB.length > MAX_DIFF_CELLS) return undefined;
+  if (midA.length + midB.length > MAX_DIFF_MIDDLE_LINES || midA.length * midB.length > MAX_DIFF_CELLS) return undefined;
   const n = midA.length, m = midB.length;
-  // lcs[i][j] = LCS length of midA[i..] and midB[j..], flattened.
-  const lcs = new Uint32Array((n + 1) * (m + 1));
+  // lcs[i][j] = LCS length of midA[i..] and midB[j..], flattened. The matrix is
+  // intentionally capped above and Uint16 is enough because the capped middle is < 65k lines.
+  const lcs = new Uint16Array((n + 1) * (m + 1));
   for (let i = n - 1; i >= 0; i--) for (let j = m - 1; j >= 0; j--) {
     lcs[i * (m + 1) + j] = midA[i] === midB[j] ? lcs[(i + 1) * (m + 1) + j + 1]! + 1
       : Math.max(lcs[(i + 1) * (m + 1) + j]!, lcs[i * (m + 1) + j + 1]!);
@@ -95,10 +99,20 @@ export function diffRows(ops: readonly DiffOp[], context = 3): DiffRow[] {
  */
 export class ChangeTracker {
   private baselines = new Map<string, string | null>();
+  private dirty = new Set<string>();
+  private diffCache = new Map<string, FileChange>();
+  private baselineBytes = 0;
   private readonly cwd: () => string;
   constructor(cwd: () => string) { this.cwd = cwd; }
 
   private 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)!));
+    this.baselines.delete(target);
+    this.dirty.delete(target);
+    this.diffCache.delete(target);
+  }
 
   /** Record the pre-change content once; returns false when the file cannot be tracked. */
   capture(path: string): boolean {
@@ -110,29 +124,64 @@ export class ChangeTracker {
     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);
+    this.baselineBytes += bytes;
     return true;
   }
 
+  /**
+   * Mark one captured file after an edit/write completes. This performs only one cheap file read;
+   * no line diff is calculated until the review UI is opened.
+   */
+  markDirty(path: string): boolean {
+    const target = this.absolute(path);
+    if (!this.baselines.has(target)) return false;
+    const before = this.baselines.get(target)!;
+    const now = readText(target);
+    this.diffCache.delete(target);
+    if (now === undefined) { this.drop(target); return false; }
+    if (now === before) {
+      this.dirty.delete(target);
+      return false;
+    }
+    this.dirty.add(target);
+    return true;
+  }
+
+  /** Materialize detailed diffs lazily for the review UI only. */
   changes(): FileChange[] {
     const result: FileChange[] = [];
-    for (const [path, before] of this.baselines) {
+    for (const path of [...this.dirty]) {
+      const before = this.baselines.get(path);
+      if (before === undefined) { this.dirty.delete(path); this.diffCache.delete(path); continue; }
       const now = readText(path);
-      if (now === undefined || now === before) continue;
+      if (now === undefined) { this.drop(path); continue; }
+      if (now === before) { this.dirty.delete(path); this.diffCache.delete(path); continue; }
+      const cached = this.diffCache.get(path);
+      if (cached) { result.push(cached); continue; }
       const ops = lineDiff(before ?? "", now ?? "");
       const added = ops ? ops.filter((op) => op.op === "+").length : splitLines(now ?? "").length;
       const removed = ops ? ops.filter((op) => op.op === "-").length : splitLines(before ?? "").length;
       const rel = relative(this.cwd(), path);
-      result.push({ path, rel: rel && !rel.startsWith("..") ? rel : path, status: before === null ? "added" : now === null ? "deleted" : "modified",
-        before: before ?? "", after: now ?? "", added, removed });
+      const change: FileChange = {
+        path, rel: rel && !rel.startsWith("..") ? rel : path,
+        status: before === null ? "added" : now === null ? "deleted" : "modified",
+        before: before ?? "", after: now ?? "", added, removed, diff: ops ?? null
+      };
+      this.diffCache.set(path, change);
+      result.push(change);
     }
     return result.sort((a, b) => a.rel.localeCompare(b.rel));
   }
 
-  count(): number { return this.changes().length; }
+  /** O(1): the footer never calculates file diffs just to show its badge. */
+  count(): number { return this.dirty.size; }
+  trackedBytes(): number { return this.baselineBytes; }
   /** Keep the current content: stop tracking the file. */
-  accept(path: string): void { this.baselines.delete(this.absolute(path)); }
-  acceptAll(): void { this.baselines.clear(); }
+  accept(path: string): void { this.drop(this.absolute(path)); }
+  acceptAll(): void { this.baselines.clear(); this.dirty.clear(); this.diffCache.clear(); this.baselineBytes = 0; }
   /** Restore the pre-change content (or remove a file the agent created). */
   revert(path: string): void {
     const target = this.absolute(path);
@@ -140,7 +189,7 @@ export class ChangeTracker {
     const before = this.baselines.get(target)!;
     if (before === null) { if (existsSync(target)) unlinkSync(target); }
     else writeFileSync(target, before);
-    this.baselines.delete(target);
+    this.drop(target);
   }
-  clear(): void { this.baselines.clear(); }
+  clear(): void { this.acceptAll(); }
 }

package/src/composer.ts

@@ -11,6 +11,7 @@ type MouseEvent = Parameters<NonNullable<EditorComponent["handleMouse"]>>[0];
 const PHASE_MOODS: Record<WorkingPhase, readonly MascotMood[]> = {
   idle: ["idle"], generating: ["happy", "thinking"], tool: ["tool"], waiting: ["waiting"]
 };
+export const COMPOSER_ACTIVE_INTERVAL_MS = 600;
 /** 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];
@@ -256,7 +257,7 @@ export class ComposerStyle {
   private owner?: EditorFactory;
   private previous?: EditorFactory;
   private tui?: TUI;
-  private timer?: ReturnType<typeof setInterval>;
+  private timer?: ReturnType<typeof setTimeout>;
   private phase: WorkingPhase = "idle";
   private frame = 0;
   private animations = true;
@@ -291,7 +292,7 @@ export class ComposerStyle {
       return text;
     },
     typed: () => this.suggestions?.clear(),
-    poke: () => { this.mascot.flash("poke", 1500); this.tui?.requestRender(); },
+    poke: () => { this.mascot.flash("poke", 1500); this.restartTimer(); this.tui?.requestRender(); },
     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;
@@ -318,36 +319,49 @@ export class ComposerStyle {
   /** Short-lived expression, e.g. on errors or a completed goal. */
   flash(mood: "error" | "complete" | "poke", ms = 3000): void {
     this.mascot.flash(mood, ms);
+    this.restartTimer();
     if (this.enabled) this.tui?.requestRender();
   }
 
   setActivity(phase: WorkingPhase, animations: boolean): void {
     const changed = this.phase !== phase || this.animations !== animations;
     this.mascot.setPhase(phase);
-    if (!changed && (this.timer || !this.enabled || !animations)) return;
+    if (!changed) return;
     this.phase = phase;
     this.animations = animations;
-    if (changed) this.frame = 0;
+    this.frame = 0;
     this.restartTimer();
-    if (changed && this.enabled) this.tui?.requestRender();
+    if (this.enabled) this.tui?.requestRender();
   }
 
-  /** One unref'd timer drives flicker, blinks and sleepiness; it renders only when the sprite changes. */
+  /**
+   * Active motion ticks at a modest 600 ms. Idle motion has no polling loop at all: it sleeps
+   * until the mascot's next blink/sleep/flash deadline, then schedules the following deadline.
+   */
   private restartTimer(): void {
     this.stopTimer();
-    if (!this.enabled || !this.animations) return;
-    const active = this.phase === "generating" || this.phase === "tool";
-    if (!active && !this.mascotOn) return;
-    this.timer = setInterval(() => {
+    if (!this.enabled || !this.animations || !this.mascotOn) return;
+    this.lastKey = this.mascot.key(Date.now(), this.frame);
+    this.scheduleTimer();
+  }
+  private scheduleTimer(): void {
+    if (!this.enabled || !this.animations || !this.mascotOn || this.timer) return;
+    const active = this.phase === "generating" || this.phase === "tool" || this.phase === "waiting";
+    const delay = active ? COMPOSER_ACTIVE_INTERVAL_MS : this.mascot.nextTransitionDelay(Date.now());
+    if (delay === undefined) return;
+    this.timer = setTimeout(() => {
+      this.timer = undefined;
       this.frame++;
-      const key = this.mascotOn ? this.mascot.key(Date.now(), this.frame) : String(this.frame);
-      if (key === this.lastKey) return;
-      this.lastKey = key;
-      this.tui?.requestRender();
-    }, 240);
+      const key = this.mascot.key(Date.now(), this.frame);
+      if (key !== this.lastKey) {
+        this.lastKey = key;
+        this.tui?.requestRender();
+      }
+      this.scheduleTimer();
+    }, delay);
     this.timer.unref?.();
   }
-  private stopTimer(): void { if (this.timer) clearInterval(this.timer); this.timer = undefined; }
+  private stopTimer(): void { if (this.timer) clearTimeout(this.timer); this.timer = undefined; }
   refreshSession(ctx: ExtensionContext): void {
     const manager = ctx.sessionManager as { getSessionId?: () => string; getSessionName?: () => string | undefined } | undefined;
     const next = sessionDisplayName(manager?.getSessionName?.(), manager?.getSessionId?.());

package/src/diff-view.ts

@@ -18,7 +18,7 @@ export const safeLine = (text: string) => text.slice(0, 4000).replace(/\t/g, "
 
 /** Styled diff rows for one file, with a gutter of old/new line numbers. */
 export function renderDiff(change: FileChange, width: number, fg: (color: string, text: string) => string): string[] {
-  const ops = lineDiff(change.before, change.after);
+  const ops = change.diff === null ? undefined : (change.diff ?? lineDiff(change.before, change.after));
   if (!ops) return [fg("warning", `Too large for an inline diff: +${change.added} −${change.removed} lines.`)];
   const rows: DiffRow[] = diffRows(ops);
   if (!rows.length) return [fg("dim", "No textual changes.")];
@@ -142,12 +142,34 @@ export async function openDiffView(ctx: ExtensionContext, tracker: ChangeTracker
 
 /** Track edit/write targets before they run, and expose `/diff` plus ctrl+alt+d. */
 export function registerChangeReview(pi: ExtensionAPI, tracker: () => ChangeTracker | undefined, changed: () => void): void {
+  // Keep the path that belonged to each in-flight edit/write so tool completion dirties only
+  // that file. Older Pi builds may omit toolCallId here, hence the small FIFO fallback.
+  const pending = new Map<string, string>();
+  const fallback: string[] = [];
   pi.on("tool_call", (event) => {
     if (event.toolName !== "edit" && event.toolName !== "write") return;
     const path = (event.input as { path?: unknown }).path;
-    if (typeof path === "string" && path.trim()) tracker()?.capture(path);
+    if (typeof path !== "string" || !path.trim() || !tracker()?.capture(path)) return;
+    const id = (event as { toolCallId?: unknown }).toolCallId;
+    if (typeof id === "string" && id) pending.set(id, path);
+    fallback.push(path);
+  });
+  pi.on("tool_result", (event) => {
+    if (event.toolName !== "edit" && event.toolName !== "write") return;
+    const id = (event as { toolCallId?: unknown }).toolCallId;
+    let path: string | undefined;
+    if (typeof id === "string" && id) {
+      path = pending.get(id);
+      pending.delete(id);
+      if (path) {
+        const index = fallback.indexOf(path);
+        if (index >= 0) fallback.splice(index, 1);
+      }
+    }
+    if (!path) path = fallback.shift();
+    if (path) tracker()?.markDirty(path);
+    changed();
   });
-  pi.on("tool_result", (event) => { if (event.toolName === "edit" || event.toolName === "write") changed(); });
   const open = async (ctx: ExtensionContext) => {
     const current = tracker();
     if (!current) return;

package/src/mascot.ts

@@ -79,6 +79,20 @@ export class Mascot {
     return tips[((frame % tips.length) + tips.length) % tips.length]!;
   }
 
+  /**
+   * Milliseconds until an idle mascot can visibly change again. Active phases are driven by
+   * the composer's low-frequency animation clock; idle uses this deadline instead of polling.
+   */
+  nextTransitionDelay(now = Date.now()): number | undefined {
+    const current = this.mood(now);
+    if (this.flashMood && now < this.flashMood.until) return Math.max(16, this.flashMood.until - now);
+    if (this.phase !== "idle") return undefined;
+    const sleepyAt = this.lastActive + SLEEPY_AFTER_MS;
+    if (now >= sleepyAt) return undefined;
+    const next = current === "blink" ? Math.min(this.nextBlink + BLINK_MS, sleepyAt) : Math.min(this.nextBlink, sleepyAt);
+    return Math.max(16, next - now);
+  }
+
   /** Visual identity for change detection (avoids needless renders). */
   key(now = Date.now(), frame = 0): string { return this.mood(now) + ":" + this.tip(now, frame); }
 }