@tt-a1i/openpi 0.1.0

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

@@ -0,0 +1,309 @@
+import { spawn, type ChildProcess } from "node:child_process";
+import { createWriteStream } from "node:fs";
+import { dirname, join } from "node:path";
+import type { Writable } from "node:stream";
+import {
+  DEFAULT_MAX_BYTES,
+  DEFAULT_MAX_LINES,
+  truncateHead,
+} from "@earendil-works/pi-coding-agent";
+import { Data, Effect, FileSystem } from "effect";
+import { COMPLETE_OUTPUT_MAX_BYTES, type CapturedOutput } from "./output.ts";
+
+const STDERR_MAX_BYTES = 64 * 1024;
+
+interface PreviewState {
+  readonly decoder: TextDecoder;
+  preview: string;
+  totalBytes: number;
+  lineBreaks: number;
+  trailingLineBreaks: number;
+  truncated: boolean;
+  captureLimitExceeded: boolean;
+}
+
+function makePreviewState(): PreviewState {
+  return {
+    decoder: new TextDecoder(),
+    preview: "",
+    totalBytes: 0,
+    lineBreaks: 0,
+    trailingLineBreaks: 0,
+    truncated: false,
+    captureLimitExceeded: false,
+  };
+}
+
+function observeStdout(state: PreviewState, chunk: Uint8Array) {
+  state.totalBytes += chunk.byteLength;
+  for (const byte of chunk) {
+    if (byte === 0x0a) {
+      state.lineBreaks++;
+      state.trailingLineBreaks++;
+    } else {
+      state.trailingLineBreaks = 0;
+    }
+  }
+
+  if (state.truncated) return;
+  state.preview += state.decoder.decode(chunk, { stream: true });
+  const truncation = truncateHead(state.preview, {
+    maxLines: DEFAULT_MAX_LINES,
+    maxBytes: DEFAULT_MAX_BYTES,
+  });
+  if (truncation.truncated) {
+    state.preview = truncation.content;
+    state.truncated = true;
+  }
+}
+
+function finishStdout(
+  state: PreviewState,
+  fullOutputPath: string,
+  captureLimitBytes: number,
+) {
+  if (!state.truncated) state.preview += state.decoder.decode();
+  const totalBytes = state.totalBytes - state.trailingLineBreaks;
+  const lineCount =
+    totalBytes === 0 ? 0 : state.lineBreaks - state.trailingLineBreaks + 1;
+  return {
+    preview: state.preview,
+    lineCount,
+    totalBytes,
+    truncated: state.truncated || state.captureLimitExceeded,
+    captureLimitExceeded: state.captureLimitExceeded,
+    captureLimitBytes,
+    fullOutputPath:
+      state.truncated && !state.captureLimitExceeded
+        ? fullOutputPath
+        : undefined,
+  } satisfies CapturedOutput;
+}
+
+class SearchProcessError extends Data.TaggedError("SearchProcessError")<{
+  readonly message: string;
+}> {}
+
+function killProcess(child: ChildProcess, signal: NodeJS.Signals) {
+  if (process.platform !== "win32" && child.pid) {
+    try {
+      process.kill(-child.pid, signal);
+      return;
+    } catch {
+      // Fall through when the process group has already exited.
+    }
+  }
+  try {
+    child.kill(signal);
+  } catch {
+    // The child may already be gone.
+  }
+}
+
+function captureProcess(
+  options: {
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly cwd: string;
+    readonly createOutput?: (path: string) => Writable;
+  },
+  fullOutputPath: string,
+  captureLimitBytes: number,
+  preview: PreviewState,
+) {
+  return Effect.callback<
+    { readonly exitCode: number; readonly stderr: string },
+    SearchProcessError
+  >((resume) => {
+    const output = options.createOutput
+      ? options.createOutput(fullOutputPath)
+      : createWriteStream(fullOutputPath, { flags: "w" });
+    const child = spawn(options.command, options.args, {
+      cwd: options.cwd,
+      detached: process.platform !== "win32",
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    let closed = false;
+    let outputClosed = false;
+    let settled = false;
+    let stderr = Buffer.alloc(0);
+    let forceKillTimer: ReturnType<typeof setTimeout> | undefined;
+
+    const complete = (
+      result: Effect.Effect<
+        { readonly exitCode: number; readonly stderr: string },
+        SearchProcessError
+      >,
+    ) => {
+      if (settled) return;
+      settled = true;
+      resume(result);
+    };
+    const terminate = () => {
+      if (closed || forceKillTimer) return;
+      killProcess(child, "SIGTERM");
+      forceKillTimer = setTimeout(() => killProcess(child, "SIGKILL"), 1_000);
+      forceKillTimer.unref();
+    };
+    const fail = (error: unknown) => {
+      terminate();
+      output.destroy();
+      const message = error instanceof Error ? error.message : String(error);
+      if (outputClosed) {
+        complete(Effect.fail(new SearchProcessError({ message })));
+      } else {
+        output.once("close", () =>
+          complete(Effect.fail(new SearchProcessError({ message }))),
+        );
+      }
+    };
+
+    output.on("close", () => {
+      outputClosed = true;
+    });
+    output.on("error", fail);
+    child.on("error", fail);
+    child.stdout.on("error", fail);
+    child.stderr.on("error", fail);
+    child.stdout.on("data", (chunk: Buffer) => {
+      if (preview.captureLimitExceeded) return;
+      const remaining = captureLimitBytes - preview.totalBytes;
+      const captured = chunk.subarray(0, Math.max(0, remaining));
+      if (captured.byteLength > 0) {
+        observeStdout(preview, captured);
+        if (!output.write(captured)) {
+          child.stdout.pause();
+          output.once("drain", () => child.stdout.resume());
+        }
+      }
+      if (captured.byteLength < chunk.byteLength) {
+        preview.captureLimitExceeded = true;
+        terminate();
+      }
+    });
+    child.stderr.on("data", (chunk: Buffer) => {
+      if (stderr.byteLength >= STDERR_MAX_BYTES) return;
+      const remaining = STDERR_MAX_BYTES - stderr.byteLength;
+      stderr = Buffer.concat([stderr, chunk.subarray(0, remaining)]);
+    });
+    child.on("close", (code, signal) => {
+      closed = true;
+      if (forceKillTimer) clearTimeout(forceKillTimer);
+      output.end(() => {
+        outputClosed = true;
+        if (signal && !preview.captureLimitExceeded) {
+          complete(
+            Effect.fail(
+              new SearchProcessError({
+                message: `process terminated by ${signal}`,
+              }),
+            ),
+          );
+          return;
+        }
+        complete(
+          Effect.succeed({
+            exitCode: preview.captureLimitExceeded ? 0 : (code ?? 1),
+            stderr: stderr.toString("utf8"),
+          }),
+        );
+      });
+    });
+
+    return Effect.callback<void>((done) => {
+      settled = true;
+      let cleanupFinished = false;
+      let processDeadlineExpired = false;
+      let cleanupDeadline: ReturnType<typeof setTimeout> | undefined;
+      const finishCleanup = () => {
+        if (
+          cleanupFinished ||
+          !outputClosed ||
+          (!closed && !processDeadlineExpired)
+        ) {
+          return;
+        }
+        cleanupFinished = true;
+        if (cleanupDeadline) clearTimeout(cleanupDeadline);
+        child.off("close", finishCleanup);
+        output.off("close", finishCleanup);
+        done(Effect.void);
+      };
+
+      child.on("close", finishCleanup);
+      output.on("close", finishCleanup);
+      cleanupDeadline = setTimeout(() => {
+        killProcess(child, "SIGKILL");
+        processDeadlineExpired = true;
+        finishCleanup();
+      }, 1_500);
+      cleanupDeadline.unref();
+      terminate();
+      child.stdout.destroy();
+      child.stderr.destroy();
+      output.destroy();
+      finishCleanup();
+
+      return Effect.sync(() => {
+        if (cleanupDeadline) clearTimeout(cleanupDeadline);
+        child.off("close", finishCleanup);
+        output.off("close", finishCleanup);
+      });
+    });
+  });
+}
+
+export function executeSearchProcess(options: {
+  readonly command: string;
+  readonly args: readonly string[];
+  readonly cwd: string;
+  readonly tempPrefix: string;
+  /** Test overrides; production capture is capped at 10 MiB. */
+  readonly maxCaptureBytes?: number;
+  readonly createOutput?: (path: string) => Writable;
+}) {
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const directory = yield* fs.makeTempDirectory({
+      prefix: options.tempPrefix,
+    });
+    const fullOutputPath = join(directory, "output.txt");
+    const captureLimitBytes = Math.max(
+      1,
+      Math.floor(options.maxCaptureBytes ?? COMPLETE_OUTPUT_MAX_BYTES),
+    );
+    const preview = makePreviewState();
+    let retainDirectory = false;
+
+    return yield* captureProcess(
+      options,
+      fullOutputPath,
+      captureLimitBytes,
+      preview,
+    ).pipe(
+      Effect.map((result) => {
+        const output = finishStdout(preview, fullOutputPath, captureLimitBytes);
+        retainDirectory = output.fullOutputPath !== undefined;
+        return { code: result.exitCode, stderr: result.stderr, output };
+      }),
+      Effect.ensuring(
+        Effect.suspend(() =>
+          retainDirectory
+            ? Effect.void
+            : fs
+                .remove(directory, { recursive: true, force: true })
+                .pipe(Effect.orDie),
+        ),
+      ),
+    );
+  });
+}
+
+export function discardCapturedOutput(output: CapturedOutput) {
+  if (!output.fullOutputPath) return Effect.void;
+  const directory = dirname(output.fullOutputPath);
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    yield* fs.remove(directory, { recursive: true, force: true });
+  });
+}

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

@@ -0,0 +1,53 @@
+/** Model-facing text for the fd and rg tools. */
+
+export const FD_TOOL_DESCRIPTION =
+  "Find files and directories by name with fd. Respects .gitignore by default. Results are limited to 1000 entries unless a higher limit is given; output is limited to 2000 lines or 50KB, and complete truncated output up to 10 MiB is saved to a temporary file.";
+
+export const FD_PROMPT_SNIPPET =
+  "Find files and directories by name with fd (fast, gitignore-aware).";
+
+export const FD_PROMPT_GUIDELINES = [
+  "Use fd as the primary tool for discovering files and directories by name, extension, or glob instead of bash with find or ls -R.",
+  "Use rg instead of fd when searching file contents rather than file names.",
+  "Keep using bash for complex multi-step workflows that pipe or post-process file listings.",
+];
+
+export const FD_PARAMETER_DESCRIPTIONS = {
+  pattern:
+    "Regex matched against file names (or a glob when glob is true). Omit to list everything under path.",
+  path: "Directory to search. Defaults to the current working directory.",
+  type: "Only return entries of this type: file, directory, or symlink.",
+  extension: "Only return files with this extension, e.g. 'ts' or 'md'.",
+  glob: "Treat pattern as a glob (e.g. '*.test.ts') instead of a regex.",
+  hidden: "Include hidden files and directories. Defaults to false.",
+  max_depth: "Maximum directory depth to descend (1-64).",
+  limit: "Maximum number of results (1-10000). Defaults to 1000.",
+};
+
+export const RG_TOOL_DESCRIPTION =
+  "Search file contents with ripgrep. Uses smart-case matching, respects .gitignore by default, and returns at most 100 matches per file unless a different max_matches_per_file value is given. Output is limited to 2000 lines or 50KB; complete truncated output up to 10 MiB is saved to a temporary file.";
+
+export const RG_PROMPT_SNIPPET =
+  "Search file contents with ripgrep (fast regex content search).";
+
+export const RG_PROMPT_GUIDELINES = [
+  "Use rg as the primary tool for searching file contents instead of bash with grep.",
+  "Use fd instead of rg when looking for files by name rather than content.",
+  "Set fixed_strings on rg when searching for literal code snippets containing regex metacharacters.",
+  "Keep using bash for complex multi-step workflows that combine searching with other commands.",
+];
+
+export const RG_PARAMETER_DESCRIPTIONS = {
+  pattern: "Regex to search for (literal text when fixed_strings is true).",
+  path: "File or directory to search. Defaults to the current working directory.",
+  glob: "Only search files matching this glob, e.g. '*.ts' or 'src/**'.",
+  file_type:
+    "Only search files of this ripgrep type, e.g. 'ts', 'js', 'py', 'rust'.",
+  case_sensitive:
+    "true forces case-sensitive matching, false forces case-insensitive. Defaults to smart-case.",
+  fixed_strings: "Treat pattern as a literal string instead of a regex.",
+  hidden: "Search hidden files and directories. Defaults to false.",
+  context: "Lines of context to show around each match (0-20).",
+  max_matches_per_file:
+    "Maximum matches returned from each file (1-1000). Defaults to 100. This is not a global result limit.",
+};

package/extensions/git-info/index.ts

@@ -0,0 +1,272 @@
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { Effect, Fiber, Schedule } from "effect";
+import {
+  emptyGitInfoState,
+  GIT_INFO_CHANNEL,
+  REFRESH_CHANNEL,
+  type PullRequestInfo,
+} from "../shared/dashboard-state.ts";
+import {
+  loadChangedFiles,
+  showChangedFiles,
+} from "./src/changed-files-view.ts";
+import { runCommand, type CommandRunner } from "./src/process.ts";
+import { makeRefreshCoordinator } from "./src/refresh-coordinator.ts";
+import {
+  createRuntime,
+  runEffect,
+  type GitInfoRuntime,
+} from "./src/runtime.ts";
+
+const POLL_INTERVAL_MS = 5_000;
+const GIT_TIMEOUT_MS = 3_000;
+const GH_TIMEOUT_MS = 10_000;
+
+function countChangedFiles(status: string) {
+  if (!status.trim()) return 0;
+  return status.split("\n").filter(Boolean).length;
+}
+
+function parsePullRequest(value: unknown) {
+  if (typeof value !== "object" || value === null) return null;
+  if (!("number" in value) || typeof value.number !== "number") return null;
+  if (!("url" in value) || typeof value.url !== "string") return null;
+  if (!("state" in value) || value.state !== "OPEN") return null;
+
+  return {
+    number: value.number,
+    url: value.url,
+    isDraft: "isDraft" in value && value.isDraft === true,
+  } satisfies PullRequestInfo;
+}
+
+function parsePullRequestJson(value: string) {
+  try {
+    return parsePullRequest(JSON.parse(value));
+  } catch {
+    return null;
+  }
+}
+
+export default function gitInfo(pi: ExtensionAPI) {
+  let state = emptyGitInfoState();
+  let runtime: GitInfoRuntime | undefined;
+  let pollingFiber: Fiber.Fiber<void> | undefined;
+  let currentContext: ExtensionContext | undefined;
+  let generation = 0;
+  let queriedPrBranch: string | null = null;
+  const refreshCoordinator = makeRefreshCoordinator();
+
+  const getRuntime = () => (runtime ??= createRuntime());
+  const publish = () => pi.events.emit(GIT_INFO_CHANNEL, { ...state });
+  const run = (
+    command: string,
+    args: string[],
+    ctx: ExtensionContext,
+    timeout: number,
+  ) => runCommand(command, args, ctx.cwd, timeout);
+
+  const lookupPullRequest = (ctx: ExtensionContext, branch: string) =>
+    Effect.gen(function* () {
+      const result = yield* run(
+        "gh",
+        ["pr", "view", branch, "--json", "number,url,state,isDraft"],
+        ctx,
+        GH_TIMEOUT_MS,
+      );
+      if (result.code !== 0) return null;
+      return parsePullRequestJson(result.stdout);
+    });
+
+  const refreshEffect = (
+    ctx: ExtensionContext,
+    forcePullRequest: boolean,
+    refreshGeneration: number,
+  ) =>
+    Effect.suspend(() => {
+      if (refreshGeneration !== generation) return Effect.void;
+      currentContext = ctx;
+
+      return Effect.gen(function* () {
+        const repo = yield* run(
+          "git",
+          ["rev-parse", "--is-inside-work-tree"],
+          ctx,
+          GIT_TIMEOUT_MS,
+        );
+        if (refreshGeneration !== generation) return;
+
+        if (repo.code !== 0 || repo.stdout.trim() !== "true") {
+          queriedPrBranch = null;
+          state = emptyGitInfoState();
+          publish();
+          return;
+        }
+
+        const [branchResult, headResult, statusResult] = yield* Effect.all(
+          [
+            run("git", ["branch", "--show-current"], ctx, GIT_TIMEOUT_MS),
+            run("git", ["rev-parse", "--short", "HEAD"], ctx, GIT_TIMEOUT_MS),
+            run(
+              "git",
+              ["status", "--porcelain=v1", "--untracked-files=all"],
+              ctx,
+              GIT_TIMEOUT_MS,
+            ),
+          ],
+          { concurrency: "unbounded" },
+        );
+        if (refreshGeneration !== generation) return;
+
+        const branchName = branchResult.stdout.trim();
+        const shortHead = headResult.stdout.trim();
+        const branch =
+          branchName || (shortHead ? `detached@${shortHead}` : "detached");
+        const branchChanged = branchName !== queriedPrBranch;
+
+        state = {
+          ...state,
+          isRepository: true,
+          branch,
+          changedFiles:
+            statusResult.code === 0
+              ? countChangedFiles(statusResult.stdout)
+              : 0,
+          pullRequest: branchChanged ? null : state.pullRequest,
+        };
+        publish();
+
+        if (!branchName) {
+          // queriedPrBranch is never "", so branchChanged already cleared pullRequest.
+          queriedPrBranch = null;
+          return;
+        }
+
+        if (forcePullRequest) {
+          queriedPrBranch = branchName;
+          const pullRequest = yield* lookupPullRequest(ctx, branchName);
+          if (refreshGeneration !== generation) return;
+          state = { ...state, pullRequest };
+          publish();
+        }
+      });
+    });
+
+  const refresh = (ctx: ExtensionContext, forcePullRequest = false) =>
+    refreshCoordinator.run(refreshEffect(ctx, forcePullRequest, generation));
+
+  const refreshIfIdle = (ctx: ExtensionContext) =>
+    refreshCoordinator.runIfIdle(refreshEffect(ctx, false, generation));
+
+  const reportBackgroundDefect = (defect: unknown) =>
+    Effect.logError("git-info background task defect", defect);
+
+  const poll = () =>
+    Effect.suspend(() =>
+      currentContext ? refreshIfIdle(currentContext) : Effect.void,
+    ).pipe(
+      Effect.catchDefect(reportBackgroundDefect),
+      Effect.repeat(Schedule.fixed(POLL_INTERVAL_MS)),
+      Effect.delay(POLL_INTERVAL_MS),
+      Effect.asVoid,
+    );
+
+  const forkBackground = (effect: Effect.Effect<void, never, CommandRunner>) =>
+    getRuntime().runFork(
+      effect.pipe(Effect.catchDefect(reportBackgroundDefect)),
+    );
+
+  const refreshInBackground = (ctx: ExtensionContext) => {
+    forkBackground(refreshIfIdle(ctx));
+  };
+
+  const stopRefreshListener = pi.events.on(REFRESH_CHANNEL, () => {
+    if (currentContext) refreshInBackground(currentContext);
+  });
+
+  pi.on("session_start", async (_event, ctx) => {
+    generation += 1;
+    queriedPrBranch = null;
+
+    const previousPollingFiber = pollingFiber;
+    pollingFiber = undefined;
+    if (previousPollingFiber) {
+      await getRuntime().runPromise(Fiber.interrupt(previousPollingFiber));
+    }
+
+    // Do not block Pi startup on GitHub/network I/O. The initial refresh publishes
+    // state when it completes; polling continues to keep it current afterwards.
+    refreshInBackground(ctx);
+    pollingFiber = forkBackground(poll());
+  });
+
+  pi.on("input", (_event, ctx) => {
+    refreshInBackground(ctx);
+    return { action: "continue" };
+  });
+
+  pi.on("tool_execution_end", (_event, ctx) => {
+    refreshInBackground(ctx);
+  });
+
+  pi.on("session_shutdown", async () => {
+    stopRefreshListener();
+    generation += 1;
+    currentContext = undefined;
+    pollingFiber = undefined;
+    const closing = runtime;
+    runtime = undefined;
+    await closing?.dispose();
+  });
+
+  pi.registerCommand("lg", {
+    description: "Browse changed files and their diffs",
+    handler: async (_args, ctx) => {
+      if (ctx.mode !== "tui") {
+        ctx.ui.notify(
+          "The local changes viewer requires the interactive TUI",
+          "warning",
+        );
+        return;
+      }
+
+      const files = await runEffect(getRuntime(), loadChangedFiles(ctx.cwd), {
+        signal: ctx.signal,
+        interruptMessage: "Loading changed files was cancelled.",
+      });
+      if (files === null) {
+        ctx.ui.notify("Not a git repository", "warning");
+        return;
+      }
+      if (files.length === 0) {
+        ctx.ui.notify("Working tree is clean", "info");
+        return;
+      }
+
+      await showChangedFiles(ctx, files);
+    },
+  });
+
+  pi.registerCommand("pr", {
+    description: "Look up pull request information for the current branch",
+    handler: async (_args, ctx) => {
+      await runEffect(getRuntime(), refresh(ctx, true), {
+        signal: ctx.signal,
+        interruptMessage: "Git and pull request refresh was cancelled.",
+      });
+      if (!state.isRepository) {
+        ctx.ui.notify("Not a git repository", "warning");
+      } else if (state.pullRequest) {
+        ctx.ui.notify(
+          `PR #${state.pullRequest.number}: ${state.pullRequest.url}`,
+          "info",
+        );
+      } else {
+        ctx.ui.notify(`No open PR found for ${state.branch}`, "info");
+      }
+    },
+  });
+}