restack

type ApplyEngine interface {
	engine.BranchLookup
	Trunk() engine.Branch
	Graph(ctx context.Context, strategy engine.SortStrategy) *engine.StackGraph
	CurrentBranch(ctx context.Context) *engine.Branch
	GetCurrentRevision(ctx context.Context) (string, error)
	RestackBranches(ctx context.Context, branches engine.Branches, opts engine.RestackOpts) (engine.RestackBatchResult, error)
	IsRebaseInProgress(ctx context.Context) bool
	RebaseAbort(ctx context.Context) error
	CheckoutBranch(ctx context.Context, branch engine.Branch) error
	Detach(ctx context.Context, revision string) error
	LastSnapshotID() string
	ListWorktrees(ctx context.Context) (git.WorktreeList, error)
	WorktreeRebaseInProgress(ctx context.Context, worktreePath engine.WorktreePath) bool
	WorktreeHasUncommittedChanges(ctx context.Context, worktreePath engine.WorktreePath) (bool, error)
}

type ConflictMode int

type ConflictReporter struct {
	Engine   RebaseStateReader
	Out      Printer
	RepoRoot string
}

type ContinuationFile string

type ContinuationStore interface {
	Save(state *config.ContinuationState) error
}

type Executor struct {
	Engine ApplyEngine
	Log    Logger
	// Report receives each branch's outcome. Use TextReporter for plain output.
	Report ProgressFunc
	// Continuations and Conflicts are used only when a plan enters the
	// conflict workflow.
	Continuations ContinuationStore
	Conflicts     *ConflictReporter
}

type Logger interface {
	Debug(msg string, args ...any)
	Info(msg string, args ...any)
	Warn(msg string, args ...any)
}

type Plan struct {
	// Branches is the requested set, in topological order.
	Branches engine.Branches
	// Engine is the engine's per-branch plan.
	Engine *engine.RestackPlan
	// Validation is the result of trial-rebasing Engine.Specs.
	Validation *engine.RebaseValidation

	// Apply holds the branches proven safe to apply, in order.
	Apply engine.Branches
	// Conflicts holds branches whose trial rebase conflicted.
	Conflicts []string
	// Blocked holds branches that were not tried because an ancestor failed.
	Blocked []string
}

type PlanEngine interface {
	BatchRevisions(ctx context.Context, branches engine.Branches) engine.RevisionMap
	GetMergeBase(ctx context.Context, rev1, rev2 string) (string, error)
	PlanRestack(ctx context.Context, branches engine.Branches) (*engine.RestackPlan, error)
	ValidateRebases(ctx context.Context, specs []engine.RebaseSpec) (*engine.RebaseValidation, error)
}

type Planner struct {
	Engine PlanEngine
	Log    Logger
}

type Printer interface {
	Info(format string, args ...any)
	Warn(format string, args ...any)
	Newline()
}

type Progress struct {
	Branch              string               // the branch being processed
	Result              engine.RestackResult // Done, Unneeded, Conflict, or Blocked
	NewRev              string               // new revision if restacked (empty otherwise)
	RerereResolvedCount int                  // number of rebase continuations handled by git rerere
	Conflict            bool                 // true if this is a conflict
	LockReason          engine.LockReason    // why the branch is locked (empty if not locked)
	Frozen              bool                 // true if the branch is frozen
	HeldBy              string               // why a worktree held this branch back (empty if it was not held)
	IsCurrent           bool                 // true if this is the current branch
	Reparented          bool                 // true if the branch was reparented
	OldParent           string               // the old parent name if reparented
	NewParent           string               // the new parent name if reparented
	StackRoot           string               // independent stack root (set by multi-stack callers; empty for single-stack)
	// contains filtered or unexported fields
}

type ProgressFunc func(Progress)

type RebaseStateReader interface {
	engine.BranchLookup
	GetUnmergedFiles(ctx context.Context) ([]string, error)
	GetRebaseHead(ctx context.Context) (string, error)
}

type Runner struct {
	Planner  Planner
	Executor Executor
}

type WorktreeInspector interface {
	ListWorktrees(ctx context.Context) (git.WorktreeList, error)
	WorktreeRebaseInProgress(ctx context.Context, worktreePath engine.WorktreePath) bool
	WorktreeHasUncommittedChanges(ctx context.Context, worktreePath engine.WorktreePath) (bool, error)
}