fleetsync

type RemovalReceipt struct {
	SchemaVersion int        `json:"schema_version"`
	Phase         string     `json:"phase"`
	Repository    string     `json:"repository"`
	ClonePath     string     `json:"clone_path"`
	HeadSHA       string     `json:"head_sha"`
	Reason        string     `json:"reason"`
	CreatedAt     time.Time  `json:"created_at"`
	RemovedAt     *time.Time `json:"removed_at,omitempty"`
	Error         string     `json:"error,omitempty"`
}

type Result struct {
	Repo   discover.Repo
	Status Status
	// PullPlanned is true only for a dry-run existing clone. PullAttempted and
	// PullSucceeded describe the real action independently of Status, which may
	// still end as Unpushed after a successful pull. Updated is a successful
	// pull whose checked-out commit moved forward.
	PullPlanned   bool
	PullAttempted bool
	PullSucceeded bool
	Updated       bool
	// BeforeHeadSHA is populated for an existing checkout when its pre-pull
	// HEAD was readable. Together with HeadSHA it is the exact lifecycle-hook
	// boundary; an unchanged pair never emits checkout-updated.
	BeforeHeadSHA string
	Detail        gitops.RepoStatus
	// Tracking is filled in only for Diverged and NoUpstream, whose reports
	// are meaningless without the branch names and ahead/behind counts.
	Tracking gitops.TrackingState
	Err      error

	// Archived mirrors repo.Archived, for callers that render results without
	// keeping the original discover.Repo alongside them.
	Archived bool
	// ArchivedNotPruned is true when Archived is true but the caller did not
	// request pruning (Sync's pruneArchived parameter was false): this
	// repository was pulled or left alone exactly like any other clone,
	// never evaluated for deletion. It exists so an archived repository is
	// never silently indistinguishable from an ordinary one in a report —
	// the whole point of making pruning opt-in is defeated if turning it off
	// also makes archived repositories invisible.
	ArchivedNotPruned bool
	// Reason explains, in prose, exactly why an archived repository was or
	// was not eligible for removal when pruning was requested. It is the
	// verbatim explanation from internal/archiveprune.Evaluate — the same
	// safety predicate wb archive clean uses — never a re-derived summary.
	Reason string
	// HeadSHA is the clone's HEAD when Sync finished with it, empty when
	// there was no clone to read (never cloned, or just removed). A report is
	// read and acted on later — sometimes hours later, by an agent that
	// cannot see the fleet — and a remedy like "reset the clone to its
	// upstream" is unrecoverable if the clone has moved since. Recording the
	// commit the finding was made against lets a reader prove the state it
	// describes still holds before mutating anything.
	HeadSHA string
	// ReceiptPath is where the deletion receipt for this clone was written,
	// set only when --prune-archived actually removed (or tried to remove)
	// it. A removal with no path here is a removal with no evidence, which
	// this package refuses to perform.
	ReceiptPath          string
	RepositoryRelocation *worktrees.RepositoryRelocateResult
}

type RunMeta struct {
	StartedAt    time.Time
	ProjectsRoot string
	Scanned      int
	DryRun       bool
	// PruneArchived records whether --prune-archived was passed. Without it
	// the ArchivedNotPruned entries cannot be explained.
	PruneArchived bool
	// RunErr is set when the run failed before scanning anything — a GitHub
	// authentication or discovery failure. Results is empty in that case, and
	// the failure is itself the issue worth reporting.
	RunErr error

	// Owners and Filter record how the run was scoped. Without them the
	// report cannot distinguish "the fleet is clean" from "the two
	// repositories I looked at are clean" — and because every run overwrites
	// the same file, a scoped run would otherwise silently replace a
	// fleet-wide finding set with a false all-clear.
	Owners []string
	Filter string
	// Discovered is how many repositories the run selected; Scanned is how
	// many it finished. Fewer scanned than discovered means the run did not
	// complete, which no report may describe as health.
	Discovered int
}

type Status int

type SummaryGroup struct {
	Label   string
	Section SummarySection
	Results []Result
}

type SummarySection string