actions

type BranchDeletionPlan struct {
	// BranchesToDelete maps branch name to deletion reason
	BranchesToDelete map[string]string
	// BranchesWithNewParents lists branches that will be reparented
	BranchesWithNewParents []string
	// SkippedInWorktree lists branches skipped due to being in a worktree
	SkippedInWorktree []string
	// UtilityBranches tracks which branches in BranchesToDelete are utility branches
	// (e.g., consolidated merge branches). These can be auto-confirmed for deletion
	// when their associated PR is closed/merged.
	UtilityBranches map[string]bool
	// UnpushedBranches tracks which branches in BranchesToDelete have unpushed local changes
	// (local branch is ahead of or diverged from remote)
	UnpushedBranches map[string]bool
	// contains filtered or unexported fields
}

type BranchDiffStats struct {
	FilesChanged int
	Additions    int
	Deletions    int
}

type BranchInfoPR struct {
	Number  *git.PRNumber
	Title   string
	State   git.PRState
	IsDraft bool
	URL     string
	Body    string
}

type BranchInfoQueryOptions struct {
	BranchName string
	Diff       bool
	Patch      bool
	Stat       bool
}

type BranchInfoResult struct {
	Name         string
	IsCurrent    bool
	IsTrunk      bool
	IsLocked     bool
	IsFrozen     bool
	NeedsRestack bool
	Scope        string
	CommitDate   string
	Parent       string
	Children     []string
	// Trunk is the repository's trunk branch name, so renderers can style a
	// trunk parent or child without re-resolving it from the engine.
	Trunk            string
	PR               *BranchInfoPR
	CommitMessages   []string
	DiffStats        BranchDiffStats
	StackTitle       string
	StackDescription string
	PatchOutput      string
	DiffOutput       string
}

type CleanBranchesDeps struct {
	Engine engine.Engine
	Out    output.Output
	Log    output.Logger
}

type CleanBranchesOptions struct {
	Force             bool
	InManagedWorktree bool   // True if running from a stackit-managed worktree
	CurrentBranch     string // Name of the current branch (used to skip deletion in worktree)
	RemoteStatuses    engine.BranchRemoteStatuses
}

type CleanBranchesResult struct {
	DeletedBranches        map[string]string // name -> reason
	BranchesWithNewParents []string
	SkippedInWorktree      []string // branches that couldn't be deleted from worktree
	SkippedUnpushed        []string // branches skipped due to unpushed local changes
	SkippedCheckedOut      []string // branches checked out in the main working tree, which cannot be removed
}

type ContinueDeps struct {
	Engine   ContinueEngine
	Out      output.Output
	RepoRoot string
	// Restack resumes the branches the interrupted command still had queued.
	Restack restack.Runner
	// Conflicts prints the conflict status when the rebase stops again.
	Conflicts *restack.ConflictReporter
}

type ContinueEngine interface {
	engine.BranchLookup
	IsRebaseInProgress(ctx context.Context) bool
	CurrentBranch(ctx context.Context) *engine.Branch
	Trunk() engine.Branch
	StageAll(ctx context.Context) error
	ContinueRebase(ctx context.Context, spec engine.ContinueRebaseSpec) (engine.ContinueRebaseResult, error)
	CheckoutBranch(ctx context.Context, branch engine.Branch) error
	ListWorktrees(ctx context.Context) (git.WorktreeList, error)
}

type ContinueOptions struct {
	AddAll bool
}

type CurrentBranchReader interface {
	CurrentBranch(ctx context.Context) *engine.Branch
}

type DebugLogger interface {
	Debug(format string, args ...any)
}

type Here struct {
	InManagedWorktree bool
	// Worktree describes the managed worktree when InManagedWorktree is set.
	Worktree *engine.WorktreeInfo
}

type ManagedWorktreeInspector interface {
	WorktreeRebaseInProgress(ctx context.Context, worktreePath engine.WorktreePath) bool
	WorktreeHasUncommittedChanges(ctx context.Context, worktreePath engine.WorktreePath) (bool, error)
}

type ManagedWorktreeSource interface {
	ManagedWorktreeInspector
	ListManagedWorktrees(ctx context.Context) ([]engine.WorktreeInfo, error)
}

type MetadataPushEngine interface {
	BatchSetLastModifiedBy(ctx context.Context, branchNames []string) error
	PrepareRemoteMetadataPush(ctx context.Context) error
	PushMetadataForBranches(ctx context.Context, branchNames []string) error
}

type MutationDeps struct {
	Out       output.Output
	Here      Here
	Snapshots Snapshots
	Restack   restack.Runner
}

type NullRestackHandler struct{}

type OwnershipEngine interface {
	engine.BranchLookup
	WorktreeOwnershipByStackRoot(ctx context.Context) (map[string]engine.WorktreeOwnership, error)
	GetStackRootForBranch(branch engine.Branch) string
}

type PRSync struct {
	Engine PRSyncEngine
	// GitHub returns the client, or nil when GitHub is unavailable. It is a
	// function so the client is only built when a PR is actually touched.
	GitHub   func() github.Client
	GHRunner github.GitCommandRunner
	Nav      pr.NavigationOptions
	Log      DebugLogger
}

type PRSyncEngine interface {
	engine.BranchReader
	MetadataPushEngine
	UpsertPrInfo(ctx context.Context, branch engine.Branch, prInfo *engine.PrInfo) error
	ClearNeedsPRBodyUpdate(ctx context.Context, branchName string) error
	GetNavigationCommentID(branch engine.Branch) (int64, error)
	SetNavigationCommentID(ctx context.Context, branch engine.Branch, commentID int64) error
	ClearNavigationCommentID(ctx context.Context, branch engine.Branch) error
}

type RecoveryEngine interface {
	IsRebaseInProgress(ctx context.Context) bool
	IsMergeInProgress(ctx context.Context) bool
	RebaseAbort(ctx context.Context) error
	MergeAbort(ctx context.Context) error
	RestoreSnapshot(ctx context.Context, snapshotID string) error
	RestoreWorktree(ctx context.Context, snapshotID string) (bool, error)
}

type RestackBranchEvent struct {
	Branch              string
	Result              RestackResult
	NewRevision         string
	PRNumber            *git.PRNumber
	LockReason          engine.LockReason
	Frozen              bool
	HeldBy              string // why a worktree held this branch back (empty if it was not held)
	IsCurrent           bool
	Parent              string
	Reparented          bool
	OldParent           string
	NewParent           string
	RerereResolvedCount int
	StackRoot           string
}

type RestackBranchFunc func(RestackBranchEvent)

type RestackConflictPolicy int

type RestackConflictPrompter interface {
	IsInteractive() bool
	PromptResolveConflicts(conflictBranches []string) (bool, error)
}

type RestackDeps struct {
	Engine    engine.Engine
	Out       output.Output
	Log       output.Logger
	RepoRoot  string
	Snapshots Snapshots
	// Interactive and Quiet mirror the global flags; together with the
	// terminal they decide whether RestackAction may prompt to enable rerere.
	Interactive bool
	Quiet       bool
}

type RestackHandler interface {
	// OnRestackStart is called at the beginning of restack with branch count
	OnRestackStart(branchCount int)

	// OnRestackBranch is called for each branch during restack.
	OnRestackBranch(event RestackBranchEvent)

	// OnRestackComplete is called when restack finishes. blocked lists
	// branches left untouched because their stack contained a conflict.
	OnRestackComplete(summary RestackSummary)
}

type RestackOptions struct {
	BranchName         string
	Scope              engine.StackRange
	AllStacks          bool
	StackRoots         []string
	ContinueOnConflict bool
	Parallel           bool // Run independent stack groups in parallel worktrees
	Jobs               int  // Number of parallel workers (0 = NumCPU)
	// NonInteractive suppresses every prompt and reports conflicts instead of
	// entering the conflict workflow. Set it for machine-readable output: the
	// workflow prints human guidance and leaves the repository mid-rebase.
	NonInteractive bool
}

type RestackOutcome struct {
	Summary RestackSummary
	// EnteredConflictWorkflow is true when the user chose to resolve a
	// conflict and the run handed off to the conflict workflow. The handler's
	// OnRestackComplete is not called in that case: the restack is unfinished.
	EnteredConflictWorkflow bool
}

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

type RestackRequest struct {
	// Branches is restacked as a single group, in topological order.
	Branches engine.Branches

	ConflictPolicy RestackConflictPolicy
	// Prompter is consulted under RestackConflictPrompt. A nil or
	// non-interactive prompter reports conflicts instead.
	Prompter RestackConflictPrompter

	// PromptRerere allows asking the user before enabling git rerere.
	PromptRerere bool
	// Pauser releases the terminal around the rerere prompt. nil uses the
	// handler when it implements rerere.Pauser.
	Pauser rerere.Pauser

	// Parallel runs independent groups in separate worktrees. It only applies
	// when there is more than one group, and always reports conflicts.
	Parallel bool
	Jobs     int // parallel workers; 0 means NumCPU

	// PRNumber overrides the PR lookup for event enrichment. nil reads the
	// branch's local metadata.
	PRNumber func(branch string) *git.PRNumber
	// contains filtered or unexported fields
}

type RestackResult string

type RestackSummary struct {
	Restacked int
	Conflicts []string // branches skipped because they conflicted
	Blocked   []string
}

type RestackWorktreeHold struct {
	Scope        RestackWorktreeHoldScope
	Branch       string
	StackRoot    string
	WorktreePath engine.WorktreePath
	Reason       string
}

type RestackWorktreeHoldReport struct {
	Holds    []RestackWorktreeHold
	Warnings []string
}

type RestackWorktreeHoldScope string

type ReviewStatus string

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

type SnapshotEngine interface {
	TakeSnapshot(ctx context.Context, opts engine.SnapshotOptions) error
	ClearLastSnapshotID()
}

type SnapshotOption func(*engine.SnapshotOptions)

type Snapshots struct {
	Engine SnapshotEngine
	// Enabled reflects undo.enabled.
	Enabled bool
	Log     DebugLogger
}

type StackInfoBranch struct {
	Name           string
	Parent         string
	IsLocked       bool
	IsFrozen       bool
	Scope          string
	PRNumber       *git.PRNumber
	PRURL          string
	CommitMessages []string
	DiffStats      BranchDiffStats
}

type StackInfoResult struct {
	StackTitle       string
	StackDescription string
	Current          string
	Trunk            string
	Branches         []StackInfoBranch // non-trunk branches, in stack order
	Order            []string          // every branch name (incl trunk), in stack order
	Parents          map[string]string // branch -> parent (incl trunk)
	UpToDate         map[string]bool   // branch -> up to date with parent (incl trunk)
}

type TopologyEngine interface {
	Graph(ctx context.Context, strategy engine.SortStrategy) *engine.StackGraph
	AllBranches() engine.Branches
	IsTrunk(branch engine.Branch) bool
}

type TreeBranchInfo struct {
	Name      string `json:"name"`
	Parent    string `json:"parent,omitempty"`
	IsCurrent bool   `json:"is_current"`
	IsTrunk   bool   `json:"is_trunk"`
	// Status booleans are always emitted (no omitempty) so consumers can rely on
	// `tree --json` as a complete, self-describing status source: an explicit
	// false is unambiguous, whereas an omitted field is indistinguishable from
	// "this field isn't reported". This is what lets agents read PR/CI status and
	// needs_restack/locked/frozen from a single command instead of also querying
	// `info --stack --json`.
	IsLocked     bool        `json:"is_locked"`
	IsFrozen     bool        `json:"is_frozen"`
	NeedsRestack bool        `json:"needs_restack"`
	Commits      *int        `json:"commits,omitempty"`
	Additions    int         `json:"additions,omitempty"`
	Deletions    int         `json:"deletions,omitempty"`
	PR           *TreePRInfo `json:"pr,omitempty"`
	Scope        string      `json:"scope,omitempty"`
	Children     []string    `json:"children,omitempty"`
}

type TreeJSONRequest struct {
	Style TreeStyle
	// Branches, when non-nil, bounds the result to exactly these branches.
	// Adapters resolve it with the text renderer's visibility rules (--stack
	// scope, --steps depth, anchor flattening) so JSON matches the text view
	// and enrichment only runs for branches the view would draw. Nil reports
	// every tracked branch.
	Branches engine.Branches
}

type TreeJSONResult struct {
	Branches        []TreeBranchInfo `json:"branches"`
	Summary         TreeSummary      `json:"summary"`
	GitHubAvailable *bool            `json:"github_available,omitempty"`
}

type TreeOptions struct {
	Style         TreeStyle
	Steps         *int
	BranchName    string
	ShowUntracked bool
	Interactive   bool
	ShowSHAs      bool // Show commit SHAs next to branch names
	JSON          bool // Output in JSON format
}

type TreePRInfo struct {
	Number       git.PRNumber `json:"number"`
	URL          string       `json:"url,omitempty"`
	Title        string       `json:"title,omitempty"`
	State        git.PRState  `json:"state"`
	IsDraft      bool         `json:"is_draft,omitempty"`
	ReviewStatus ReviewStatus `json:"review_status,omitempty"`
	CIStatus     string       `json:"ci_status,omitempty"`
}

type TreeStyle string

type TreeSummary struct {
	TotalBranches int  `json:"total_branches"`
	ApprovedCount *int `json:"approved_count,omitempty"`
	InReviewCount *int `json:"in_review_count,omitempty"`
}

type Warner interface {
	Warn(format string, args ...any)
}

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