Git bridge: oxy git fetch and oxy git push against a Git remote through a bare mirror, incremental import seeded by imported and exported commits, export chained onto fetched tips (spec 0.6p) 30ea9c1e70fa

Working alongside Git: `oxy git import <repo> <dest>` converts a Git history, `oxy git fetch <url>`

brings new commits of a Git remote into the bookmark, `oxy git push <url>` publishes the bookmark as

commits on top of them, and `oxy git export <dir>` writes a plain Git mirror.

/// Git commits with a known Oxygen counterpart.

struct GitKnown {

    /// Imported commit → its change.

    imported: HashMap<String, ChangeHash>,

    /// Exported commit (or a fetched tip) → the bookmark state it equals.

    exported: HashMap<String, ObjectRef>,

}

    /// `state ref → Git commit sha` for bookmark states that equal a Git

    /// commit's tree (recorded by import and fetch).

    fn read_git_states(path: &Path) -> Result<BTreeMap<ObjectRef, String>> {

        let mut out = BTreeMap::new();

        if let Ok(text) = fs::read_to_string(path) {

            for line in text.lines() {

                if let Some((h, sha)) = line.split_once(' ') {

                    if let Some(h) = ObjectRef::from_hex(h) {

                        out.insert(h, sha.trim().to_string());

                    }

                }

            }

        }

        Ok(out)

    }

    fn record_git_state(&self, git_dir: &Path, state: &ObjectRef, sha: &str) -> Result<()> {

        let path = self.git_marks_dir(git_dir)?.join("git-states");

        let mut states = Self::read_git_states(&path)?;

        states.insert(*state, sha.to_string());

        let text: String = states.iter().map(|(h, s)| format!("{} {s}\n", h.to_hex())).collect();

        write_atomic(&path, text.as_bytes())

    }

    /// The bare mirror this repository keeps for the Git remote `url`.

    fn git_mirror(&self, url: &str) -> Result<PathBuf> {

        let key = hash_object(ObjectType::Chunk, url.as_bytes()).short(16);

        let dir = self.oxy.join("git").join(key).join("mirror.git");

        if !dir.join("HEAD").exists() {

            fs::create_dir_all(&dir)?;

            git(&dir, &["init", "--bare", "-q"])?;

        }

        Ok(dir)

    }

    /// Git commits already imported into the bookmark, by sha.

    fn imported_commits(&self) -> Result<HashMap<String, ChangeHash>> {

        let mut map = HashMap::new();

        for e in self.log()? {

            if e.is_working_copy {

                continue;

            }

            if let Some(sha) = e.change.message.lines().rev().find_map(|l| l.strip_prefix("Git-Commit: ")) {

                map.insert(sha.trim().to_string(), e.hash);

            }

        }

        Ok(map)

    }

    /// Bring the mirror's `branch` up to date with the Git remote `url`.

    /// A remote without that branch yet leaves the mirror as it is.

    fn git_mirror_fetch(&self, mirror: &Path, url: &str, branch: &str) -> Result<()> {

        let spec = format!("+refs/heads/{branch}:refs/heads/{branch}");

        match git(mirror, &["fetch", "-q", url, &spec]) {

            Ok(_) => Ok(()),

            Err(e) => {

                let ls = git(mirror, &["ls-remote", "--heads", url, branch]).unwrap_or_default();

                if ls.trim().is_empty() { Ok(()) } else { Err(e) }

            }

        }

    }

    /// Fetch `branch` of the Git repository at `url` (a path or a Git URL)

    /// through a mirror and import the commits not yet in the bookmark

    /// (spec §23). Works on a repository that already has history: the

    /// new changes join the bookmark like a pull.

    pub fn git_fetch(&self, url: &str, branch: &str) -> Result<GitImportReport> {

        let mirror = self.git_mirror(url)?;

        self.git_mirror_fetch(&mirror, url, branch)?;

        if git(&mirror, &["rev-parse", "--verify", "-q", &format!("refs/heads/{branch}")]).is_err() {

            return fail(format!("{url} has no branch {branch:?}"));

        }

        self.import_git_commits(&mirror, branch, &format!("oxy git fetch {url} {branch}"))

    }

    /// Export the bookmark to `branch` of the Git repository at `url`

    /// through the mirror and push it. The remote's tip must already have

    /// been fetched (`git_fetch`), so the push fast-forwards.

    pub fn git_push(&self, url: &str, branch: &str) -> Result<GitExportReport> {

        let mirror = self.git_mirror(url)?;

        self.git_mirror_fetch(&mirror, url, branch)?;

        if let Ok(tip) = git(&mirror, &["rev-parse", "--verify", "-q", &format!("refs/heads/{branch}")]) {

            let known = self.git_known(&mirror)?;

            if !known.imported.contains_key(&tip) && !known.exported.contains_key(&tip) {

                return fail(format!("{url} {branch} has commits not yet fetched; run `oxy git fetch {url}` first"));

            }

        }

        let report = self.git_export_as(&mirror, branch)?;

        let spec = format!("refs/heads/{branch}:refs/heads/{branch}");

        git(&mirror, &["push", "-q", url, &spec])?;

        Ok(report)

    }

        let bookmark = self.config.bookmark.clone();

        self.git_export_as(git_dir, &bookmark)

    }

    /// `git_export` to the Git branch `branch`. A state that came from a

    /// Git commit (`oxy git fetch`) is not re-exported: later states chain

    /// onto that commit, so a push back to the Git remote fast-forwards.

    pub fn git_export_as(&self, git_dir: &Path, branch: &str) -> Result<GitExportReport> {

        let git_states = Self::read_git_states(&marks_dir.join("git-states"))?;

        let mut report = GitExportReport { branch: branch.to_string(), heads: self.bookmark_heads()?.len(), ..Default::default() };

        // The fast-import parent of the next commit: `:mark` or a commit sha.

        let mut last_parent: Option<String> = None;

            if let Some(sha) = git_states.get(&state_ref) {

                report.skipped += 1;

                last_parent = Some(sha.clone());

                prev = Some((state_ref, state.heads.clone()));

                continue;

            }

                last_parent = Some(format!(":{m}"));

            let parents: Vec<String> = last_parent.clone().into_iter().collect();

            last_parent = Some(format!(":{mark}"));

        if let Some(p) = &last_parent {

            stream.extend_from_slice(format!("reset refs/heads/{branch}\nfrom {p}\n\n").as_bytes());

            let target = match (git_states.get(&t.state), marks.get(&t.state)) {

                (Some(sha), _) => sha.clone(),

                (None, Some(m)) => format!(":{m}"),

                (None, None) => {

                    format!(":{mark}")

            stream.extend_from_slice(format!("reset refs/tags/{}\nfrom {target}\n\n", t.name).as_bytes());

        self.import_git_commits(git_dir, branch, &format!("oxy git import {} {branch}", git_dir.display()))

    }

    /// Import the commits of `branch` that the bookmark does not have yet,

    /// then move the bookmark to the union of its heads and theirs.

    fn import_git_commits(&self, git_dir: &Path, branch: &str, command: &str) -> Result<GitImportReport> {

        let mut known = self.git_known(git_dir)?;

        let old_heads = self.bookmark_heads()?;

        let mut new_changes: Vec<Change> = Vec::new();

            if known.imported.contains_key(&gc.sha) || known.exported.contains_key(&gc.sha) {

                continue;

            }

                (Some(p1), _) => {

                    let mut st = State::new();

                    self.add_git_ancestors(&mut st, git_dir, &[p1.as_str()], &known)?;

                    st

                }

                let refs: Vec<&str> = args.iter().map(String::as_str).collect();

                self.add_git_ancestors(&mut base, git_dir, &refs, &known)?;

            new_changes.push(change.clone());

            known.imported.insert(gc.sha.clone(), hash);

        // The bookmark: heads of the old state plus every new change.

        report.heads = old_heads.len();

        if last.is_none() {

            return Ok(report);

        }

        let mut all = self.load_state(&old_heads)?;

        for c in new_changes {

            all.add_unchecked(c);

        }

        let mut heads = all.heads();

        heads.sort();

        let old_state_ref = view.bookmarks.get(&self.config.bookmark).copied();

        let state_ref = self.store.put_state(&StateObject::new(heads.clone()))?;

        view.bookmarks.insert(self.config.bookmark.clone(), state_ref);

        self.record_op(&[op_ref], command, view)?;

        // The new state equals the tip's tree when the old one was itself a

        // Git commit's tree (fetched or exported), or there was none.

        let old_known = old_heads.is_empty() || old_state_ref.is_some_and(|s| known.exported.values().any(|e| *e == s));

        if let (Some(tip), true) = (commits.last(), old_known) {

            self.record_git_state(git_dir, &state_ref, &tip.sha)?;

        }

        // The working copy follows when it was clean on the old heads.

        if old_heads.is_empty() {

            self.checkout(&heads, true, &format!("{command} (checkout)"))?;

        } else {

            let snap = self.snapshot(command)?;

            let clean = snap.wc.tree_ops.is_empty() && snap.wc.edits.is_empty();

            let mut base = snap.base.maximal(&snap.wc.deps);

            base.sort();

            let mut sorted_old = old_heads.clone();

            sorted_old.sort();

            if clean && base == sorted_old {

                self.checkout(&heads, false, &format!("{command} (checkout)"))?;

            }

        }

    /// Add to `st` the changes of every Git commit `rev-list args` lists:

    /// an imported commit's change, or the whole state an exported commit

    /// was made from (which may hold changes Git never saw).

    fn add_git_ancestors(&self, st: &mut State, git_dir: &Path, args: &[&str], known: &GitKnown) -> Result<()> {

        let mut full = vec!["rev-list"];

        full.extend(args);

        let out = git(git_dir, &full)?;

            if let Some(h) = known.imported.get(sha) {

            } else if let Some(state_ref) = known.exported.get(sha) {

                let heads = self.store.get_state(state_ref)?.heads;

                for h in self.negotiate(&[], &heads)? {

                    st.add_unchecked(self.store.get_change(&h)?);

                }

            }

        }

        Ok(())

    }

    /// Commits this repository can relate to Oxygen history: imported

    /// ones by change, exported ones (through `git_dir`'s marks) by state.

    fn git_known(&self, git_dir: &Path) -> Result<GitKnown> {

        let imported = self.imported_commits()?;

        let marks_dir = self.git_marks_dir(git_dir)?;

        let oxy_marks = Self::read_oxy_marks(&marks_dir.join("oxy-marks"))?;

        let mut sha_of_mark: HashMap<u64, String> = HashMap::new();

        if let Ok(text) = fs::read_to_string(marks_dir.join("git-marks")) {

            for line in text.lines() {

                if let Some((m, sha)) = line.split_once(' ') {

                    if let Ok(m) = m.trim_start_matches(':').parse::<u64>() {

                        sha_of_mark.insert(m, sha.trim().to_string());

                    }

                }

            }

        }

        let mut exported = HashMap::new();

        for (state_ref, m) in oxy_marks {

            if let Some(sha) = sha_of_mark.get(&m) {

                exported.insert(sha.clone(), state_ref);

        for (state_ref, sha) in Self::read_git_states(&marks_dir.join("git-states"))? {

            exported.entry(sha).or_insert(state_ref);

        }

        Ok(GitKnown { imported, exported })

    fn write_commit(&self, out: &mut Vec<u8>, reference: &str, mark: u64, author: &str, secs: u64, message: &str, parents: &[String], snapshot: &Snapshot) -> Result<()> {

            out.extend_from_slice(format!("{} {p}\n", if i == 0 { "from" } else { "merge" }).as_bytes());

#[test]

fn git_fetch_and_push_round_trip() {

    hermetic();

    if std::process::Command::new("git").arg("--version").output().is_err() {

        eprintln!("git not installed; skipping");

        return;

    }

    let dir = tempfile::tempdir().unwrap();

    let root = dir.path();

    let git_in = |d: &Path, args: &[&str]| -> String {

        let out = std::process::Command::new("git")

            .arg("-C")

            .arg(d)

            .args(["-c", "user.name=Grace", "-c", "[email protected]", "-c", "commit.gpgsign=false"])

            .args(args)

            .output()

            .unwrap();

        assert!(out.status.success(), "git {args:?}: {}", String::from_utf8_lossy(&out.stderr));

        String::from_utf8_lossy(&out.stdout).trim().to_string()

    };

    // A bare "remote" and a work tree that pushes to it.

    let remote = root.join("remote.git");

    fs::create_dir_all(&remote).unwrap();

    git_in(&remote, &["init", "-q", "--bare", "-b", "main"]);

    let work = root.join("work");

    git_in(root, &["clone", "-q", remote.to_str().unwrap(), work.to_str().unwrap()]);

    git_in(&work, &["checkout", "-q", "-b", "main"]);

    write(&work, "README.md", b"# Project\n");

    write(&work, "src/lib.rs", b"pub fn a() {}\n");

    git_in(&work, &["add", "."]);

    git_in(&work, &["commit", "-q", "-m", "initial"]);

    write(&work, "src/lib.rs", b"pub fn a() {}\npub fn b() {}\n");

    git_in(&work, &["commit", "-q", "-am", "second"]);

    git_in(&work, &["push", "-q", "origin", "main"]);

    let tip1 = git_in(&work, &["rev-parse", "HEAD"]);

    // Fetch into a fresh oxy repository.

    let o = root.join("oxy");

    let mut repo = Repo::init(&o).unwrap().with_home(root.join("home"));

    repo.create_identity("Ada", "[email protected]", IdentityScope::User).unwrap();

    let url = remote.to_string_lossy().to_string();

    let r = repo.git_fetch(&url, "main").unwrap();

    assert_eq!((r.commits, r.heads), (2, 1));

    assert_eq!(fs::read(o.join("src/lib.rs")).unwrap(), b"pub fn a() {}\npub fn b() {}\n");

    assert!(!repo.snapshot("status").unwrap().changed);

    assert_eq!(repo.git_fetch(&url, "main").unwrap().commits, 0, "nothing new");

    // An oxy change, pushed back: one commit on top of the Git tip.

    write(&o, "src/lib.rs", b"pub fn a() {}\npub fn b() {}\npub fn c() {}\n");

    write(&o, "NOTES.md", b"from oxy\n");

    let h_oxy = repo.commit("add c and notes", &[]).unwrap();

    let r = repo.git_push(&url, "main").unwrap();

    assert_eq!(r.exported, 1, "{r:?}");

    git_in(&work, &["pull", "-q", "--ff-only", "origin", "main"]);

    assert_eq!(git_in(&work, &["log", "--format=%s", "main"]), "add c and notes\nsecond\ninitial");

    assert_eq!(git_in(&work, &["rev-parse", "HEAD~1"]), tip1);

    assert_eq!(fs::read(work.join("NOTES.md")).unwrap(), b"from oxy\n");

    assert_eq!(git_in(&work, &["log", "-1", "--format=%an", "main"]), "Ada");

    assert!(git_in(&work, &["log", "-1", "--format=%B", "main"]).contains(&format!("Oxy-Hash: {}", h_oxy.to_hex())));

    assert_eq!(repo.git_push(&url, "main").unwrap().exported, 0, "already pushed");

    // Git moves on; pushing without fetching is refused, fetching brings

    // the commit in and the working copy follows.

    write(&work, "README.md", b"# Project\n\nMore.\n");

    git_in(&work, &["commit", "-q", "-am", "readme from git"]);

    git_in(&work, &["push", "-q", "origin", "main"]);

    let tip2 = git_in(&work, &["rev-parse", "HEAD"]);

    assert!(repo.git_push(&url, "main").unwrap_err().to_string().contains("fetch"));

    let r = repo.git_fetch(&url, "main").unwrap();

    assert_eq!((r.commits, r.heads), (1, 2), "the Git change and the oxy change commute");

    assert_eq!(fs::read(o.join("README.md")).unwrap(), b"# Project\n\nMore.\n");

    assert_eq!(fs::read(o.join("NOTES.md")).unwrap(), b"from oxy\n");

    assert!(!repo.snapshot("status").unwrap().changed);

    // Another oxy change pushes on top of Git's newest commit.

    write(&o, "NOTES.md", b"from oxy\nagain\n");

    repo.commit("notes again", &[]).unwrap();

    assert_eq!(repo.git_push(&url, "main").unwrap().exported, 1);

    git_in(&work, &["pull", "-q", "--ff-only", "origin", "main"]);

    assert_eq!(git_in(&work, &["rev-parse", "HEAD~1"]), tip2);

    assert_eq!(fs::read(work.join("NOTES.md")).unwrap(), b"from oxy\nagain\n");

    assert_eq!(git_in(&work, &["log", "--format=%s", "main"]).lines().count(), 5);

}

- [x] Rename detection on Git import (similarity ≥ 50%); `oxy git fetch`/`push` against a Git remote via a mirror. (Done: detection lives in the change builder, so working-copy renames are tracked too; fetch/push through `.oxy/git/<key>/mirror.git` with fast-forward chaining; spec 0.6p.)

- 2026-09-27 07:20 iteration 13: rename detection (snapshots and Git import) and oxy git fetch/push via a mirror (spec 0.6p). 108 tests.

| **Status** | Draft 0.6p |

- **Fetch and push against a Git remote.** `oxy git fetch URL` keeps a bare mirror under `.oxy/git/` for the remote, fetches the branch into it, and imports the commits the bookmark does not have yet, seeding the import with the commits already known: an imported commit maps to its change, and a commit this repository exported maps to the bookmark state it was made from (so a Git commit on top of exported work is based on everything that work contained, including changes Git never saw). The bookmark moves to the union of its heads and the new changes, like a pull; the working copy follows when it was clean. A fetched state whose previous state was itself a Git tree is remembered as equal to the fetched tip. `oxy git push URL` refuses until the remote's tip is known, exports the bookmark's later states as commits chained onto that tip, and pushes the branch, so the push is always a fast-forward.

oxy git import|export|fetch|push   (fetch and push go through a bare mirror under .oxy/git/)

*Changelog.* Draft 0.6p (2026-09-27): `oxy git fetch` and `oxy git push` against a Git remote through a mirror, with incremental import seeded by imported and exported commits (§23).

Draft 0.6o (2026-09-27): rename detection on snapshot and Git import records moves of the existing node (§7.1, §23).

    Export {

        git_dir: PathBuf,

        /// Git branch to write (default: the bookmark name)

        #[arg(long)]

        branch: Option<String>,

    },

    /// Fetch a branch from a Git remote (path or URL) into the current bookmark

    Fetch {

        url: String,

        #[arg(long, default_value = "main")]

        branch: String,

    },

    /// Push the current bookmark to a branch of a Git remote (fetch first)

    Push {

        url: String,

        #[arg(long, default_value = "main")]

        branch: String,

    },

        Cmd::Git { cmd: GitCmd::Export { git_dir, branch } } => sync::git_export(&git_dir, branch.as_deref()),

        Cmd::Git { cmd: GitCmd::Fetch { url, branch } } => sync::git_fetch(&url, &branch),

        Cmd::Git { cmd: GitCmd::Push { url, branch } } => sync::git_push(&url, &branch),

pub fn git_export(git_dir: &std::path::Path, branch: Option<&str>) -> Result<i32> {

    let r = match branch {

        Some(b) => repo.git_export_as(git_dir, b)?,

        None => repo.git_export(git_dir)?,

    };

pub fn git_fetch(url: &str, branch: &str) -> Result<i32> {

    let repo = open()?;

    let sp = ui::spinner(&format!("Fetching {url} {branch}…"));

    let r = repo.git_fetch(url, branch)?;

    sp.clear();

    if r.commits == 0 {

        println!("{} {}", ui::done("Fetched"), ui::dim(format!("nothing new from {url} {branch}")));

    } else {

        println!(

            "{} {} ({} merges) from {} {}{}{} now has {}",

            ui::done("Fetched"),

            plural(r.commits, "new commit"),

            r.merges,

            ui::path(url),

            ui::bookmark(branch),

            ui::sep(),

            ui::bookmark(&repo.config.bookmark),

            plural(r.heads, "head")

        );

        if !repo.snapshot("oxy git fetch")?.changed {

            println!("  {} {}", ui::note(), ui::dim("working copy updated"));

        } else {

            println!("  {} {}", ui::note(), ui::dim("run oxy checkout to update the working copy"));

        }

    }

    if r.skipped_submodules > 0 {

        println!("  {} {}", ui::note(), ui::dim(format!("skipped {} submodule entries", r.skipped_submodules)));

    }

    Ok(0)

}

pub fn git_push(url: &str, branch: &str) -> Result<i32> {

    let repo = open()?;

    let sp = ui::spinner(&format!("Pushing to {url} {branch}…"));

    let r = repo.git_push(url, branch)?;

    sp.clear();

    println!(

        "{} {} to {} {} {}",

        ui::done("Pushed"),

        plural(r.exported, "new commit"),

        ui::path(url),

        ui::bookmark(&r.branch),

        ui::dim(format!("({} already there)", r.skipped))

    );

    Ok(0)

}