merge

type BranchMergeInfo struct {
	BranchName    string
	PRNumber      git.PRNumber
	PRURL         string
	IsDraft       bool
	ChecksStatus  ChecksStatus
	MatchesRemote bool
}

type CIConfig interface {
	CICommand() string
	CITimeout() int
}

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

type CIWaiterClient interface {
	github.ChecksReader
	github.PRMerger
}

type CIWaiterOptions struct {
	Client            CIWaiterClient
	Output            output.Output
	Timeout           time.Duration // Default: 10 minutes
	PollInterval      time.Duration // Default: 15 seconds
	RegistrationDelay time.Duration // Default: CIRegistrationDelay
}

type ChecksStatus string

type CollectedBranches struct {
	BranchesToMerge MergeBranches
	UpstackBranches []string
	CurrentBranch   string
	Validation      *PlanValidation
}

type Config interface {
	MergeMethodConfig
	CIConfig
}

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

type ConsolidationResult struct {
	BranchName string
	PRNumber   git.PRNumber
	PRURL      string
}

type CreatePlanOptions struct {
	Strategy     Strategy
	Force        bool
	Scope        string
	TargetBranch string // Optional branch to merge from (instead of current)
	Wait         bool   // Whether to wait for CI/merge (applies to consolidate strategy)
}

type Deps struct {
	// Engine is the full engine: merge plans, executes and cleans up across
	// the whole stack graph — locking, PR info, restacks, worktrees, pushes —
	// and hands the engine to the multi-stack worktree executor and stack
	// discovery, which take engine.Engine too. A merge in a temporary
	// worktree swaps in an engine rooted there.
	Engine engine.Engine
	Out    output.Output
	// GitHub returns the client, or nil when GitHub is unavailable. It is a
	// function so the client is only built when merge actually needs it.
	GitHub func() github.Client
	// GitHubError explains why GitHub returned nil, when known. May be nil.
	GitHubError func() error
	// GHRunner runs the GraphQL queries merge and automerge go through.
	GHRunner github.GitCommandRunner
	// PRSync pushes metadata and refreshes the PRs of locked or closed
	// branches.
	PRSync  actions.PRSync
	Prompts handler.Prompter
	// RepoRoot is where restack continuation state is persisted.
	RepoRoot string
	Config   Config

	// Sync is what the post-merge sync runs with.
	Sync sync.Deps
	// Submit is what drain publishes restacked branches with.
	Submit submit.Deps
	// Checkout is what the post-merge trunk checkout runs with.
	Checkout checkout.Deps
}

type DrainBranchPushedEvent struct {
	BranchName string
	URL        string
	Failed     bool
	Err        error
}

type DrainOptions struct {
	// Plan is the bottom-up plan the caller showed and confirmed. Its
	// BranchesToMerge are locked for the duration of the drain.
	Plan *Plan
	// TargetBranch and Scope select the stack to re-plan on each iteration.
	TargetBranch string
	Scope        string
	Force        bool
	// Limit caps the number of PRs to merge (0 = all).
	Limit int
	// MergeMethod is the resolved merge method used for every PR.
	MergeMethod github.MergeMethod
}

type DrainPRStartedEvent struct {
	BranchName string
	PRNumber   git.PRNumber
	Position   int
	Total      int
}

type DrainResult struct {
	Merged int
}

type DrainStoppedEvent struct {
	Merged int
	Reason error
}

type DrainSyncingEvent struct {
	PRNumber git.PRNumber
}

type Event struct {
	Phase     Phase
	Type      EventType
	StepIndex int
	Step      *PlanStep
	Message   string
	Error     error

	// Waiting-specific fields
	Elapsed time.Duration
	Timeout time.Duration
	Checks  []github.CheckDetail

	// Estimate fields
	EstimatedDuration time.Duration
}

type EventHandler interface {
	// Start is called when the merge plan is ready to execute.
	// The plan contains all steps that will be executed.
	Start(plan *Plan)

	// EmitEvent sends a progress event to the handler.
	// Called for each step transition (started, completed, failed, waiting).
	// May be called concurrently from multiple goroutines.
	EmitEvent(event Event)

	// Complete is called when the merge operation is finished.
	// Result contains success status and any consolidation result.
	Complete(result *Result)

	// Cleanup ensures terminal state is restored.
	// Should be called via defer after creating the handler.
	// No-op for non-TTY handlers.
	Cleanup()
}

type EventType string

type ExcludeReason string

type ExecuteOptions struct {
	Plan                    *Plan
	Strategy                Strategy
	Force                   bool
	Wait                    bool                       // Whether to wait for CI/merge (applies to consolidate)
	Handler                 EventHandler               // Optional progress handler
	UndoStackDepth          int                        // Maximum undo stack depth (from config)
	LinearStacks            bool                       // stack.shape == linear (from config)
	ConsolidationResultFunc func(*ConsolidationResult) // Callback for consolidation results
	MergeMethod             github.MergeMethod         // Optional: override merge method (empty = auto-detect/prompt)
	CIRegistrationDelay     time.Duration              // Optional: override CIRegistrationDelay (0 = default)
}

type InteractiveHandler interface {
	EventHandler

	// IsInteractive returns true if this handler supports interactive prompts.
	// Non-interactive handlers (e.g., SimpleMergeEventHandler) return false,
	// and their prompt methods will return errors.
	// Check this before calling prompt methods to provide better error messages.
	IsInteractive() bool

	// PromptMergeType asks user what to merge (this/scope/stacks).
	// Called at the start of the wizard when no merge target is pre-selected.
	// canMergeThisBranch indicates if "This branch" is a valid option (false on trunk or empty worktree).
	// Returns ErrCanceled if user cancels.
	PromptMergeType(canMergeThisBranch bool, availableScopes []string, availableStacks []MultiStackInfo) (MergeType, error)

	// PromptScope asks user to select a scope from available options.
	// Called when user selects MergeTypeScope.
	// Returns ErrCanceled if user cancels.
	PromptScope(availableScopes []string) (string, error)

	// PromptStacks asks user to select stacks (multi-select with ordering).
	// Returns selected stack root names in priority order.
	// Called when user selects MergeTypeStacks.
	// Returns ErrCanceled if user cancels.
	PromptStacks(availableStacks []MultiStackInfo) ([]string, error)

	// PromptStrategy asks user to select merge strategy.
	// plan provides context (branch count, etc.) for display.
	// recommended is the suggested default based on stack size.
	// Returns ErrCanceled if user cancels.
	PromptStrategy(plan *Plan, recommended Strategy) (StrategyChoice, error)

	// PromptConfirm asks user to confirm an action.
	// Returns ErrCanceled if user cancels.
	PromptConfirm(message string, defaultYes bool) (bool, error)

	// ShowPlan displays the merge plan for review.
	// This is informational - no return value needed.
	// Called before prompting for strategy selection.
	ShowPlan(plan *Plan, validation *PlanValidation)

	// ShowMidStackWarning displays a warning when user is mid-stack in a scope.
	// Called when branches above the current branch share the same scope.
	ShowMidStackWarning(scope string, upstackBranchesInScope []string)

	// PromptPostMerge asks user what to do after merge completes.
	// Called after successful merge execution.
	// Returns ErrCanceled if user cancels (treated as "done").
	PromptPostMerge(hasUncommittedChanges bool, trunkName string) (PostMergeAction, error)

	// PromptSimpleMergeConfirm shows a simplified confirmation for single-branch merges.
	// This provides a cleaner UX than ShowPlan + PromptConfirm for simple cases.
	// Returns true to proceed, false to cancel.
	PromptSimpleMergeConfirm(branch BranchMergeInfo, baseBranch string) (bool, error)
}

type LocalCISearchResult struct {
	WorkingStacks MultiStacks          // Stacks that pass CI together
	FailedStacks  []MultiStackExcluded // Stacks that failed CI
}

type LocalCIValidator struct {
	Command string
	Timeout time.Duration
	// contains filtered or unexported fields
}

type MergeBranches []BranchMergeInfo

type MergeMethodConfig interface {
	MergeMethod() github.MergeMethod
	SetMergeMethod(method github.MergeMethod) error
}

type MergePROptions struct {
	BranchName  string
	PRNumber    git.PRNumber
	MergeMethod github.MergeMethod
	Wait        bool // Block until the PR merges instead of returning after enabling automerge
}

type MergePROutcome int

type MergeType string

type MultiStackExcluded struct {
	Stack  MultiStackInfo
	Reason ExcludeReason
}

type MultiStackInfo = stackview.StackInfo

type MultiStackOptions struct {
	SelectedStacks []string // Stack roots selected by user (skips picker if provided)
	SkipLocalCI    bool     // Skip local CI validation
	Wait           bool     // Wait for CI and auto-merge
}

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

type MultiStackResult struct {
	IncludedStacks MultiStacks          // Stacks that were successfully included
	ExcludedStacks []MultiStackExcluded // Stacks that were excluded with reasons
	PRNumber       git.PRNumber         // Created PR number
	PRURL          string               // Created PR URL
	BranchName     string               // Consolidation branch name
}

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

type MultiStackWorktreeResult struct {
	MergedStacks   MultiStacks          // Stacks that were successfully merged
	ConflictStacks []MultiStackExcluded // Stacks that conflicted
	WorktreePath   engine.WorktreePath  // Path to the worktree
	WorktreeEngine engine.Engine        // Engine for the worktree
	Cleanup        func()               // Function to clean up the worktree
}

type MultiStacks = stackview.Stacks

type NullEventHandler struct{}

type NullProgressHandler struct{}

type Options struct {
	DryRun         bool
	Confirm        bool
	Strategy       Strategy
	Force          bool
	Wait           bool // Whether to wait for CI/merge (applies to consolidate)
	Scope          string
	TargetBranch   string
	Plan           *Plan // Optional pre-calculated plan
	UndoStackDepth int   // Maximum undo stack depth (from config)
	LinearStacks   bool  // stack.shape == linear (from config)
	Handler        EventHandler
	MergeMethod    github.MergeMethod // Optional: override merge method (empty = auto-detect/prompt)
}

type PRAlreadyMergedEvent struct {
	PRNumber git.PRNumber
}

type PRAutomergeEnabledEvent struct {
	PRNumber git.PRNumber
}

type PRCleanStatusRaceEvent struct {
	PRNumber git.PRNumber
}

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

type PRCleanupConfig struct {
	// Source identifies the cleanup source for footer text
	Source PRCleanupSource

	// ConsolidationPRNumber is the PR number of the consolidation PR
	ConsolidationPRNumber git.PRNumber

	// UserName is the username to include in the footer (optional)
	UserName string
}

type PRCleanupResult struct {
	ClosedPRs  []git.PRNumber // PR numbers that were closed
	FailedPRs  []git.PRNumber // PR numbers that failed to close
	SkippedPRs []git.PRNumber // PR numbers that were already closed
}

type PRCleanupSource string

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

type PREnablingAutomergeEvent struct {
	PRNumber git.PRNumber
	Method   github.MergeMethod
}

type PRMergedEvent struct {
	PRNumber git.PRNumber
	External bool
}

type PRMergingDirectlyEvent struct {
	PRNumber     git.PRNumber
	Method       github.MergeMethod
	MergeState   string
	AfterWaiting bool
}

type PRWaitingForMergeEvent struct {
	PRNumber git.PRNumber
}

type PRWaitingForMergeableEvent struct {
	PRNumber git.PRNumber
}

type Phase string

type Plan struct {
	Strategy        Strategy
	CurrentBranch   string
	BranchesToMerge MergeBranches // Branches that will be merged (bottom to top)
	UpstackBranches []string      // Branches above current that will be restacked
	Steps           []PlanStep    // Ordered steps to execute
	Warnings        []string      // Non-blocking warnings
	Infos           []string      // Informational messages
	CreatedAt       time.Time
}

type PlanStep struct {
	StepType     StepType
	BranchName   string
	PRNumber     git.PRNumber
	Description  string        // Human-readable description for display
	WaitTimeout  time.Duration // Timeout for waiting steps (e.g., CI checks)
	ExpectChecks bool          // Whether we expect CI checks to be present
}

type PlanValidation struct {
	Valid    bool
	Errors   []string // Blocking errors
	Warnings []string // Non-blocking warnings
	Infos    []string // Informational messages
}

type PostMergeAction string

type PostMergeActionRequiredError struct {
	Action PostMergeAction
}

type PostMergeCheckoutError struct {
	Err error
}

type PostMergeSyncOptions struct {
	// RestackScope limits the restack to these branches (empty = sync default).
	RestackScope []string
	// OnTrunkCheckedOut, when set, is called after trunk is checked out and
	// before sync runs, so adapters can surface worktree-switch directives in
	// order.
	OnTrunkCheckedOut func(result checkout.Result)
}

type PostMergeSyncResult struct {
	// Summary is the sync summary; ConflictBranches lists restacks that were
	// left unresolved.
	Summary sync.Summary
}

type ProgressEvent interface {
	// contains filtered or unexported methods
}

type ProgressHandler interface {
	OnProgress(event ProgressEvent)
}

type Result struct {
	Success             bool
	ConsolidationResult *ConsolidationResult
	Error               error
}

type StepType string

type Strategy string

type StrategyChoice struct {
	Strategy Strategy
	Wait     bool // Whether to wait for CI (consolidate strategy only)
}

type WaitResult struct {
	Passed      bool
	MaxDuration time.Duration // Maximum duration of any check (for estimating future runs)
}

type WizardOptions struct {
	DryRun       bool     // If true, show plan but don't execute
	Force        bool     // Skip validation checks
	Scope        string   // Pre-selected scope (empty = prompt or use current branch)
	TargetBranch string   // Pre-selected target branch (empty = current branch)
	Strategy     Strategy // Pre-selected strategy (empty = prompt)
	Wait         bool     // Pre-selected wait option (for consolidate)

	// Resolved configuration, supplied by the caller.
	UndoStackDepth int  // Maximum undo stack depth (undo.depth)
	LinearStacks   bool // stack.shape == linear
}