@tt-a1i/openpi 0.4.0 → 0.6.0

package/extensions/plan-mode/index.ts

@@ -26,17 +26,21 @@
  * may predate the plan and still hold the full tool set.
  */
 
-import type {
-  ExtensionAPI,
-  ExtensionCommandContext,
-  ExtensionContext,
+import {
+  getMarkdownTheme,
+  keyHint,
+  type ExtensionAPI,
+  type ExtensionCommandContext,
+  type ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
+import { Markdown, Text, truncateToWidth } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import {
   PLAN_MODE_CHANNEL,
   type PlanModeState,
 } from "../shared/plan-mode-state.ts";
 import {
+  loadOpenPiCapabilities,
   OPENPI_TOOL_SURFACE,
   patchOwnedTools,
 } from "../shared/tool-surface.ts";
@@ -45,6 +49,8 @@ import { planBashDecision } from "./bash-policy.ts";
 
 export const MAX_READY_PLAN_CHARS = 50_000;
 export const MAX_READY_PLAN_UTF8_BYTES = 48_000;
+/** Preview lines shown in the collapsed plan_ready result. */
+const PLAN_PREVIEW_LINES = 10;
 export const PLAN_MODE_STATE_ENTRY = "my-pi-setup-plan-mode-state";
 
 export type PersistedPlanModeState =
@@ -173,6 +179,9 @@ export const PLAN_SAFE_TOOLS = new Set([
   "ls",
   "fd",
   "rg",
+  "git_show",
+  "git_diff",
+  "git_log",
   // Web research without write actions.
   "web_search",
   "source_check",
@@ -208,7 +217,7 @@ export const PLAN_SAFE_TOOLS = new Set([
 ]);
 
 export const BLOCK_REASON =
-  "Plan mode is active: no changes yet. Keep investigating with read-only tools (read, fd, rg, web search, read-only bash like git log/diff/status, and subagent_spawn for parallel exploration — planning children get read-only tools). When the plan is decision-complete, call plan_ready alone with the complete Markdown plan; the user then chooses the next action with `/plan`, or cancels with `/plan off`.";
+  "Plan mode is active: no changes yet. Keep investigating with read-only tools (read, fd, rg, git_log/git_diff/git_show, web search, read-only bash like git log/status, and subagent_spawn for parallel exploration — planning children get read-only tools). Raw git diff/show and diff-generating git log forms are blocked; use the structured Git tools instead. When the plan is decision-complete, call plan_ready alone with the complete Markdown plan; the user then chooses the next action with `/plan`, or cancels with `/plan off`.";
 
 export function planToolCallDecision(
   toolName: string,
@@ -256,6 +265,7 @@ export default function planMode(pi: ExtensionAPI) {
     hasUI: boolean;
     ui: { setStatus: (key: string, value?: string) => void };
   }) => {
+    if (planning) loadOpenPiCapabilities(pi, ["search"]);
     syncPlanTool();
     pi.events.emit(PLAN_MODE_CHANNEL, { planning } satisfies PlanModeState);
     if (!ctx.hasUI) return;
@@ -445,6 +455,72 @@ export default function planMode(pi: ExtensionAPI) {
         terminate: true,
       };
     },
+    /**
+     * Render a completed plan for the TUI. Collapsed shows the line count
+     * plus a bounded preview (PLAN_PREVIEW_LINES) with an expand hint;
+     * expanded renders the full plan as Markdown. Pi only reflects the
+     * expanded flag — it never truncates custom renderer output, so this
+     * renderer owns the collapsed/expanded contract.
+     */
+    renderResult(result, { expanded }, theme) {
+      const plan = (result.details as { plan?: string } | undefined)?.plan;
+      if (!plan) {
+        // Failed invocations (not in plan mode, empty plan, size cap, abort)
+        // produce {content:[{text:reason}], details:{}} from agent-loop's
+        // createErrorToolResult; surface the real reason instead of a
+        // placeholder, mirroring subagent_spawn's fallback.
+        const first = result.content?.[0];
+        return new Text(
+          first?.type === "text"
+            ? first.text
+            : theme.fg("muted", "(no plan content)"),
+          0,
+          0,
+        );
+      }
+      if (!expanded) {
+        // Bound the collapsed preview by rendered rows, not source lines: a
+        // single long source line wraps into many terminal rows at narrow
+        // widths, so render the body at the caller's width, keep the first
+        // PLAN_PREVIEW_LINES rows, and truncate every row to the viewport
+        // width (same contract as renderWaitResult's fixedRows).
+        const body = new Text(
+          plan
+            .split("\n")
+            .map((line) => theme.fg("toolOutput", line))
+            .join("\n"),
+          0,
+          0,
+        );
+        return {
+          render(width: number) {
+            const bodyRows = body.render(width);
+            const shown = bodyRows.slice(0, PLAN_PREVIEW_LINES);
+            const hidden = bodyRows.length - shown.length;
+            const header = theme.fg(
+              "muted",
+              `Plan ready · ${plan.split("\n").length} lines`,
+            );
+            const rows = [header, ...shown];
+            if (hidden > 0) {
+              // The hint gets its own row: tucking it into the header tail
+              // lets a narrow viewport clip it away along with the rest of
+              // the header, hiding the expand affordance exactly when the
+              // preview is clipped.
+              rows.push(keyHint("app.tools.expand", "to expand"));
+              rows.push(theme.fg("muted", `... (${hidden} more rows)`));
+            }
+            return rows.map((row) => truncateToWidth(row, Math.max(1, width)));
+          },
+          invalidate() {
+            body.invalidate();
+          },
+        };
+      }
+      // A plan is prose to read, not source to inspect. Without a renderer the
+      // TUI falls back to plain text and shows raw Markdown syntax.
+      return new Markdown(plan, 0, 0, getMarkdownTheme());
+    },
   });
 
   pi.registerCommand("plan", {
@@ -519,7 +595,7 @@ export default function planMode(pi: ExtensionAPI) {
         {
           customType: "plan-mode-armed",
           content:
-            `Plan mode is on: investigate and propose a plan, but do not change anything yet. Edits and writes are blocked until the user explicitly chooses an implementation action. For files use the read, ls, grep and fd tools; bash is limited to read-only git and gh history commands such as \`git log\`, \`git diff\`, \`git status\`, \`git show\`, \`git blame\` and \`gh pr view\` — one plain command, no pipes or redirects. You can still delegate with \`subagent_spawn\` to explore several parts of the codebase at once: children spawned while planning receive read-only tools, so use them for investigation rather than for work to be done later.${objective ? `\n\nPlan for: ${objective}` : ""}` +
+            `Plan mode is on: investigate and propose a plan, but do not change anything yet. Edits and writes are blocked until the user explicitly chooses an implementation action. For files use the read, ls, grep, fd and rg tools. Use \`git_log\`, \`git_diff\` and \`git_show\` for history and changes; they disable repository external diff and textconv programs. Bash is limited to read-only git and gh commands such as \`git log\`, \`git status\`, \`git blame\` and \`gh pr view\` — raw Git commands that render diffs are blocked, and every Bash call must be one plain command with no pipes or redirects. You can still delegate with \`subagent_spawn\` to explore several parts of the codebase at once: children spawned while planning receive read-only tools, so use them for investigation rather than for work to be done later.${objective ? `\n\nPlan for: ${objective}` : ""}` +
             "\n\nUse read-only tools to ground the plan. When it is decision-complete, call `plan_ready` alone with the complete Markdown plan. That records the plan but does not start implementation; the user chooses the next action with `/plan`.",
           display: true,
           details: {},

package/extensions/post-edit/index.ts

@@ -21,6 +21,14 @@ import { sanitizeTerminalText } from "../shared/terminal-text.ts";
 
 /** Tools whose success means a file on disk changed. */
 const MUTATING_TOOLS = new Set(["write", "edit"]);
+const NOTICE_COMMAND_MAX_CHARS = 160;
+const NOTICE_DETAIL_MAX_CHARS = 320;
+
+function boundedNoticeText(value: string, maxChars: number) {
+  const chars = [...sanitizeTerminalText(value).trim()];
+  if (chars.length <= maxChars) return chars.join("");
+  return `${chars.slice(0, maxChars - 1).join("")}…`;
+}
 
 export default function postEdit(
   pi: ExtensionAPI,
@@ -75,18 +83,20 @@ export default function postEdit(
       })
       .then((result) => {
         if (result.code === 0) return;
-        const detail = sanitizeTerminalText(
+        const commandPreview = boundedNoticeText(ran, NOTICE_COMMAND_MAX_CHARS);
+        const detail = boundedNoticeText(
           result.stderr || result.stdout || "",
-        )
-          .trim()
-          .slice(0, 500);
+          NOTICE_DETAIL_MAX_CHARS,
+        );
         warn(
-          `post-edit command failed (exit ${result.code}): ${sanitizeTerminalText(ran)}${detail ? `\n${detail}` : ""}`,
+          `post-edit command failed (exit ${result.code}): ${commandPreview}${detail ? `\n${detail}` : ""}`,
         );
       })
       .catch((error: unknown) => {
         const detail = error instanceof Error ? error.message : String(error);
-        warn(`post-edit command could not run: ${detail}`);
+        warn(
+          `post-edit command could not run: ${boundedNoticeText(detail, NOTICE_DETAIL_MAX_CHARS)}`,
+        );
       })
       .finally(() => {
         if (active?.controller === controller) active = undefined;

package/extensions/sessions/git-stats.ts

@@ -1,4 +1,6 @@
 import { execFile } from "node:child_process";
+import { realpath } from "node:fs/promises";
+import { resolve } from "node:path";
 import type { SessionInfoLike } from "./sessions.ts";
 
 export interface SessionStats {
@@ -7,8 +9,15 @@ export interface SessionStats {
   del: number;
 }
 
+export type SessionStatsState =
+  | { status: "pending" }
+  | { status: "ready"; stats: SessionStats }
+  | { status: "unavailable" };
+
+type CachedSessionStats = Exclude<SessionStatsState, { status: "pending" }>;
+
 interface StatsLoaderOptions {
-  cache?: Map<string, SessionStats>;
+  cache?: Map<string, CachedSessionStats>;
   maxCache?: number;
   maxConcurrency?: number;
   runGit?: (
@@ -16,6 +25,8 @@ interface StatsLoaderOptions {
     cwd: string,
     signal: AbortSignal,
   ) => Promise<string>;
+  canonicalizeCwd?: (cwd: string) => Promise<string>;
+  canonicalizeConcurrency?: number;
 }
 
 interface QueueEntry {
@@ -27,6 +38,7 @@ interface QueueEntry {
 const GIT_STATS_TIMEOUT_MS = 3_000;
 const DEFAULT_MAX_CACHE = 256;
 const DEFAULT_MAX_CONCURRENCY = 4;
+const DEFAULT_CANONICALIZE_CONCURRENCY = 8;
 
 const abortError = () => {
   const error = new Error("Session stats load was cancelled.");
@@ -97,7 +109,7 @@ function createQueue(maxConcurrency: number) {
 }
 
 const runGit = (args: string[], cwd: string, signal: AbortSignal) =>
-  new Promise<string>((resolve) => {
+  new Promise<string>((resolveOutput, reject) => {
     try {
       execFile(
         "git",
@@ -108,10 +120,13 @@ const runGit = (args: string[], cwd: string, signal: AbortSignal) =>
           timeout: GIT_STATS_TIMEOUT_MS,
           signal,
         },
-        (error, stdout) => resolve(error ? "" : stdout),
+        (error, stdout) => {
+          if (error) reject(error);
+          else resolveOutput(stdout);
+        },
       );
-    } catch {
-      resolve("");
+    } catch (error) {
+      reject(error);
     }
   });
 
@@ -133,94 +148,265 @@ const calculateStats = (outputs: readonly string[]) => {
 };
 
 export function createSessionStatsLoader(options: StatsLoaderOptions = {}) {
-  const cache = options.cache ?? new Map<string, SessionStats>();
+  const cache = options.cache ?? new Map<string, CachedSessionStats>();
   const maxCache = options.maxCache ?? DEFAULT_MAX_CACHE;
   const execute = options.runGit ?? runGit;
+  const canonicalize = options.canonicalizeCwd ?? realpath;
+  const canonicalizeConcurrency = Math.max(
+    1,
+    options.canonicalizeConcurrency ?? DEFAULT_CANONICALIZE_CONCURRENCY,
+  );
   const queue = createQueue(
     Math.max(1, options.maxConcurrency ?? DEFAULT_MAX_CONCURRENCY),
   );
-  const loading = new Map<string, AbortSignal>();
+  interface Request {
+    key: string;
+    cwd: string;
+    after: string;
+    before: string;
+    includeWorktreeDiff: boolean;
+  }
+  interface ActiveRequest {
+    controller: AbortController;
+    promise: Promise<void>;
+  }
 
-  const loadOne = async (
-    session: SessionInfoLike,
-    isLatestForCwd: boolean,
+  const active = new Map<string, ActiveRequest>();
+  const pathKeys = new Map<string, string>();
+  const canonicalCwds = new Map<string, Promise<string>>();
+  let canonicalUniverse:
+    | {
+        universe: readonly SessionInfoLike[];
+        controller: AbortController;
+        promise: Promise<Map<string, string>>;
+      }
+    | undefined;
+  let requestedPaths = new Set<string>();
+  let reconcileGeneration = 0;
+  let notify = () => {};
+
+  const canonicalCwd = (cwd: string) => {
+    const absolute = resolve(cwd);
+    let pending = canonicalCwds.get(absolute);
+    if (!pending) {
+      pending = canonicalize(absolute).catch(() => absolute);
+      canonicalCwds.set(absolute, pending);
+    }
+    return pending;
+  };
+
+  const buildCanonicalWorkspaceMap = async (
+    sessions: readonly SessionInfoLike[],
     signal: AbortSignal,
-    onUpdate: () => void,
   ) => {
-    const key = session.path;
-    if (cache.has(key)) return;
-    const currentLoad = loading.get(key);
-    if (currentLoad && !currentLoad.aborted) return;
-    loading.set(key, signal);
+    const workspaces = [
+      ...new Set(sessions.map((session) => resolve(session.cwd))),
+    ];
+    const result = new Map<string, string>();
+    let index = 0;
+    const worker = async () => {
+      while (!signal.aborted) {
+        const cwd = workspaces[index++];
+        if (!cwd) return;
+        result.set(cwd, await canonicalCwd(cwd));
+      }
+    };
+    await Promise.all(
+      Array.from(
+        { length: Math.min(canonicalizeConcurrency, workspaces.length) },
+        worker,
+      ),
+    );
+    if (signal.aborted) throw abortError();
+    return result;
+  };
+
+  const canonicalWorkspaceMap = (sessions: readonly SessionInfoLike[]) => {
+    if (
+      canonicalUniverse?.universe === sessions &&
+      !canonicalUniverse.controller.signal.aborted
+    ) {
+      return canonicalUniverse.promise;
+    }
+    canonicalUniverse?.controller.abort();
+    const controller = new AbortController();
+    const promise = buildCanonicalWorkspaceMap(sessions, controller.signal);
+    canonicalUniverse = { universe: sessions, controller, promise };
+    return promise;
+  };
+
+  const latestPathsByCwd = (
+    sessions: readonly SessionInfoLike[],
+    canonical: ReadonlyMap<string, string>,
+  ) => {
+    const latest = new Map<string, SessionInfoLike>();
+    for (const session of sessions) {
+      const cwd = canonical.get(resolve(session.cwd)) ?? resolve(session.cwd);
+      const current = latest.get(cwd);
+      if (!current || session.modified.getTime() > current.modified.getTime()) {
+        latest.set(cwd, session);
+      }
+    }
+    return new Map(
+      [...latest].map(([cwd, session]) => [cwd, session.path] as const),
+    );
+  };
 
+  const requestFor = (
+    session: SessionInfoLike,
+    latest: ReadonlyMap<string, string>,
+    canonical: ReadonlyMap<string, string>,
+  ): Request => {
+    const cwd = canonical.get(resolve(session.cwd)) ?? resolve(session.cwd);
     const after = session.created
       ? session.created.toISOString()
       : new Date(session.modified.getTime() - 24 * 3600 * 1000).toISOString();
     const before = session.modified.toISOString();
+    const includeWorktreeDiff = latest.get(cwd) === session.path;
+    return {
+      key: JSON.stringify([cwd, after, before, includeWorktreeDiff]),
+      cwd,
+      after,
+      before,
+      includeWorktreeDiff,
+    };
+  };
 
-    try {
-      const outputs = await Promise.all([
-        queue
-          .run(
+  const putCache = (key: string, value: CachedSessionStats) => {
+    if (cache.has(key)) cache.delete(key);
+    while (cache.size >= Math.max(1, maxCache)) {
+      const oldest = cache.keys().next().value;
+      if (oldest === undefined) break;
+      cache.delete(oldest);
+    }
+    cache.set(key, value);
+  };
+
+  const start = (request: Request) => {
+    const controller = new AbortController();
+    const promise = Promise.all([
+      queue.run(
+        () =>
+          execute(
+            [
+              "log",
+              `--after=${request.after}`,
+              `--before=${request.before}`,
+              "--numstat",
+              "--pretty=format:",
+            ],
+            request.cwd,
+            controller.signal,
+          ),
+        controller.signal,
+      ),
+      request.includeWorktreeDiff
+        ? queue.run(
             () =>
-              execute(
-                [
-                  "log",
-                  `--after=${after}`,
-                  `--before=${before}`,
-                  "--numstat",
-                  "--pretty=format:",
-                ],
-                session.cwd,
-                signal,
-              ),
-            signal,
+              execute(["diff", "--numstat"], request.cwd, controller.signal),
+            controller.signal,
           )
-          .catch(() => ""),
-        isLatestForCwd
-          ? queue
-              .run(
-                () => execute(["diff", "--numstat"], session.cwd, signal),
-                signal,
-              )
-              .catch(() => "")
-          : Promise.resolve(""),
-      ]);
-      if (signal.aborted || loading.get(key) !== signal) return;
-
-      if (cache.size >= maxCache) {
-        const oldest = cache.keys().next().value;
-        if (oldest !== undefined) cache.delete(oldest);
-      }
-      cache.set(key, calculateStats(outputs));
-      onUpdate();
-    } finally {
-      if (loading.get(key) === signal) loading.delete(key);
-    }
+        : Promise.resolve(""),
+    ])
+      .then((outputs) => {
+        if (!controller.signal.aborted) {
+          putCache(request.key, {
+            status: "ready",
+            stats: calculateStats(outputs),
+          });
+          notify();
+        }
+      })
+      .catch(() => {
+        const cancelled = controller.signal.aborted;
+        if (!cancelled) {
+          putCache(request.key, { status: "unavailable" });
+          notify();
+          controller.abort();
+        }
+      })
+      .finally(() => {
+        if (active.get(request.key)?.controller === controller) {
+          active.delete(request.key);
+        }
+      });
+    const entry = { controller, promise };
+    active.set(request.key, entry);
+    return entry;
   };
 
-  const load = (
-    sessions: SessionInfoLike[],
-    signal: AbortSignal,
+  const cancelKey = (key: string) => {
+    const entry = active.get(key);
+    if (!entry) return;
+    active.delete(key);
+    entry.controller.abort();
+  };
+
+  const reconcile = async (
+    targets: readonly SessionInfoLike[],
+    universe: readonly SessionInfoLike[],
     onUpdate: () => void,
   ) => {
-    const latestByCwd = new Map<string, string>();
-    for (const session of sessions) {
-      if (!latestByCwd.has(session.cwd)) {
-        latestByCwd.set(session.cwd, session.path);
-      }
+    notify = onUpdate;
+    const generation = ++reconcileGeneration;
+    requestedPaths = new Set(targets.map((session) => session.path));
+    if (targets.length === 0) {
+      for (const key of [...active.keys()]) cancelKey(key);
+      pathKeys.clear();
+      return;
     }
-    return Promise.all(
-      sessions.map((session) =>
-        loadOne(
-          session,
-          latestByCwd.get(session.cwd) === session.path,
-          signal,
-          onUpdate,
-        ),
-      ),
-    ).then(() => undefined);
+
+    let canonical: ReadonlyMap<string, string>;
+    try {
+      canonical = await canonicalWorkspaceMap(universe);
+    } catch {
+      return;
+    }
+    if (generation !== reconcileGeneration) return;
+    const latest = latestPathsByCwd(universe, canonical);
+    const requests = targets.map((session) => ({
+      session,
+      request: requestFor(session, latest, canonical),
+    }));
+    const wanted = new Set(requests.map(({ request }) => request.key));
+
+    for (const key of active.keys()) {
+      if (!wanted.has(key)) cancelKey(key);
+    }
+
+    pathKeys.clear();
+    const pending: Promise<void>[] = [];
+    for (const { session, request } of requests) {
+      pathKeys.set(session.path, request.key);
+      if (cache.has(request.key)) continue;
+      const current = active.get(request.key) ?? start(request);
+      pending.push(current.promise);
+    }
+    await Promise.all(pending);
+  };
+
+  const get = (session: SessionInfoLike): SessionStatsState | undefined => {
+    if (!requestedPaths.has(session.path)) return undefined;
+    const key = pathKeys.get(session.path);
+    if (!key) return { status: "pending" };
+    const cached = cache.get(key);
+    if (cached) {
+      cache.delete(key);
+      cache.set(key, cached);
+      return cached;
+    }
+    if (active.has(key)) return { status: "pending" };
+    return undefined;
+  };
+
+  const cancel = () => {
+    reconcileGeneration++;
+    canonicalUniverse?.controller.abort();
+    canonicalUniverse = undefined;
+    for (const key of [...active.keys()]) cancelKey(key);
+    pathKeys.clear();
+    requestedPaths.clear();
   };
 
-  return { cache, load };
+  return { cache, get, reconcile, cancel };
 }