tau-coding-agent 0.1.0

package/extensions/ghostty.ts

@@ -0,0 +1,301 @@
+/**
+ * Ghostty terminal title integration.
+ *
+ * - Shows project/session in the terminal title
+ * - Shows a braille spinner in the title while the agent is working
+ * - Shows a ? marker while an extension prompt is waiting for input
+ * - Updates title with the current tool name during tool execution
+ * - Treats background /review runs as working state via review:start/review:end events
+ *
+ * Pi now emits native OSC 9;4 progress indicators, so this extension only manages the title.
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import path from "node:path";
+
+const STATUS_SPINNER_INTERVAL_MS = 80;
+const STATUS_SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const REVIEW_EVENT_START = "review:start";
+const REVIEW_EVENT_END = "review:end";
+
+let sessionName: string | undefined;
+let sessionCwd: string | undefined;
+let currentTool: string | undefined;
+let isWorking = false;
+let frameIndex = 0;
+let spinnerTimer: ReturnType<typeof setInterval> | undefined;
+let pendingPromptCount = 0;
+let latestCtx: ExtensionContext | undefined;
+let currentSessionKey: string | undefined;
+const activeReviewSessions = new Set<string>();
+
+function buildTitle(extra?: string, marker = "π"): string {
+  const cwd = sessionCwd ?? process.cwd();
+  const segments: string[] = [marker, path.basename(cwd)];
+  if (sessionName) segments.push(sessionName);
+  if (extra) segments.push(extra);
+  return segments.join(" · ");
+}
+
+function clearSpinnerTimer(): void {
+  if (!spinnerTimer) return;
+  clearInterval(spinnerTimer);
+  spinnerTimer = undefined;
+}
+
+function currentFrame(): string {
+  return STATUS_SPINNER_FRAMES[frameIndex % STATUS_SPINNER_FRAMES.length];
+}
+
+function hasPendingPrompts(): boolean {
+  return pendingPromptCount > 0;
+}
+
+function getSessionKey(ctx: ExtensionContext): string {
+  return ctx.sessionManager.getSessionFile() ?? `session:${ctx.sessionManager.getSessionId()}`;
+}
+
+function extractReviewSessionKey(data: unknown): string | undefined {
+  if (!data || typeof data !== "object") return undefined;
+  const payload = data as { sessionKey?: unknown };
+  if (typeof payload.sessionKey !== "string") return undefined;
+  const sessionKey = payload.sessionKey.trim();
+  return sessionKey.length > 0 ? sessionKey : undefined;
+}
+
+function hasActiveReviewRuns(): boolean {
+  if (!currentSessionKey) return false;
+  return activeReviewSessions.has(currentSessionKey);
+}
+
+function isBusy(): boolean {
+  return isWorking || hasActiveReviewRuns();
+}
+
+function getWorkingExtra(): string | undefined {
+  if (currentTool) return currentTool;
+  if (!isWorking && hasActiveReviewRuns()) return "review";
+  return undefined;
+}
+
+function renderWorkingTitle(ctx: ExtensionContext): void {
+  ctx.ui.setTitle(buildTitle(getWorkingExtra(), currentFrame()));
+}
+
+function renderPromptTitle(ctx: ExtensionContext): void {
+  const extra = isBusy() ? getWorkingExtra() : undefined;
+  ctx.ui.setTitle(buildTitle(extra, "?"));
+}
+
+function renderActiveTitle(ctx: ExtensionContext): void {
+  if (hasPendingPrompts()) {
+    renderPromptTitle(ctx);
+    return;
+  }
+
+  if (isBusy()) {
+    renderWorkingTitle(ctx);
+    return;
+  }
+
+  ctx.ui.setTitle(buildTitle());
+}
+
+function startSpinnerTimer(ctx: ExtensionContext): void {
+  clearSpinnerTimer();
+  spinnerTimer = setInterval(() => {
+    if (!isBusy() || hasPendingPrompts()) return;
+    frameIndex = (frameIndex + 1) % STATUS_SPINNER_FRAMES.length;
+    renderWorkingTitle(ctx);
+  }, STATUS_SPINNER_INTERVAL_MS);
+}
+
+function startSpinner(ctx: ExtensionContext): void {
+  clearSpinnerTimer();
+  isWorking = true;
+  currentTool = undefined;
+  frameIndex = 0;
+  renderActiveTitle(ctx);
+
+  if (!hasPendingPrompts()) {
+    startSpinnerTimer(ctx);
+  }
+}
+
+function stopSpinner(ctx: ExtensionContext): void {
+  isWorking = false;
+  currentTool = undefined;
+  clearSpinnerTimer();
+
+  if (hasPendingPrompts()) {
+    renderActiveTitle(ctx);
+    return;
+  }
+
+  if (hasActiveReviewRuns()) {
+    renderWorkingTitle(ctx);
+    startSpinnerTimer(ctx);
+    return;
+  }
+
+  renderActiveTitle(ctx);
+}
+
+function handlePromptStart(ctx: ExtensionContext): void {
+  clearSpinnerTimer();
+  renderActiveTitle(ctx);
+}
+
+function handlePromptEnd(ctx: ExtensionContext): void {
+  if (hasPendingPrompts()) {
+    renderActiveTitle(ctx);
+    return;
+  }
+
+  if (isBusy()) {
+    renderWorkingTitle(ctx);
+    startSpinnerTimer(ctx);
+    return;
+  }
+
+  renderActiveTitle(ctx);
+}
+
+function syncSessionTitle(ctx: ExtensionContext): void {
+  renderActiveTitle(ctx);
+}
+
+function markReviewSessionActive(sessionKey: string): void {
+  activeReviewSessions.add(sessionKey);
+}
+
+function markReviewSessionInactive(sessionKey: string): void {
+  activeReviewSessions.delete(sessionKey);
+}
+
+function handleReviewStart(ctx: ExtensionContext): void {
+  renderActiveTitle(ctx);
+  if (!hasPendingPrompts()) {
+    startSpinnerTimer(ctx);
+  }
+}
+
+function handleReviewEnd(ctx: ExtensionContext): void {
+  if (isWorking) {
+    renderActiveTitle(ctx);
+    return;
+  }
+
+  if (hasPendingPrompts()) {
+    renderActiveTitle(ctx);
+    return;
+  }
+
+  if (hasActiveReviewRuns()) {
+    renderActiveTitle(ctx);
+    startSpinnerTimer(ctx);
+    return;
+  }
+
+  clearSpinnerTimer();
+  renderActiveTitle(ctx);
+}
+
+export default function (pi: ExtensionAPI) {
+  pi.on("session_start", async (_event, ctx) => {
+    if (!ctx.hasUI) return;
+    latestCtx = ctx;
+    currentSessionKey = getSessionKey(ctx);
+    sessionCwd = ctx.cwd;
+    sessionName = pi.getSessionName();
+    syncSessionTitle(ctx);
+    clearSpinnerTimer();
+    if (isBusy() && !hasPendingPrompts()) {
+      startSpinnerTimer(ctx);
+    }
+  });
+
+  pi.on("agent_start", async (_event, ctx) => {
+    if (!ctx.hasUI) return;
+    latestCtx = ctx;
+    startSpinner(ctx);
+  });
+
+  pi.on("agent_end", async (_event, ctx) => {
+    if (!ctx.hasUI) return;
+    latestCtx = ctx;
+    stopSpinner(ctx);
+  });
+
+  pi.on("tool_execution_start", async (event, ctx) => {
+    currentTool = event.toolName;
+    if (!ctx.hasUI) return;
+    latestCtx = ctx;
+    if (!isWorking) return;
+    renderActiveTitle(ctx);
+  });
+
+  pi.on("tool_execution_end", async (_event, ctx) => {
+    currentTool = undefined;
+    if (!ctx.hasUI) return;
+    latestCtx = ctx;
+    if (!isWorking) return;
+    renderActiveTitle(ctx);
+  });
+
+  pi.events.on("ui:prompt_start", () => {
+    pendingPromptCount += 1;
+
+    const ctx = latestCtx;
+    if (!ctx || !ctx.hasUI) return;
+    handlePromptStart(ctx);
+  });
+
+  pi.events.on("ui:prompt_end", () => {
+    if (pendingPromptCount === 0) return;
+    pendingPromptCount -= 1;
+
+    const ctx = latestCtx;
+    if (!ctx || !ctx.hasUI) return;
+    handlePromptEnd(ctx);
+  });
+
+  pi.events.on(REVIEW_EVENT_START, (data) => {
+    const sessionKey = extractReviewSessionKey(data);
+    if (!sessionKey) return;
+
+    markReviewSessionActive(sessionKey);
+
+    const ctx = latestCtx;
+    if (!ctx || !ctx.hasUI) return;
+    if (currentSessionKey !== sessionKey) return;
+    handleReviewStart(ctx);
+  });
+
+  pi.events.on(REVIEW_EVENT_END, (data) => {
+    const sessionKey = extractReviewSessionKey(data);
+    if (!sessionKey) return;
+
+    markReviewSessionInactive(sessionKey);
+
+    const ctx = latestCtx;
+    if (!ctx || !ctx.hasUI) return;
+    if (currentSessionKey !== sessionKey) return;
+    handleReviewEnd(ctx);
+  });
+
+  pi.on("session_shutdown", async (_event, ctx) => {
+    clearSpinnerTimer();
+    isWorking = false;
+    currentTool = undefined;
+    pendingPromptCount = 0;
+    const sessionKey = getSessionKey(ctx);
+    activeReviewSessions.delete(sessionKey);
+    if (currentSessionKey === sessionKey) {
+      currentSessionKey = undefined;
+      sessionCwd = undefined;
+      sessionName = undefined;
+    }
+    latestCtx = undefined;
+  });
+}

package/extensions/git-diff-stats.ts

@@ -0,0 +1,277 @@
+import {
+  isEditToolResult,
+  isWriteToolResult,
+  type ExtensionAPI,
+  type ExtensionContext,
+} from "@mariozechner/pi-coding-agent";
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { copyFile, mkdtemp, rm } from "node:fs/promises";
+import path from "node:path";
+
+const STATUS_KEY = "1-git-diff-stats";
+const REFRESH_DEBOUNCE_MS = 250;
+const WRITE_REFRESH_DEBOUNCE_MS = 1_000;
+
+type DiffStats = {
+  added: number;
+  removed: number;
+};
+
+function isInsideGitRepo(startDir: string): boolean {
+  for (let currentDir = path.resolve(startDir); ; currentDir = path.dirname(currentDir)) {
+    if (existsSync(path.join(currentDir, ".git"))) return true;
+    if (path.dirname(currentDir) === currentDir) return false;
+  }
+}
+
+function mergeNumstatEntries(output: string, statsByPath: Map<string, DiffStats>): void {
+  for (const line of output.split("\n")) {
+    if (!line) continue;
+
+    const firstTab = line.indexOf("\t");
+    if (firstTab === -1) continue;
+
+    const secondTab = line.indexOf("\t", firstTab + 1);
+    if (secondTab === -1) continue;
+
+    const filePath = line.slice(secondTab + 1);
+    if (statsByPath.has(filePath)) continue;
+
+    const addedToken = line.slice(0, firstTab);
+    const removedToken = line.slice(firstTab + 1, secondTab);
+    statsByPath.set(filePath, {
+      added: addedToken === "-" ? 0 : Number(addedToken) || 0,
+      removed: removedToken === "-" ? 0 : Number(removedToken) || 0,
+    });
+  }
+}
+
+async function gitText(
+  cwd: string,
+  args: string[],
+  options?: {
+    env?: NodeJS.ProcessEnv;
+    stdin?: string;
+  },
+): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const child = spawn("git", args, {
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: options?.env ? { ...process.env, ...options.env } : process.env,
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    child.on("error", reject);
+    child.stdin?.on("error", () => {});
+    child.stdout?.on("data", (chunk: Buffer) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr?.on("data", (chunk: Buffer) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("close", (code) => {
+      const exitCode = code ?? -1;
+      if (exitCode !== 0) {
+        const details = [stdout.trim(), stderr.trim()].filter(Boolean).join("\n");
+        reject(new Error(details || `git ${args.join(" ")} failed`));
+        return;
+      }
+
+      resolve(stdout.trim());
+    });
+
+    child.stdin?.end(options?.stdin);
+  });
+}
+
+async function computeLocalStats(cwd: string): Promise<DiffStats | undefined> {
+  if (!isInsideGitRepo(cwd)) return undefined;
+
+  const gitDir = await gitText(cwd, ["rev-parse", "--path-format=absolute", "--git-dir"]);
+  const tempDir = await mkdtemp(path.join(gitDir, "pi-git-diff-stats-"));
+  const tempIndex = path.join(tempDir, "index");
+  const realIndex = path.join(gitDir, "index");
+
+  try {
+    try {
+      await copyFile(realIndex, tempIndex);
+    } catch (error) {
+      const code = (error as NodeJS.ErrnoException).code;
+      if (code !== "ENOENT") throw error;
+    }
+
+    const addIntent = gitText(cwd, ["add", "-N", "--all"], { env: { GIT_INDEX_FILE: tempIndex } });
+    const head = spawn("git", ["rev-parse", "--verify", "--quiet", "HEAD"], {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    let headStdout = "";
+    let headStderr = "";
+    head.stdout?.on("data", (chunk: Buffer) => {
+      headStdout += chunk.toString("utf8");
+    });
+    head.stderr?.on("data", (chunk: Buffer) => {
+      headStderr += chunk.toString("utf8");
+    });
+
+    const headOidPromise = new Promise<string | undefined>((resolve, reject) => {
+      head.on("error", reject);
+      head.on("close", (code) => {
+        if (code === 0) {
+          resolve(headStdout.trim());
+          return;
+        }
+        if (code === 1) {
+          resolve(undefined);
+          return;
+        }
+
+        const details = [headStdout.trim(), headStderr.trim()].filter(Boolean).join("\n");
+        reject(new Error(details || "git rev-parse --verify --quiet HEAD failed"));
+      });
+    });
+
+    const [, headOid] = await Promise.all([addIntent, headOidPromise]);
+    const baseOid =
+      headOid ?? (await gitText(cwd, ["hash-object", "-t", "tree", "--stdin"], { stdin: "" }));
+
+    const [workingTreeDiff, stagedDiff] = await Promise.all([
+      gitText(cwd, ["diff", "--numstat", baseOid, "--"], { env: { GIT_INDEX_FILE: tempIndex } }),
+      gitText(cwd, ["diff", "--cached", "--numstat", baseOid, "--"], {
+        env: { GIT_INDEX_FILE: tempIndex },
+      }),
+    ]);
+
+    const statsByPath = new Map<string, DiffStats>();
+    mergeNumstatEntries(workingTreeDiff, statsByPath);
+    mergeNumstatEntries(stagedDiff, statsByPath);
+    if (statsByPath.size === 0) return undefined;
+
+    let added = 0;
+    let removed = 0;
+    for (const fileStats of statsByPath.values()) {
+      added += fileStats.added;
+      removed += fileStats.removed;
+    }
+
+    return { added, removed };
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+}
+
+export default function gitDiffStatsExtension(pi: ExtensionAPI) {
+  let ctx: ExtensionContext | undefined;
+  let stats: DiffStats | undefined;
+  let generation = 0;
+  let refreshTimer: NodeJS.Timeout | undefined;
+  let refreshInFlight: Promise<void> | null = null;
+  let refreshQueued = false;
+
+  function reset(nextCtx?: ExtensionContext): void {
+    clearStatus();
+    ctx = nextCtx;
+    stats = undefined;
+    generation += 1;
+    resetRefreshState();
+
+    if (nextCtx?.hasUI) scheduleRefresh(0);
+  }
+
+  function clearStatus(): void {
+    ctx?.ui.setStatus(STATUS_KEY, undefined);
+  }
+
+  function renderStatus(): void {
+    const activeCtx = ctx;
+    if (!activeCtx?.hasUI) return;
+
+    activeCtx.ui.setStatus(
+      STATUS_KEY,
+      stats ? activeCtx.ui.theme.fg("dim", `+${stats.added} -${stats.removed}`) : undefined,
+    );
+  }
+
+  function resetRefreshState(): void {
+    if (refreshTimer) clearTimeout(refreshTimer);
+    refreshTimer = undefined;
+    refreshInFlight = null;
+    refreshQueued = false;
+  }
+
+  function scheduleRefresh(delay = REFRESH_DEBOUNCE_MS): void {
+    const activeCtx = ctx;
+    if (!activeCtx?.hasUI) return;
+
+    if (refreshTimer) clearTimeout(refreshTimer);
+
+    const cwd = activeCtx.cwd;
+    const refreshGeneration = generation;
+    refreshTimer = setTimeout(() => {
+      refreshTimer = undefined;
+      void refresh(cwd, refreshGeneration);
+    }, delay);
+  }
+
+  async function refresh(cwd: string, refreshGeneration: number): Promise<void> {
+    if (refreshInFlight) {
+      refreshQueued = true;
+      return;
+    }
+
+    const promise = (async () => {
+      try {
+        const nextStats = await computeLocalStats(cwd);
+        if (generation !== refreshGeneration) return;
+
+        stats = nextStats;
+        renderStatus();
+      } catch {
+        if (generation !== refreshGeneration) return;
+
+        stats = undefined;
+        clearStatus();
+      }
+    })();
+
+    refreshInFlight = promise;
+
+    try {
+      await promise;
+    } finally {
+      if (refreshInFlight === promise) {
+        refreshInFlight = null;
+        if (refreshQueued) {
+          refreshQueued = false;
+          scheduleRefresh(0);
+        }
+      }
+    }
+  }
+
+  pi.on("session_start", async (_event, nextCtx) => {
+    reset(nextCtx);
+  });
+
+  pi.on("tool_result", async (event, nextCtx) => {
+    ctx = nextCtx;
+
+    if (isEditToolResult(event) || isWriteToolResult(event)) {
+      scheduleRefresh(WRITE_REFRESH_DEBOUNCE_MS);
+    }
+  });
+
+  pi.on("turn_end", async (_event, nextCtx) => {
+    ctx = nextCtx;
+    scheduleRefresh();
+  });
+
+  pi.on("session_shutdown", async () => {
+    reset(undefined);
+  });
+}