pi-better-subagents 0.1.6 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-subagents",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Pi extension for detached, sandboxed subagent runs that keep the foreground session free.",
   "license": "MIT",
   "type": "module",
@@ -30,6 +30,8 @@
     "access": "public"
   },
   "scripts": {
+    "pretest": "node ../../scripts/sync-shared-log-utils.mjs",
+    "prepack": "node ../../scripts/sync-shared-log-utils.mjs",
     "typecheck": "node -e \"console.log('pi-better-subagents: typecheck skipped for legacy mixed TS/MJS package')\"",
     "test": "node --import tsx --test tests/*.test.mjs",
     "test:cross-session": "node --import tsx --test --test-name-pattern \"callback session isolation\" tests/extension_health_lifecycle.test.mjs",

package/parse.ts

@@ -23,10 +23,10 @@
 import {
     closeSync,
     openSync,
-    readFileSync,
     readSync,
     statSync,
 } from "node:fs";
+import { readBoundedTail } from "./shared-log-utils.ts";
 import { readAppendedLines, type LogCursor } from "./log-cursor.ts";
 import { logPathFor } from "./registry.ts";
 
@@ -87,63 +87,7 @@ interface TailRead {
  * Read at most `maxBytes` from the end of `path`. Avoids `readFileSync` so logs
  * larger than Node's max string length can still be tailed for live output.
  */
-function readTail(path: string, maxBytes: number): TailRead {
-    let totalBytes = 0;
-    try {
-        totalBytes = statSync(path).size;
-    } catch {
-        return { text: "", truncated: false, totalBytes: 0, error: "log not found" };
-    }
-
-    if (totalBytes === 0) {
-        return { text: "", truncated: false, totalBytes: 0 };
-    }
-
-    if (totalBytes <= maxBytes) {
-        try {
-            return { text: readFileSync(path, "utf-8"), truncated: false, totalBytes };
-        } catch (e) {
-            return {
-                text: "",
-                truncated: false,
-                totalBytes,
-                error: `read failed: ${(e as Error).message}`,
-            };
-        }
-    }
-
-    let fd: number;
-    try {
-        fd = openSync(path, "r");
-    } catch (e) {
-        return {
-            text: "",
-            truncated: true,
-            totalBytes,
-            error: `open failed: ${(e as Error).message}`,
-        };
-    }
-
-    const buf = Buffer.alloc(maxBytes);
-    const offset = totalBytes - maxBytes;
-    let read = 0;
-    try {
-        read = readSync(fd, buf, 0, maxBytes, offset);
-    } catch (e) {
-        closeSync(fd);
-        return {
-            text: "",
-            truncated: true,
-            totalBytes,
-            error: `tail read failed: ${(e as Error).message}`,
-        };
-    }
-    closeSync(fd);
-
-    const text = buf.toString("utf-8", 0, read);
-
-    return { text, truncated: true, totalBytes };
-}
+const readTail: (path: string, maxBytes: number) => TailRead = readBoundedTail;
 
 /** Last `n` lines of a run's log, or a placeholder if empty/unreadable. */
 export function tailLog(id: string, n: number, maxBytes = maxRawTailBytes()): string {

package/shared-log-utils.ts

@@ -0,0 +1,104 @@
+// Generated from packages/log-utils/index.ts. Do not edit directly.
+import { closeSync, openSync, readFileSync, readSync, statSync } from "node:fs";
+
+export interface TailRead {
+  text: string;
+  truncated: boolean;
+  totalBytes: number;
+  error?: string;
+}
+
+function errorText(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+/**
+ * Read no more than `maxBytes` from a file's end. This avoids whole-file
+ * allocation for live logs that can grow past Node's string-size limit.
+ */
+export function readBoundedTail(path: string, maxBytes: number): TailRead {
+  const budget = Math.max(1, Math.floor(maxBytes));
+  let totalBytes: number;
+  try {
+    totalBytes = statSync(path).size;
+  } catch (error) {
+    return { text: "", truncated: false, totalBytes: 0, error: errorText(error) };
+  }
+  if (totalBytes === 0) return { text: "", truncated: false, totalBytes };
+  if (totalBytes <= budget) {
+    try {
+      return { text: readFileSync(path, "utf8"), truncated: false, totalBytes };
+    } catch (error) {
+      return { text: "", truncated: false, totalBytes, error: errorText(error) };
+    }
+  }
+
+  let fd: number | undefined;
+  try {
+    fd = openSync(path, "r");
+    const buffer = Buffer.allocUnsafe(budget);
+    const start = totalBytes - budget;
+    let offset = 0;
+    while (offset < budget) {
+      const read = readSync(fd, buffer, offset, budget - offset, start + offset);
+      if (read <= 0) break;
+      offset += read;
+    }
+    return { text: buffer.toString("utf8", 0, offset), truncated: true, totalBytes };
+  } catch (error) {
+    return { text: "", truncated: true, totalBytes, error: errorText(error) };
+  } finally {
+    if (fd !== undefined) {
+      try { closeSync(fd); } catch { /* best effort */ }
+    }
+  }
+}
+
+/**
+ * Convert terminal-like output into display rows. A bare carriage return is a
+ * cursor reset, so repeated progress redraws collapse to their latest state;
+ * CRLF remains a normal newline. Individual rows are capped defensively.
+ */
+export function terminalDisplayRows(text: string, maxRowChars = 8 * 1024): string[] {
+  const rowLimit = Math.max(64, Math.floor(maxRowChars));
+  const rows: string[] = [];
+  let current = "";
+  let progress = "";
+
+  const append = (value: string) => {
+    current += value;
+    if (current.length > rowLimit) current = `...${current.slice(-(rowLimit - 3))}`;
+  };
+  const emit = () => {
+    const value = current || progress;
+    if (value) rows.push(value);
+    current = "";
+    progress = "";
+  };
+
+  for (let i = 0; i < text.length; i += 1) {
+    const char = text[i]!;
+    if (char === "\r") {
+      if (text[i + 1] === "\n") {
+        emit();
+        i += 1;
+      } else {
+        progress = current || progress;
+        current = "";
+      }
+    } else if (char === "\n") {
+      emit();
+    } else {
+      append(char);
+    }
+  }
+  const final = current || progress;
+  if (final) rows.push(final);
+  return rows;
+}
+
+export function tailTerminalDisplay(text: string, rows: number, maxRowChars?: number): string {
+  const rendered = terminalDisplayRows(text, maxRowChars);
+  const count = Math.max(1, Math.floor(rows));
+  return rendered.slice(-count).join("\n");
+}

package/shared-navigator.ts

@@ -35,7 +35,7 @@ export type BackgroundWorkDetail = {
   statusTone: BackgroundWorkStatusTone;
   subtitle?: string;
   metadata: Array<{ label: string; value: string }>;
-  foldedSections?: Array<{ id: string; label: string; text: string; collapsedText?: string }>;
+  foldedSections?: Array<{ id: string; label: string; text: string; collapsedText?: string; expandedByDefault?: boolean }>;
   evidence: { label: string; text: string };
   footerActions?: string[];
 };
@@ -94,7 +94,7 @@ export const MAIN_LIST_WIDGET_KEY = "background-work-list";
 export const DETAIL_TICK_MS = 1000;
 export const CLOSE_ARM_MS = 3000;
 export const DEFAULT_LOG_TAIL_ROWS = 10;
-export const LOG_TAIL_ROW_CHOICES = [10, 25, 50, 100] as const;
+export const LOG_TAIL_ROW_CHOICES = [10, 25] as const;
 // Row rebuild cadence. Each tick asks every provider for rows, which stats and
 // parses run logs, so this is a per-provider I/O cadence and not a paint rate:
 // the widget repaints from render() whenever the TUI asks. 1 Hz matches
@@ -671,6 +671,7 @@ function createOverlayComponent(
   const expandedSections = new Set<string>();
   let detailId: string | null = initialDetailId ?? null;
   let detail: BackgroundWorkDetail | null = detailId ? (detailFor(detailId, Date.now(), { logTailLines: logTailRows }) ?? null) : null;
+  applyDefaultExpandedSections(detail, expandedSections);
   if (detailId) {
     const idx = overlayState.rows.findIndex((row) => row.navigatorId === detailId);
     if (idx >= 0) overlayState.selected = idx;
@@ -729,6 +730,7 @@ function createOverlayComponent(
     detailId = row.navigatorId;
     expandedSections.clear();
     detail = detailFor(row.navigatorId, Date.now(), { logTailLines: logTailRows }) ?? fallbackDetail(row);
+    applyDefaultExpandedSections(detail, expandedSections);
     mode = "detail";
     startDetailTimer();
     requestRender();
@@ -815,16 +817,6 @@ function createOverlayComponent(
             requestRender();
           }
         }
-        else if (data === "[") {
-          logTailRows = previousLogTailRows(logTailRows);
-          if (detailId) detail = detailFor(detailId, Date.now(), { logTailLines: logTailRows }) ?? detail;
-          requestRender();
-        }
-        else if (data === "]") {
-          logTailRows = nextLogTailRows(logTailRows);
-          if (detailId) detail = detailFor(detailId, Date.now(), { logTailLines: logTailRows }) ?? detail;
-          requestRender();
-        }
         else if (data === "l" || data === "L") {
           logTailRows = cycleLogTailRows(logTailRows);
           if (detailId) detail = detailFor(detailId, Date.now(), { logTailLines: logTailRows }) ?? detail;
@@ -939,7 +931,7 @@ function buildDetailLines(
   const foldedAction = toggleableSectionId
     ? (options.expandedSections?.has(toggleableSectionId) ? "Enter collapse" : "Enter expand")
     : null;
-  const actions = [foldedAction, ...(detail.footerActions?.length ? detail.footerActions : ["x close"]), "[ fewer", "] more", "l cycle", "Esc close"].filter(Boolean).join(" · ");
+  const actions = [foldedAction, ...(detail.footerActions?.length ? detail.footerActions : ["x close"]), "l 10/25", "Esc close"].filter(Boolean).join(" · ");
   lines.push(dim(`   ← back · ${actions}`, fg));
   lines.push("");
   lines.push(`   status   ${fg(toneColor(detail.statusTone, detail.status), detail.status)}`);
@@ -1004,6 +996,12 @@ function firstToggleableSectionId(detail: BackgroundWorkDetail | null | undefine
   return detail && isFoldableEvidence(detail) ? EVIDENCE_SECTION_ID : undefined;
 }
 
+function applyDefaultExpandedSections(detail: BackgroundWorkDetail | null, expandedSections: Set<string>): void {
+  for (const section of detail?.foldedSections ?? []) {
+    if (section.expandedByDefault) expandedSections.add(section.id);
+  }
+}
+
 function isFoldableEvidence(detail: BackgroundWorkDetail): boolean {
   return !/log/i.test(detail.evidence.label);
 }
@@ -1043,19 +1041,6 @@ function wrapEvidenceText(text: string, width: number): string[] {
   return rows.length ? rows : ["(no output yet)"];
 }
 
-function nextLogTailRows(current: number): number {
-  for (const value of LOG_TAIL_ROW_CHOICES) if (value > current) return value;
-  return LOG_TAIL_ROW_CHOICES[LOG_TAIL_ROW_CHOICES.length - 1];
-}
-
-function previousLogTailRows(current: number): number {
-  for (let i = LOG_TAIL_ROW_CHOICES.length - 1; i >= 0; i -= 1) {
-    const value = LOG_TAIL_ROW_CHOICES[i]!;
-    if (value < current) return value;
-  }
-  return LOG_TAIL_ROW_CHOICES[0];
-}
-
 function cycleLogTailRows(current: number): number {
   const idx = LOG_TAIL_ROW_CHOICES.findIndex((value) => value === current);
   return LOG_TAIL_ROW_CHOICES[(idx + 1) % LOG_TAIL_ROW_CHOICES.length];