Struct Git 

pub struct Git<R: ProcessRunner = JobRunner> { /* private fields */ }

The real Git client. Generic over the ProcessRunner so tests can inject a fake process executor; Git::new uses the real job-backed runner.

Wraps a ManagedClient: enable lock-contention retry with with_retry (opt-in; off by default).

Every client (not just hardened) scrubs the inherited repo-redirector environment variables below, so a GIT_DIR (etc.) leaking from the parent process — e.g. running inside a git hook, which exports GIT_DIR/GIT_INDEX_FILE — can’t silently redirect commands at a different repository than the bound dir. (harden() additionally scrubs the command-hook vars and pins hooks/fsmonitor/sshCommand off.)

Implementations

impl Git<JobRunner>

pub fn new() -> Self

Create a client driving the real job-backed runner.

impl<R: ProcessRunner> Git<R>

pub fn with_runner(runner: R) -> Self

Create a client driving runner — inject a fake in tests.

pub fn default_timeout(self, timeout: Duration) -> Self

Apply a default timeout to every command this client builds.

pub fn default_env( self, key: impl AsRef<OsStr>, value: impl AsRef<OsStr>, ) -> Self

Set an environment variable on every command this client builds.

pub fn default_env_remove(self, key: impl AsRef<OsStr>) -> Self

Remove an inherited environment variable on every command this client builds.

pub fn default_cancel_on(self, token: CancellationToken) -> Self

Cancel every command this client builds when token fires.

impl<R: ProcessRunner> Git<R>

pub fn with_retry(self, policy: RetryPolicy) -> Self

Retry whole-repo lock-contention failures (another process holds the repo’s index.lock) per policy — opt-in, off by default. Safe even for mutating commands: that lock is acquired before any write, so a failure is pre-execution (git never ran) and a retry can’t double-apply. Per-ref lock failures are not retried (a multi-ref op can fail a ref lock mid-way). See RetryPolicy and is_lock_contention.

pub fn with_credentials(self, provider: Arc<dyn CredentialProvider>) -> Self

Supply credentials for HTTPS remote operations (fetch/push/clone/ ls-remote) via a CredentialProvider — opt-in, off by default (ambient git credential helpers / SSH agent). When the provider yields a credential, each remote op runs with an inline credential.helper that feeds the secret from an environment variable, so the token never appears in argv. Local operations are unaffected. This covers HTTPS only — an SSH remote ignores the helper and authenticates via the ambient SSH agent, as before.

pub fn with_token(self, token: impl Into<Secret>) -> Self

Convenience for the common case: authenticate HTTPS remotes with a single static token (a personal-access token; the default username x-access-token is used). Shorthand for with_credentials(Arc::new(StaticCredential::token(token))). For a specific username, build a Credential::userpass and use with_credentials.

pub fn with_env_token(self, var: impl Into<String>) -> Self

Convenience: read the HTTPS token from environment variable var at request time; if var is unset/empty, fall back to ambient auth. Shorthand for with_credentials(Arc::new(EnvToken::new(var))).

impl<R: ProcessRunner> Git<R>

pub async fn run_args(&self, args: &[&str]) -> Result<String>

Run git <args> over string slices — git.run_args(&["status", "-s"]) without allocating a Vec<String>. Inherent (not on the object-safe trait), so it can take &[&str]; forwards to the same path as GitApi::run.

pub async fn run_raw_args(&self, args: &[&str]) -> Result<ProcessResult<String>>

Like run_args but never errors on a non-zero exit (mirrors GitApi::run_raw).

pub fn at<'a>(&'a self, dir: &'a Path) -> GitAt<'a, R>

Bind this client to dir, returning a GitAt handle whose methods omit the dir argument: git.at(dir).status() runs status against dir. The dir-taking GitApi methods stay on Git for driving many directories (e.g. linked worktrees) from one client.

pub fn harden(self) -> Self

Harden this client for driving repositories it didn’t create: running git inside an untrusted checkout executes that repository’s hooks and honours its config — arbitrary code execution by default. The profile (applied to every command this client runs):

⚠ Requires git ≥ 2.31. The hook / fsmonitor / sshCommand pins ride git’s env-based config (GIT_CONFIG_COUNT), which older git silently ignores — so on git < 2.31 harden() still scrubs the environment and turns prompts off, but repo-local hooks/fsmonitor/sshCommand are not disabled (no error is raised). There is no built-in 2.31 gate yet (capabilities().ensure_supported() only checks the major version, so it passes on 2.0–2.30). Before relying on harden() against a fully untrusted repo on a host you don’t control, check the version yourself — Git::new().capabilities().await?.version exposes major/minor — and require ≥ 2.31, or add an OS-level sandbox. (A machine-checked minor-version floor is tracked for a future release; see docs/audit-2026-07.md H3.)

• Disables hooks — core.hooksPath=/dev/null pinned via git’s env-based config (GIT_CONFIG_COUNT/KEY_n/VALUE_n, git ≥ 2.31; verified to suppress hooks on Windows too) — and core.fsmonitor (a config-driven daemon launch). Env-config overrides even the repo-local .git/config for the keys it names, so these pins beat a poisoned .git/config.
• Neutralizes core.sshCommand (pinned empty) — the config-key twin of the scrubbed GIT_SSH_COMMAND, an arbitrary program git would run for the SSH transport. Empty is falsy to git, so the default ssh (ambient ~/.ssh/config/agent) still works; only the repo’s override is dropped.
• Removes inherited repo redirectors so a poisoned parent environment can’t point commands at another repository: GIT_DIR, GIT_WORK_TREE, GIT_INDEX_FILE, GIT_COMMON_DIR, GIT_OBJECT_DIRECTORY, GIT_ALTERNATE_OBJECT_DIRECTORIES, GIT_NAMESPACE, GIT_CEILING_DIRECTORIES, GIT_CONFIG_PARAMETERS, GIT_CONFIG_GLOBAL, GIT_CONFIG_SYSTEM. (The first seven are also scrubbed by every client — see the type-level doc — not just here.)
• Removes inherited command hooks that make git spawn an arbitrary program from the environment (a second code-execution path besides repo hooks): GIT_SSH_COMMAND/GIT_SSH (transport), GIT_ASKPASS (credential prompt), GIT_EXTERNAL_DIFF (diff driver), GIT_PAGER, GIT_EDITOR/GIT_SEQUENCE_EDITOR, GIT_PROXY_COMMAND (a program for a git:// connection), GIT_EXEC_PATH (relocates git’s own sub-commands), and GIT_TEMPLATE_DIR (seeds hooks/config on init/clone). It also drops the pathspec-mode vars (GIT_LITERAL_PATHSPECS / GIT_GLOB_PATHSPECS / GIT_NOGLOB_PATHSPECS / GIT_ICASE_PATHSPECS), which silently change which paths a command matches. The library’s own auth seam (with_credentials) injects credentials via a git credential.helper / token env, not these variables, so it keeps working through a hardened client; an operator who deliberately relies on an ambient GIT_SSH_COMMAND/GIT_ASKPASS should inject it per-call instead of inheriting it into an untrusted-repo run.
• Skips system config (GIT_CONFIG_NOSYSTEM=1) and keeps terminal prompts off everywhere (GIT_TERMINAL_PROMPT=0).

Residual repo-local-config vectors (NOT neutralized). harden() closes the hooks, fsmonitor, core.sshCommand, and the env redirector/command- hook paths — but a few repo-local .git/config / .gitattributes keys still run an arbitrary program and are not pinned: filter.<drv>.clean/ smudge (run on any working-tree materialization — checkout, stash pop, worktree add), and diff.<drv>.textconv / diff.external (run when a diff is produced; diff_text defends itself with --no-ext-diff, but other diff/blame reads do not). So for a fully untrusted repo, do not materialize its working tree or run diffs through a hardened client without an OS-level sandbox — harden() is hardening, not a sandbox.

What it does NOT do beyond that: sandbox the git binary itself, or stop the repo’s content from being malicious. In a colocated jj repo, git hooks only run when git commands run — harden the Git client; Jj needs no equivalent (jj has no repo-local hooks; see the vcs-jj docs).

Chainable — Git::with_runner(rec).harden() works in tests; use Git::hardened() for the common case.

pub async fn switch_with_stash(&self, dir: &Path, branch: &str) -> Result<()>

Switch to branch, carrying uncommitted changes (tracked and untracked) across via the stash: stash push -u → checkout → stash pop --index. --index restores the staged/unstaged split faithfully (a bare pop returns everything unstaged). A clean tree skips the round-trip; and because stash push can exit 0 having saved nothing (e.g. a submodule-only change), the stash-list depth is checked around the push so a no-op push doesn’t leave the later pop grabbing an older, unrelated stash.

Single-actor contract: this assumes no other process pushes or pops a stash in the same repository between this call’s own stash push and pop.

Failure behaviour:

• checkout fails (atomic — the working copy stays on the original branch): the stash is popped back to restore the original state, and the checkout error is returned. If that restoring pop also fails, the changes stay safe in the stash (git stash list).
• stash pop on the target branch conflicts: the error is returned with the target branch checked out; git keeps the stash entry, so the changes can be resolved or re-applied manually.

Inherent (not on the object-safe trait): a composed operation, not a 1:1 CLI verb — mock the underlying status/stash_*/checkout instead.

impl Git

pub fn hardened() -> Self

A hardened real (job-backed) client — Git::new().harden(); see harden for what the profile does.

Trait Implementations

impl Default for Git<JobRunner>

fn default() -> Self

Returns the “default value” for a type.

impl<R: ProcessRunner> GitApi for Git<R>

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. The at(dir) bound view does not re-bind run/run_args (they and the other run* hatches stay process-cwd, unlike every modelled GitAt method); pass -C dir explicitly if you need the bound repo (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 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 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 conflicted_files<'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,

Paths with unresolved merge conflicts, repo-relative with / separators (git diff --name-only --diff-filter=U -z). Empty when there are none.

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 str, 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 guarded against being parsed as a flag.

fn rev_parse<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, rev: &'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,

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 str, ) -> 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 add -- <paths>).

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 str, ) -> 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, reference: &'life2 str, ) -> 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 or revision (git checkout <reference>).

fn checkout_detach<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, commit: &'life2 str, ) -> 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 commit [--amend] -m <message> --only -- <paths>); see CommitPaths.

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 str, ) -> 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 str, ) -> 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 str, ) -> 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 branch’s upstream, e.g. Some("origin/main") (rev-parse --abbrev-ref --symbolic-full-name @{u}); None when unset.

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, 'life2, 'life3, 'async_trait>( &'life0 self, dir: &'life1 Path, branch: &'life2 str, target: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

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

Whether branch is fully merged into target (branch --merged <target>).

fn set_upstream<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, dir: &'life1 Path, branch: &'life2 str, upstream: &'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 branch’s upstream to upstream (e.g. origin/main) (branch --set-upstream-to=<upstream> <branch>).

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

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

Delete a local branch (branch -d, or -D when force).

fn rename_branch<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, dir: &'life1 Path, old: &'life2 str, new: &'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,

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

fn rev_list_count<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, range: &'life2 str, ) -> 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 str, ) -> 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 str, ) -> 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_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_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 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 str, ) -> 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 str, ) -> 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 str, ) -> 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 str, ) -> 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 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, include_untracked: bool, ) -> 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.

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, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, path: &'life2 Path, force: bool, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

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

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 str, rev: Option<String>, ) -> 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 str, ) -> 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 str, 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>).

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<String>, ) -> 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 str, ) -> 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 str, ) -> 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.