flight

type AbortMsg ¶

type AbortMsg struct{ ID string }

AbortMsg asks whatever composes screens to abort promotion ID — closing the PR, deleting the branch, or whatever "abort" means operationally is out of scope for this screen; it only requests it (same convention as OpenPRMsg above).

type BackMsg ¶

type BackMsg struct{}

BackMsg pops this screen back to whatever was underneath it (mirrors plan.BackMsg).

type DriveFunc ¶

type DriveFunc func(ctx context.Context, s engine.PromotionState) (next engine.PromotionState, done bool, statuses []engine.StepStatus, err error)

DriveFunc advances a promotion by one poll iteration: it runs engine.Drive once (Drive itself calls Act on whichever steps are not yet satisfied, in order, then returns at the first step that is Waiting, Blocked, or erroring — see engine.Drive's own doc comment) and re-derives every step's own standing with engine.Status, so the screen can render the full step list rather than only wherever Drive stopped. err is non-nil only for a genuine plumbing failure (Known bug classes: a 404/permissions hiccup on Checks or Comments, mirroring cmd/hoist/drive.go's driveToCompletion) — Waiting, Blocked and "not yet acted on" are never errors, they are read from statuses instead.

cmd/hoist supplies the concrete function, closing over the real git.Git/forge.Forge adaptors and whatever state-save path the CLI's own promote/resume commands already use — the same shape plan.ResolveFunc uses to keep the plan screen ignorant of cluster/registry adaptors (AGENTS.md §4.8's "cmd/hoist owns the adapter" rule). This package therefore never imports pkg/git, pkg/forge, or a state-persistence path; it takes and returns plain engine.PromotionState values (not a pointer) so a tea.Cmd's goroutine never races the model's own copy — see driveCmd. done and statuses mirror engine.Status's own return shape exactly (a real implementation is expected to call engine.Drive then engine.Status in turn) rather than making this package re-derive "is the promotion finished" from the statuses slice by, say, checking whether the last entry names StepMerged — engine.Status already answers that question and its short-circuit's own reasoning (see its doc comment) lives in exactly one place.

type Model ¶

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

Model is the flight screen. It is a value: Update, SetSize and SetStyles return the updated model, matching internal/app/plan and internal/app/matrix's convention.

func New(state engine.PromotionState, poll PollDurations, driveFn DriveFunc) Model

func (m Model) Cancel()

func (m Model) Init() tea.Cmd

func (m Model) SetSize(width, height int) Model

func (m Model) SetStyles(s ui.Styles) Model

func (m Model) Update(msg tea.Msg) (Model, tea.Cmd)

func (m Model) View() string

func (m Model) WithNow(now func() time.Time) Model

type OpenPRMsg ¶

type OpenPRMsg struct{ URL string }

OpenPRMsg asks whatever composes screens to open s.PR's URL in the operator's browser — the actual open mechanism (exec.Command("open", …) or equivalent) is out of scope for this screen (AGENTS.md §4.8: a screen requests navigation by emitting its own concrete type; mirrors matrix.OpenPlanMsg and plan.BackMsg).

type PollDurations ¶

type PollDurations struct {
	CI, Approval, Argo, Rollout, Deadline time.Duration
}

PollDurations is the plain-value slice of internal/config.PollConfig this screen actually needs, in place of importing internal/config itself. AGENTS.md §4.8: a screen never imports config/registry policy, only the plain values or function types cmd/hoist (the one place allowed to know both sides) translates for it. Zero values are valid — New/pollInterval already fall back to a fixed default for anything left unset.

type Row ¶

type Row struct {
	Step  engine.StepName
	Glyph string
	// Active is true for exactly the one row DeriveRows considers "current" — the step
	// Status stopped at (Blocked, Waiting, or plainly not yet Satisfied). Never true when
	// done is true: every row is Done then.
	Active bool
	// Detail is the human string shown under an active row: Observation.Detail for a
	// waiting or not-yet-acted step, Observation.Blocked for a blocked one. It is never
	// invented here — always exactly what the engine step itself produced (AGENTS.md §4.1).
	// It is NOT already redacted by the time it reaches this package: engine.Status calls
	// each Step's own Observe directly and returns its Observation as-is (engine.go's
	// doc comment on Status/ObserveAll) — it never goes through engine.go's appendHistory,
	// which only wraps Drive's own history-writing path, a different call this package's
	// data never travels through. No Step.Observe in internal/engine/steps*.go redacts its
	// own Detail/Blocked text either. The actual guarantee here is model.go's View(), which
	// passes its whole assembled output (this Detail included) through redact.Strings once
	// at the final boundary before anything reaches the terminal — the same
	// belt-and-suspenders convention as plan.Model's own View(). That is the one place, not
	// two, where this package's data is scrubbed; DeriveRows and this struct carry it
	// unredacted up to that point, same as engine.Status hands it over.
	Detail string
}

Row is one step in the flight list, derived with no terminal dependency.

func DeriveRows(order []engine.StepName, done bool, statuses []engine.StepStatus) []Row

type Summary ¶

type Summary struct {
	ID             string
	Source, Target string
	Direct         bool
	StartedAt      time.Time
	PR             *forge.PR
	Rows           []Row
	Done           bool
	// Err is why this promotion could not be re-observed (a forge scope gap, a repo no
	// longer in config), redacted at the render boundary like every other upstream string.
	// The Rows are then every step not-reached and the pane says so rather than guessing.
	Err string
}

Summary is one promotion as the matrix's in-flight pane shows it (M10, #85 screen 05): the identity, the step rows engine.Status produced for it, and what it is waiting for — all re-observed from the forge and the cluster the moment it was listed, never read from the state file's recorded phase (AGENTS.md §4.1). Built by Summarize from the same (done, statuses) shape DeriveRows takes, so the pane and the flight screen agree.

func Summarize(s engine.PromotionState, done bool, statuses []engine.StepStatus, err error) Summary

func (s Summary) Action() (text, command string)

func (s Summary) StepStrip() string

func (s Summary) Verdict() string