Struct MockGitApi 

pub struct MockGitApi { /* private fields */ }

The Git operations this crate exposes — the interface consumers code against and mock in tests.

Injection safety: reference names and revision expressions are taken as the validated RefName / RevSpec newtypes (directly or inside an options struct), so a flag-like or malformed value is rejected at construction, before it can reach an argv slot. The remaining caller-supplied bare positionals that are not refs/revisions — remote names and URLs — keep an internal reject_flag_like guard: a value that is empty or begins with - is rejected with an Error::Spawn before spawning. Flag-value slots (-m <msg>, --branch <b>), filesystem path arguments (---separated pathspecs, plus worktree paths and clone destinations — typed Path, caller-trusted), and the run/run_raw escape hatches are not guarded. The one context-dependent special value, git’s - “previous branch”, is CheckoutTarget::Previous.

Implementations

impl MockGitApi

pub fn checkpoint(&mut self)

Validate that all current expectations for all methods have been satisfied, and discard them.

pub fn new() -> Self

Create a new mock object with no expectations.

This method will not be generated if the real struct already has a new method. However, it will be generated if the struct implements a trait with a new method. The trait’s new method can still be called like <MockX as TraitY>::new

impl MockGitApi

pub fn expect_run(&mut self) -> &mut Expectation

Create an Expectation for mocking the run method

pub fn expect_run_raw(&mut self) -> &mut Expectation

Create an Expectation for mocking the run_raw method

pub fn expect_version(&mut self) -> &mut Expectation

Create an Expectation for mocking the version method

pub fn expect_capabilities(&mut self) -> &mut Expectation

Create an Expectation for mocking the capabilities method

pub fn expect_status(&mut self) -> &mut Expectation

Create an Expectation for mocking the status method

pub fn expect_status_text(&mut self) -> &mut Expectation

Create an Expectation for mocking the status_text method

pub fn expect_status_tracked(&mut self) -> &mut Expectation

Create an Expectation for mocking the status_tracked method

pub fn expect_branch_status(&mut self) -> &mut Expectation

Create an Expectation for mocking the branch_status method

pub fn expect_conflicted_files(&mut self) -> &mut Expectation

Create an Expectation for mocking the conflicted_files method

pub fn expect_current_branch(&mut self) -> &mut Expectation

Create an Expectation for mocking the current_branch method

pub fn expect_branches(&mut self) -> &mut Expectation

Create an Expectation for mocking the branches method

pub fn expect_log(&mut self) -> &mut Expectation

Create an Expectation for mocking the log method

pub fn expect_log_paths(&mut self) -> &mut Expectation

Create an Expectation for mocking the log_paths method

pub fn expect_rev_parse(&mut self) -> &mut Expectation

Create an Expectation for mocking the rev_parse method

pub fn expect_rev_parse_short(&mut self) -> &mut Expectation

Create an Expectation for mocking the rev_parse_short method

pub fn expect_init(&mut self) -> &mut Expectation

Create an Expectation for mocking the init method

pub fn expect_add(&mut self) -> &mut Expectation

Create an Expectation for mocking the add method

pub fn expect_commit(&mut self) -> &mut Expectation

Create an Expectation for mocking the commit method

pub fn expect_create_branch(&mut self) -> &mut Expectation

Create an Expectation for mocking the create_branch method

pub fn expect_checkout(&mut self) -> &mut Expectation

Create an Expectation for mocking the checkout method

pub fn expect_checkout_detach(&mut self) -> &mut Expectation

Create an Expectation for mocking the checkout_detach method

pub fn expect_commit_paths(&mut self) -> &mut Expectation

Create an Expectation for mocking the commit_paths method

pub fn expect_last_commit_message(&mut self) -> &mut Expectation

Create an Expectation for mocking the last_commit_message method

pub fn expect_is_unborn(&mut self) -> &mut Expectation

Create an Expectation for mocking the is_unborn method

pub fn expect_diff_is_empty(&mut self) -> &mut Expectation

Create an Expectation for mocking the diff_is_empty method

pub fn expect_common_dir(&mut self) -> &mut Expectation

Create an Expectation for mocking the common_dir method

pub fn expect_git_dir(&mut self) -> &mut Expectation

Create an Expectation for mocking the git_dir method

pub fn expect_resolve_commit(&mut self) -> &mut Expectation

Create an Expectation for mocking the resolve_commit method

pub fn expect_remote_head_branch(&mut self) -> &mut Expectation

Create an Expectation for mocking the remote_head_branch method

pub fn expect_branch_exists(&mut self) -> &mut Expectation

Create an Expectation for mocking the branch_exists method

pub fn expect_remote_branch_exists(&mut self) -> &mut Expectation

Create an Expectation for mocking the remote_branch_exists method

pub fn expect_remote_url(&mut self) -> &mut Expectation

Create an Expectation for mocking the remote_url method

pub fn expect_upstream(&mut self) -> &mut Expectation

Create an Expectation for mocking the upstream method

pub fn expect_remote_branches(&mut self) -> &mut Expectation

Create an Expectation for mocking the remote_branches method

pub fn expect_is_merged(&mut self) -> &mut Expectation

Create an Expectation for mocking the is_merged method

pub fn expect_set_upstream(&mut self) -> &mut Expectation

Create an Expectation for mocking the set_upstream method

pub fn expect_delete_branch(&mut self) -> &mut Expectation

Create an Expectation for mocking the delete_branch method

pub fn expect_rename_branch(&mut self) -> &mut Expectation

Create an Expectation for mocking the rename_branch method

pub fn expect_rev_list_count(&mut self) -> &mut Expectation

Create an Expectation for mocking the rev_list_count method

pub fn expect_diff_range_is_empty(&mut self) -> &mut Expectation

Create an Expectation for mocking the diff_range_is_empty method

pub fn expect_diff_stat(&mut self) -> &mut Expectation

Create an Expectation for mocking the diff_stat method

pub fn expect_diff_text(&mut self) -> &mut Expectation

Create an Expectation for mocking the diff_text method

pub fn expect_diff(&mut self) -> &mut Expectation

Create an Expectation for mocking the diff method

pub fn expect_staged_is_empty(&mut self) -> &mut Expectation

Create an Expectation for mocking the staged_is_empty method

pub fn expect_is_rebase_in_progress(&mut self) -> &mut Expectation

Create an Expectation for mocking the is_rebase_in_progress method

pub fn expect_is_merge_in_progress(&mut self) -> &mut Expectation

Create an Expectation for mocking the is_merge_in_progress method

pub fn expect_is_am_in_progress(&mut self) -> &mut Expectation

Create an Expectation for mocking the is_am_in_progress method

pub fn expect_is_cherry_pick_in_progress(&mut self) -> &mut Expectation

Create an Expectation for mocking the is_cherry_pick_in_progress method

pub fn expect_is_revert_in_progress(&mut self) -> &mut Expectation

Create an Expectation for mocking the is_revert_in_progress method

pub fn expect_is_bisect_in_progress(&mut self) -> &mut Expectation

Create an Expectation for mocking the is_bisect_in_progress method

pub fn expect_fetch(&mut self) -> &mut Expectation

Create an Expectation for mocking the fetch method

pub fn expect_fetch_from(&mut self) -> &mut Expectation

Create an Expectation for mocking the fetch_from method

pub fn expect_fetch_branch(&mut self) -> &mut Expectation

Create an Expectation for mocking the fetch_branch method

pub fn expect_push(&mut self) -> &mut Expectation

Create an Expectation for mocking the push method

pub fn expect_merge_squash(&mut self) -> &mut Expectation

Create an Expectation for mocking the merge_squash method

pub fn expect_merge_commit(&mut self) -> &mut Expectation

Create an Expectation for mocking the merge_commit method

pub fn expect_merge_no_commit(&mut self) -> &mut Expectation

Create an Expectation for mocking the merge_no_commit method

pub fn expect_merge_abort(&mut self) -> &mut Expectation

Create an Expectation for mocking the merge_abort method

pub fn expect_merge_continue(&mut self) -> &mut Expectation

Create an Expectation for mocking the merge_continue method

pub fn expect_reset_merge(&mut self) -> &mut Expectation

Create an Expectation for mocking the reset_merge method

pub fn expect_reset_hard(&mut self) -> &mut Expectation

Create an Expectation for mocking the reset_hard method

pub fn expect_rebase(&mut self) -> &mut Expectation

Create an Expectation for mocking the rebase method

pub fn expect_rebase_abort(&mut self) -> &mut Expectation

Create an Expectation for mocking the rebase_abort method

pub fn expect_am_abort(&mut self) -> &mut Expectation

Create an Expectation for mocking the am_abort method

pub fn expect_am_continue(&mut self) -> &mut Expectation

Create an Expectation for mocking the am_continue method

pub fn expect_rebase_continue(&mut self) -> &mut Expectation

Create an Expectation for mocking the rebase_continue method

pub fn expect_stash_push(&mut self) -> &mut Expectation

Create an Expectation for mocking the stash_push method

pub fn expect_stash_pop(&mut self) -> &mut Expectation

Create an Expectation for mocking the stash_pop method

pub fn expect_worktree_list(&mut self) -> &mut Expectation

Create an Expectation for mocking the worktree_list method

pub fn expect_worktree_add(&mut self) -> &mut Expectation

Create an Expectation for mocking the worktree_add method

pub fn expect_worktree_remove(&mut self) -> &mut Expectation

Create an Expectation for mocking the worktree_remove method

pub fn expect_worktree_move(&mut self) -> &mut Expectation

Create an Expectation for mocking the worktree_move method

pub fn expect_worktree_prune(&mut self) -> &mut Expectation

Create an Expectation for mocking the worktree_prune method

pub fn expect_clone_repo(&mut self) -> &mut Expectation

Create an Expectation for mocking the clone_repo method

pub fn expect_tag_create(&mut self) -> &mut Expectation

Create an Expectation for mocking the tag_create method

pub fn expect_tag_create_annotated(&mut self) -> &mut Expectation

Create an Expectation for mocking the tag_create_annotated method

pub fn expect_tag_list(&mut self) -> &mut Expectation

Create an Expectation for mocking the tag_list method

pub fn expect_tag_delete(&mut self) -> &mut Expectation

Create an Expectation for mocking the tag_delete method

pub fn expect_show_file(&mut self) -> &mut Expectation

Create an Expectation for mocking the show_file method

pub fn expect_config_get(&mut self) -> &mut Expectation

Create an Expectation for mocking the config_get method

pub fn expect_config_set(&mut self) -> &mut Expectation

Create an Expectation for mocking the config_set method

pub fn expect_remote_add(&mut self) -> &mut Expectation

Create an Expectation for mocking the remote_add method

pub fn expect_remote_set_url(&mut self) -> &mut Expectation

Create an Expectation for mocking the remote_set_url method

pub fn expect_blame(&mut self) -> &mut Expectation

Create an Expectation for mocking the blame method

pub fn expect_cherry_pick(&mut self) -> &mut Expectation

Create an Expectation for mocking the cherry_pick method

pub fn expect_revert(&mut self) -> &mut Expectation

Create an Expectation for mocking the revert method

pub fn expect_rebase_skip(&mut self) -> &mut Expectation

Create an Expectation for mocking the rebase_skip method

pub fn expect_cherry_pick_abort(&mut self) -> &mut Expectation

Create an Expectation for mocking the cherry_pick_abort method

pub fn expect_cherry_pick_continue(&mut self) -> &mut Expectation

Create an Expectation for mocking the cherry_pick_continue method

pub fn expect_revert_abort(&mut self) -> &mut Expectation

Create an Expectation for mocking the revert_abort method

pub fn expect_revert_continue(&mut self) -> &mut Expectation

Create an Expectation for mocking the revert_continue method

pub fn expect_bisect_reset(&mut self) -> &mut Expectation

Create an Expectation for mocking the bisect_reset method

Trait Implementations

impl Debug for MockGitApi

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

Formats the value using the given formatter.

impl Default for MockGitApi

fn default() -> Self

Returns the “default value” for a type.

impl GitApi for MockGitApi

The Git operations this crate exposes — the interface consumers code against and mock in tests.

Injection safety: reference names and revision expressions are taken as the validated RefName / RevSpec newtypes (directly or inside an options struct), so a flag-like or malformed value is rejected at construction, before it can reach an argv slot. The remaining caller-supplied bare positionals that are not refs/revisions — remote names and URLs — keep an internal reject_flag_like guard: a value that is empty or begins with - is rejected with an Error::Spawn before spawning. Flag-value slots (-m <msg>, --branch <b>), filesystem path arguments (---separated pathspecs, plus worktree paths and clone destinations — typed Path, caller-trusted), and the run/run_raw escape hatches are not guarded. The one context-dependent special value, git’s - “previous branch”, is CheckoutTarget::Previous.

fn run<'life0, 'life1, 'async_trait>( &'life0 self, args: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Run git <args> in the process’s current directory, returning trimmed stdout (throws on a non-zero exit). A raw escape hatch for unmodelled commands — you supply the whole argv, so target a specific repo with -C <dir> in the args. This method on the client is the process-cwd escape hatch; the at(dir) bound view’s run is instead bound to dir (it forwards to Git::run_in, so git.at(dir).run(…) runs in the bound repo). Use git.at(dir).run(…) (or Git::run_in) for the bound repo; use this for the process cwd (T-035, was M15).

fn run_raw<'life0, 'life1, 'async_trait>( &'life0 self, args: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<ProcessResult<String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Like GitApi::run but never errors on a non-zero exit — returns the captured ProcessResult.

fn version<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Installed Git version (git --version).

fn capabilities<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<GitCapabilities>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

The installed binary’s parsed version, as GitCapabilities (git --version). A value type — probe once and keep it; an unrecognisable version string is an Error::Parse.

fn status<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<Vec<StatusEntry>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Working-tree status (git status --porcelain=v1 -z).

fn status_text<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Raw porcelain status text (git status --porcelain=v1) — the unparsed counterpart of status, mirroring vcs_jj status_text.

fn status_tracked<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<Vec<StatusEntry>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Like status but ignoring untracked files (git status --porcelain=v1 -z --untracked-files=no) — “is the tracked tree dirty”, staged or not.

fn branch_status<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<BranchStatus>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

A combined branch + working-tree snapshot in one spawn (git status --porcelain=v2 --branch -z): HEAD, branch, upstream, ahead/behind, and change counts — the data a prompt/status-bar needs without N round-trips. See BranchStatus.

fn conflicted_files<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<Vec<PathBuf>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Paths with unresolved merge conflicts, repo-relative with / separators (git diff --name-only --diff-filter=U -z). Empty when there are none. Returns PathBufs built from the raw -z bytes, so a non-UTF-8 conflicted path survives losslessly.

fn current_branch<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<Option<String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Current branch name, or None on a detached HEAD (git symbolic-ref --quiet --short HEAD). Returns the branch name for a normal branch and for an unborn branch (a fresh init/clone before the first commit); None only when HEAD is detached. Mirrors JjApi::current_bookmark’s Option shape, so cross-backend code treats “no named branch/bookmark” the same way on both wrappers.

fn branches<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<Vec<Branch>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Local branches, current one flagged (git branch).

fn log<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, revspec: &'life2 RevSpec, max: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<Commit>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Up to max commits reachable from revspec, newest first (git log <revspec>). Pass "HEAD" for the current branch’s history, or a range like "main..HEAD" / "origin/main..HEAD" to scope it. Mirrors JjApi::log’s revset argument, so cross-backend code uses one signature. The revspec is a validated RevSpec, so it can never be parsed as a flag.

fn log_paths<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, dir: &'life1 Path, revspec: &'life2 RevSpec, max: usize, paths: &'life3 [String], ) -> Pin<Box<dyn Future<Output = Result<Vec<Commit>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Like log, but scoped to commits that touched paths (git --literal-pathspecs log <revspec> -n <max> -- <paths>) — e.g. “who changed this module”. --literal-pathspecs matches a path containing */?/[] literally rather than as pathspec glob magic (R-02); the -- separator keeps a path from being read as a flag (same convention as add/commit_paths). An empty paths is refused before spawning: silently falling back to log’s unrestricted history would defeat the “scoped to these paths” contract. Mirrors JjApi::log_paths, which takes filesets instead of pathspecs.

Unlike add/commit_paths, git’s log has no --pathspec-from-file support, so a paths set that would risk exceeding the OS argv limit is instead split into multiple git log calls, each within budget; the per-call results are merged (deduplicated by hash — a commit can touch paths spread across more than one chunk) and restored to git’s own commit order using a separate, pathless git log <revspec> --format=%H oracle call (T-052/R-03): pathspec filtering only drops non-matching commits, it never reorders the ones that remain, so the oracle’s order — over the same revspec, unrestricted by paths — gives the exact relative order a single, hypothetical unchunked call would have produced. Unlike sorting by a parsed date field, this needs no assumption about author-vs-committer timestamps or same-second ties (git log dates have no sub-second precision). A paths set that fits in one call is unaffected — same single invocation, same order, as before.

Before any of that, revspec (which may be symbolic, e.g. HEAD, or a range, e.g. main..feature) is resolved exactly once via git rev-parse into a fixed set of commit ids that every chunk call and the oracle call then reuse verbatim (T-052/R-04): without this, each of those several independent invocations would re-resolve the same symbolic text on its own, so a concurrent commit/reset/ref-move landing between any two of them could make them see different repository snapshots, silently omitting a newer matching commit, including one no longer reachable, or interleaving two different histories into the merged result. This resolution only happens on the chunked path (more than one invocation); the single-call fast path is unaffected. Also before any of that, every individual path is checked against the argv budget on its own (T-052/R-05): git log has no NUL-safe transport to fall back to the way add/commit_paths do, so a single path that by itself cannot fit in argv is rejected up front with a clear error rather than silently forwarded as an over-budget singleton chunk.

fn rev_parse<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, rev: &'life2 RevSpec, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Resolve a revision to a full hash (git rev-parse --verify <rev>). --verify requires rev to name exactly one object, so a non-revision (e.g. a filename) errors instead of being echoed back as a fake id.

fn rev_parse_short<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, rev: &'life2 RevSpec, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Resolve a revision to its abbreviated hash (git rev-parse --short <rev>) — e.g. to label a detached HEAD.

fn init<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Initialise a repository (git init).

fn add<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, paths: &'life2 [PathBuf], ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Stage paths (git --literal-pathspecs add -- <paths>) — --literal-pathspecs applies regardless of path-set size, so a path containing */?/[] always matches literally rather than as pathspec glob magic (R-01). A path set whose combined length would risk exceeding the OS command-line limit (ARGV_PATHSPEC_BUDGET; Windows’ CreateProcess caps out around 32,767 characters) instead goes over stdin via --pathspec-from-file=- --pathspec-file-nul — the paths never touch argv at all in that case, so there is no upper bound left to exceed (T-052).

fn commit<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, message: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Commit staged changes (git commit -m).

fn create_branch<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, name: &'life2 RefName, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Create a branch without switching to it (git branch <name>).

fn checkout<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, target: &'life2 CheckoutTarget, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Switch to a branch/revision, or the previous branch (git checkout <target>); see CheckoutTarget.

fn checkout_detach<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, commit: &'life2 RevSpec, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Check out a commit as a detached HEAD (git checkout --detach <commit>).

fn commit_paths<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, spec: CommitPaths, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Commit exactly the spec’s paths’ working-tree content, ignoring the index (git --literal-pathspecs commit [--amend] -m <message> --only -- <paths>); see CommitPaths. --literal-pathspecs applies regardless of path-set size, so a glob-magic character (*/?/[]) in a path is matched literally rather than expanded — otherwise commit_paths’s “exactly these paths” contract could be violated (R-01). Like add, a path set that would risk exceeding the OS argv limit is instead routed over stdin (--pathspec-from-file=- --pathspec-file-nul) — always as a single git commit invocation either way, so the one-atomic-commit contract is unaffected by the path set’s size (T-052).

fn last_commit_message<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

The last commit’s full message (git log -1 --format=%B) — e.g. to pre-fill an amend.

fn is_unborn<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Whether HEAD is unborn — a fresh repo with no commits yet (git rev-parse --verify -q HEAD, exit-code mapped).

fn diff_is_empty<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Whether the working tree has no unstaged modifications to tracked files (git diff --quiet). Untracked files are not counted — this is not a full “is the working tree clean?” check; use status for that.

fn common_dir<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<PathBuf>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

The repository’s common git directory (rev-parse --git-common-dir) — stable across linked worktrees.

fn git_dir<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<PathBuf>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

This worktree’s git directory (rev-parse --git-dir).

fn resolve_commit<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, rev: &'life2 RevSpec, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Resolve a revision to a commit hash, peeling tags (rev-parse --verify <rev>^{commit}).

fn remote_head_branch<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<Option<String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

The remote’s default branch from symbolic-ref refs/remotes/origin/HEAD (short name only); None when origin/HEAD is unset.

fn branch_exists<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, name: &'life2 RefName, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Whether a local branch exists (show-ref --verify --quiet refs/heads/<name>).

fn remote_branch_exists<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, name: &'life2 RefName, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Whether origin has name, without fetching (ls-remote origin refs/heads/<name> — the fully-qualified ref, so foo can’t tail-match bar/foo). Runs with GIT_TERMINAL_PROMPT=0 and a 10s timeout so a missing credential or a flaky network can’t hang the call.

fn remote_url<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, remote: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

A remote’s URL (remote get-url <remote>).

fn upstream<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<Option<String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

The current attached branch’s upstream, e.g. Some("origin/main") (rev-parse --abbrev-ref --symbolic-full-name @{u}); None when unset. A detached HEAD or a directory outside a repository is an error.

fn remote_branches<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, remote: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Branch names on remote, without fetching (ls-remote --heads <remote>).

fn is_merged<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, spec: MergeCheck, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Whether the MergeCheck’s branch is fully merged into its base (branch --merged <base>). Build it as MergeCheck::branch(RefName::new("feature")?).into_base(RevSpec::new("main")?) so the two refs can’t be transposed (a swap would invert the answer).

fn set_upstream<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, dir: &'life1 Path, branch: &'life2 RefName, upstream: &'life3 RefName, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Set branch’s upstream to upstream (e.g. origin/main) (branch --set-upstream-to=<upstream> <branch>).

fn delete_branch<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, spec: BranchDelete, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete a local branch (branch -d, or -D when forced); see BranchDelete.

fn rename_branch<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, dir: &'life1 Path, old: &'life2 RefName, new: &'life3 RefName, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Rename a local branch (branch -m <old> <new>).

fn rev_list_count<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, range: &'life2 RevSpec, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Count commits in a range (rev-list --count <range>).

fn diff_range_is_empty<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, range: &'life2 RevSpec, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Whether a diff range is empty (diff --quiet <range>).

fn diff_stat<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, range: &'life2 RevSpec, ) -> Pin<Box<dyn Future<Output = Result<DiffStat>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Aggregate change stats for a range (diff --shortstat <range>). Named to match vcs_jj::JjApi::diff_stat.

fn diff_text<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, spec: DiffSpec, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Raw git-format unified diff text for spec (diff <spec> --no-color --no-ext-diff -M) — stable machine output, returned verbatim (a trailing blank context line is preserved, so the last hunk stays in sync with its @@ line count for a re-parse/re-apply).

fn diff<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, spec: DiffSpec, ) -> Pin<Box<dyn Future<Output = Result<Vec<FileDiff>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Parsed per-file unified diff for spec, layered on diff_text.

fn staged_is_empty<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Whether the index has no staged changes (diff --cached --quiet).

fn is_rebase_in_progress<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Whether a rebase is in progress (a rebase-merge dir, or a rebase-apply dir not left by git am, exists under the git dir).

fn is_merge_in_progress<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Whether a merge is in progress (a MERGE_HEAD exists under the git dir).

fn is_am_in_progress<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Whether a git am (mailbox apply) is in progress (rebase-apply/applying). Distinct from a rebase, which shares the rebase-apply dir but without the applying marker — aborting an am needs am --abort, not rebase --abort.

fn is_cherry_pick_in_progress<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Whether a cherry-pick is in progress (CHERRY_PICK_HEAD under the git dir). A cherry-pick conflict writes CHERRY_PICK_HEAD, not MERGE_HEAD, so this is distinct from a merge and is aborted/continued with cherry-pick --abort / --continue, not merge --abort.

fn is_revert_in_progress<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Whether a revert is in progress (REVERT_HEAD under the git dir). Like a cherry-pick, a revert conflict writes its own head file, not MERGE_HEAD; it is driven with revert --abort / --continue.

fn is_bisect_in_progress<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Whether a git bisect session is in progress (BISECT_LOG under the git dir). Ended with bisect reset (there is no --continue).

fn fetch<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch from the default remote (fetch --quiet), with GIT_TERMINAL_PROMPT=0. Transient (network) failures are retried (3 attempts, 500 ms backoff).

fn fetch_from<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, remote: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Fetch from a named remote (fetch --quiet <remote>), with GIT_TERMINAL_PROMPT=0. Transient failures are retried like fetch.

fn fetch_branch<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, branch: &'life2 RefName, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Fetch a single branch from origin into its remote-tracking ref (fetch --quiet origin refs/heads/<b>:refs/remotes/origin/<b>), with GIT_TERMINAL_PROMPT=0. Transient failures are retried (3×, 500 ms).

fn push<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, spec: GitPush, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Push to a remote (push [-u] <remote> <refspec>); see GitPush.

fn merge_squash<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, branch: &'life2 RevSpec, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Stage a branch’s changes without committing (merge --squash <branch>).

fn merge_commit<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, spec: MergeCommit, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Merge a branch (merge [--no-ff] [-m <msg> | --no-edit] <branch>); with no message it takes the default merge message non-interactively (--no-edit). See MergeCommit.

fn merge_no_commit<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, spec: MergeNoCommit, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Merge a branch but stop before committing, so the result can be inspected (merge --no-commit [--squash | --no-ff] <branch>). With no_ff (and not squash) git records MERGE_HEAD, so the in-progress merge is abortable via merge_abort — the dry-run pattern. With squash, git stages the squashed result but records no MERGE_HEAD, so it is not an abortable merge: undo it with reset_merge / reset_hard, not merge_abort. See MergeNoCommit.

fn merge_abort<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Abort an in-progress merge (merge --abort).

fn merge_continue<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Finish a merge after resolving conflicts (commit --no-edit).

fn reset_merge<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Undo an in-progress (or just-staged) merge: reset --merge resets the index and the merge-touched working-tree files back to HEAD and drops MERGE_HEAD, discarding the merge’s changes while keeping unrelated unstaged edits. Use it after merge_squash / merge_no_commit(squash), where there is no MERGE_HEAD for merge_abort to act on.

fn reset_hard<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, rev: &'life2 RevSpec, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Hard-reset the working tree to a revision (reset --hard <rev>).

fn rebase<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, onto: &'life2 RevSpec, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Rebase the current branch onto onto (rebase <onto>); the editor is suppressed (GIT_EDITOR=true) so it never hangs a headless caller.

fn rebase_abort<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Abort an in-progress rebase (rebase --abort).

fn am_abort<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Abort an in-progress git am (am --abort), restoring the pre-am HEAD.

fn am_continue<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Continue a git am after resolving conflicts (am --continue); the editor is suppressed (GIT_EDITOR=true) so the patch’s message-confirm never hangs a headless caller. On a multi-patch mailbox it can stop again on the next patch’s conflict (exit non-zero) — a conflict, not a hard error, like the other sequencer --continues.

fn rebase_continue<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Continue a rebase after resolving conflicts (rebase --continue); the editor is suppressed (GIT_EDITOR=true) so the message-confirm never hangs.

fn stash_push<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, spec: StashPush, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Stash the working tree (stash push, --include-untracked when asked) — e.g. to save state before a copy-on-write restore. See StashPush.

fn stash_pop<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Restore the most recent stash and drop it (stash pop).

fn worktree_list<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<Vec<Worktree>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List worktrees (worktree list --porcelain).

fn worktree_add<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, spec: WorktreeAdd, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Add a worktree (worktree add [-b <branch>] <path> [<commitish>]).

fn worktree_remove<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, spec: WorktreeRemove, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Remove a worktree (worktree remove [--force] <path>); see WorktreeRemove.

fn worktree_move<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, dir: &'life1 Path, from: &'life2 Path, to: &'life3 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Move a worktree (worktree move <from> <to>).

fn worktree_prune<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Prune stale worktree admin entries (worktree prune).

fn clone_repo<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, url: &'life1 str, dest: &'life2 Path, spec: CloneSpec, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Clone url into dest (git clone <url> <dest> + CloneSpec flags). Runs without a working directory — pass an absolute dest.

fn tag_create<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, name: &'life2 RefName, rev: Option<RevSpec>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Create a lightweight tag at rev (tag <name> [<rev>]; None = HEAD).

fn tag_create_annotated<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, spec: AnnotatedTag, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Create an annotated tag (tag -a <name> -m <message> [<rev>]); see AnnotatedTag.

fn tag_list<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Tag names, sorted by git’s default ordering (tag --list).

fn tag_delete<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, name: &'life2 RefName, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Delete a tag (tag -d <name>).

fn show_file<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, dir: &'life1 Path, rev: &'life2 RevSpec, path: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

A file’s content at a revision (git show <rev>:<path>). path is repo-relative; backslashes are normalised to / (git requires it). Content is decoded lossily — binary files come back mangled rather than erroring — and returned verbatim: the blob’s trailing newline(s) are preserved (not trimmed), so a read-modify-write round-trip is byte-exact.

fn config_get<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, key: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

The value of a config key, or None when unset (config --get <key>, whose exit 1 covers both “unset” and “no such section” — git doesn’t distinguish). A multi-valued key errors; read those via run.

fn config_set<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, dir: &'life1 Path, key: &'life2 str, value: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Set a config key in the repository’s local config (config <key> <value>).

Trusted-input sink. key is guarded against a flag-shape, but this writes whatever key/value it’s given — including code-execution keys like core.sshCommand or filter.<drv>.clean. Never wire untrusted input into it; a harden()ed client does not protect against config you write.

fn remote_add<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, dir: &'life1 Path, name: &'life2 str, url: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Add a remote (remote add <name> <url>).

fn remote_set_url<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, dir: &'life1 Path, name: &'life2 str, url: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Change a remote’s URL (remote set-url <name> <url>).

fn blame<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, path: &'life2 str, rev: Option<RevSpec>, ) -> Pin<Box<dyn Future<Output = Result<Vec<BlameLine>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Per-line authorship of path (blame --line-porcelain [<rev>] -- <path>; None = the working tree’s HEAD).

fn cherry_pick<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, rev: &'life2 RevSpec, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Apply a commit onto the current branch (cherry-pick <rev>). A conflict surfaces as an error classified by is_merge_conflict.

fn revert<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, rev: &'life2 RevSpec, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Revert a commit with the default message (revert --no-edit <rev>).

fn rebase_skip<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Skip the current patch of a paused rebase (rebase --skip). Mainly for the apply backend’s “nothing to commit” stop — the default merge backend auto-drops emptied patches on --continue.

fn cherry_pick_abort<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Abort an in-progress cherry-pick (cherry-pick --abort), restoring the pre-cherry-pick state.

fn cherry_pick_continue<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Continue a cherry-pick after resolving conflicts (cherry-pick --continue); the editor is suppressed (GIT_EDITOR=true) so the message-confirm never hangs a headless caller. On a multi-commit pick it can stop again on the next commit’s conflict (exit non-zero) — a conflict, not a hard error.

fn revert_abort<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Abort an in-progress revert (revert --abort), restoring the pre-revert state.

fn revert_continue<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Continue a revert after resolving conflicts (revert --continue); the editor is suppressed like cherry_pick_continue, and it too can stop on the next commit’s conflict.

fn bisect_reset<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

End a git bisect session (bisect reset), returning to the branch/commit that was checked out before it started. This is the “abort” for a bisect; bisect has no --continue.