worktree

type AttachOptions struct {
	Branch string // Any branch in the stack (we find the stack root)
	Name   string // Optional worktree name (defaults to stack root name)
}

type BranchWorktrees struct{ Deps Deps }

type ChildRestoreMode int

type CreateOptions struct {
	Name  string // User-provided name for the worktree
	Scope string // Optional scope to set on the anchor branch
	// Config is the main repository's resolved configuration. Worktrees are
	// always created from the main repository, so when the command runs inside
	// a managed worktree the caller resolves the main repository's config.
	// Nil falls back to Deps.Config.
	Config RepoConfig
}

type Deps struct {
	// Engine is the full engine. Worktree lifecycle spans registrations, branch
	// creation and deletion, metadata, reparenting, and physical checkouts, and
	// CreateAction swaps in a freshly built main-repository engine of the same
	// type, so a narrow interface would restate most of engine.Engine.
	Engine engine.Engine
	Out    output.Output
	// Log is handed to the git runner of the main-repository engine CreateAction
	// builds when invoked from inside a managed worktree.
	Log      output.Logger
	RepoRoot string
	// Here is where the command runs: the main repository or a managed worktree.
	Here actions.Here
	// Config is the repository configuration already loaded at bootstrap. Nil
	// means none was loaded. Lifecycle actions read resolved values from it and
	// post-create hooks use it as their approval store.
	Config config.Configurer
	// Prompts asks the user to approve unseen post-worktree-create hooks.
	Prompts handler.Prompter
}

type DetachOptions struct {
	Selector WorktreeSelector // Worktree name or anchor branch
	Policy   RemovalPolicy    // Whether detach may discard uncommitted changes
}

type Entry struct {
	Name          engine.WorktreeName `json:"name"`          // User-provided name
	AnchorBranch  string              `json:"anchor_branch"` // Registered anchor branch name
	Path          WorktreePath        `json:"path"`
	StackSize     int                 `json:"stack_size"`               // Number of real branches in the stack
	CurrentBranch string              `json:"current_branch,omitempty"` // Branch currently checked out in this worktree
	RootBranches  []string            `json:"root_branches,omitempty"`  // Real stack roots visible to the user
	Lifecycle     WorktreeLifecycle   `json:"lifecycle"`
	StatusMessage string              `json:"status_message,omitempty"` // Human-readable summary of current state
	// contains filtered or unexported fields
}

type LifecycleCapability string

type ListOptions struct {
	Selector WorktreeSelector
}

type ListResult struct {
	Worktrees     []Entry
	CurrentAnchor string // Anchor branch of the worktree we're currently in (if any)
	// OwnershipWarnings report branches whose physical checkout location does
	// not agree with Stackit's derived ownership model. They are warnings so
	// `worktree list` remains useful for diagnosing a damaged repository.
	OwnershipWarnings []string `json:"ownership_warnings,omitempty"`
}

type OpenOptions struct {
	Selector WorktreeSelector // Worktree name or anchor branch
}

type OwnershipWarningsEngine interface {
	ListWorktrees(ctx context.Context) (git.WorktreeList, error)
	OwningWorktree(ctx context.Context, branch engine.Branch) (*engine.WorktreeInfo, error)
	GetBranch(name string) engine.Branch
}

type PruneOptions struct {
	DryRun bool // If true, only show what would be pruned
}

type PruneResult struct {
	Pruned  []string       // Names of pruned worktrees
	Skipped []SkippedEntry // Worktrees that were skipped and why
}

type RegistrationState string

type RemovalPolicy = worktreeutil.RemovalPolicy

type RemoveOptions struct {
	Selector WorktreeSelector // Worktree name or anchor branch
	Policy   RemovalPolicy    // Whether removal may discard uncommitted changes
}

type RepairEntry struct {
	Name         string `json:"name"`
	Action       string `json:"action"`
	AnchorBranch string `json:"anchor_branch,omitempty"`
}

type RepairOptions struct {
	Selector WorktreeSelector
	// Config is the main repository's resolved configuration, used to name
	// anchors for legacy registrations. Nil falls back to Deps.Config.
	Config RepoConfig
}

type RepairResult struct {
	Repaired []RepairEntry  `json:"repaired"`
	Skipped  []SkippedEntry `json:"skipped,omitempty"`
}

type RepoConfig interface {
	Trunk() string
	UndoStackDepth() int
	LinearStacks() bool
	WorktreeBasePath() string
	BranchNamePattern() string
}

type SkippedEntry struct {
	Name   string
	Reason string
}

type WarmStartResult struct {
	Enabled         bool
	Copied          []string
	SkippedExisting []string
	// SkippedUnsafe lists files that could not be placed because something on
	// their path is not a plain directory — most often a tracked file on trunk
	// occupying a name the include file also selects as a directory.
	SkippedUnsafe []WarmStartSkip
}

type WarmStartSkip struct {
	Path   string
	Reason string
}

type WorktreeChanges string

type WorktreeCheckout string

type WorktreeLifecycle struct {
	Registration RegistrationState   `json:"registration_state"`
	Presence     WorktreePresence    `json:"presence"`
	Checkout     WorktreeCheckout    `json:"checkout"`
	Changes      WorktreeChanges     `json:"changes"`
	Remove       LifecycleCapability `json:"remove"`
	Detach       LifecycleCapability `json:"detach"`
}

type WorktreePath = engine.WorktreePath

type WorktreePresence string

type WorktreeResult struct {
	Name         string       // The name of the worktree
	AnchorBranch string       // The name of the anchor branch
	Path         WorktreePath // The path to the worktree
}

type WorktreeSelector string