claude_pipe/main.go

// Command claude_pipe is a drop-in-ish replacement for `claude -p` that works by
// driving the interactive `claude` TUI through a pseudo-terminal, capturing its
// rendered screen, and parsing it back into structured data — the assistant's
// answer plus the visible conversation turns.
//
// It exists for the (unusual) case where you want the result of an interactive
// claude session as data, going THROUGH the TUI rather than through
// `claude -p --output-format json`. For most programmatic use the stream-json path
// (claude_stream_go_core) is cleaner and more robust; claude_pipe is the TUI-parsing
// alternative, kept because the TUI exposes things `-p` does not.
//
// Pipeline (all registry functions):
//
//	pty_capture_idle_go_infra  -> capture the TUI render headlessly via PTY
//	vt_render_go_tui           -> reconstruct the 2D screen as plain text
//	parse_claude_tui_go_tui    -> extract turns + final answer
//
// Output formats:
//
//	--format json   {"type":"result","subtype":"success","is_error":false,"result":"<answer>"}
//	                (mirrors `claude -p --output-format json`)
//	--format text   just the answer text (mirrors plain `claude -p`)
//	--format turns  the full ClaudeTUIParse (every visible turn + answer) as JSON
//	--format screen debug: the raw rendered screen before parsing
package main

import (
	"encoding/json"
	"flag"
	"fmt"
	"os"
	"strings"
	"time"

	"context"

	"fn-registry/functions/infra"
	"fn-registry/functions/tui"
)

// PTY grid size. Must match what pty_capture_idle_go_infra uses internally (40x120)
// so vt_render reconstructs the layout with the same wrapping.
const (
	ptyRows = 40
	ptyCols = 120
)

// claudePResult mirrors the shape of `claude -p --output-format json`.
type claudePResult struct {
	Type    string `json:"type"`
	Subtype string `json:"subtype"`
	IsError bool   `json:"is_error"`
	Result  string `json:"result"`
}

func main() {
	var (
		prompt    = flag.String("prompt", "", "prompt to send. If empty, taken from the positional arg, or from piped stdin")
		format    = flag.String("format", "json", "output format: json (like claude -p --output-format json), text (just the answer), turns (full parse), screen (debug: raw render)")
		cwd       = flag.String("cwd", "", "run claude in this directory (use a repo root whose MCP servers are approved, to skip the startup dialog)")
		bin       = flag.String("bin", "claude", "claude binary to launch")
		warmup    = flag.Duration("warmup", 4*time.Second, "wait before sending the prompt, so the TUI finishes loading")
		stepDelay = flag.Duration("step-delay", 600*time.Millisecond, "delay between typing the prompt and pressing Enter")
		idle      = flag.Duration("idle", 4*time.Second, "stop capturing after this much silence (response finished rendering)")
		maxDur    = flag.Duration("max", 120*time.Second, "hard timeout for the whole capture")
	)
	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, `claude_pipe — get a claude answer as data by parsing its TUI (alternative to claude -p).

Usage:
  claude_pipe [flags] [prompt]

Examples:
  claude_pipe --cwd /home/enmanuel/fn_registry "responde solo PONG"
  claude_pipe --format text --cwd /repo "resume el README en 3 lineas"
  echo "explica este error" | claude_pipe --cwd /repo
  claude_pipe --format turns --cwd /repo "lee main.go y resume"   # incluye tool_use/tool_result visibles

Flags:
`)
		flag.PrintDefaults()
	}
	flag.Parse()

	if *cwd != "" {
		if err := os.Chdir(*cwd); err != nil {
			fmt.Fprintf(os.Stderr, "claude_pipe: --cwd: %v\n", err)
			os.Exit(1)
		}
	}

	promptText := *prompt
	if promptText == "" && flag.NArg() > 0 {
		promptText = strings.Join(flag.Args(), " ")
	}
	if promptText == "" && stdinIsPiped() {
		if data, err := os.ReadFile("/dev/stdin"); err == nil {
			promptText = strings.TrimRight(string(data), "\n")
		}
	}
	if promptText == "" {
		fmt.Fprintln(os.Stderr, "claude_pipe: no prompt (use --prompt, a positional arg, or pipe stdin)")
		os.Exit(2)
	}

	// Type the prompt and press Enter as SEPARATE steps: a "\r" glued to the text is
	// treated by claude as a literal newline in the input box, not a submit.
	inputs := []string{promptText, "\r"}

	ctx, cancel := context.WithTimeout(context.Background(), *maxDur+10*time.Second)
	defer cancel()

	raw, err := infra.PTYCaptureIdle(ctx, *bin, nil, *warmup, inputs, *stepDelay, *idle, *maxDur)
	if err != nil {
		fmt.Fprintf(os.Stderr, "claude_pipe: capture failed: %v\n", err)
		os.Exit(1)
	}

	screen := tui.VTRender(raw, ptyRows, ptyCols)

	if *format == "screen" {
		fmt.Println(screen)
		return
	}

	parsed := tui.ParseClaudeTUI(screen)

	switch *format {
	case "text":
		fmt.Println(parsed.Answer)
	case "turns":
		enc := json.NewEncoder(os.Stdout)
		enc.SetIndent("", "  ")
		if err := enc.Encode(parsed); err != nil {
			fmt.Fprintf(os.Stderr, "claude_pipe: encode: %v\n", err)
			os.Exit(1)
		}
	case "json":
		res := claudePResult{
			Type:    "result",
			Subtype: "success",
			IsError: parsed.Answer == "",
			Result:  parsed.Answer,
		}
		enc := json.NewEncoder(os.Stdout)
		if err := enc.Encode(res); err != nil {
			fmt.Fprintf(os.Stderr, "claude_pipe: encode: %v\n", err)
			os.Exit(1)
		}
	default:
		fmt.Fprintf(os.Stderr, "claude_pipe: unknown --format %q (want json|text|turns|screen)\n", *format)
		os.Exit(2)
	}
}

// stdinIsPiped reports whether stdin is connected to a pipe/file rather than a terminal.
func stdinIsPiped() bool {
	info, err := os.Stdin.Stat()
	if err != nil {
		return false
	}
	return (info.Mode() & os.ModeCharDevice) == 0
}