tui

type BatchDoneMsg ¶

type BatchDoneMsg struct{ Summary string }

BatchDoneMsg closes the run with a final summary line.

type BatchStartMsg ¶

type BatchStartMsg struct{ Total int }

BatchStartMsg opens a run and sets the optional denominator/header.

type ConfirmMsg ¶

type ConfirmMsg struct {
	Prompt string
	Reply  chan bool
}

ConfirmMsg asks the model to render an in-UI yes/no prompt and deliver the answer on Reply. It is the in-band confirmation path: the y/N decision is a key prompt rendered by the model rather than a read of os.Stdin behind the running program. Reply should be a buffered (cap >= 1) channel so the model's non-blocking send always lands.

type HintReporter ¶ added in v0.36.0

type HintReporter interface {
	Reporter
	// TaskDoneHint is TaskDone with hint shown at the end of the task's row.
	TaskDoneHint(id string, ok bool, summary, hint, capturedOutput string)
}

HintReporter is a Reporter that can show a short next step beside a finished task's outcome. It is optional: the plain and no-op backends do not implement it, so a hint reaches only the live region.

type LogMsg ¶

type LogMsg struct{ Level, Text string }

LogMsg routes a logger/output line into the TUI scrollback so stray writes do not corrupt a frame.

type Options ¶

type Options struct {
	// NoTUI is the --no-tui flag value; when true the TUI is suppressed and
	// command code falls back to plain output.
	NoTUI bool
}

Options carries the runtime inputs that gate the live TUI. NoTUI mirrors the --no-tui CLI flag value.

type Program ¶

type Program struct {
	// contains filtered or unexported fields
}

Program is a thin wrapper over a *tea.Program that owns the run goroutine and exposes a small Start/Wait/Stop lifecycle plus Send and the terminal release/restore passthroughs (§4.1).

SIGINT is reconciled, not double-owned (AD9): the program is created with WithoutSignalHandler so Bubble Tea installs no competing signal handler. Ctrl-C reaches the model as a key message, and the model invokes the injected cancel — the caller's existing cancellation chain — before quitting. The program is NOT bound to the caller's context: bubbletea kills a program whose context ends, which skips the final render and leaves the last live frame on screen. A watcher releases the region instead, as Stop does.

func NewProgram(ctx context.Context, cancel func(), m *model, out io.Writer, in io.Reader) *Program

func (p *Program) Confirm(prompt string) bool

func (p *Program) PrintHistory(w io.Writer) error

func (p *Program) ReleaseTerminal() error

func (p *Program) RestoreTerminal() error

func (p *Program) Send(msg tea.Msg)

func (p *Program) Start()

func (p *Program) Stop()

func (p *Program) Wait() error

type Reporter ¶

type Reporter interface {
	// BatchStart opens a run; total is an optional denominator (0 = unknown).
	BatchStart(total int)
	// TaskStart registers a task slot under a display label.
	TaskStart(id, label string)
	// TaskStage moves a task to a named stage.
	TaskStage(id, stage string)
	// TaskProgress sets a task's progress fraction; frac < 0 = indeterminate.
	TaskProgress(id string, frac float64)
	// TaskLine emits one tail update for a task. eol=false is an in-place
	// replacement of the live line (carriage-return / partial flush); eol=true
	// commits the line into the bounded tail (it ended with a newline). See
	// TaskLineMsg for the model-side semantics.
	TaskLine(id string, stream Stream, text string, eol bool)
	// TaskDone terminates a task; capturedOutput carries the full buffer for
	// the error path (the Output: %s contract at applier.go is preserved).
	TaskDone(id string, ok bool, summary, capturedOutput string)
	// Log routes a logger/output line into the UI.
	Log(level, text string)
	// BatchDone closes the run with a final summary.
	BatchDone(summary string)
}

Reporter is the single sink command code emits progress to. Both backends implement it: teaReporter forwards each call as a tea.Msg through program.Send, plainReporter writes deterministic lines to an io.Writer.

A nil or Noop reporter is exactly equivalent to having no progress reporting: silent, fully-buffered execution. Command code holding a possibly-nil Reporter should normalize it through orNoop before use.

func NewPlainReporter(w io.Writer, throttle time.Duration) Reporter

func Noop() Reporter

type Stream ¶

type Stream int

Stream identifies which subprocess stream a captured tail line came from.

const (
	// StreamStdout is the child process's standard output.
	StreamStdout Stream = iota
	// StreamStderr is the child process's standard error.
	StreamStderr
)

func (s Stream) String() string

type StreamCapture ¶

type StreamCapture struct {
	// contains filtered or unexported fields
}

StreamCapture is the streaming capture seam that replaces exec's CombinedOutput for long subprocesses. It implements io.Writer, so it can be assigned to cmd.Stdout / cmd.Stderr, and tees every write into two sinks:

• capture: an in-memory copy of the most recent output, returned by Captured() for the error path (the "Output: %s on failure" contract). It keeps the last MaxCapturedBytes verbatim and counts the bytes it dropped before them;
• a line emitter that splits the stream into lines and forwards each update to the Reporter as a TaskLine event. It treats "\r" as an in-place line replacement and "\r\n" as a single terminator.

All mutable state is guarded by a mutex so a single StreamCapture is safe to drive from an os/exec copy goroutine and passes -race.

func NewStreamCapture(r Reporter, id string, stream Stream) *StreamCapture

func (c *StreamCapture) Captured() string

func (c *StreamCapture) Close() error

func (c *StreamCapture) Write(p []byte) (int, error)

type TaskDoneMsg ¶

type TaskDoneMsg struct {
	ID             string
	OK             bool
	Summary        string
	CapturedOutput string
	Hint           string
}

TaskDoneMsg terminates a task. CapturedOutput carries the full buffered child output for the error path (the model never renders it in full). Hint is an optional next step shown at the end of the task's history row; empty means none.

type TaskLineMsg ¶

type TaskLineMsg struct {
	ID     string
	Stream Stream
	Text   string
	EOL    bool
}

TaskLineMsg carries one tail update for a task. Text is the full content of the line currently being assembled. EOL distinguishes the two terminal behaviors the StreamCapture emitter detects:

• EOL=false: an in-place update (the child emitted "\r" or the partial line was flushed). The model REPLACES the task's live line.
• EOL=true: the line ended with "\n". The model COMMITS the live line into the bounded tail ring and starts a fresh live line.

type TaskProgressMsg ¶

type TaskProgressMsg struct {
	ID   string
	Frac float64
}

TaskProgressMsg sets a task's progress fraction. Frac < 0 means indeterminate (render a spinner rather than a bar).

type TaskStageMsg ¶

type TaskStageMsg struct{ ID, Stage string }

TaskStageMsg moves a task to a named stage ("manifest", "llm-fix", …).

type TaskStartMsg ¶

type TaskStartMsg struct{ ID, Label string }

TaskStartMsg registers a new task slot with a display label.