feat: support piping between agents (foo.md | bar.md)

Add stdout TTY detection to disable post-run menu and markdown
rendering when output is piped to another command. This enables
chaining agents: `foo.claude.md | bar.claude.md`

- Add isStdoutTTY option to CliRunner (alongside existing isStdinTTY)
- Update shouldShowMenu to check both stdin AND stdout are TTYs
- Add defense-in-depth check in showPostRunMenu
- Add tests for piping scenarios

Author: johnlindquist

src/cli-runner.test.ts

@@ -333,4 +333,59 @@ Content without command`);
       expect(result.errorMessage).toContain("No command specified");
     });
   });
+
+  describe("piping support (isStdoutTTY)", () => {
+    it("accepts isStdoutTTY option", async () => {
+      env.addFile("/test/pipe.echo.md", `---
+---
+Test piping`);
+
+      // Simulates: md pipe.echo.md | other-command
+      // When piping, stdout is not a TTY
+      const runner = new CliRunner({
+        env,
+        isStdinTTY: true,
+        isStdoutTTY: false, // stdout piped to another command
+        cwd: "/test",
+      });
+
+      const result = await runner.run(["node", "md", "/test/pipe.echo.md", "--_dry-run"]);
+      expect(result.exitCode).toBe(0);
+    });
+
+    it("accepts both stdin and stdout as non-TTY (middle of pipeline)", async () => {
+      env.addFile("/test/middle.echo.md", `---
+---
+Middle of pipeline`);
+
+      // Simulates: first.md | md middle.echo.md | last.md
+      const runner = new CliRunner({
+        env,
+        isStdinTTY: false, // stdin from pipe
+        isStdoutTTY: false, // stdout to pipe
+        stdinContent: "piped input",
+        cwd: "/test",
+      });
+
+      const result = await runner.run(["node", "md", "/test/middle.echo.md", "--_dry-run"]);
+      expect(result.exitCode).toBe(0);
+    });
+
+    it("defaults isStdoutTTY when not provided", async () => {
+      env.addFile("/test/default.echo.md", `---
+---
+Test default`);
+
+      // When isStdoutTTY is not provided, it should default to process.stdout.isTTY
+      const runner = new CliRunner({
+        env,
+        isStdinTTY: true,
+        // isStdoutTTY not provided - should use process.stdout.isTTY
+        cwd: "/test",
+      });
+
+      const result = await runner.run(["node", "md", "/test/default.echo.md", "--_dry-run"]);
+      expect(result.exitCode).toBe(0);
+    });
+  });
 });

src/cli-runner.ts

@@ -107,6 +107,7 @@ export interface CliRunnerOptions {
   processEnv?: Record<string, string | undefined>;
   cwd?: string;
   isStdinTTY?: boolean;
+  isStdoutTTY?: boolean;
   stdinContent?: string;
   promptInput?: (message: string) => Promise<string>;
   /** Custom prompt with history function (for testing) */
@@ -119,6 +120,7 @@ export class CliRunner {
   private processEnv: Record<string, string | undefined>;
   private cwd: string;
   private isStdinTTY: boolean;
+  private isStdoutTTY: boolean;
   private stdinContent: string | undefined;
   private promptInput: (message: string) => Promise<string>;
   private promptInputWithHistory: (message: string, defaultValue?: string) => Promise<string>;
@@ -128,6 +130,7 @@ export class CliRunner {
     this.processEnv = options.processEnv ?? process.env;
     this.cwd = options.cwd ?? process.cwd();
     this.isStdinTTY = options.isStdinTTY ?? Boolean(process.stdin.isTTY);
+    this.isStdoutTTY = options.isStdoutTTY ?? Boolean(process.stdout.isTTY);
     this.stdinContent = options.stdinContent;
     // Lazy-load input prompt only when actually needed
     this.promptInput = options.promptInput ?? (async (msg) => {
@@ -392,7 +395,8 @@ export class CliRunner {
     startSpinner(preview);
 
     // Determine if we should capture output for post-run menu
-    const shouldShowMenu = this.isStdinTTY && !parsed.noMenu;
+    // Disable when piping (stdout not TTY) to support: foo.md | bar.md
+    const shouldShowMenu = this.isStdinTTY && this.isStdoutTTY && !parsed.noMenu;
     const captureMode = shouldShowMenu ? "tee" as const : false;
 
     const runResult = await runCommand({
@@ -537,8 +541,9 @@ export class CliRunner {
     }
 
     // Determine if we should capture output for post-run menu
-    // Only capture when: TTY, not piped, menu not disabled
-    const shouldShowMenu = this.isStdinTTY && !parsed.noMenu;
+    // Only capture when: TTY (stdin+stdout), not piped, menu not disabled
+    // Checking stdout.isTTY enables piping: foo.md | bar.md
+    const shouldShowMenu = this.isStdinTTY && this.isStdoutTTY && !parsed.noMenu;
     // Always capture stderr when in interactive mode for failure menu
     const captureMode = shouldShowMenu ? "tee" as const : false;
 

src/post-run-menu.test.ts

@@ -206,3 +206,34 @@ describe("saveToFile", () => {
     expect(result).toBe(false);
   });
 });
+
+describe("showPostRunMenu TTY behavior", () => {
+  /**
+   * Note: showPostRunMenu checks process.stdin.isTTY and process.stdout.isTTY directly.
+   * These are read-only properties that can't be easily mocked in tests.
+   *
+   * The expected behavior (tested indirectly via CliRunner):
+   * - Returns undefined when process.stdin.isTTY is false
+   * - Returns undefined when process.stdout.isTTY is false (piping support)
+   * - Returns undefined when output is empty
+   * - Only shows menu when both stdin and stdout are TTYs and output is non-empty
+   *
+   * This enables piping: foo.md | bar.md
+   * - foo.md has stdout piped, so menu is skipped
+   * - bar.md receives clean output without menu interference
+   */
+
+  it("documents TTY requirements for menu display", () => {
+    // This test documents the expected behavior rather than testing it directly
+    // The actual TTY checks are in showPostRunMenu():
+    //   if (!output.trim() || !process.stdin.isTTY || !process.stdout.isTTY) {
+    //     return undefined;
+    //   }
+
+    // Integration tests in cli-runner.test.ts verify:
+    // - isStdoutTTY option is accepted
+    // - Both stdin and stdout non-TTY works (middle of pipeline)
+
+    expect(true).toBe(true); // Placeholder - behavior documented above
+  });
+});

src/post-run-menu.ts

@@ -349,8 +349,9 @@ export const postRunMenu = createPrompt<PostRunMenuResult, PostRunMenuConfig>(
 export async function showPostRunMenu(
   output: string
 ): Promise<PostRunMenuResult | undefined> {
-  // Don't show menu if no output or not a TTY
-  if (!output.trim() || !process.stdin.isTTY) {
+  // Don't show menu if no output or not a TTY (stdin AND stdout)
+  // Checking stdout enables piping: foo.md | bar.md
+  if (!output.trim() || !process.stdin.isTTY || !process.stdout.isTTY) {
     return undefined;
   }