jj-git(1)

jj-git 💅✨

okay bestie, welcome to the jj-git manual page (manual section 1, General Commands Manual, iykyk) — the whole vibe here is commands for working with Git remotes and the underlying Git repo. yes that's a mouthful. yes it's iconic. 🫶

---

✨ NAME ✨

jj-git — commands for working with Git remotes and the underlying Git repo 🦋

---

🌸 SYNOPSIS 🌸

jj git [-R|--repository] [--ignore-working-copy]
[--no-integrate-operation] [--ignore-immutable] [--at-operation]
[--debug] [--color] [--quiet] [--no-pager] [--config] [--config-file]
[-h|--help] <subcommands>

---

💖 DESCRIPTION 💖

Commands for working with Git remotes and the underlying Git repo. literally what it says on the tin, no cap.

See this comparison, including a table of commands, if you wanna see how this stacks up:

• https://docs.jj-vcs.dev/latest/git-comparison/
• https://docs.jj-vcs.dev/latest/git-command-table

---

🎀 OPTIONS 🎀

• -h, --help — print help. and if you want the short version, hit it with '-h' instead. cute, right?

---

👑 GLOBAL OPTIONS 👑

these apply everywhere, main character energy:

• -R, --repository <REPOSITORY> — the path to the repository you wanna operate on. 💅

by default, Jujutsu goes hunting for the closest .jj/ directory in an ancestor of the current working directory. it's giving "I'll find it myself, don't worry."

• --ignore-working-copy — don't snapshot the working copy, and don't update it. 🛑

so like, by default Jujutsu snapshots the working copy at the beginning of every command. and the working copy also gets updated at the end of the command, if the command modified the working-copy commit (@). if you'd rather avoid snapshotting the working copy and instead see a possibly stale working-copy commit, you can use --ignore-working-copy. this may be useful e.g. in a command prompt, especially if you have another process that commits the working copy. teamwork!

ngl, loading the repository at a specific operation with --at-operation implies --ignore-working-copy. so that's automatic, bestie.

• --no-integrate-operation — run the command as usual but don't integrate any operations. 🙈

when this option is given, the operations will still be created as usual but they will not be integrated to the operation log. the working copy will also not be updated. so the work happened, it's just not in the log yet.

the command will print the resulting operation ID. you can pass that to e.g. jj --at-op to inspect the resulting repo state, or you can pass it to jj op restore to restore the repo to that state. you can also pass the ID to jj op integrate to integrate the operation. so many options, so much power.

⚠️ note that this does not prevent side effects outside the repo. for example, jj git push --no-integrate-operation will still perform the push. that push is real. that push is out there. 😭

• --ignore-immutable — allow rewriting immutable commits. 😳

by default, Jujutsu prevents rewriting commits in the configured set of immutable commits. this option disables that check and lets you rewrite any commit but the root commit. feral behaviour, honestly.

this option only affects the check. it does not affect the immutable_heads() revset or the immutable template keyword.

• --at-operation <AT_OPERATION> — operation to load the repo at. 🕰️

operation to load the repo at. by default, Jujutsu loads the repo at the most recent operation, or at the merge of the divergent operations if any.

you can use --at-op=<operation ID> to see what the repo looked like at an earlier operation. for example jj --at-op=<operation ID> st will show you what jj st would have shown you when the given operation had just finished. --at-op=@ is pretty much the same as the default except that divergent operations will never be merged. okay slay.

use jj op log to find the operation ID you want. any unambiguous prefix of the operation ID is enough. no need for the whole thing, we're not doing all that. ✨

when loading the repo at an earlier operation, the working copy will be ignored, as if --ignore-working-copy had been specified.

it is possible to run mutating commands when loading the repo at an earlier operation. doing that is equivalent to having run concurrent commands starting at the earlier operation. there's rarely a reason to do that, but it is possible. you can. nobody's stopping you. 😭

• --debug — enable debug logging. 🐛 for the girlies who need to see everything.
• --color <WHEN> — when to colorize output. 🌈

possible values:

• always
• never
• debug
• auto

• --quiet — silence non-primary command output. 🤫

for example, jj file list will still list files, but it won't tell you if the working copy was snapshotted or if descendants were rebased. it's keeping it lowkey.

warnings and errors will still be printed. the important stuff always gets through, periodt.

• --no-pager — disable the pager.
• --config <NAME=VALUE> — additional configuration options (can be repeated). 💜

the name should be specified as TOML dotted keys. the value should be specified as a TOML expression. if string value isn't enclosed by any TOML constructs (such as array notation), quotes can be omitted. fancy but make it easy.

• --config-file <PATH> — additional configuration files (can be repeated). 📁

---

🦋 SUBCOMMANDS 🦋

the whole squad, in order:

• jj-git-clone(1) — create a new repo backed by a clone of a Git repo.
• jj-git-colocation(1) — manage Jujutsu repository colocation with Git.
• jj-git-export(1) — update the underlying Git repo with changes made in the repo.
• jj-git-fetch(1) — fetch from a Git remote.
• jj-git-import(1) — update repo with changes made in the underlying Git repo.
• jj-git-init(1) — create a new Git backed repo.
• jj-git-push(1) — push to a Git remote.
• jj-git-remote(1) — manage Git remotes.
• jj-git-root(1) — show the underlying Git directory of a repository using the Git backend.

---

okay that's the whole page, bestie, you ate it. 💅✨ this cutie came to you from the git source, dated jj-git(1), manual section 1 — go forth and git responsibly. 🎀🫶 bye!!