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.

[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.

[jarkad]

I present my own script, jj to, inspired by jj update from an earlier comment.

The meat hides in these two lines:

jj rebase -r "$commit" -A "$bookmark"
jj bookmark move -f "$bookmark" -t "$bookmark+"

That is, move the commit just after the bookmark, and then move the bookmark on top of it. "$bookmark+" works, because after rebase -A, the only child of $bookmark is $commit. I do not use $commit itself because it might point to a different commit after the rebase (e.g. @-).

My workflow uses mega-merge: I write a commit or two, and then move them to relevant branches with jj to. As a bonus, bookmarks are kept up-to-date for easy pushing.

[revset-aliases]
# those who would be abandoned
# if you check out something else
ephemeral = 'description(exact:"") & empty()'

[aliases]
to = ['util', 'exec', '--', 'sh', '-c', '''
set -eux

bookmark=$1
commit=${2-}

# default to latest non-ephemeral commit
if [ -z "$commit" ]; then
	commit=$(jj log --no-graph -T change_id -r '@ ~ ephemeral')
	if [ -n "$commit" ]; then
		# moving current commit, create a new one to preserve
		# current position in the commit DAG
		jj new
	else
		commit=@-
	fi
fi

jj rebase -r "$commit" -A "$bookmark"
jj bookmark move -f "$bookmark" -t "$bookmark+"
''', 'jj-to']

[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())

[G-Huber]

I'm doing this a bit differently using a script:

JJ_TUG.PS1

param(
    [Parameter(Mandatory = $false)]
    [string]$r = "@"
)

# Execute jj bookmark move command with the provided or default parameter
jj bookmark move -f "heads(first_ancestors($r) & bookmarks())" -t $r

Doing it like this, a target revision can be specified (defaulting to @) and it won't move multiple bookmarks as "heads(::@ & bookmarks())" might in a environment where merging branches is common.

[jaens]

Indeed, came here to write something very similar to this:

[revset-aliases]
'closest_bookmark(to)' = '''
  coalesce(
    heads(first_ancestors(to) & bookmarks()),
    heads(ancestors(to) & bookmarks())
  )
'''

This falls back to tugging from the "other" side if there is no bookmark on the "current" side.