@tt-a1i/openpi 0.3.0 → 0.4.0

package/extensions/file-search/src/binaries.ts

@@ -3,21 +3,22 @@
  *
  * Resolution order (per tool, first usable wins):
  *   1. A normally installed system binary (`fd`/`fdfind`, `rg`) — used silently.
- *   2. An existing fallback in this repository's `bin/` directory — used silently.
- *   3. A fresh download of an official release into `bin/` — the only case that
- *      should surface a UI notification.
+ *   2. An existing binary in the agent's managed bin directory
+ *      (`~/.pi/agent/bin`), cached by an earlier download — used silently.
+ *   3. A fresh download of an official release into that directory — the only
+ *      case that should surface a UI notification.
  *
  * The decision logic is an Effect over a small injectable environment
  * (`BinaryEnv`) so tests can drive it without touching the filesystem or the
  * network. `liveBinaryEnv` is the real implementation.
  */
 
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import * as NodeHttpClient from "@effect/platform-node/NodeHttpClient";
 import * as NodeServices from "@effect/platform-node/NodeServices";
 import { execFile } from "node:child_process";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 import { Crypto, Data, Effect, Encoding, FileSystem, Stream } from "effect";
 import { FetchHttpClient, HttpClient } from "effect/unstable/http";
@@ -56,13 +57,13 @@ const RG_SHA256: Readonly<Record<string, string>> = {
 };
 
 export type ToolName = "fd" | "rg";
-export type BinarySource = "system" | "bundled" | "installed";
+export type BinarySource = "system" | "cached" | "installed";
 
 export interface ToolSpec {
   readonly tool: ToolName;
   /** Commands probed on PATH, in order. Debian/Ubuntu install fd as `fdfind`. */
   readonly systemCommands: readonly string[];
-  /** Executable name used inside release archives and the repo bin directory. */
+  /** Executable name used inside release archives and the managed bin directory. */
   readonly binaryName: string;
 }
 
@@ -144,10 +145,9 @@ export function currentTarget(): PlatformTarget {
   return { os: process.platform, arch: process.arch };
 }
 
-/** Repository root (`~/.pi/agent`) resolved from this module's location. */
-export function repositoryBinDir() {
-  const moduleDir = dirname(fileURLToPath(import.meta.url));
-  return join(moduleDir, "..", "..", "..", "bin");
+/** Pi agent's managed binaries directory (`~/.pi/agent/bin`). */
+export function managedBinDir() {
+  return join(getAgentDir(), "bin");
 }
 
 export class UnsupportedPlatformError extends Data.TaggedError(
@@ -179,7 +179,7 @@ export interface ResolvedBinary {
   readonly version?: string;
 }
 
-/** Resolve one tool: system binary, existing bin fallback, or fresh install. */
+/** Resolve one tool: system binary, cached fallback, or fresh install. */
 export function resolveBinary(
   spec: ToolSpec,
   binDir: string,
@@ -193,9 +193,9 @@ export function resolveBinary(
       }
     }
 
-    const bundled = join(binDir, spec.binaryName);
-    if (yield* env.probe(bundled, spec.tool)) {
-      return { tool: spec.tool, command: bundled, source: "bundled" as const };
+    const cached = join(binDir, spec.binaryName);
+    if (yield* env.probe(cached, spec.tool)) {
+      return { tool: spec.tool, command: cached, source: "cached" as const };
     }
 
     const asset = releaseAsset(spec.tool, target);
@@ -205,17 +205,17 @@ export function resolveBinary(
       });
     }
 
-    yield* env.install(asset, bundled);
+    yield* env.install(asset, cached);
 
-    if (!(yield* env.probe(bundled, spec.tool))) {
+    if (!(yield* env.probe(cached, spec.tool))) {
       return yield* new InstallError({
-        message: `${spec.tool} ${asset.version} was installed to ${bundled} but failed to run.`,
+        message: `${spec.tool} ${asset.version} was installed to ${cached} but failed to run.`,
       });
     }
 
     return {
       tool: spec.tool,
-      command: bundled,
+      command: cached,
       source: "installed" as const,
       version: asset.version,
     };

package/extensions/git-info/src/changed-files-view.ts

@@ -7,6 +7,7 @@ import {
   visibleWidth,
 } from "@earendil-works/pi-tui";
 import { Effect } from "effect";
+import { hintLine } from "../../shared/screen-chrome.ts";
 import { sanitizeTerminalText } from "../../shared/terminal-text.ts";
 import { runCommand } from "./process.ts";
 
@@ -174,6 +175,15 @@ export async function showChangedFiles(
         return Math.max(8, Math.floor(tui.terminal.rows * 0.8) - 2);
       }
 
+      /**
+       * Rows the diff pane actually paints: one row of the frame's budget goes
+       * to the hint line below it. Scroll limits must use this and not
+       * bodyHeight(), or the last diff line can never be scrolled into view.
+       */
+      function visibleRows() {
+        return Math.max(4, bodyHeight() - 1);
+      }
+
       function ensureSelectedFileVisible() {
         const visibleFiles = Math.max(1, Math.floor(bodyHeight() / 2));
         if (selectedIndex < sidebarOffset) sidebarOffset = selectedIndex;
@@ -192,7 +202,7 @@ export async function showChangedFiles(
       function moveDiff(amount: number) {
         const maxOffset = Math.max(
           0,
-          files[selectedIndex]!.diff.length - bodyHeight(),
+          files[selectedIndex]!.diff.length - visibleRows(),
         );
         diffOffset = Math.max(0, Math.min(maxOffset, diffOffset + amount));
         tui.requestRender();
@@ -216,13 +226,18 @@ export async function showChangedFiles(
         return theme.fg("text", expanded);
       }
 
+      /**
+       * Frame edge with an optional label set into it. Muted, not accent: the
+       * frame is not the content, and the accent is spent on the focused pane
+       * seam where it actually tells you something.
+       */
       function border(width: number, label: string, top: boolean) {
         const left = top ? "┌" : "└";
         const right = top ? "┐" : "┘";
-        const text = `─ ${label} `;
+        const text = label ? `─ ${label} ` : "─";
         const remaining = Math.max(0, width - visibleWidth(text) - 2);
         return theme.fg(
-          "borderAccent",
+          "borderMuted",
           truncateToWidth(
             `${left}${text}${"─".repeat(remaining)}${right}`,
             width,
@@ -289,11 +304,11 @@ export async function showChangedFiles(
           return;
         }
         if (matchesKey(data, Key.ctrl("d"))) {
-          moveDiff(Math.max(1, Math.floor(bodyHeight() / 2)));
+          moveDiff(Math.max(1, Math.floor(visibleRows() / 2)));
           return;
         }
         if (matchesKey(data, Key.ctrl("u"))) {
-          moveDiff(-Math.max(1, Math.floor(bodyHeight() / 2)));
+          moveDiff(-Math.max(1, Math.floor(visibleRows() / 2)));
           return;
         }
         if (matchesKey(data, Key.home) || data === "g") {
@@ -304,21 +319,23 @@ export async function showChangedFiles(
         if (matchesKey(data, Key.end) || data === "G") {
           diffOffset = Math.max(
             0,
-            files[selectedIndex]!.diff.length - bodyHeight(),
+            files[selectedIndex]!.diff.length - visibleRows(),
           );
           tui.requestRender();
         }
       }
 
       function render(width: number) {
-        const height = bodyHeight();
+        const height = visibleRows();
         const sidebarWidth = Math.min(
           48,
           Math.max(24, Math.floor(width * 0.34)),
         );
         const diffWidth = Math.max(1, width - sidebarWidth - 3);
         const selectedFile = files[selectedIndex]!;
-        const title = `local changes · ${files.length} ${files.length === 1 ? "file" : "files"} · ${focus === "files" ? "FILES" : "DIFF"}`;
+        // No shouted FILES/DIFF badge: the accent-lit pane seam already says
+        // where the keyboard is, without a second thing to read.
+        const title = `local changes · ${files.length} ${files.length === 1 ? "file" : "files"}`;
         const lines = [border(width, title, true)];
 
         for (let row = 0; row < height; row += 1) {
@@ -329,7 +346,7 @@ export async function showChangedFiles(
           if (file) {
             const isSelected = fileIndex === selectedIndex;
             if (row % 2 === 0) {
-              const marker = isSelected ? "› " : "  ";
+              const marker = isSelected ? "❯ " : "  ";
               const isBinary =
                 file.additions === null || file.deletions === null;
               const stats = isBinary
@@ -386,11 +403,27 @@ export async function showChangedFiles(
           );
         }
 
-        const help =
-          focus === "files"
-            ? "j/k or ↑/↓ select · enter/space/l open diff · esc close"
-            : "j/k or ↑/↓ scroll · ctrl-d/u page · g/G top/bottom · esc/h files";
-        lines.push(border(width, help, false));
+        lines.push(border(width, "", false));
+        // Hints below the frame rather than crammed into its bottom edge, with
+        // keys a step brighter than the words describing them.
+        lines.push(
+          hintLine(
+            theme,
+            focus === "files"
+              ? [
+                  ["j/k or ↑/↓", "select"],
+                  ["enter/space/l", "open diff"],
+                  ["esc", "close"],
+                ]
+              : [
+                  ["j/k or ↑/↓", "scroll"],
+                  ["ctrl-d/u", "page"],
+                  ["g/G", "top/bottom"],
+                  ["esc/h", "files"],
+                ],
+            width,
+          ),
+        );
         return lines;
       }
 

package/extensions/git-read/index.ts

@@ -0,0 +1,330 @@
+/**
+ * git-read — read-only git inspection tools for pi.
+ *
+ * Registers git_show, git_diff, and git_log: the minimal surface a review or
+ * exploration agent needs from git history without any write path. All three
+ * share the file-search output discipline (bounded preview, complete output
+ * persisted up to 10 MiB) and every user-controlled argument is validated
+ * before it reaches a child process, so a revision or path can never inject
+ * flags or escape the repository. The tools are child-safe by design and are
+ * classified in CHILD_SAFE_PACKAGE_TOOL_NAMES so review/advisor subagents can
+ * read diffs their tool boundary otherwise excludes (issue #61).
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { StringEnum } from "@earendil-works/pi-ai";
+import type {
+  AgentToolResult,
+  ExtensionAPI,
+  ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { Cause, Effect, Exit } from "effect";
+import { type Static, Type } from "typebox";
+import { formatCapturedOutput } from "../file-search/src/output.ts";
+import { sanitizeTerminalText } from "../shared/terminal-text.ts";
+import {
+  OPENPI_TOOL_SURFACE,
+  patchOwnedTools,
+} from "../shared/tool-surface.ts";
+import {
+  buildDiffArgs,
+  buildLogArgs,
+  buildShowArgs,
+  type GitDiffParams,
+  type GitLogParams,
+  type GitShowParams,
+  InvalidPathError,
+  InvalidRevisionError,
+} from "./src/args.ts";
+import { type GitOutcome, runGit } from "./src/process.ts";
+import {
+  GIT_DIFF_PARAMETER_DESCRIPTIONS,
+  GIT_DIFF_PROMPT_GUIDELINES,
+  GIT_DIFF_PROMPT_SNIPPET,
+  GIT_DIFF_TOOL_DESCRIPTION,
+  GIT_LOG_PARAMETER_DESCRIPTIONS,
+  GIT_LOG_PROMPT_GUIDELINES,
+  GIT_LOG_PROMPT_SNIPPET,
+  GIT_LOG_TOOL_DESCRIPTION,
+  GIT_SHOW_PARAMETER_DESCRIPTIONS,
+  GIT_SHOW_PROMPT_GUIDELINES,
+  GIT_SHOW_PROMPT_SNIPPET,
+  GIT_SHOW_TOOL_DESCRIPTION,
+} from "./src/prompt.ts";
+
+interface GitToolDetails {
+  readonly command: string;
+  readonly truncated: boolean;
+  readonly lineCount?: number;
+  readonly fullOutputPath?: string;
+}
+
+function causeMessage(cause: unknown): string {
+  if (
+    cause instanceof InvalidRevisionError ||
+    cause instanceof InvalidPathError
+  ) {
+    return cause.message;
+  }
+  if (cause instanceof Error) return cause.message;
+  return String(cause);
+}
+
+function unwrapToolExit<A, E>(exit: Exit.Exit<A, E>, tool: string) {
+  if (Exit.isSuccess(exit)) return exit.value;
+  if (Cause.hasInterruptsOnly(exit.cause)) {
+    throw new Error(`${tool} was cancelled.`);
+  }
+  throw new Error(causeMessage(Cause.squash(exit.cause)));
+}
+
+function gitResult(
+  outcome: GitOutcome,
+  command: string,
+): AgentToolResult<GitToolDetails> {
+  const formatted = formatCapturedOutput(outcome.output);
+  return {
+    content: [
+      {
+        type: "text",
+        text: sanitizeTerminalText(formatted.text) || "(no output)",
+      },
+    ],
+    details: {
+      command,
+      truncated: formatted.truncated,
+      lineCount: formatted.lineCount,
+      fullOutputPath: formatted.fullOutputPath,
+    },
+  };
+}
+
+function showParameters() {
+  return Type.Object({
+    revision: Type.String({
+      description: GIT_SHOW_PARAMETER_DESCRIPTIONS.revision,
+    }),
+    path: Type.Optional(
+      Type.String({ description: GIT_SHOW_PARAMETER_DESCRIPTIONS.path }),
+    ),
+  });
+}
+
+function diffParameters() {
+  return Type.Object({
+    from: Type.Optional(
+      Type.String({ description: GIT_DIFF_PARAMETER_DESCRIPTIONS.from }),
+    ),
+    to: Type.Optional(
+      Type.String({ description: GIT_DIFF_PARAMETER_DESCRIPTIONS.to }),
+    ),
+    staged: Type.Optional(
+      Type.Boolean({ description: GIT_DIFF_PARAMETER_DESCRIPTIONS.staged }),
+    ),
+    stat: Type.Optional(
+      Type.Boolean({ description: GIT_DIFF_PARAMETER_DESCRIPTIONS.stat }),
+    ),
+    path: Type.Optional(
+      Type.String({ description: GIT_DIFF_PARAMETER_DESCRIPTIONS.path }),
+    ),
+  });
+}
+
+function logParameters() {
+  return Type.Object({
+    revision: Type.Optional(
+      Type.String({ description: GIT_LOG_PARAMETER_DESCRIPTIONS.revision }),
+    ),
+    file: Type.Optional(
+      Type.String({ description: GIT_LOG_PARAMETER_DESCRIPTIONS.file }),
+    ),
+    limit: Type.Optional(
+      Type.Integer({
+        description: GIT_LOG_PARAMETER_DESCRIPTIONS.limit,
+        minimum: 1,
+        maximum: 1000,
+      }),
+    ),
+    oneline: Type.Optional(
+      Type.Boolean({ description: GIT_LOG_PARAMETER_DESCRIPTIONS.oneline }),
+    ),
+  });
+}
+
+function displayRevision(value: string | undefined, fallback = "HEAD") {
+  return value === undefined || value.trim() === "" ? fallback : value.trim();
+}
+
+export default function gitReadTools(pi: ExtensionAPI) {
+  const resultDirectories = new Set<string>();
+  const rememberOutput = (outcome: GitOutcome) => {
+    if (outcome.output.fullOutputPath) {
+      resultDirectories.add(path.dirname(outcome.output.fullOutputPath));
+    }
+  };
+
+  pi.on("session_start", () => {
+    patchOwnedTools(pi, "gitRead", {
+      enable: OPENPI_TOOL_SURFACE.gitRead.entry,
+    });
+  });
+
+  pi.on("session_shutdown", () => {
+    for (const directory of resultDirectories) {
+      try {
+        fs.rmSync(directory, { recursive: true, force: true });
+      } catch {
+        // Temporary git artifacts are best-effort cleanup.
+      }
+    }
+    resultDirectories.clear();
+  });
+
+  pi.registerTool<ReturnType<typeof showParameters>, GitToolDetails>({
+    name: "git_show",
+    label: "Git Show",
+    description: GIT_SHOW_TOOL_DESCRIPTION,
+    promptSnippet: GIT_SHOW_PROMPT_SNIPPET,
+    promptGuidelines: GIT_SHOW_PROMPT_GUIDELINES,
+    parameters: showParameters(),
+
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+      const exit = await Effect.runPromiseExit(
+        Effect.gen(function* () {
+          const args = buildShowArgs(params as GitShowParams);
+          const outcome = yield* runGit(args, ctx.cwd);
+          rememberOutput(outcome);
+          return gitResult(outcome, args.join(" "));
+        }),
+        signal ? { signal } : undefined,
+      );
+      return unwrapToolExit(exit, "git_show");
+    },
+
+    renderCall(args) {
+      return new Text(`git show ${displayRevision(args.revision)}`, 0, 0);
+    },
+
+    renderResult(result, { expanded }, theme) {
+      const details = result.details;
+      let text = details?.command
+        ? `showed ${details.lineCount ?? 0} lines`
+        : "shown";
+      if (details?.truncated) text += " (truncated)";
+      if (expanded)
+        text += expandedResultPreview(result, details?.fullOutputPath, theme);
+      return new Text(text, 0, 0);
+    },
+  });
+
+  pi.registerTool<ReturnType<typeof diffParameters>, GitToolDetails>({
+    name: "git_diff",
+    label: "Git Diff",
+    description: GIT_DIFF_TOOL_DESCRIPTION,
+    promptSnippet: GIT_DIFF_PROMPT_SNIPPET,
+    promptGuidelines: GIT_DIFF_PROMPT_GUIDELINES,
+    parameters: diffParameters(),
+
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+      const exit = await Effect.runPromiseExit(
+        Effect.gen(function* () {
+          const args = buildDiffArgs(params as GitDiffParams);
+          const outcome = yield* runGit(args, ctx.cwd);
+          rememberOutput(outcome);
+          return gitResult(outcome, args.join(" "));
+        }),
+        signal ? { signal } : undefined,
+      );
+      return unwrapToolExit(exit, "git_diff");
+    },
+
+    renderCall(args) {
+      const from = displayRevision(
+        args.from,
+        args.staged ? "HEAD (staged)" : "index",
+      );
+      const to = args.to ? displayRevision(args.to) : "worktree";
+      let text = `git diff ${from} → ${to}`;
+      if (args.stat) text += " (stat)";
+      if (args.path) text += ` ${args.path}`;
+      return new Text(text, 0, 0);
+    },
+
+    renderResult(result, { expanded }, theme) {
+      const details = result.details;
+      let text = details?.command
+        ? `${details.lineCount ?? 0} diff lines`
+        : "diffed";
+      if (details?.truncated) text += " (truncated)";
+      if (expanded)
+        text += expandedResultPreview(result, details?.fullOutputPath, theme);
+      return new Text(text, 0, 0);
+    },
+  });
+
+  pi.registerTool<ReturnType<typeof logParameters>, GitToolDetails>({
+    name: "git_log",
+    label: "Git Log",
+    description: GIT_LOG_TOOL_DESCRIPTION,
+    promptSnippet: GIT_LOG_PROMPT_SNIPPET,
+    promptGuidelines: GIT_LOG_PROMPT_GUIDELINES,
+    parameters: logParameters(),
+
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+      const exit = await Effect.runPromiseExit(
+        Effect.gen(function* () {
+          const args = buildLogArgs(params as GitLogParams);
+          const outcome = yield* runGit(args, ctx.cwd);
+          rememberOutput(outcome);
+          return gitResult(outcome, args.join(" "));
+        }),
+        signal ? { signal } : undefined,
+      );
+      return unwrapToolExit(exit, "git_log");
+    },
+
+    renderCall(args) {
+      let text = `git log ${displayRevision(args.revision)}`;
+      if (args.file) text += ` -- ${args.file}`;
+      if (args.limit !== undefined) text += ` -n ${args.limit}`;
+      return new Text(text, 0, 0);
+    },
+
+    renderResult(result, { expanded }, theme) {
+      const details = result.details;
+      let text = details?.command
+        ? `${details.lineCount ?? 0} output lines`
+        : "logged";
+      if (details?.truncated) text += " (truncated)";
+      if (expanded)
+        text += expandedResultPreview(result, details?.fullOutputPath, theme);
+      return new Text(text, 0, 0);
+    },
+  });
+}
+
+const EXPANDED_PREVIEW_LINES = 20;
+
+export function expandedResultPreview(
+  result: { content: { type: string; text?: string }[] },
+  fullOutputPath: string | undefined,
+  theme: { fg(color: string, text: string): string },
+) {
+  let text = "";
+  const content = result.content[0];
+  if (content?.type === "text" && content.text) {
+    const lines = sanitizeTerminalText(content.text).split("\n");
+    for (const line of lines.slice(0, EXPANDED_PREVIEW_LINES)) {
+      text += `\n${theme.fg("dim", line)}`;
+    }
+    if (lines.length > EXPANDED_PREVIEW_LINES) {
+      text += `\n${theme.fg("muted", `... ${lines.length - EXPANDED_PREVIEW_LINES} more lines`)}`;
+    }
+  }
+  if (fullOutputPath) {
+    text += `\n${theme.fg("dim", `Full output: ${sanitizeTerminalText(fullOutputPath)}`)}`;
+  }
+  return text;
+}