@spec as_workspace(t(), [{:cwd, String.t() | nil}]) :: Dagger.Workspace.t()

Creates a synthetic workspace from this repository's HEAD and uncommitted file changes.

Pending changes are applied at the repository root. The staging split is not preserved. The source repository is not modified.

@spec branch(t(), String.t(), [{:no_lock, boolean() | nil}]) :: Dagger.GitRef.t()

Returns details of a branch.

@spec branches(t(), [{:patterns, [String.t()]}]) ::
  {:ok, [String.t()]} | {:error, term()}

branches that match any of the given glob patterns.

@spec bundle(t(), [String.t()], [{:base, Dagger.GitRef.t() | nil}]) ::
  Dagger.GitBundle.t()

Pack the given refs and the objects needed to reconstruct them into a Git bundle.

@spec commit(t(), String.t()) :: Dagger.GitCommit.t()

Returns details of a commit.

@spec default_remote(t()) :: {:ok, Dagger.GitRemote.t() | nil} | {:error, term()}

Return the sole remote, otherwise origin, otherwise the selected branch's upstream remote, otherwise null.

Frozen workspaces retain their captured upstream selection. Does not contact remote servers.

@spec head(t(), [{:no_lock, boolean() | nil}]) :: Dagger.GitRef.t()

Returns details for HEAD.

@spec id(t()) :: {:ok, String.t()} | {:error, term()}

A unique identifier for this GitRepository.

@spec latest(t(), version: String.t() | nil, no_lock: boolean() | nil) ::
  Dagger.GitRef.t()

Return the latest stable release tag, falling back to HEAD when no release exists.

Release selection accepts an optional "v" prefix, incomplete versions, and zero-padded numeric components. This operation is pinned unless noLock is enabled.

@spec ref(t(), String.t(), [{:no_lock, boolean() | nil}]) :: Dagger.GitRef.t()

Returns details of a ref.

@spec remote(t(), String.t()) :: Dagger.GitRemote.t()

Look up a remote by name. Fails when the remote does not exist.

@spec remotes(t()) :: {:ok, [Dagger.GitRemote.t()]} | {:error, term()}

List this repository's named remotes, with registered remotes overriding configured ones. Does not contact remote servers.

@spec tag(t(), String.t(), [{:no_lock, boolean() | nil}]) :: Dagger.GitRef.t()

Returns details of a tag.

@spec tags(t(), [{:patterns, [String.t()]}]) :: {:ok, [String.t()]} | {:error, term()}

tags that match any of the given glob patterns.

@spec uncommitted(t()) :: Dagger.Changeset.t()

Returns the changeset of uncommitted changes in the git repository.

@spec url(t()) :: {:ok, String.t() | nil} | {:error, term()}

The URL of the git repository.

@spec with_bundle(t(), Dagger.GitBundle.t(), [{:prerequisite_ref, String.t() | nil}]) ::
  t()

Import a Git bundle after fetching and verifying all of its prerequisites.

@spec with_contents(t(), Dagger.Directory.t()) :: t()

Replace this repository's storage with the supplied self-contained Git repository, retaining its logical URL and push destinations.

Accepts a whole checkout (including .git and pending file edits), .git contents, or a bare repository. Does not initialize a repository, merge histories, or modify either input.

The receiver's logical routing wins over the supplied Git configuration; that configuration is not rewritten. Use Directory.asGit to open the supplied repository without retaining the receiver's routing.

When the receiver is a remote repository (or was derived from one), that remote is retained with its authentication: refs the supplied storage does not contain resolve through it.

@spec with_remote(t(), String.t(), String.t(), [{:push_url, String.t() | nil}]) :: t()

Register a named remote on this repository, replacing any registered remote of the same name.

Registered remotes are recorded in checkouts materialized from this repository (GitRef.tree, Workspace.git.directory), so remote-aware tooling like gh can resolve and fetch from them. The origin remote also routes push when no explicit destination is passed: its push URL, or its URL, becomes the default destination.

Routing metadata only, never a credential grant: pushes still authenticate with the caller's own credentials and require approval as usual.