fix(pager): render static diffs in captured pagers (#271)

Author: benvinegar

CHANGELOG.md

@@ -12,6 +12,7 @@ All notable user-visible changes to Hunk are documented in this file.
 
 ### Fixed
 
+- Made `hunk pager` emit static highlighted diff output for captured pager contexts like LazyGit, and pass diff input through unchanged when stdout is non-interactive.
 - Fixed `hunk pager` parsing for Git diffs emitted with `diff.mnemonicPrefix=true` so file paths do not keep `i/`, `w/`, `c/`, `1/`, or `2/` side prefixes.
 - Fixed large tracked and untracked file handling so very large diffs render as skipped placeholders instead of slowing startup or overflowing the JavaScript call stack.
 

src/core/startup.test.ts

@@ -89,6 +89,9 @@ describe("startup planning", () => {
       parseCliImpl: async () => ({ kind: "pager", options: { theme: "paper" } }),
       readStdinText: async () => "diff --git a/a.ts b/a.ts\n@@ -1 +1 @@\n-old\n+new\n",
       looksLikePatchInputImpl: () => true,
+      stdoutIsTTY: true,
+      env: { TERM: "xterm-256color" },
+      openControllingTerminalImpl: () => ({ stdin: {} as never, close: () => {} }),
       resolveRuntimeCliInputImpl(input) {
         seenInputs.push(input);
         return input;
@@ -121,6 +124,101 @@ describe("startup planning", () => {
     expect(seenInputs).toHaveLength(3);
   });
 
+  test("passes diff-like pager stdin through when stdout is not interactive", async () => {
+    let loaded = false;
+    const patchText = "diff --git a/a.ts b/a.ts\n@@ -1 +1 @@\n-old\n+new\n";
+
+    const plan = await prepareStartupPlan(["bun", "hunk", "pager"], {
+      parseCliImpl: async () => ({ kind: "pager", options: {} }),
+      readStdinText: async () => patchText,
+      looksLikePatchInputImpl: () => true,
+      stdoutIsTTY: false,
+      loadAppBootstrapImpl: async () => {
+        loaded = true;
+        throw new Error("unreachable");
+      },
+    });
+
+    expect(plan).toEqual({ kind: "passthrough", text: patchText });
+    expect(loaded).toBe(false);
+  });
+
+  test("passes diff-like pager stdin through for a plain dumb terminal", async () => {
+    let loaded = false;
+    const patchText = "diff --git a/a.ts b/a.ts\n@@ -1 +1 @@\n-old\n+new\n";
+
+    const plan = await prepareStartupPlan(["bun", "hunk", "pager"], {
+      parseCliImpl: async () => ({ kind: "pager", options: {} }),
+      readStdinText: async () => patchText,
+      looksLikePatchInputImpl: () => true,
+      stdoutIsTTY: true,
+      env: { TERM: "dumb" },
+      loadAppBootstrapImpl: async () => {
+        loaded = true;
+        throw new Error("unreachable");
+      },
+    });
+
+    expect(plan).toEqual({ kind: "passthrough", text: patchText });
+    expect(loaded).toBe(false);
+  });
+
+  test("routes diff-like pager stdin to static output when the host advertises a captured pager", async () => {
+    let loaded = false;
+    const patchText = "diff --git a/a.ts b/a.ts\n@@ -1 +1 @@\n-old\n+new\n";
+
+    const plan = await prepareStartupPlan(["bun", "hunk", "pager"], {
+      parseCliImpl: async () => ({ kind: "pager", options: { theme: "paper" } }),
+      readStdinText: async () => patchText,
+      looksLikePatchInputImpl: () => true,
+      stdoutIsTTY: true,
+      env: { TERM: "dumb", LV: "-c" },
+      resolveRuntimeCliInputImpl: (input) => input,
+      resolveConfiguredCliInputImpl: (input) =>
+        ({
+          input: { ...input, options: { ...input.options, lineNumbers: false, theme: "paper" } },
+        }) as never,
+      loadAppBootstrapImpl: async () => {
+        loaded = true;
+        throw new Error("unreachable");
+      },
+    });
+
+    expect(plan).toEqual({
+      kind: "static-diff-pager",
+      text: patchText,
+      options: { theme: "paper", pager: true, lineNumbers: false },
+    });
+    expect(loaded).toBe(false);
+  });
+
+  test("routes diff-like pager stdin to static output when no controlling terminal is available", async () => {
+    let loaded = false;
+    const patchText = "diff --git a/a.ts b/a.ts\n@@ -1 +1 @@\n-old\n+new\n";
+
+    const plan = await prepareStartupPlan(["bun", "hunk", "pager"], {
+      parseCliImpl: async () => ({ kind: "pager", options: {} }),
+      readStdinText: async () => patchText,
+      looksLikePatchInputImpl: () => true,
+      stdoutIsTTY: true,
+      env: { TERM: "xterm-256color" },
+      resolveRuntimeCliInputImpl: (input) => input,
+      resolveConfiguredCliInputImpl: (input) => ({ input }) as never,
+      openControllingTerminalImpl: () => null,
+      loadAppBootstrapImpl: async () => {
+        loaded = true;
+        throw new Error("unreachable");
+      },
+    });
+
+    expect(plan).toEqual({
+      kind: "static-diff-pager",
+      text: patchText,
+      options: { pager: true },
+    });
+    expect(loaded).toBe(false);
+  });
+
   test("rejects watch mode for stdin-backed patch inputs", async () => {
     const cliInput: CliInput = {
       kind: "patch",

src/core/startup.ts

@@ -28,13 +28,31 @@ export type StartupPlan =
       kind: "plain-text-pager";
       text: string;
     }
+  | {
+      kind: "passthrough";
+      text: string;
+    }
+  | {
+      kind: "static-diff-pager";
+      text: string;
+      options: CliInput["options"];
+    }
   | {
       kind: "app";
       bootstrap: AppBootstrap;
       cliInput: CliInput;
       controllingTerminal: ControllingTerminal | null;
     };
 
+function isCapturedPagerHost(env: NodeJS.ProcessEnv) {
+  return (
+    env.TERM === "dumb" &&
+    (env.LV === "-c" ||
+      Boolean(env.GIT_PAGER) ||
+      Object.keys(env).some((key) => key.startsWith("LAZYGIT")))
+  );
+}
+
 export interface StartupDeps {
   parseCliImpl?: (argv: string[]) => Promise<ParsedCliInput>;
   readStdinText?: () => Promise<string>;
@@ -44,6 +62,8 @@ export interface StartupDeps {
   loadAppBootstrapImpl?: typeof loadAppBootstrap;
   usesPipedPatchInputImpl?: typeof usesPipedPatchInput;
   openControllingTerminalImpl?: typeof openControllingTerminal;
+  stdoutIsTTY?: boolean;
+  env?: NodeJS.ProcessEnv;
 }
 
 /** Normalize startup work so help, pager, and app-bootstrap paths can be tested directly. */
@@ -60,8 +80,11 @@ export async function prepareStartupPlan(
   const loadAppBootstrapImpl = deps.loadAppBootstrapImpl ?? loadAppBootstrap;
   const usesPipedPatchInputImpl = deps.usesPipedPatchInputImpl ?? usesPipedPatchInput;
   const openControllingTerminalImpl = deps.openControllingTerminalImpl ?? openControllingTerminal;
+  const stdoutIsTTY = deps.stdoutIsTTY ?? Boolean(process.stdout.isTTY);
+  const env = deps.env ?? process.env;
 
   let parsedCliInput = await parseCliImpl(argv);
+  let controllingTerminal: ControllingTerminal | null = null;
 
   if (parsedCliInput.kind === "help") {
     return {
@@ -85,6 +108,27 @@ export async function prepareStartupPlan(
 
   if (parsedCliInput.kind === "pager") {
     const stdinText = await readStdinText();
+    const pagerOptions = parsedCliInput.options;
+    const staticPagerPlan = () => {
+      const staticPatchInput: CliInput = {
+        kind: "patch",
+        file: "-",
+        text: stdinText,
+        options: {
+          ...pagerOptions,
+          pager: true,
+        },
+      };
+      const configuredStaticInput = resolveConfiguredCliInputImpl(
+        resolveRuntimeCliInputImpl(staticPatchInput),
+      ).input;
+
+      return {
+        kind: "static-diff-pager" as const,
+        text: stdinText,
+        options: configuredStaticInput.options,
+      };
+    };
 
     if (!looksLikePatchInputImpl(stdinText)) {
       return {
@@ -93,6 +137,31 @@ export async function prepareStartupPlan(
       };
     }
 
+    if (!stdoutIsTTY) {
+      return {
+        kind: "passthrough",
+        text: stdinText,
+      };
+    }
+
+    if (env.TERM === "dumb" && !isCapturedPagerHost(env)) {
+      return {
+        kind: "passthrough",
+        text: stdinText,
+      };
+    }
+
+    // Captured pager hosts like LazyGit can provide a PTY while advertising TERM=dumb.
+    // In that mode, emit static colored diff output instead of launching the TUI.
+    if (isCapturedPagerHost(env)) {
+      return staticPagerPlan();
+    }
+
+    controllingTerminal = openControllingTerminalImpl();
+    if (!controllingTerminal) {
+      return staticPagerPlan();
+    }
+
     parsedCliInput = {
       kind: "patch",
       file: "-",
@@ -117,10 +186,15 @@ export async function prepareStartupPlan(
     );
   }
 
-  const bootstrap = await loadAppBootstrapImpl(cliInput);
-  const controllingTerminal = usesPipedPatchInputImpl(cliInput)
-    ? openControllingTerminalImpl()
-    : null;
+  let bootstrap: AppBootstrap;
+  try {
+    bootstrap = await loadAppBootstrapImpl(cliInput);
+  } catch (error) {
+    controllingTerminal?.close();
+    throw error;
+  }
+
+  controllingTerminal ??= usesPipedPatchInputImpl(cliInput) ? openControllingTerminalImpl() : null;
 
   return {
     kind: "app",

src/main.tsx

@@ -6,6 +6,7 @@ import { formatCliError } from "./core/errors";
 import { installJobControlSuspendSupport } from "./core/jobControl";
 import { pagePlainText } from "./core/pager";
 import { shutdownSession } from "./core/shutdown";
+import { renderStaticDiffPager } from "./ui/staticDiffPager";
 import { prepareStartupPlan } from "./core/startup";
 import { shouldUseMouseForApp } from "./core/terminal";
 import { resolveStartupUpdateNotice } from "./core/updateNotice";
@@ -48,6 +49,16 @@ async function main() {
     process.exit(0);
   }
 
+  if (startupPlan.kind === "passthrough") {
+    process.stdout.write(startupPlan.text);
+    process.exit(0);
+  }
+
+  if (startupPlan.kind === "static-diff-pager") {
+    process.stdout.write(await renderStaticDiffPager(startupPlan.text, startupPlan.options));
+    process.exit(0);
+  }
+
   if (startupPlan.kind !== "app") {
     throw new Error("Unreachable startup plan.");
   }