Enum StackModel 

pub enum StackModel {
    None,
    Graphite,
    GhStack,
    Mixed {
        primary: StackProvider,
    },
    Git,
}

Which stacked-diff tool is managing stacks in this repository.

Variants

None

No stack tool; today’s branch-flat behavior.

Graphite

Graphite (gt) manages stacks via refs/branch-metadata/*.

GhStack

gh stack (the github/gh-stack extension) manages stacks via a JSON file. See stack/gh_stack.rs’s module docs for the shared-catalog model.

Mixed

Both Graphite and gh-stack have ref-backed tracked branches in this repository. primary is consulted first by current_stack, enumerate_stacks, and crate::assemble_changesets; the other provider answers only when primary has no row for the branch in question. Only reachable via "auto" (or unset) config — an explicit workon.stackModel = graphite/gh-stack stays strict, never falling back to the other provider even when it also has live branches. See StackModel::detect.

Fields

primary: StackProvider

Git

No stack-metadata tool; changesets are inferred purely from git, one per commit in upstream..HEAD. Unlike StackModel::Graphite/StackModel::GhStack, this carries no branch-level stack topology: enumerate_stacks and current_stack treat it as flat (same as StackModel::None), since there is no metadata to enumerate stacks from or to group branches into. Only crate::assemble_changesets (M1 changeset assembly) gives this variant meaning, walking upstream..HEAD per-commit.

Not reachable via StackModel::detect — see the module docs’ Default-on-behavior note on why auto-detection never resolves to Git.

Implementations

impl StackModel

pub fn detect(repo: &Repository) -> Self

Auto-detect the active stack model from the repository environment.

Returns StackModel::Graphite when the repo has been initialized with gt init (.graphite_repo_config or .graphite_metadata.db exists). Otherwise returns StackModel::None.

Deliberately does NOT consult [graphite::detect_gt]: the repo’s own metadata is the ground truth for “is this a Graphite stack,” and reading it is pure libgit2 (see the module docs — no gt process is needed for detection or visualization). Gating on the binary’s presence would report None for a genuine Graphite stack whenever gt happens to be missing from PATH, silently emptying the review TUI’s stack. Whether gt can be executed is a separate question, and belongs to the call sites that execute it.

Never returns StackModel::Git: auto-detection only distinguishes “a stack tool is active” from “no stack tool,” since CLI routing treats any non-None model as stack-active. Auto-resolving to Git for every repository with an upstream-tracking branch would silently flip that routing for nearly every user. Git is reachable via explicit workon.stackModel = git config, or a caller mapping None to Git before calling crate::assemble_changesets (the review crate does this from M3 onward).

When both tools’ artifacts are present, detection tie-breaks on live metadata — whether each provider has at least one ref-backed tracked branch (see [graphite::has_live_branches]/[gh_stack::has_live_branches]) — rather than always preferring one provider:

• Both live → StackModel::Mixed with gh-stack as primary: GitHub’s native stack support is the more deliberate signal now that it exists, so it answers first, but neither provider’s tracked branches are hidden.
• Only one live → that provider, strict (not Mixed): the other’s artifacts are stale (e.g. a lingering .graphite_repo_config from a repo that migrated to gh-stack), so there is nothing to fall back to.
• Neither live → GhStack: an ambiguous, doubly-stale state that doctor’s BothStackToolsDetected check explains rather than detection resolving further.

A single artifact present (no ambiguity) skips the liveness read entirely and returns that provider, matching today’s behavior. The escape hatch out of Mixed — or out of a tie-break you disagree with — is an explicit workon.stackModel = graphite/gh-stack, which is strict and never reachable via "auto".

pub fn providers(self) -> impl Iterator<Item = StackProvider>

Providers to consult, in fallback order. Graphite/GhStack consult only themselves (strict, no fallback); Mixed consults primary first, then the other; None/Git have no provider to consult.

Trait Implementations

impl Clone for StackModel

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for StackModel

impl Debug for StackModel

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for StackModel

impl PartialEq for StackModel

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for StackModel