initctx

type Action struct {
	Kind ActionKind
	// Files lists what the step writes (relative to Plan.Dir); Run names
	// what it runs, in the words of the screen ("" = nothing).
	Files []string
	Run   string
	// Command is the flag-twin command line, run from Plan.Dir.
	Command string
	// Network is whether the step needs the network.
	Network bool
	// The parameters the executor hands to the functions behind Command.
	Name, Env, Domain, Driver, Service, Path, Implementation string
	Groups                                                   []string
}

type ActionKind string

type Answers struct {
	// Dir is the project directory ("" = the situation's default: the
	// working directory, or the git root below which the user stands).
	Dir string
	// Name is metadata.name ("" = the directory name).
	Name string
	// Env is the environment file: mise, direnv or none ("" = the one the
	// directory already has, else mise).
	Env string
	// GitInit asks for `git init` (honoured only without a repository).
	GitInit bool
	// Domain and Driver describe the first cluster spec; "" = none.
	Domain, Driver string
	// Use makes Domain the active domain (`lo use`).
	Use bool
	// Toolchain runs `lo toolchain install` with Groups (nil = the
	// default groups).
	Toolchain bool
	Groups    []string
}

type ClusterInput struct {
	Domain, Driver string
	Active         bool
	// Force is the verb's --force: an existing spec is replaced.
	Force       bool
	DomainGiven bool
	DriverGiven bool
	ActiveGiven bool
}

type Domain struct {
	Name string
	// Kind is the driver of cluster.lok8s.yaml (lowercase), "deploy" for
	// a deploy-only domain, "?" when unreadable.
	Kind string
}

type Entry struct {
	Key, Label, Twin string
}

type Git struct {
	// Available is whether git ran at all.
	Available bool
	// Root is the repository root ("" = not a repository), in the path
	// form of State.Cwd (git resolves symlinks; the card prints one form).
	Root string
	// AtRoot is whether cwd is the repository root.
	AtRoot bool
	// Branch is the current branch ("" = detached HEAD).
	Branch string
	// Uncommitted counts the paths `git status --porcelain` lists.
	Uncommitted int
	// Submodule is whether Root carries a `.git` FILE (a submodule
	// checkout, or a worktree) rather than a directory.
	Submodule bool
}

type IO struct {
	In  io.Reader
	Out io.Writer
	// Accessible runs the fields as line prompts instead of the
	// interactive forms (off a TTY; the tests).
	Accessible bool
}

type Loop struct {
	Out     io.Writer
	IO      IO
	Detect  func() (State, error)
	Execute func(Plan) error
}

type Plan struct {
	// Dir is the project directory every action runs in (absolute).
	Dir string
	// Name is the project name the actions use.
	Name string
	// Force overwrites existing files (a verb's --force; a screen never
	// sets it).
	Force bool
	// Actions in execution order; empty = nothing to do.
	Actions []Action
}

type Project struct {
	// Root is the project root (the marker walk from cwd).
	Root string
	// AtRoot is whether cwd is Root.
	AtRoot bool
	// Name is metadata.name of the project file ("" when the marker is
	// clusters/ alone).
	Name string
	// ProjectFile is whether Root/lok8s.yaml is a `kind: Project` file.
	ProjectFile bool
	// Clusters is whether Root/clusters exists.
	Clusters bool
	// Domains lists the domains under clusters/ that carry a spec.
	Domains []Domain
	// Active is clusters/.active ("" when unset or invalid).
	Active string
	// Kubeconfig is whether the active domain's cluster has a kubeconfig
	// under .kubeconfig/ (<metadata.name>.yaml: the cluster was
	// provisioned once).
	Kubeconfig bool
	// EnvFile is the environment file present: "mise" (mise.toml),
	// "direnv" (.envrc), "" (none). With both present, mise.
	EnvFile string
	// BYAML is whether .bin/b.yaml exists; BYAMLInvalid whether it exists
	// but cannot be read or parsed (then Tools is 0).
	BYAML, BYAMLInvalid bool
	// Tools counts the pinned tools: b itself plus every `binaries:`
	// entry of .bin/b.yaml. ToolsMissing lists the ones that do not
	// resolve under the project (by name); nil = all present.
	Tools        int
	ToolsMissing []string
	// BashTree is whether Root/.lok8s/lo exists (an ejected or vendored
	// bash tree).
	BashTree bool
	// Implementation is spec.implementation.default ("go" or "bash";
	// "go" when the block is absent), ImplementationErr the loader's
	// error text when the block is invalid.
	Implementation    string
	ImplementationErr string
	// Services is whether Root/services.yaml exists; Tests whether
	// Root/tests is a directory.
	Services, Tests bool
}

type Result struct {
	Key, Value string
}

type Screen struct {
	// Title heads the screen ("New project").
	Title string
	// Values are the rows above the writes/runs lines.
	Values []row
	// Plan is what Create executes.
	Plan Plan
	// Details builds the editable fields, bound to the values (nil = no
	// details: every value came from the command line).
	Details func() []huh.Field
	// Incomplete is whether a value the screen needs is still empty: the
	// details open before the screen is shown, and --plan refuses with
	// Missing.
	Incomplete bool
	// Missing is the error line for an incomplete screen off the details
	// (--plan, or a verb off a terminal).
	Missing string
}

type ServiceInput struct {
	Name, Path string
	NameGiven  bool
	PathGiven  bool
}

type Situation int

type State struct {
	// Cwd is the working directory, absolute.
	Cwd string
	// Empty is whether Cwd has no entries besides `.git`.
	Empty bool
	// Entries counts the entries of Cwd besides `.git`.
	Entries int
	// ServiceDir is whether Cwd holds a kind-less lok8s.yaml (a service
	// directory).
	ServiceDir bool
	// Git is the git state; Project the project state (nil = no project
	// above Cwd).
	Git     Git
	Project *Project
	// Terminal is set by the caller (DetectTerminal); Detect leaves it
	// zero.
	Terminal Terminal
}

type StepError struct {
	Command string
	Err     error
	NotRun  []string
}

type Terminal struct {
	// StdinTTY and StdoutTTY report whether the two streams are terminals.
	StdinTTY, StdoutTTY bool
	// CI is whether the CI environment variable is set (any value).
	CI bool
	// Yes is the --yes flag.
	Yes bool
}

type TestsInput struct {
	Path      string
	PathGiven bool
}