@tt-a1i/openpi 0.1.0

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

@@ -0,0 +1,414 @@
+import { basename } from "node:path";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import {
+  Key,
+  matchesKey,
+  truncateToWidth,
+  visibleWidth,
+} from "@earendil-works/pi-tui";
+import { Effect } from "effect";
+import { sanitizeTerminalText } from "../../shared/terminal-text.ts";
+import { runCommand } from "./process.ts";
+
+export { sanitizeTerminalText };
+
+const DIFF_SCROLL_STEP = 5;
+const MAX_DIFF_LINES = 20_000;
+
+interface ChangedPath {
+  path: string;
+  status: string;
+}
+
+export interface ChangedFile {
+  additions: number | null;
+  deletions: number | null;
+  diff: string[];
+  name: string;
+  path: string;
+}
+
+function parseChangedPaths(output: string) {
+  const records = output.split("\0");
+  const paths: ChangedPath[] = [];
+
+  for (let index = 0; index < records.length; index += 1) {
+    const record = records[index];
+    if (!record || record.length < 4) continue;
+
+    const status = record.slice(0, 2);
+    const path = record.slice(3);
+    paths.push({ path, status });
+
+    // In porcelain v1 -z output, rename/copy records are followed by the old path.
+    if (status.includes("R") || status.includes("C")) index += 1;
+  }
+
+  return [...new Map(paths.map((entry) => [entry.path, entry])).values()];
+}
+
+function parseNumstat(output: string) {
+  const line = output.split("\n").find(Boolean);
+  if (!line) return { additions: 0, deletions: 0 };
+
+  const [added, deleted] = line.split("\t");
+  return {
+    additions: added === "-" ? null : Number.parseInt(added ?? "0", 10),
+    deletions: deleted === "-" ? null : Number.parseInt(deleted ?? "0", 10),
+  };
+}
+
+function cleanDisplayPath(path: string) {
+  return sanitizeTerminalText(path).replace(/[\r\n\t]/g, " ");
+}
+
+const run = (cwd: string, args: string[]) =>
+  runCommand("git", args, cwd, 10_000);
+
+const loadFile = Effect.fn("git-info.loadFile")(function* (
+  repoRoot: string,
+  changedPath: ChangedPath,
+  hasHead: boolean,
+) {
+  const useNoIndex = changedPath.status === "??" || !hasHead;
+  const diffArguments = useNoIndex
+    ? [
+        "diff",
+        "--no-index",
+        "--no-ext-diff",
+        "--no-color",
+        "--unified=3",
+        "--",
+        "/dev/null",
+        changedPath.path,
+      ]
+    : [
+        "diff",
+        "--no-ext-diff",
+        "--no-color",
+        "--unified=3",
+        "HEAD",
+        "--",
+        changedPath.path,
+      ];
+  const statArguments = useNoIndex
+    ? ["diff", "--no-index", "--numstat", "--", "/dev/null", changedPath.path]
+    : ["diff", "--numstat", "HEAD", "--", changedPath.path];
+  const [diffResult, statResult] = yield* Effect.all(
+    [run(repoRoot, diffArguments), run(repoRoot, statArguments)],
+    { concurrency: "unbounded" },
+  );
+  const stats = parseNumstat(statResult.stdout);
+  const allDiffLines = diffResult.stdout
+    .trimEnd()
+    .split("\n")
+    .map(sanitizeTerminalText);
+  const diff =
+    allDiffLines.length > MAX_DIFF_LINES
+      ? [
+          ...allDiffLines.slice(0, MAX_DIFF_LINES),
+          `… diff truncated after ${MAX_DIFF_LINES.toLocaleString()} lines …`,
+        ]
+      : allDiffLines;
+
+  return {
+    ...stats,
+    diff:
+      diff.length === 1 && diff[0] === ""
+        ? ["No textual diff available."]
+        : diff,
+    name: cleanDisplayPath(basename(changedPath.path)),
+    path: cleanDisplayPath(changedPath.path),
+  } satisfies ChangedFile;
+});
+
+export const loadChangedFiles = Effect.fn("git-info.loadChangedFiles")(
+  function* (cwd: string) {
+    const rootResult = yield* run(cwd, ["rev-parse", "--show-toplevel"]);
+    if (rootResult.code !== 0) return null;
+
+    const repoRoot = rootResult.stdout.trim();
+    const [statusResult, headResult] = yield* Effect.all(
+      [
+        run(repoRoot, [
+          "status",
+          "--porcelain=v1",
+          "-z",
+          "--untracked-files=all",
+        ]),
+        run(repoRoot, ["rev-parse", "--verify", "HEAD"]),
+      ],
+      { concurrency: "unbounded" },
+    );
+    if (statusResult.code !== 0) return null;
+
+    const changedPaths = parseChangedPaths(statusResult.stdout);
+    const files: ChangedFile[] = [];
+    for (const changedPath of changedPaths) {
+      files.push(yield* loadFile(repoRoot, changedPath, headResult.code === 0));
+    }
+
+    return files;
+  },
+);
+
+function padToWidth(text: string, width: number) {
+  const truncated = truncateToWidth(text, width, "");
+  return `${truncated}${" ".repeat(Math.max(0, width - visibleWidth(truncated)))}`;
+}
+
+export async function showChangedFiles(
+  ctx: ExtensionContext,
+  files: ChangedFile[],
+) {
+  if (ctx.mode !== "tui") return;
+
+  await ctx.ui.custom<void>(
+    (tui, theme, _keybindings, done) => {
+      let focus: "files" | "diff" = "files";
+      let selectedIndex = 0;
+      let sidebarOffset = 0;
+      let diffOffset = 0;
+
+      function bodyHeight() {
+        return Math.max(8, Math.floor(tui.terminal.rows * 0.8) - 2);
+      }
+
+      function ensureSelectedFileVisible() {
+        const visibleFiles = Math.max(1, Math.floor(bodyHeight() / 2));
+        if (selectedIndex < sidebarOffset) sidebarOffset = selectedIndex;
+        if (selectedIndex >= sidebarOffset + visibleFiles) {
+          sidebarOffset = selectedIndex - visibleFiles + 1;
+        }
+      }
+
+      function moveFile(amount: number) {
+        selectedIndex = (selectedIndex + amount + files.length) % files.length;
+        diffOffset = 0;
+        ensureSelectedFileVisible();
+        tui.requestRender();
+      }
+
+      function moveDiff(amount: number) {
+        const maxOffset = Math.max(
+          0,
+          files[selectedIndex]!.diff.length - bodyHeight(),
+        );
+        diffOffset = Math.max(0, Math.min(maxOffset, diffOffset + amount));
+        tui.requestRender();
+      }
+
+      function styleDiffLine(line: string) {
+        const expanded = sanitizeTerminalText(line).replaceAll("\t", "    ");
+        if (
+          expanded.startsWith("diff --git") ||
+          expanded.startsWith("index ")
+        ) {
+          return theme.fg("accent", theme.bold(expanded));
+        }
+        if (expanded.startsWith("@@")) return theme.fg("mdHeading", expanded);
+        if (expanded.startsWith("---") || expanded.startsWith("+++")) {
+          return theme.fg("muted", expanded);
+        }
+        if (expanded.startsWith("+")) return theme.fg("success", expanded);
+        if (expanded.startsWith("-")) return theme.fg("error", expanded);
+        if (expanded.startsWith("…")) return theme.fg("warning", expanded);
+        return theme.fg("text", expanded);
+      }
+
+      function border(width: number, label: string, top: boolean) {
+        const left = top ? "┌" : "└";
+        const right = top ? "┐" : "┘";
+        const text = `─ ${label} `;
+        const remaining = Math.max(0, width - visibleWidth(text) - 2);
+        return theme.fg(
+          "borderAccent",
+          truncateToWidth(
+            `${left}${text}${"─".repeat(remaining)}${right}`,
+            width,
+            "",
+          ),
+        );
+      }
+
+      function handleInput(data: string) {
+        if (focus === "files") {
+          if (matchesKey(data, Key.escape)) {
+            done(undefined);
+            return;
+          }
+          if (matchesKey(data, Key.down) || data === "j") {
+            moveFile(1);
+            return;
+          }
+          if (matchesKey(data, Key.up) || data === "k") {
+            moveFile(-1);
+            return;
+          }
+          if (matchesKey(data, Key.home) || data === "g") {
+            selectedIndex = 0;
+            diffOffset = 0;
+            ensureSelectedFileVisible();
+            tui.requestRender();
+            return;
+          }
+          if (matchesKey(data, Key.end) || data === "G") {
+            selectedIndex = files.length - 1;
+            diffOffset = 0;
+            ensureSelectedFileVisible();
+            tui.requestRender();
+            return;
+          }
+          if (
+            matchesKey(data, Key.enter) ||
+            matchesKey(data, Key.space) ||
+            matchesKey(data, Key.right) ||
+            data === "l"
+          ) {
+            focus = "diff";
+            tui.requestRender();
+          }
+          return;
+        }
+
+        if (
+          matchesKey(data, Key.escape) ||
+          matchesKey(data, Key.left) ||
+          data === "h"
+        ) {
+          focus = "files";
+          tui.requestRender();
+          return;
+        }
+        if (matchesKey(data, Key.down) || data === "j") {
+          moveDiff(DIFF_SCROLL_STEP);
+          return;
+        }
+        if (matchesKey(data, Key.up) || data === "k") {
+          moveDiff(-DIFF_SCROLL_STEP);
+          return;
+        }
+        if (matchesKey(data, Key.ctrl("d"))) {
+          moveDiff(Math.max(1, Math.floor(bodyHeight() / 2)));
+          return;
+        }
+        if (matchesKey(data, Key.ctrl("u"))) {
+          moveDiff(-Math.max(1, Math.floor(bodyHeight() / 2)));
+          return;
+        }
+        if (matchesKey(data, Key.home) || data === "g") {
+          diffOffset = 0;
+          tui.requestRender();
+          return;
+        }
+        if (matchesKey(data, Key.end) || data === "G") {
+          diffOffset = Math.max(
+            0,
+            files[selectedIndex]!.diff.length - bodyHeight(),
+          );
+          tui.requestRender();
+        }
+      }
+
+      function render(width: number) {
+        const height = bodyHeight();
+        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"}`;
+        const lines = [border(width, title, true)];
+
+        for (let row = 0; row < height; row += 1) {
+          const fileIndex = sidebarOffset + Math.floor(row / 2);
+          const file = files[fileIndex];
+          let sidebar = "";
+
+          if (file) {
+            const isSelected = fileIndex === selectedIndex;
+            if (row % 2 === 0) {
+              const marker = isSelected ? "› " : "  ";
+              const isBinary =
+                file.additions === null || file.deletions === null;
+              const stats = isBinary
+                ? "binary"
+                : `+${file.additions} -${file.deletions}`;
+              const styledStats = isBinary
+                ? theme.fg("success", stats)
+                : `${theme.fg("success", `+${file.additions}`)} ${theme.fg("error", `-${file.deletions}`)}`;
+              const nameWidth = Math.max(
+                1,
+                sidebarWidth - visibleWidth(marker) - visibleWidth(stats) - 1,
+              );
+              const name = truncateToWidth(
+                cleanDisplayPath(file.name),
+                nameWidth,
+                "…",
+              );
+              const gap = " ".repeat(
+                Math.max(
+                  1,
+                  sidebarWidth -
+                    visibleWidth(marker) -
+                    visibleWidth(name) -
+                    visibleWidth(stats),
+                ),
+              );
+              sidebar = `${marker}${name}${gap}${styledStats}`;
+            } else {
+              sidebar = `  ${theme.fg("dim", truncateToWidth(cleanDisplayPath(file.path), Math.max(1, sidebarWidth - 2), "…"))}`;
+            }
+
+            sidebar = padToWidth(sidebar, sidebarWidth);
+            if (isSelected) {
+              sidebar = theme.bg(
+                focus === "files" ? "selectedBg" : "customMessageBg",
+                sidebar,
+              );
+            }
+          } else {
+            sidebar = " ".repeat(sidebarWidth);
+          }
+
+          const diffLine = selectedFile.diff[diffOffset + row];
+          const diff = padToWidth(
+            diffLine === undefined ? "" : styleDiffLine(diffLine),
+            diffWidth,
+          );
+          const separator = theme.fg(
+            focus === "diff" ? "borderAccent" : "borderMuted",
+            "│",
+          );
+          lines.push(
+            `${theme.fg("borderMuted", "│")}${sidebar}${separator}${diff}${theme.fg("borderMuted", "│")}`,
+          );
+        }
+
+        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));
+        return lines;
+      }
+
+      return {
+        handleInput,
+        invalidate() {},
+        render,
+      };
+    },
+    {
+      overlay: true,
+      overlayOptions: {
+        anchor: "center",
+        margin: 1,
+        maxHeight: "90%",
+        minWidth: 60,
+        width: "95%",
+      },
+    },
+  );
+}

package/extensions/git-info/src/process.ts

@@ -0,0 +1,107 @@
+import { Context, Effect, Layer, Stream } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+
+const MAX_STREAM_CHARS = 10 * 1_024 * 1_024;
+const TRUNCATED_MARKER = "\n[command output truncated]\n";
+
+function appendBounded(current: string, chunk: string) {
+  if (current.endsWith(TRUNCATED_MARKER)) return current;
+  if (current.length + chunk.length <= MAX_STREAM_CHARS) return current + chunk;
+  const remaining = Math.max(0, MAX_STREAM_CHARS - current.length);
+  return `${current}${chunk.slice(0, remaining)}${TRUNCATED_MARKER}`;
+}
+
+export interface CommandResult {
+  code: number;
+  stderr: string;
+  stdout: string;
+}
+
+interface CommandRunnerShape {
+  run(
+    command: string,
+    args: string[],
+    cwd: string,
+    timeout: number,
+  ): Effect.Effect<CommandResult>;
+}
+
+export class CommandRunner extends Context.Service<
+  CommandRunner,
+  CommandRunnerShape
+>()("git-info/CommandRunner") {}
+
+function appendCommandFailure(stderr: string, command: string, error: Error) {
+  const failure = `Failed to run ${command}: ${error.message}`;
+  return stderr ? `${stderr.trimEnd()}\n${failure}` : failure;
+}
+
+export const CommandRunnerLive = Layer.effect(
+  CommandRunner,
+  Effect.gen(function* () {
+    const spawner = yield* ChildProcessSpawner;
+
+    return CommandRunner.of({
+      run: (command, args, cwd, timeout) =>
+        Effect.suspend(() => {
+          let stderr = "";
+          let stdout = "";
+          const child = ChildProcess.make(command, args, {
+            cwd,
+            detached: false,
+            forceKillAfter: "5 seconds",
+            stdin: "ignore",
+            stderr: "pipe",
+            stdout: "pipe",
+          });
+
+          return Effect.scoped(
+            Effect.gen(function* () {
+              const handle = yield* spawner.spawn(child);
+              const [, , code] = yield* Effect.all(
+                [
+                  Stream.runForEach(Stream.decodeText(handle.stdout), (chunk) =>
+                    Effect.sync(() => {
+                      stdout = appendBounded(stdout, chunk);
+                    }),
+                  ),
+                  Stream.runForEach(Stream.decodeText(handle.stderr), (chunk) =>
+                    Effect.sync(() => {
+                      stderr = appendBounded(stderr, chunk);
+                    }),
+                  ),
+                  handle.exitCode,
+                ],
+                { concurrency: "unbounded" },
+              );
+              return { code: Number(code), stderr, stdout };
+            }),
+          ).pipe(
+            Effect.timeoutOrElse({
+              duration: timeout,
+              orElse: () => Effect.succeed({ code: -1, stderr, stdout }),
+            }),
+            Effect.catch((error) =>
+              Effect.succeed({
+                code: 1,
+                stderr: appendCommandFailure(stderr, command, error),
+                stdout,
+              }),
+            ),
+          );
+        }),
+    });
+  }),
+);
+
+export const runCommand = (
+  command: string,
+  args: string[],
+  cwd: string,
+  timeout: number,
+) =>
+  Effect.gen(function* () {
+    const commands = yield* CommandRunner;
+    return yield* commands.run(command, args, cwd, timeout);
+  });

package/extensions/git-info/src/refresh-coordinator.ts

@@ -0,0 +1,13 @@
+import { Effect, Semaphore } from "effect";
+
+/** Serializes explicit refreshes while allowing background refreshes to coalesce. */
+export function makeRefreshCoordinator() {
+  const semaphore = Semaphore.makeUnsafe(1);
+
+  return {
+    run: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+      semaphore.withPermit(effect),
+    runIfIdle: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+      semaphore.withPermitsIfAvailable(1)(effect).pipe(Effect.asVoid),
+  };
+}

package/extensions/git-info/src/runtime.ts

@@ -0,0 +1,28 @@
+import { NodeServices } from "@effect/platform-node";
+import { Cause, Exit, Layer, ManagedRuntime, type Effect } from "effect";
+import { CommandRunner, CommandRunnerLive } from "./process.ts";
+
+const AppLayer = CommandRunnerLive.pipe(Layer.provide(NodeServices.layer));
+
+export function createRuntime() {
+  return ManagedRuntime.make(AppLayer);
+}
+
+export type GitInfoRuntime = ReturnType<typeof createRuntime>;
+
+export async function runEffect<A, E>(
+  runtime: GitInfoRuntime,
+  effect: Effect.Effect<A, E, CommandRunner>,
+  options: { signal?: AbortSignal; interruptMessage?: string } = {},
+) {
+  const exit = await runtime.runPromiseExit(
+    effect,
+    options.signal ? { signal: options.signal } : undefined,
+  );
+  if (Exit.isSuccess(exit)) return exit.value;
+  if (Cause.hasInterruptsOnly(exit.cause)) {
+    throw new Error(options.interruptMessage ?? "Operation was aborted.");
+  }
+  const [first] = Cause.prettyErrors(exit.cause);
+  throw new Error(first?.message ?? Cause.pretty(exit.cause));
+}