Find the closest bookmark in history to advance it forward

[jennings]

When appending a new commit to a branch using jj commit, I need to find the "closest" bookmark to move it forward. Is there a shorter way to do this besides jj bookmark set my-bookmark -r @-?

[jennings]

The revset to find the commit with the bookmark closest to @ is heads(::@ & bookmarks()).

Some people in the jj community have an alias they call jj tug that uses this revset to advance the closest bookmark. Configuration:

[revset-aliases]
'closest_bookmark(to)' = 'heads(::to & bookmarks())'

[aliases]
tug = ["bookmark", "move", "--from", "closest_bookmark(@-)", "--to", "@-"]

Usage:

$ jj new my-feature

# work work work

$ jj commit -m "Add some changes"
$ jj tug

# The bookmark my-feature is now at @-

If you want to move the bookmark to @ instead of @-, substitute @ in the definition of the tug alias.

[bryceberger]

Note that this doesn't play very nice with the megamerge workflow.

o current work
o merge point
|\
| o bookmark A
o | bookmark B
|/
o trunk

closest_bookmark() will see both bookmarks, and move both of them.

[senekor]

This can be fixed with a script. The following alias jj tug will correctly work with the mega-merge workflow.

[aliases]
tug = ["util", "exec", "--", "bash", "-c", """
#!/usr/bin/env bash
set -euo pipefail

for parent in $(jj log --no-graph --revisions @- --template 'commit_id ++ "\n"')
do
    jj --ignore-working-copy \
        bookmark move \
        --from "heads(::$parent & bookmarks())" \
        --to "$parent"
done
""", ""]

There are two small downsides to this:

1. bash must be installed. If you don't have it, it should be easy enough to port the script to another scripting language.
2. This script will create several entries in the op log, meaning it cannot be undone with a simple jj undo.

Edit: For the script to work, the merge commit must also be the working copy. So, in the example in the above comment, it doesn't work either:

o current work
o merge point
|\
| o bookmark A
o | bookmark B

It would work if it looked instead like this:

o current work (also merge point)
|\
| o bookmark A
o | bookmark B

[cormacrelf]

Re megamerge workflow, see also #5130

[senekor]

The more I think about it, my script above probably doesn't fit into a good workflow. Two reasons:

• It only works if the megamerge is "flat", i.e. no stacked PRs (sad):

  @      (working copy)
  ├─╮─╮
  │ │ ○  feat/A
  │ ○ │  feat/B
  ○ ├─╯  feat/C
  │ ○    feat/D (also being worked on, but A and B depend on it)
  ├─╯
  ○      main (immutable)
  

  My script above cannot advance the bookmark feat/D, because it isn't an immediate parent of the megamerge commit.

• The workflow is still a little tedious, you still have to do these steps manually:

  • create a new commit
  • rebase the commit with --insert-after the desired bookmark
  • run jj tug (which, as mentioned, doesn't even work for feat/D)

I have another idea which is orthogonal to jj tug: A script which performs the above steps in one go. (commit, rebase, bookmark move). I have it wrapped in an alias "cob" ("commit onto bookmark"), so I can call it with jj cob <bookmark_name> [commit args...].

@cormacrelf do you think this could suit your workflow?

#!/usr/bin/env bash
set -euo pipefail

if test -z ${1+x}
then
    echo "You need to specify a bookmark onto which to place the commit!"
    exit 1
fi
target_bookmark="$1" ; shift

jj commit "$@"

change_id="$(jj --ignore-working-copy log --revisions @- --no-graph --template change_id)"

jj --ignore-working-copy rebase --revisions "$change_id" --insert-after "$target_bookmark"
jj --ignore-working-copy bookmark move "$target_bookmark" --to "$change_id"

Edit: Oh and this jj cob also works completely independent of where the working copy is.

[joyously]

Read about the --advance-branches feature request : #2338

[emesterhazy]

+1, please take a look and see if this meets your needs. There is additional discussion about it here as well: #3549

[glehmann]

A slightly modified version that also works with the edit workflow:

[revset-aliases]
'closest_bookmark(to)' = 'heads(::to & bookmarks())'
'closest_pushable(to)' = 'heads(::to & ~description(exact:"") & (~empty() | merges()))'

[aliases]
tug = ["bookmark", "move", "--from", "closest_bookmark(@)", "--to", "closest_pushable(@)"]

Instead of moving the bookmark to the commit before the working copy, it moves the bookmark to the closest commit with a description that is either not empty or a merge.

[calebdw]

I had to add mutable() to the closest_pushable alias---on a sizable repository the tug command was taking over 6 seconds:

[aliases]
tug = ["bookmark", "move", "--from", "closest_bookmark(@)", "--to", "closest_pushable(@)"]

[revset-aliases]
'closest_bookmark(to)' = 'heads(::to & bookmarks())'
'closest_pushable(to)' = 'heads(::to & mutable() & ~description(exact:"") & (~empty() | merges()))'

# BEFORE
$ time jj tug
Moved 1 bookmarks to utnqyptt b4eb4f18 develop* | feat: set remember me checkbox to true by default
________________________________________________________
Executed in    6.27 secs    fish           external
   usr time    6.23 secs  272.00 micros    6.23 secs
   sys time    0.18 secs  153.00 micros    0.18 secs

# AFTER
$ time jj tug
Moved 1 bookmarks to utnqyptt b4eb4f18 develop* | feat: set remember me checkbox to true by default
________________________________________________________
Executed in   69.17 millis    fish           external
   usr time  134.44 millis  373.00 micros  134.07 millis
   sys time  101.30 millis    0.00 micros  101.30 millis

[OliverUv]

Combined some of the above to

[aliases]
tug = ["util", "exec", "--", "sh", "-c", """
if [ "x$1" = "x" ]; then
  jj bookmark move --from "closest_bookmark(@)" --to "closest_pushable(@)"
else
  jj bookmark move --to "closest_pushable(@)" "$@"
fi
""", ""]

and

[revset-aliases]
'closest_bookmark(to)' = 'heads(::to & bookmarks())'
'closest_pushable(to)' = 'heads(::to & mutable() & ~description(exact:"") & (~empty() | merges()))'

[alkeryn]

pretty cool, i wonder if there is a way to set it to run the command automatically whenever there is a new on top of the lattest unbookmarked change.

[calebdw]

pretty cool, i wonder if there is a way to set it to run the command automatically whenever there is a new on top of the lattest unbookmarked change.

That's not what you want, there's another discussion on here that would enable bookmarks to auto advance

[glehmann]

@alkeryn did you look at the experimental-advance-branches mentioned in #5568 (comment)? It might do what you want.

[lgarron]

I'm trying to adapt some of the discussion here and at #6832

My goal is to select single closest bookmark for my prompt:

It seems a bunch of issues stem from two problems:

• There may be multiple bookmarks equally close. Seems I can use latest(…) for that: How do I get a single "closest" bookmark? #6958
• The latest bookmark may be assigned to a change with another bookmark. In this case, using a template to output bookmarks() will print multiple bookmarks instead of one.

https://jj-vcs.github.io/jj/latest/templates/#global-functions suggests that coalesce(…) might do the trick, but it seems to have no effect.

As a workaround, I can try to use jj guess-branch | head -n 1 but that loses the color formatting.

Is there a way to get the first element of a List<CommitRef> directly?

[scott2000]

It's a bit of a hack, but you could maybe do something like stringify(bookmarks.map(|b| b.name()).join("\n")).first_line()?

[lgarron]

It's a bit of a hack, but you could maybe do something like stringify(bookmarks.map(|b| b.name()).join("\n")).first_line()?

Thanks, that was actually the first thing I tried to do, but it also loses formatting color.

[lgarron]

Aha, I guess I could do:

label(\"bookmark\", stringify(bookmarks.map(|b| b.name()).join(\"\n\")).first_line())

That's rather unwieldy and technically performs wasteful work, but as far as I can tell it's at least correct. In particular, this preserves the * marker for a tracked branch when I do:

label(\"bookmark\", stringify(bookmarks.join(\"\n\")).first_line())