pi-jar 0.1.6 → 0.1.7

package/src/diff-view.ts

@@ -1,6 +1,6 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { Key, matchesKey, truncateToWidth, type TuiMouseEvent } from "@earendil-works/pi-tui";
-import { diffRows, lineDiff, type ChangeTracker, type DiffRow, type FileChange } from "./changes.ts";
+import { Key, matchesKey, truncateToWidth, visibleWidth, type TuiMouseEvent } from "@earendil-works/pi-tui";
+import { coarseLineDiff, diffHunkOffsets, diffLineCount, diffRowCount, diffRowsWindow, lineDiff, MAX_REVIEW_DIFF_LINES, type ChangeTracker, type DiffOp, type DiffRow, type FileChange } from "./changes.ts";
 import { CHILD_BASELINE_ENV, writeChildBaseline } from "./child-baselines.ts";
 import { contentRows, optionList, sidebarWidth, splitFrame } from "./split-view.ts";
 
@@ -12,20 +12,77 @@ const ACTIONS = [
 ] as const;
 
 const STATUS_MARK = { added: "A", modified: "M", deleted: "D" } as const;
+const PREVIEW_WINDOW = 1500;
+const SUMMARY_AFTER_BYTES = 256 * 1024;
+const SEARCH_HINT = "/ filter · Enter apply · Esc clear";
+
+function wrapPath(path: string, width: number): string[] {
+  const points = Array.from(path);
+  const lines: string[] = [];
+  let line = "";
+  for (const point of points) {
+    if (line && visibleWidth(line + point) > width) { lines.push(line); line = ""; }
+    line += point;
+  }
+  if (line || !lines.length) lines.push(line);
+  return lines;
+}
+
+export interface DiffSearchResult { files: FileChange[]; selected: number }
+export function filterChanges(changes: readonly FileChange[], query: string): DiffSearchResult {
+  const needle = query.trim().toLocaleLowerCase();
+  if (!needle) return { files: [...changes], selected: 0 };
+  return { files: changes.filter(change => `${change.path}\n${change.rel}\n${change.status}`.toLocaleLowerCase().includes(needle)), selected: 0 };
+}
+
+export function fullReviewRequired(change: FileChange): boolean {
+  return change.diff === null || Buffer.byteLength(change.before) + Buffer.byteLength(change.after) > SUMMARY_AFTER_BYTES
+    || diffLineCount(change.before) + diffLineCount(change.after) > PREVIEW_WINDOW;
+}
+
+export function fullReviewSupported(change: FileChange): boolean {
+  return diffLineCount(change.before) + diffLineCount(change.after) <= MAX_REVIEW_DIFF_LINES;
+}
 
 /** Keep indentation but drop escape sequences and control characters that would break layout. */
 export const safeLine = (text: string) => text.slice(0, 4000).replace(/\t/g, "  ")
   .replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)?|\x1b\[[0-?]*[ -/]*[@-~]|\x1b./g, "").replace(/[\x00-\x1f\x7f-\x9f]/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 = 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.")];
-  const gutter = Math.max(3, String(Math.max(...rows.map((row) => Math.max(row.oldLine ?? 0, row.newLine ?? 0)))).length);
+export function renderDiff(change: FileChange, width: number, fg: (color: string, text: string) => string,
+  options: { fullReview?: boolean; scroll?: number; rows?: number; unified?: boolean; ops?: readonly DiffOp[]; coarse?: boolean } = {}): string[] {
+  const large = fullReviewRequired(change);
+  if (large && (!options.fullReview || !fullReviewSupported(change))) return [
+    fg("warning", `Summary preview · +${change.added} −${change.removed} · ${(Buffer.byteLength(change.before) + Buffer.byteLength(change.after)) / 1024 | 0} KiB`),
+    fg("dim", fullReviewSupported(change) ? "Press v for a windowed full review, or keep this summary." : "Full review unavailable: preview is bounded to 100,000 combined lines."),
+    fg("dim", "Older/binary/over-1 MiB files are not tracked for safe revert.")
+  ];
+  const exact = options.ops ? change.diff : (change.diff === null ? undefined : (change.diff ?? lineDiff(change.before, change.after)));
+  const ops = options.ops ?? exact ?? coarseLineDiff(change.before, change.after);
+  const rows = Math.min(options.rows ?? PREVIEW_WINDOW, PREVIEW_WINDOW);
+  const scroll = Math.max(0, options.scroll ?? 0);
+  const visible = diffRowsWindow(ops, 3, scroll, rows);
+  if (!visible.length) return [fg("dim", scroll ? "End of diff." : "No textual changes.")];
+  const bounded = options.coarse ?? (change.diff === null || (!options.ops && exact === undefined));
+  const gutter = Math.max(3, String(Math.max(...visible.map((row) => Math.max(row.oldLine ?? 0, row.newLine ?? 0)))).length);
   const num = (value?: number) => (value ? String(value) : "").padStart(gutter);
-  return rows.map((row) => {
+  if (options.unified === false) {
+    const column = Math.max(8, Math.floor((width - 3) / 2));
+    return [
+      truncateToWidth(fg("accent", "Original"), column, "…", true) + fg("dim", " │ ") + fg("accent", "Updated"),
+      ...(bounded ? [fg("warning", "Coarse preview: replacement groups are approximate.")] : []),
+      ...visible.map(row => {
+        if (row.kind === "hunk") return fg("accent", row.text);
+        const oldText = row.kind === "add" ? "" : `${num(row.oldLine)} ${row.kind === "remove" ? "-" : " "}${safeLine(row.text)}`;
+        const newText = row.kind === "remove" ? "" : `${num(row.newLine)} ${row.kind === "add" ? "+" : " "}${safeLine(row.text)}`;
+        const left = truncateToWidth(oldText, column, "…", true);
+        const right = truncateToWidth(newText, column, "…", true);
+        return (row.kind === "remove" ? fg("error", left) : fg("muted", left)) + fg("dim", " │ ")
+          + (row.kind === "add" ? fg("success", right) : fg("muted", right));
+      })
+    ];
+  }
+  const rendered = visible.map((row) => {
     if (row.kind === "hunk") return fg("accent", row.text);
     const text = truncateToWidth(safeLine(row.text), Math.max(1, width - gutter * 2 - 4));
     const prefix = fg("dim", `${num(row.oldLine)} ${num(row.newLine)} `);
@@ -33,6 +90,9 @@ export function renderDiff(change: FileChange, width: number, fg: (color: string
     if (row.kind === "remove") return prefix + fg("error", "-" + text);
     return prefix + fg("muted", " " + text);
   });
+  if (bounded) rendered.unshift(fg("warning", "Coarse preview: LCS budget exceeded; full review preserves file order but replacement groups are approximate."));
+  if (change.added + change.removed > rows) rendered.push(fg("dim", `Windowed preview at row ${scroll + 1} · PgUp/PgDn or j/k`));
+  return rendered;
 }
 
 /**
@@ -47,17 +107,24 @@ export async function openDiffView(ctx: ExtensionContext, tracker: ChangeTracker
     let selected = 0;
     let scroll = 0;
     let listScroll = 0;
+    let query = "";
+    let searchMode = false;
+    let fullReview = false;
+    let unified = true;
     let bodyRows = 0;
+    let viewportRows = 1;
     let width = 80;
     let armed: "one" | "all" | undefined;
     let message = "";
     let layout = { top: 1, rows: 0, leftWidth: 0, bodyX: 2, footerTop: 0 };
     let cache: { key: string; lines: string[] } | undefined;
+    let opCache: { key: string; ops: readonly DiffOp[]; hunks: number[]; rows: number; coarse: boolean } | undefined;
     const fg = (color: string, text: string) => theme.fg(color as never, text);
     const refresh = () => {
       changes = tracker.changes();
       cache = undefined;
-      selected = Math.min(selected, Math.max(0, changes.length - 1));
+      opCache = undefined;
+      selected = Math.min(selected, Math.max(0, visibleChanges().length - 1));
       scroll = 0;
       if (!changes.length) done();
     };
@@ -66,12 +133,26 @@ export async function openDiffView(ctx: ExtensionContext, tracker: ChangeTracker
       catch (error) { message = "failed: " + (error instanceof Error ? error.message : String(error)); ctx.ui.notify("pi-jar: " + message, "error"); }
       refresh();
     };
-    const select = (index: number) => { selected = Math.max(0, Math.min(changes.length - 1, index)); scroll = 0; };
-    const scrollBody = (delta: number) => { scroll = Math.max(0, Math.min(Math.max(0, (cache?.lines.length ?? 0) - bodyRows), scroll + delta)); };
+    const visibleChanges = () => filterChanges(changes, query).files;
+    const currentChange = () => visibleChanges()[selected];
+    const select = (index: number) => { selected = Math.max(0, Math.min(visibleChanges().length - 1, index)); scroll = 0; fullReview = false; cache = undefined; opCache = undefined; };
+    const scrollBody = (delta: number) => {
+      const max = Math.max(0, (opCache?.rows ?? 0) - viewportRows);
+      scroll = Math.max(0, Math.min(max, scroll + delta)); cache = undefined;
+    };
     const component = {
       invalidate() { cache = undefined; },
       handleInput(data: string) {
-        const current = changes[selected];
+        if (searchMode) {
+          if (matchesKey(data, Key.escape)) { searchMode = false; query = ""; selected = 0; listScroll = 0; }
+          else if (matchesKey(data, Key.ctrl("u"))) query = "";
+          else if (matchesKey(data, Key.enter)) searchMode = false;
+          else if (matchesKey(data, Key.backspace)) query = query.slice(0, -1);
+          else if (data.length === 1 && data >= " " && data <= "~") query += data;
+          selected = Math.min(selected, Math.max(0, visibleChanges().length - 1));
+          listScroll = 0; scroll = 0; cache = undefined; opCache = undefined; tui.requestRender(); return;
+        }
+        const current = currentChange();
         if (armed && (data === "y" || (armed === "one" && data === "r") || (armed === "all" && data === "R"))) {
           const scope = armed; armed = undefined;
           if (scope === "all") run(`reverted ${changes.length} file(s)`, () => { for (const change of changes) tracker.revert(change.path); });
@@ -79,15 +160,32 @@ export async function openDiffView(ctx: ExtensionContext, tracker: ChangeTracker
           tui.requestRender(); return;
         }
         armed = undefined;
+        if (matchesKey(data, Key.escape) && query) {
+          query = ""; selected = 0; listScroll = 0; scroll = 0; fullReview = false; cache = undefined; opCache = undefined;
+          tui.requestRender(); return;
+        }
         if (matchesKey(data, Key.escape) || data === "q") return done();
-        if (data === "a" && current) run(`accepted ${current.rel}`, () => tracker.accept(current.path));
-        else if (data === "A") run(`accepted ${changes.length} file(s)`, () => tracker.acceptAll());
+        if (data === "/") { searchMode = true; query = ""; }
+        else if (data === "n" && query) select(selected + 1);
+        else if (data === "N" && query) select(selected - 1);
+        else if (data === "t") { unified = !unified; cache = undefined; message = unified ? "Unified diff" : "Side-by-side diff"; }
+        else if (data === "v" && current && fullReviewRequired(current) && fullReviewSupported(current)) {
+          fullReview = !fullReview; scroll = 0; cache = undefined; opCache = undefined; message = fullReview ? "Full windowed review · LCS budget may label a coarse replacement" : "Summary preview";
+        }
+        else if (data === "a" && current) run(`accepted ${current.rel}`, () => tracker.accept(current.path));
+        else if (data === "A" && current) run(`accepted ${changes.length} file(s)`, () => tracker.acceptAll());
         else if (data === "r" && current) { armed = "one"; message = `revert ${current.rel}? press r or y to confirm`; }
-        else if (data === "R") { armed = "all"; message = `revert all ${changes.length} files? press R or y to confirm`; }
+        else if (data === "R" && current) { armed = "all"; message = `revert all ${changes.length} files? press R or y to confirm`; }
         else if (matchesKey(data, Key.up) || data === "k") select(selected - 1);
         else if (matchesKey(data, Key.down) || data === "j") select(selected + 1);
         else if (matchesKey(data, Key.pageDown) || data === " ") scrollBody(Math.max(1, bodyRows - 2));
         else if (matchesKey(data, Key.pageUp)) scrollBody(-Math.max(1, bodyRows - 2));
+        else if (data === "n" && !query && opCache?.hunks.length) {
+          scroll = opCache.hunks.find(offset => offset > scroll) ?? opCache.hunks[0]!; cache = undefined;
+        }
+        else if (data === "p" && opCache?.hunks.length) {
+          scroll = [...opCache.hunks].reverse().find(offset => offset < scroll) ?? opCache.hunks.at(-1)!; cache = undefined;
+        }
         else if (data === "g") scrollBody(-Infinity);
         else if (data === "G") scrollBody(Infinity);
         tui.requestRender();
@@ -102,37 +200,50 @@ export async function openDiffView(ctx: ExtensionContext, tracker: ChangeTracker
         }
         if (event.type !== "click" || event.button !== "left") return;
         if (event.y === 0 && event.x >= width - 3) { done(); return { handled: true }; }
-        if (inContent && inList && listScroll + row < changes.length) { select(listScroll + row); tui.requestRender(); return { handled: true, focus: true }; }
+        if (inContent && inList && listScroll + row < visibleChanges().length) { select(listScroll + row); tui.requestRender(); return { handled: true, focus: true }; }
         const action = ACTIONS[event.y - layout.footerTop];
         if (action) { component.handleInput(action.key); return { handled: true }; }
       },
       render(available: number): string[] {
         width = Math.max(24, available);
-        bodyRows = contentRows(6 + ACTIONS.length, 6);
+        bodyRows = contentRows(7 + ACTIONS.length, 6);
         const listWidth = sidebarWidth(width, 20, 36);
         const bodyWidth = listWidth ? width - listWidth - 6 : width - 4;
-        const current = changes[selected];
-        if (!current) return [];
-        const key = `${selected}:${bodyWidth}:${current.after.length}`;
-        if (cache?.key !== key) cache = { key, lines: renderDiff(current, bodyWidth, fg) };
-        const header = listWidth ? [] : [fg("accent", `‹ ${selected + 1}/${changes.length} ${current.rel} ›`), ""];
-        const content = [...header, ...cache.lines];
-        scroll = Math.max(0, Math.min(scroll, Math.max(0, content.length - bodyRows)));
+        const filtered = visibleChanges();
+        const current = filtered[selected];
+        if (!current) return [fg("dim", `No files match /${safeLine(query)}`), fg("dim", "Press / to edit the filter or Esc to clear it.")];
+        const opKey = `${current.path}:${current.before.length}:${current.after.length}`;
+        if (opCache?.key !== opKey && (!fullReviewRequired(current) || fullReview)) {
+          const exact = current.diff === null ? undefined : (current.diff ?? lineDiff(current.before, current.after));
+          const coarse = exact === undefined;
+          const ops = exact ?? coarseLineDiff(current.before, current.after);
+          opCache = { key: opKey, ops, hunks: diffHunkOffsets(ops), rows: diffRowCount(ops), coarse };
+        }
+        const pathLines = wrapPath(current.path.replace(/[\x00-\x1f\x7f-\x9f]/g, char => `\\x${char.charCodeAt(0).toString(16).padStart(2, "0")}`), bodyWidth);
+        // Reserve wrapped path, metadata, split/coarse headers and the optional window footer.
+        viewportRows = Math.max(1, bodyRows - pathLines.length - 1 - (unified ? 0 : 1) - (opCache?.coarse ? 1 : 0) - 1);
+        scroll = Math.min(scroll, Math.max(0, (opCache?.rows ?? 0) - viewportRows));
+        const key = `${current.path}:${bodyWidth}:${bodyRows}:${viewportRows}:${unified}:${fullReview}:${scroll}`;
+        if (cache?.key !== key) cache = { key, lines: renderDiff(current, bodyWidth, fg, { fullReview, scroll, rows: viewportRows, ops: opCache?.ops, coarse: opCache?.coarse, unified }) };
+        // The absolute path is intentionally the first row of the right pane, even in split mode.
+        const content = [...pathLines.map(path => fg("accent", path)),
+          fg("dim", `${selected + 1}/${filtered.length} · ${current.status} · +${current.added} −${current.removed}`), ...cache.lines];
         if (selected < listScroll) listScroll = selected;
         if (selected >= listScroll + bodyRows) listScroll = selected - bodyRows + 1;
-        const list = changes.slice(listScroll, listScroll + bodyRows).map((change, index) => {
+        const list = filtered.slice(listScroll, listScroll + bodyRows).map((change, index) => {
           const active = listScroll + index === selected;
           const counts = fg("success", `+${change.added}`) + fg("error", ` −${change.removed}`);
           const name = truncateToWidth((active ? "▌" : " ") + STATUS_MARK[change.status] + " " + change.rel, Math.max(4, listWidth - String(change.added).length - String(change.removed).length - 4));
           return fg(active ? "accent" : "muted", name) + " " + counts;
         });
-        const totals = changes.reduce((sum, change) => [sum[0]! + change.added, sum[1]! + change.removed], [0, 0]);
-        const title = `± CHANGES · ${changes.length} file${changes.length === 1 ? "" : "s"} · +${totals[0]} −${totals[1]}`;
+        const totals = filtered.reduce((sum, change) => [sum[0]! + change.added, sum[1]! + change.removed], [0, 0]);
+        const title = `± CHANGES · ${filtered.length}/${changes.length} files · +${totals[0]} −${totals[1]}`;
         const footer = [
           ...optionList(theme, ACTIONS.map((item) => item.label), -1, ACTIONS.map((item) => item.key)),
-          message ? fg(armed ? "warning" : "dim", message) : fg("dim", "↑↓ file · PgUp/PgDn scroll · press a key or click an action · Esc close")
+          fg(searchMode ? "accent" : "dim", searchMode ? `/${query} · Enter apply · Esc clear` : query ? `/${query} · n/N next match · / new search` : `${SEARCH_HINT} · n/p hunk · t split/unified · v full preview`),
+          message ? fg(armed ? "warning" : "dim", message) : fg("dim", "↑↓ file · PgUp/PgDn scroll · a accept · r revert · Esc close")
         ];
-        const split = splitFrame(theme, width, title, list, content.slice(scroll, scroll + bodyRows), footer, bodyRows, listWidth);
+        const split = splitFrame(theme, width, title, list, content.slice(0, bodyRows), footer, bodyRows, listWidth);
         layout = split.layout;
         return split.lines;
       }

package/src/shell-notifications.ts

@@ -0,0 +1,104 @@
+import type { ExtensionAPI, CustomMessageEntryDraft } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { cleanText } from "./status.ts";
+import { describe, SHELL_MESSAGE, type ShellEvent, type ShellManager } from "./shells.ts";
+
+export interface ShellNotificationDetails {
+  summary: string;
+  ids: string[];
+  events: Array<{ id: string; name: string; kind: ShellEvent["kind"]; status: string; exitCode?: number | null }>;
+}
+
+/** A compact transport payload; logs are fetched explicitly, never copied into wake-up messages. */
+export function shellNotification(events: readonly ShellEvent[]): CustomMessageEntryDraft {
+  const failed = events.filter(({ kind, job }) => kind === "exit" && (job.status === "failed" || (job.status === "exited" && job.exitCode !== 0))).length;
+  const ready = events.filter(event => event.kind === "match").length;
+  const completed = events.length - ready;
+  const summary = `Background shells · ${completed} completed${failed ? ` · ${failed} failed` : ""}${ready ? ` · ${ready} ready` : ""}`;
+  const details: ShellNotificationDetails = {
+    summary, ids: events.map(event => event.job.id),
+    events: events.map(({ kind, job }) => ({ id: job.id, name: job.name, kind, status: job.status, exitCode: job.exitCode }))
+  };
+  return {
+    type: "custom_message", customType: SHELL_MESSAGE, display: true, details,
+    content: [summary, ...events.map(({ kind, job }) => kind === "match" ? `${job.id} · ${job.name} · ready: ${cleanText(job.matched ?? "", 120)}` : describe(job)),
+      "Use jar_shell output for relevant diagnostics only; observed completions do not replay."].join("\n")
+  };
+}
+
+/** Keep events in our own queue while the model runs, not Pi's irrevocable follow-up queue.
+ * Boundary entries are consumed before final settlement; output/peek/wait can acknowledge events
+ * before delivery. Idle events wake once after a debounce, and session replacement drops old work. */
+export function registerShellNotifications(pi: ExtensionAPI, manager: () => ShellManager | undefined): { notify(): void; dispose(): void } {
+  let active = false;
+  let interrupted = false;
+  let deliveryFailures = 0;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const warned = new Set<string>();
+  const cancelTimer = () => { clearTimeout(timer); timer = undefined; };
+  const take = () => {
+    cancelTimer();
+    const events = manager()?.takeNotifications() ?? [];
+    return events.length ? shellNotification(events) : undefined;
+  };
+  const notify = () => {
+    if (active || interrupted || timer || !manager()?.pendingNotifications()) return;
+    const owner = manager();
+    timer = setTimeout(() => {
+      timer = undefined;
+      if (active || interrupted || owner !== manager()) return;
+      const events = owner?.takeNotifications() ?? [];
+      if (!events.length) return;
+      const { type: _type, ...message } = shellNotification(events);
+      try { pi.sendMessage(message, { triggerTurn: true, deliverAs: "nextTurn" }); deliveryFailures = 0; }
+      catch (error) {
+        owner?.restoreNotifications(events);
+        console.error("pi-jar: could not deliver shell summary", error);
+        if (++deliveryFailures < 3) notify();
+      }
+    }, 300);
+    timer.unref?.();
+  };
+  const reset = () => { cancelTimer(); active = false; interrupted = false; deliveryFailures = 0; warned.clear(); };
+
+  pi.registerMessageRenderer?.<ShellNotificationDetails>(SHELL_MESSAGE, (message, { expanded }, theme) => {
+    const text = typeof message.content === "string" ? message.content : "Background shells";
+    const summary = message.details?.summary ?? text.split("\n", 1)[0] ?? "Background shells";
+    return new Text(expanded ? text : theme.fg("accent", cleanText(summary, 160)) + theme.fg("dim", " · expand for status"), 0, 0);
+  });
+  pi.on?.("session_start", reset);
+  pi.on?.("session_shutdown", reset);
+  pi.on?.("before_agent_start", () => {
+    active = true;
+    interrupted = false;
+    const entry = take();
+    if (!entry) return;
+    const { type: _type, ...message } = entry;
+    return { message };
+  });
+  pi.on?.("agent_start", () => { active = true; cancelTimer(); });
+  pi.on?.("turn_end", event => {
+    if (event.outcome !== "completed" || event.context?.canContinue === false) return;
+    const entry = take();
+    if (entry) return { entries: [entry], continue: true };
+  });
+  pi.on?.("agent_before_settle", event => {
+    interrupted = event.outcome !== "completed";
+    if (interrupted || event.context?.canContinue === false) return;
+    const entry = take();
+    if (entry) return { entries: [entry], continue: true };
+    // One reminder per outstanding finite job, never a self-repeating continuation loop.
+    const owner = manager();
+    const known = new Set(owner?.summaries().map(job => job.id) ?? []);
+    for (const id of warned) if (!known.has(id)) warned.delete(id);
+    const pending = (owner?.verificationPending() ?? []).filter(job => !warned.has(job.id));
+    if (!pending.length) return;
+    for (const job of pending) warned.add(job.id);
+    return { entries: [{ type: "custom_message" as const, customType: SHELL_MESSAGE, display: true,
+      content: `Verification still pending: ${pending.map(job => `${job.id} (${job.name})`).join(", ")}. Use jar_shell wait/peek for these ids before claiming success, or clearly report them as pending. Do not wait for long-lived services.`,
+      details: { summary: `${pending.length} background check(s) still pending`, ids: pending.map(job => job.id) }
+    }], continue: true };
+  });
+  pi.on?.("agent_settled", () => { active = false; notify(); });
+  return { notify, dispose: reset };
+}