@tt-a1i/openpi 0.4.0 → 0.6.0

package/extensions/file-mutation-display/render.ts

@@ -1,13 +1,11 @@
-import { isAbsolute, relative } from "node:path";
-import { stripVTControlCharacters } from "node:util";
 import type {
   AgentToolResult,
   Theme,
   ToolDefinition,
 } from "@earendil-works/pi-coding-agent";
-import { truncateToWidth, type Component } from "@earendil-works/pi-tui";
+import type { Component } from "@earendil-works/pi-tui";
 import type { TSchema } from "typebox";
-import { spinnerFrame } from "../shared/spinner.ts";
+import { renderPaddedToolActivityLine } from "../shared/tool-activity.ts";
 
 type ActivityStatus = "pending" | "success" | "error";
 
@@ -23,33 +21,11 @@ type ActivityRenderState<TDetails> = {
   };
 };
 
-type ActivityRow = {
-  verb: string;
-  target: string;
-  detail?: string;
-};
-
-const HORIZONTAL_PADDING = "  ";
-
 const emptyComponent: Component = {
   render: () => [],
   invalidate() {},
 };
 
-function record(value: unknown): Record<string, unknown> {
-  return value !== null && typeof value === "object"
-    ? (value as Record<string, unknown>)
-    : {};
-}
-
-function string(value: unknown) {
-  return typeof value === "string" ? value : "";
-}
-
-function number(value: unknown) {
-  return typeof value === "number" ? value : undefined;
-}
-
 function textOutput(result: AgentToolResult<unknown> | undefined) {
   return (
     result?.content
@@ -59,228 +35,6 @@ function textOutput(result: AgentToolResult<unknown> | undefined) {
   );
 }
 
-function resultCount(result: AgentToolResult<unknown> | undefined) {
-  return textOutput(result)
-    .split(/\r?\n/)
-    .filter((line) => line.trim().length > 0 && !line.trim().startsWith("["))
-    .length;
-}
-
-function grepMatchCount(result: AgentToolResult<unknown> | undefined) {
-  const output = textOutput(result).trim();
-  if (!output || output === "No matches found") return 0;
-  return output.split(/\r?\n/).filter((line) => /^.+:\d+:/.test(line)).length;
-}
-
-function itemCount(
-  result: AgentToolResult<unknown> | undefined,
-  emptyMessage: string,
-) {
-  const output = textOutput(result).trim();
-  return !output || output === emptyMessage ? 0 : resultCount(result);
-}
-
-function plural(count: number, singular: string) {
-  const pluralForm =
-    singular === "match"
-      ? "matches"
-      : singular === "entry"
-        ? "entries"
-        : `${singular}s`;
-  return `${count} ${count === 1 ? singular : pluralForm}`;
-}
-
-function editStats(details: unknown) {
-  const diff = string(record(details).diff);
-  if (!diff) return undefined;
-  let additions = 0;
-  let removals = 0;
-  for (const line of diff.split(/\r?\n/)) {
-    if (line.startsWith("+") && !line.startsWith("+++")) additions += 1;
-    if (line.startsWith("-") && !line.startsWith("---")) removals += 1;
-  }
-  return { additions, removals };
-}
-
-function range(args: Record<string, unknown>) {
-  const offset = number(args.offset);
-  const limit = number(args.limit);
-  if (offset === undefined && limit === undefined) return "";
-  const start = offset ?? 1;
-  return limit === undefined ? `:${start}-` : `:${start}-${start + limit - 1}`;
-}
-
-function displayPath(path: string, cwd: string) {
-  if (!isAbsolute(path)) return path;
-  const local = relative(cwd, path);
-  if (local === "") return ".";
-  return local.startsWith("..") || isAbsolute(local) ? path : local;
-}
-
-function activityRow(
-  name: string,
-  argsValue: unknown,
-  result: AgentToolResult<unknown> | undefined,
-  cwd: string,
-): ActivityRow {
-  const args = record(argsValue);
-  const path = displayPath(string(args.path) || ".", cwd);
-  switch (name) {
-    case "read":
-      return { verb: "Read", target: `${path}${range(args)}` };
-    case "bash":
-      return {
-        verb: "Ran",
-        target: string(args.command).replace(/\s+/g, " ").trim(),
-      };
-    case "write": {
-      const content = string(args.content);
-      const lines =
-        content.length === 0
-          ? 0
-          : content.replace(/\r?\n$/, "").split(/\r?\n/).length;
-      return { verb: "Wrote", target: path, detail: plural(lines, "line") };
-    }
-    case "edit":
-      return { verb: "Edited", target: path };
-    case "grep":
-      return {
-        verb: "Searched",
-        target: string(args.pattern),
-        detail: `in ${path}  ${plural(grepMatchCount(result), "match")}`,
-      };
-    case "find":
-      return {
-        verb: "Searched",
-        target: string(args.pattern),
-        detail: `in ${path}  ${plural(itemCount(result, "No files found matching pattern"), "result")}`,
-      };
-    case "ls":
-      return {
-        verb: "Listed",
-        target: path,
-        detail: plural(itemCount(result, "(empty directory)"), "entry"),
-      };
-    default:
-      return { verb: name, target: "" };
-  }
-}
-
-function pendingVerb(name: string) {
-  switch (name) {
-    case "read":
-      return "Reading";
-    case "bash":
-      return "Running";
-    case "write":
-      return "Writing";
-    case "edit":
-      return "Editing";
-    case "grep":
-    case "find":
-      return "Searching";
-    case "ls":
-      return "Listing";
-    default:
-      return "Running";
-  }
-}
-
-function activityIcon(name: string) {
-  switch (name) {
-    case "read":
-      return "\ueaa4"; // Nerd Fonts Codicon: book
-    case "bash":
-      return "\uea85"; // Nerd Fonts Codicon: terminal
-    case "write":
-    case "edit":
-      return "\uea73"; // Nerd Fonts Codicon: edit
-    case "grep":
-    case "find":
-      return "\uea6d"; // Nerd Fonts Codicon: search
-    case "ls":
-      return "\uea83"; // Nerd Fonts Codicon: folder
-    default:
-      return "✓";
-  }
-}
-
-function errorSummary(result: AgentToolResult<unknown> | undefined) {
-  const lines = textOutput(result)
-    .split(/\r?\n/)
-    .map((line) => stripVTControlCharacters(line).trim())
-    .filter(Boolean);
-  return (
-    [...lines]
-      .reverse()
-      .find((line) =>
-        /(?:command (?:exited|timed out|aborted)|error|denied|failed)/i.test(
-          line,
-        ),
-      ) ?? lines[0]
-  );
-}
-
-function duration(
-  state: NonNullable<ActivityRenderState<unknown>["openpiActivity"]>,
-) {
-  if (state.startedAt === undefined) return undefined;
-  const seconds = Math.floor(
-    ((state.endedAt ?? Date.now()) - state.startedAt) / 1000,
-  );
-  return seconds > 0 ? `${seconds}s` : undefined;
-}
-
-function activityText(
-  name: string,
-  args: unknown,
-  state: NonNullable<ActivityRenderState<unknown>["openpiActivity"]>,
-  theme: Theme,
-  cwd: string,
-) {
-  const row = activityRow(name, args, state.result, cwd);
-  const elapsed = duration(state);
-  const verbText = (
-    state.status === "pending"
-      ? pendingVerb(name)
-      : state.status === "error"
-        ? "Failed"
-        : row.verb
-  ).padEnd(8);
-  const verb = theme.fg(
-    state.status === "error"
-      ? "error"
-      : state.status === "success"
-        ? "muted"
-        : "toolTitle",
-    verbText,
-  );
-  if (state.status === "pending") {
-    const detail = elapsed ? ` · ${elapsed}` : "";
-    return `${theme.fg("warning", spinnerFrame(Date.now()))} ${verb} ${row.target}${theme.fg("dim", detail)}`;
-  }
-  if (state.status === "error") {
-    const summary = errorSummary(state.result);
-    const detail = [elapsed, summary].filter(Boolean).join(" · ");
-    return `${theme.fg("error", "✕")} ${verb} ${row.target}${detail ? theme.fg("dim", ` · ${detail}`) : ""}`;
-  }
-  const parts: string[] = [];
-  if (name === "edit") {
-    // Kimi-style diff stats: additions green, removals red.
-    const stats = editStats(state.result?.details);
-    if (stats) {
-      parts.push(
-        `${theme.fg("success", `+${stats.additions}`)} ${theme.fg("error", `-${stats.removals}`)}`,
-      );
-    }
-  } else if (row.detail) {
-    parts.push(theme.fg("dim", row.detail));
-  }
-  if (elapsed) parts.push(theme.fg("dim", elapsed));
-  const detail = parts.join(theme.fg("dim", " · "));
-  return `${theme.fg("dim", activityIcon(name))} ${verb} ${theme.fg("muted", row.target)}${detail ? `  ${detail}` : ""}`;
-}
-
 function activityComponent(
   name: string,
   args: unknown,
@@ -290,15 +44,21 @@ function activityComponent(
 ): Component {
   return {
     render(width) {
-      const contentWidth = width - HORIZONTAL_PADDING.length * 2;
-      if (contentWidth <= 0) return [];
-      return [
-        `${HORIZONTAL_PADDING}${truncateToWidth(
-          activityText(name, args, state, theme, cwd),
-          contentWidth,
-          "…",
-        )}${HORIZONTAL_PADDING}`,
-      ];
+      const line = renderPaddedToolActivityLine(
+        {
+          name,
+          args,
+          output: textOutput(state.result),
+          details: state.result?.details,
+          status: state.status,
+          cwd,
+          startedAt: state.startedAt,
+          endedAt: state.endedAt,
+        },
+        theme,
+        width,
+      );
+      return line ? [line] : [];
     },
     invalidate() {},
   };

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

@@ -20,7 +20,15 @@ import { execFile } from "node:child_process";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { promisify } from "node:util";
-import { Crypto, Data, Effect, Encoding, FileSystem, Stream } from "effect";
+import {
+  Crypto,
+  Data,
+  Effect,
+  Encoding,
+  FileSystem,
+  Layer,
+  Stream,
+} from "effect";
 import { FetchHttpClient, HttpClient } from "effect/unstable/http";
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
 
@@ -161,6 +169,12 @@ export class InstallError extends Data.TaggedError("InstallError")<{
   readonly cause?: unknown;
 }> {}
 
+export class BinaryDownloadError extends Data.TaggedError(
+  "BinaryDownloadError",
+)<{
+  readonly message: string;
+}> {}
+
 export interface BinaryEnv {
   /** True when the executable runs and supports the flags this tool requires. */
   readonly probe: (command: string, tool: ToolName) => Effect.Effect<boolean>;
@@ -237,9 +251,9 @@ export function readBoundedResponse<E, R>(
   return Effect.gen(function* () {
     const declaredLength = Number(response.headers["content-length"]);
     if (Number.isFinite(declaredLength) && declaredLength > maxBytes) {
-      return yield* Effect.fail(
-        new Error(`download exceeds the ${maxBytes}-byte size limit`),
-      );
+      return yield* new BinaryDownloadError({
+        message: `download exceeds the ${maxBytes}-byte size limit`,
+      });
     }
 
     const result = yield* Stream.runFoldEffect(
@@ -249,7 +263,9 @@ export function readBoundedResponse<E, R>(
         const totalBytes = accumulator.totalBytes + chunk.byteLength;
         if (totalBytes > maxBytes) {
           return Effect.fail(
-            new Error(`download exceeds the ${maxBytes}-byte size limit`),
+            new BinaryDownloadError({
+              message: `download exceeds the ${maxBytes}-byte size limit`,
+            }),
           );
         }
         return Effect.sync(() => {
@@ -272,9 +288,9 @@ function downloadAsset(client: HttpClient.HttpClient, initialUrl: URL) {
 
     for (let redirects = 0; redirects <= MAX_DOWNLOAD_REDIRECTS; redirects++) {
       if (url.protocol !== "https:") {
-        return yield* Effect.fail(
-          new Error(`refusing non-HTTPS download URL: ${url.href}`),
-        );
+        return yield* new BinaryDownloadError({
+          message: `refusing non-HTTPS download URL: ${url.href}`,
+        });
       }
 
       const result = yield* Effect.scoped(
@@ -283,31 +299,27 @@ function downloadAsset(client: HttpClient.HttpClient, initialUrl: URL) {
           if ([301, 302, 303, 307, 308].includes(response.status)) {
             const location = response.headers.location;
             if (!location) {
-              return yield* Effect.fail(
-                new Error(`redirect from ${url.href} had no location header`),
-              );
+              return yield* new BinaryDownloadError({
+                message: `redirect from ${url.href} had no location header`,
+              });
             }
             if (redirects === MAX_DOWNLOAD_REDIRECTS) {
-              return yield* Effect.fail(
-                new Error(
-                  `download exceeded ${MAX_DOWNLOAD_REDIRECTS} redirects`,
-                ),
-              );
+              return yield* new BinaryDownloadError({
+                message: `download exceeded ${MAX_DOWNLOAD_REDIRECTS} redirects`,
+              });
             }
             if (!URL.canParse(location, url)) {
-              return yield* Effect.fail(
-                new Error(
-                  `download returned an invalid redirect URL: ${location}`,
-                ),
-              );
+              return yield* new BinaryDownloadError({
+                message: `download returned an invalid redirect URL: ${location}`,
+              });
             }
             return { _tag: "Redirect" as const, url: new URL(location, url) };
           }
 
           if (response.status < 200 || response.status >= 300) {
-            return yield* Effect.fail(
-              new Error(`download failed with HTTP ${response.status}`),
-            );
+            return yield* new BinaryDownloadError({
+              message: `download failed with HTTP ${response.status}`,
+            });
           }
           return {
             _tag: "Complete" as const,
@@ -320,7 +332,9 @@ function downloadAsset(client: HttpClient.HttpClient, initialUrl: URL) {
       url = result.url;
     }
 
-    return yield* Effect.fail(new Error("download redirect handling failed"));
+    return yield* new BinaryDownloadError({
+      message: "download redirect handling failed",
+    });
   });
 }
 
@@ -344,9 +358,9 @@ export const liveBinaryEnv: BinaryEnv = {
   install: (asset, destination) => {
     const install = Effect.gen(function* () {
       if (!URL.canParse(asset.url)) {
-        return yield* Effect.fail(
-          new Error(`invalid download URL: ${asset.url}`),
-        );
+        return yield* new BinaryDownloadError({
+          message: `invalid download URL: ${asset.url}`,
+        });
       }
 
       const url = new URL(asset.url);
@@ -360,11 +374,9 @@ export const liveBinaryEnv: BinaryEnv = {
       const digestBytes = yield* crypto.digest("SHA-256", bytes);
       const digest = Encoding.encodeHex(digestBytes);
       if (digest !== asset.sha256) {
-        return yield* Effect.fail(
-          new Error(
-            `SHA-256 mismatch for ${asset.fileName}: expected ${asset.sha256}, received ${digest}`,
-          ),
-        );
+        return yield* new BinaryDownloadError({
+          message: `SHA-256 mismatch for ${asset.fileName}: expected ${asset.sha256}, received ${digest}`,
+        });
       }
 
       const workDir = yield* fs.makeTempDirectoryScoped({
@@ -384,9 +396,9 @@ export const liveBinaryEnv: BinaryEnv = {
         }),
       ).pipe(Effect.timeout(60_000));
       if (tarExitCode !== ChildProcessSpawner.ExitCode(0)) {
-        return yield* Effect.fail(
-          new Error(`tar failed with exit code ${tarExitCode}`),
-        );
+        return yield* new BinaryDownloadError({
+          message: `tar failed with exit code ${tarExitCode}`,
+        });
       }
 
       const extracted = join(workDir, asset.archiveDir, asset.binaryName);
@@ -401,13 +413,17 @@ export const liveBinaryEnv: BinaryEnv = {
       yield* fs.rename(stagedDestination, destination);
     });
 
-    return install.pipe(
-      Effect.scoped,
-      Effect.provide(NodeServices.layer),
-      Effect.provide(NodeHttpClient.layerFetch),
-      Effect.provideService(FetchHttpClient.RequestInit, {
+    const InstallLayer = Layer.mergeAll(
+      NodeServices.layer,
+      NodeHttpClient.layerFetch,
+      Layer.succeed(FetchHttpClient.RequestInit, {
         redirect: "manual",
       }),
+    );
+
+    return install.pipe(
+      Effect.scoped,
+      Effect.provide(InstallLayer),
       Effect.mapError(
         (cause) =>
           new InstallError({

package/extensions/git-read/index.ts

@@ -13,15 +13,13 @@
 
 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 { Type } from "typebox";
 import { formatCapturedOutput } from "../file-search/src/output.ts";
 import { sanitizeTerminalText } from "../shared/terminal-text.ts";
 import {