Struct JjVcs 

pub struct JjVcs { /* private fields */ }

Implementations

impl JjVcs

pub fn open(root: &Path) -> Result<Self, VcsError>

Open at DiffSettings::default.

pub fn open_with_settings( root: &Path, settings: &DiffSettings, ) -> Result<Self, VcsError>

Trait Implementations

impl Vcs for JjVcs

fn status(&self) -> Result<StatusModel, VcsError>

Built from working_tree_diff (@- vs the whole working copy in one diff pass): jj’s snapshot marks a new file intent-to-add in the colocated index, so merging git’s own untracked/unstaged/staged lists would double-count it, git2 reporting it once as added (tree vs index) and again as modified (index vs workdir).

fn commit(&self, message: &str) -> Result<String, VcsError>

Messages go as --message=<text>: clap reads a separate value that starts with - as a flag.

fn amend( &self, message: Option<&str>, use_index: bool, ) -> Result<String, VcsError>

message: None folds the working copy into its parent, keeping the parent’s description (jj squash -u: a bare squash opens an editor when both sides are described); Some with use_index folds and sets the new description in the same squash; Some without use_index rewords the parent alone (jj describe), leaving the working copy untouched.

fn create_branch(&self, name: &str, _checkout: bool) -> Result<(), VcsError>

Labels the current change (@) with a bookmark; checkout is a no-op since @ is already where the reader is standing.

fn delete_branch(&self, name: &str) -> Result<(), VcsError>

exact:, since jj reads a bare name as a glob.

fn checkout(&self, name: &str) -> Result<(), VcsError>

jj new <rev> keeps working on top of the branch; jj edit edits its tip commit in place. jj new never discards the change being left behind, only detaches it.

fn has_index(&self) -> bool

Whether this backend has a staging area at all: true for git; jj has none, so its whole working copy reads as StatusModel::staged and the UI drops staging entirely.

fn native_git_checkout(&self) -> bool

Whether a raw git/forge CLI command (git switch, gh pr checkout) may check out a branch directly: true for plain git; jj’s own operation log and working-copy snapshot would never see a write made this way, so a checkout there must go through Vcs::checkout instead.

fn git_dir(&self) -> Result<PathBuf, VcsError>

Resolved repository metadata directory. In a plain repo this is <root>/.git; in a linked worktree <root>/.git is a gitlink file and this resolves to the external gitdir it points at.

fn head(&self) -> Result<HeadInfo, VcsError>

Current branch, commit, and upstream.

fn working_tree_diff(&self) -> Result<DiffModel, VcsError>

HEAD vs workdir+index including untracked files: the review view.

fn tree_to_workdir_diff(&self, base_oid: &str) -> Result<DiffModel, VcsError>

Vcs::working_tree_diff taken from an arbitrary base commit instead of HEAD, so uncommitted work shows alongside the commits since base.

fn commit_diff(&self, oid: &str) -> Result<DiffModel, VcsError>

Changes a single commit introduced over its first parent.

fn range_diff( &self, oldest_oid: &str, newest_oid: &str, ) -> Result<DiffModel, VcsError>

Combined diff of a contiguous commit range, from the first parent of oldest to newest (git diff <oldest>^..<newest> semantics). When oldest is a root commit its first-parent tree is the empty tree, so the range includes everything oldest introduced.

fn tree_diff( &self, base_oid: &str, newest_oid: &str, ) -> Result<DiffModel, VcsError>

Diff between two trees as-is (git diff <base> <newest> semantics); with base a merge base this is a PR-style three-dot diff.

fn merge_base(&self, a: &str, b: &str) -> Result<String, VcsError>

Best common ancestor of two commits.

fn resolve(&self, revision: &str) -> Result<String, VcsError>

Resolve a revision (oid, ref name, remote ref) to a full commit oid.

fn log(&self, limit: usize) -> Result<Vec<LogEntry>, VcsError>

History from HEAD, newest first.

fn default_branch(&self, remote: &str) -> Result<Option<String>, VcsError>

The branch a pull request merges into by default; None when the repository offers no answer.

fn commits_between( &self, base: &str, head: &str, ) -> Result<Vec<LogEntry>, VcsError>

Commits reachable from head but not base, newest first: what a pull request from head would carry.

fn unpushed(&self, limit: usize) -> Result<Option<Vec<LogEntry>>, VcsError>

Commits on HEAD that no remote-tracking branch contains, newest first, at most limit of them: work that exists only on this machine. None when the repository has no remote-tracking refs, where being pushed has no meaning yet. Asking the remotes rather than the configured upstream is what makes the answer true: an upstream may be another local branch, or a stale ref from before the last fetch. limit bounds a walk that is otherwise the whole history whenever no remote ref sits on it.

fn blame(&self, rel: &Path) -> Result<Vec<BlameSpan>, VcsError>

Last commit to touch each line of rel as the worktree has it, in line order. Lines the worktree added since the last commit come back as one span of their own, owned by no commit.

fn read_at(&self, rev: &str, path: &str) -> Result<Option<String>, VcsError>

One file’s content as recorded in rev’s tree, None when that tree has no such path. Lets a review pinned to one tree (a commit, a range’s newest, a PR’s head) resolve a walkthrough’s anchors against what it actually shows, rather than whatever the worktree holds now.

fn read_blob(&self, oid: &str) -> Result<Option<Vec<u8>>, VcsError>

A blob’s raw bytes by its hex id (a crate::model::BlobIds side), None when the object store has no such blob.

fn tracked_files(&self) -> Result<Vec<PathBuf>, VcsError>

Every tracked file, repo-relative and sorted. This is the index, so a staged new file is tracked and an untracked one is not.

fn attr(&self, rel: &Path, name: &str) -> bool

Whether the repo’s git attributes set name to true for rel. Unreadable attribute files read as unset: the caller is refining a guess, so there is nothing to report and nothing to recover.

fn branches(&self) -> Result<Vec<BranchInfo>, VcsError>

Local branches, their divergence left unresolved.

fn divergence(&self, branch: &str) -> Result<Option<(usize, usize)>, VcsError>

How far branch stands from its upstream, as (ahead, behind), or None when it tracks nothing.

fn all_branches(&self) -> Result<Vec<String>, VcsError>

Local and remote-tracking branch names, for pickers that name a revision rather than check one out.

fn stage(&self, _rel: &Path) -> Result<(), VcsError>

Stage a whole file (worktree deletions become staged deletions).

fn stage_everything(&self) -> Result<(), VcsError>

Stage every change in the worktree, deletions and untracked files included. Resolved against the repository as it is now, so a file edited since the caller last looked is still caught.

fn unstage_everything(&self) -> Result<(), VcsError>

Reset the whole index back to HEAD, keeping the worktree.

fn stage_hunk(&self, _rel: &Path, _hunk: &HunkId) -> Result<(), VcsError>

Stage one hunk out of the unstaged (or untracked) changes of a file.

fn unstage(&self, _rel: &Path) -> Result<(), VcsError>

Reset a file’s index entry back to HEAD, keeping the worktree.

fn unstage_hunk(&self, _rel: &Path, _hunk: &HunkId) -> Result<(), VcsError>

Remove one staged hunk from the index, keeping the worktree.

fn discard(&self, rel: &Path) -> Result<(), VcsError>

Throw away worktree changes only; an untracked file is deleted. Refused while the file has staged changes (unstage first).

fn head_message(&self) -> Result<String, VcsError>

Full message of the HEAD commit, for amend/reword editor templates.

fn stash_push(&self, _message: Option<&str>) -> Result<(), VcsError>

Stash tracked changes (staged + unstaged), reverting the worktree to HEAD; untracked files are left in place, matching git stash. message None lets the backend label it. Local-only: no network.

fn stash_pop(&self) -> Result<(), VcsError>

Restore the most recent stash and drop it. Refused when there is no stash or the pop would conflict.

fn network_argv(&self, op: NetworkOp) -> Result<Vec<String>, VcsError>

Argv to run for a network op, e.g. ["git", "push"]. The binary runs this in Vcs::workdir so the backend’s own CLI handles credentials; diffler never touches them. The jj backend returns ["jj", "git", …] for a fetch; push and pull would move git’s refs behind jj’s back, so it rejects every push/pull variant instead.

fn workdir(&self) -> Result<PathBuf, VcsError>

Working directory to run Vcs::network_argv in.

fn remote_url(&self, name: &str) -> Result<Option<String>, VcsError>

URL of the named remote (e.g. origin), if it exists. Used to detect the CI provider’s host without shelling out.

fn remotes(&self) -> Result<Vec<String>, VcsError>

Names of every configured remote, for multi-remote CI detection.

fn set_diff_algorithm(&self, algorithm: DiffAlgorithm, indent_heuristic: bool)

Switch the line-diff algorithm every diff this instance computes from now on uses (config keys diff.algorithm, diff.indent_heuristic).