fix: support git pager stdin patches

Author: benvinegar

README.md

@@ -161,13 +161,21 @@ Interpretation:
 
 ## Git integration
 
-Use Hunk as the viewer for `git diff` and `git show`:
+Use Hunk as the default Git pager:
+
+```bash
+git config --global core.pager 'hunk patch -'
+```
+
+Or scope it just to `git diff` and `git show`:
 
 ```bash
 git config --global pager.diff 'hunk patch -'
 git config --global pager.show 'hunk patch -'
 ```
 
+When Hunk reads a patch from stdin, it automatically switches to pager-style chrome, strips Git's color escape sequences before parsing, and binds keyboard input to the controlling terminal so it works correctly as a Git pager.
+
 Then:
 
 ```bash

src/core/loaders.ts

@@ -48,6 +48,15 @@ function stripPrefixes(path: string) {
   return path.replace(/^[ab]\//, "");
 }
 
+/** Remove terminal escape sequences so Git-colored pager input still parses as plain patch text. */
+function stripTerminalControl(text: string) {
+  return text
+    .replace(/\x1bP[\s\S]*?\x1b\\/g, "")
+    .replace(/\x1b\][\s\S]*?(?:\x07|\x1b\\)/g, "")
+    .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+    .replace(/\x1b[@-_]/g, "");
+}
+
 /** Split a multi-file patch into per-file chunks so each diff file keeps its original patch text. */
 function splitPatchIntoFileChunks(rawPatch: string) {
   const patch = rawPatch.replaceAll("\r\n", "\n");
@@ -188,9 +197,10 @@ function normalizePatchChangeset(
   sourceLabel: string,
   agentContext: AgentContext | null,
 ): Changeset {
-  const parsedPatches = parsePatchFiles(patchText, "patch", true);
+  const normalizedPatchText = stripTerminalControl(patchText.replaceAll("\r\n", "\n"));
+  const parsedPatches = parsePatchFiles(normalizedPatchText, "patch", true);
   const metadataFiles = parsedPatches.flatMap((entry) => entry.files);
-  const chunks = splitPatchIntoFileChunks(patchText);
+  const chunks = splitPatchIntoFileChunks(normalizedPatchText);
 
   return {
     id: `changeset:${Date.now()}`,

src/core/terminal.ts

@@ -0,0 +1,51 @@
+import fs from "node:fs";
+import tty from "node:tty";
+import type { CliInput } from "./types";
+
+/** Detect the stdin-pipe patch workflow used by `git diff` pagers. */
+export function usesPipedPatchInput(input: CliInput, stdinIsTTY = Boolean(process.stdin.isTTY)) {
+  return input.kind === "patch" && (!input.file || input.file === "-") && !stdinIsTTY;
+}
+
+/** Enable pager-style chrome automatically when Hunk is consuming a piped patch. */
+export function shouldUsePagerMode(input: CliInput, stdinIsTTY = Boolean(process.stdin.isTTY)) {
+  return Boolean(input.options.pager) || usesPipedPatchInput(input, stdinIsTTY);
+}
+
+/** Apply runtime CLI defaults that depend on whether stdin is an interactive terminal. */
+export function resolveRuntimeCliInput(input: CliInput, stdinIsTTY = Boolean(process.stdin.isTTY)): CliInput {
+  return {
+    ...input,
+    options: {
+      ...input.options,
+      pager: shouldUsePagerMode(input, stdinIsTTY),
+    },
+  } as CliInput;
+}
+
+export interface ControllingTerminal {
+  stdin: tty.ReadStream;
+  stdout: tty.WriteStream;
+  close: () => void;
+}
+
+/** Open the controlling terminal so the UI can stay interactive while stdin carries patch data. */
+export function openControllingTerminal(): ControllingTerminal | null {
+  try {
+    const stdinFd = fs.openSync("/dev/tty", "r");
+    const stdoutFd = fs.openSync("/dev/tty", "w");
+    const stdin = new tty.ReadStream(stdinFd);
+    const stdout = new tty.WriteStream(stdoutFd);
+
+    return {
+      stdin,
+      stdout,
+      close: () => {
+        stdin.destroy();
+        stdout.destroy();
+      },
+    };
+  } catch {
+    return null;
+  }
+}

src/main.tsx

@@ -5,16 +5,21 @@ import { createRoot } from "@opentui/react";
 import { parseCli } from "./core/cli";
 import { loadAppBootstrap } from "./core/loaders";
 import { shutdownSession } from "./core/shutdown";
+import { openControllingTerminal, resolveRuntimeCliInput, usesPipedPatchInput } from "./core/terminal";
 import { App } from "./ui/App";
 
-const cliInput = await parseCli(process.argv);
+const cliInput = resolveRuntimeCliInput(await parseCli(process.argv));
 const bootstrap = await loadAppBootstrap(cliInput);
+const controllingTerminal = usesPipedPatchInput(cliInput) ? openControllingTerminal() : null;
 
 const renderer = await createCliRenderer({
+  stdin: controllingTerminal?.stdin,
+  stdout: controllingTerminal?.stdout,
   useMouse: !cliInput.options.pager,
   useAlternateScreen: true,
   exitOnCtrlC: true,
   openConsoleOnError: true,
+  onDestroy: () => controllingTerminal?.close(),
 });
 
 const root = createRoot(renderer);

test/loaders.test.ts

@@ -161,4 +161,40 @@ describe("loadAppBootstrap", () => {
       process.chdir(previousCwd);
     }
   });
+
+  test("loads colorized git patch files like the real pager stdin stream", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "hunk-patch-"));
+    tempDirs.push(dir);
+
+    const before = join(dir, "before.ts");
+    const after = join(dir, "after.ts");
+    const patch = join(dir, "input.patch");
+
+    writeFileSync(before, "export const answer = 41;\n");
+    writeFileSync(after, "export const answer = 42;\nexport const added = true;\n");
+
+    const diffProc = Bun.spawnSync(["git", "diff", "--no-index", "--color=always", "--", before, after], {
+      cwd: dir,
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    if (diffProc.exitCode !== 0 && diffProc.exitCode !== 1) {
+      const stderr = Buffer.from(diffProc.stderr).toString("utf8");
+      throw new Error(stderr.trim() || `git diff --color=always failed`);
+    }
+
+    writeFileSync(patch, Buffer.from(diffProc.stdout).toString("utf8"));
+
+    const bootstrap = await loadAppBootstrap({
+      kind: "patch",
+      file: patch,
+      options: { mode: "auto" },
+    });
+
+    expect(bootstrap.changeset.files).toHaveLength(1);
+    expect(bootstrap.changeset.files[0]?.path.endsWith("after.ts")).toBe(true);
+    expect(bootstrap.changeset.files[0]?.stats.additions).toBeGreaterThan(0);
+  });
 });

test/terminal.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, test } from "bun:test";
+import type { CliInput } from "../src/core/types";
+import { resolveRuntimeCliInput, shouldUsePagerMode, usesPipedPatchInput } from "../src/core/terminal";
+
+function createPatchInput(file?: string, pager = false): CliInput {
+  return {
+    kind: "patch",
+    file,
+    options: {
+      mode: "auto",
+      pager,
+    },
+  };
+}
+
+describe("terminal runtime defaults", () => {
+  test("treats stdin patch mode as pager-style when stdin is piped", () => {
+    const input = createPatchInput("-", false);
+
+    expect(usesPipedPatchInput(input, false)).toBe(true);
+    expect(shouldUsePagerMode(input, false)).toBe(true);
+    expect(resolveRuntimeCliInput(input, false).options.pager).toBe(true);
+  });
+
+  test("does not force pager mode for patch files or interactive stdin", () => {
+    expect(usesPipedPatchInput(createPatchInput("changes.patch"), false)).toBe(false);
+    expect(shouldUsePagerMode(createPatchInput("changes.patch"), false)).toBe(false);
+    expect(shouldUsePagerMode(createPatchInput("-"), true)).toBe(false);
+  });
+
+  test("keeps explicit pager mode enabled", () => {
+    const input = createPatchInput(undefined, true);
+
+    expect(shouldUsePagerMode(input, true)).toBe(true);
+    expect(resolveRuntimeCliInput(input, true).options.pager).toBe(true);
+  });
+});

test/tty-render-smoke.test.ts

@@ -40,6 +40,8 @@ function createFixtureFiles() {
   const before = join(dir, "before.ts");
   const after = join(dir, "after.ts");
   const agent = join(dir, "agent.json");
+  const patch = join(dir, "input.patch");
+  const coloredPatch = join(dir, "input-colored.patch");
 
   writeFileSync(before, "export const answer = 41;\n");
   writeFileSync(after, "export const answer = 42;\nexport const added = true;\n");
@@ -56,7 +58,33 @@ function createFixtureFiles() {
     }),
   );
 
-  return { dir, before, after, agent };
+  const patchProc = Bun.spawnSync(["git", "diff", "--no-index", "--no-color", "--", before, after], {
+    cwd: dir,
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const coloredPatchProc = Bun.spawnSync(["git", "diff", "--no-index", "--color=always", "--", before, after], {
+    cwd: dir,
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  if (patchProc.exitCode !== 0 && patchProc.exitCode !== 1) {
+    const stderr = Buffer.from(patchProc.stderr).toString("utf8");
+    throw new Error(stderr.trim() || `failed to build fixture patch: ${patchProc.exitCode}`);
+  }
+
+  if (coloredPatchProc.exitCode !== 0 && coloredPatchProc.exitCode !== 1) {
+    const stderr = Buffer.from(coloredPatchProc.stderr).toString("utf8");
+    throw new Error(stderr.trim() || `failed to build colored fixture patch: ${coloredPatchProc.exitCode}`);
+  }
+
+  writeFileSync(patch, Buffer.from(patchProc.stdout).toString("utf8"));
+  writeFileSync(coloredPatch, Buffer.from(coloredPatchProc.stdout).toString("utf8"));
+
+  return { dir, before, after, agent, patch, coloredPatch };
 }
 
 async function runTtySmoke(options: { mode?: "split" | "stack"; pager?: boolean; agentContext?: boolean }) {
@@ -96,6 +124,30 @@ async function runTtySmoke(options: { mode?: "split" | "stack"; pager?: boolean;
   return stripTerminalControl(await Bun.file(transcript).text());
 }
 
+async function runStdinPagerSmoke() {
+  const fixture = createFixtureFiles();
+  const transcript = join(fixture.dir, "stdin-pager-transcript.txt");
+  const patchCommand = `cat ${shellQuote(fixture.coloredPatch)} | bun run src/main.tsx patch -`;
+  const scriptCommand = `timeout 5 script -q -f -e -c ${shellQuote(patchCommand)} ${shellQuote(transcript)}`;
+  const proc = Bun.spawnSync(["bash", "-lc", `(sleep 1; printf q) | ${scriptCommand}`], {
+    cwd: process.cwd(),
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+    env: {
+      ...process.env,
+      TERM: "xterm-256color",
+    },
+  });
+
+  if (proc.exitCode !== 0) {
+    const stderr = Buffer.from(proc.stderr).toString("utf8");
+    throw new Error(stderr.trim() || `stdin pager smoke command failed with exit ${proc.exitCode}`);
+  }
+
+  return stripTerminalControl(await Bun.file(transcript).text());
+}
+
 afterEach(() => {
   cleanupTempDirs();
 });
@@ -141,4 +193,18 @@ describe("TTY render smoke", () => {
     expect(output).toContain("before.ts -> after.ts");
     expect(output).toContain("export const answer = 42;");
   });
+
+  test("stdin patch mode auto-enters pager mode and can quit from terminal input", async () => {
+    if (!ttyToolsAvailable) {
+      return;
+    }
+
+    const output = await runStdinPagerSmoke();
+
+    expect(output).not.toContain("View  Navigate  Theme  Agent  Help");
+    expect(output).not.toContain("F10 menu");
+    expect(output).toContain("after.ts");
+    expect(output).toContain("@@ -1 +1,2 @@");
+    expect(output).toContain("export const answer = 42;");
+  });
 });