feat(jujutsu)!: expose the bookmark distance as a template method

BREAKING CHANGE: the fetch_ahead_counter and ahead_icon options are
gone, finishing the fetch-option removal for jujutsu. ClosestBookmarks
now returns only the undecorated bookmark names, memoized so repeated
template references cost a single jj call. The distance to the closest
bookmark moves to a new lazy AheadCount template method - referencing
it is the fetch trigger, following git's StashCount pattern: the extra
jj log call runs on first use, memoized per render through unexported
fields gob snapshots never carry, reuses ClosestBookmarks' memoized
query for the bookmark it measures from, and returns 0 on error or
when no bookmark exists.

Configs with fetch_ahead_counter: true lose the inline decoration
inside .ClosestBookmarks and compose it in the template instead, e.g.
{{ if gt .AheadCount 0 }}{{ .AheadCount }}{{ end }} with an icon of
choice - ahead_icon existed only for that decoration. The dead keys
keep parsing silently. Docs, schema and the studio's recorded segment
data follow.

Co-Authored-By: Claude <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01M4RA9ZrP7vuqVSR7nddNiQ

Author: claude

src/segments/jujutsu.go

@@ -16,8 +16,6 @@ const (
 
 	IgnoreWorkingCopy options.Option = "ignore_working_copy"
 	ChangeIDMinLen    options.Option = "change_id_min_len"
-	FetchAhead        options.Option = "fetch_ahead_counter"
-	AheadIcon         options.Option = "ahead_icon"
 )
 
 type JujutsuStatus struct {
@@ -42,12 +40,16 @@ func (s *JujutsuStatus) add(code byte) {
 var jujutsuStatusFields = []string{workingField, "ChangeID", "ChangeIDPrefix", "ChangeIDRest"}
 
 type Jujutsu struct {
-	Working        *JujutsuStatus
-	ChangeID       string
-	ChangeIDPrefix string
-	ChangeIDRest   string
+	Working          *JujutsuStatus
+	ChangeID         string
+	ChangeIDPrefix   string
+	ChangeIDRest     string
+	closestBookmarks string
 	Scm
 	FieldRefs
+	aheadCount          int
+	closestBookmarksSet bool
+	aheadCountSet       bool
 }
 
 func (jj *Jujutsu) Template() string {
@@ -85,52 +87,60 @@ func (jj *Jujutsu) CacheKey() (string, bool) {
 	return dir.Path, true
 }
 
+// ClosestBookmarks returns the bookmark name(s) on the closest bookmarked
+// ancestor(s) of the working copy, undecorated. Resolved lazily on first
+// template use and memoized, so a template can reference it more than once
+// per render at the cost of a single jj call.
 func (jj *Jujutsu) ClosestBookmarks() string {
+	if jj.closestBookmarksSet {
+		return jj.closestBookmarks
+	}
+
+	jj.closestBookmarksSet = true
+
 	statusString, err := jj.getJujutsuCommandOutput("log", "-r", "heads(::@ & bookmarks())", "--no-graph", "-T", "bookmarks")
 	if err != nil {
 		return ""
 	}
 
-	line, _, _ := strings.Cut(statusString, "\n")
+	jj.closestBookmarks, _, _ = strings.Cut(statusString, "\n")
 
-	if !jj.options.Bool(FetchAhead, false) || len(line) == 0 {
-		return line
+	return jj.closestBookmarks
+}
+
+// AheadCount returns the number of changes between the working copy and the
+// closest bookmark (see ClosestBookmarks). Referencing it in a template is
+// what triggers the extra jj call: it runs on first use, memoized, and
+// returns 0 when there is no bookmark or the call fails. Templates compose
+// their own decoration, e.g. {{ if gt .AheadCount 0 }}\u21e1{{ .AheadCount }}{{ end }}.
+func (jj *Jujutsu) AheadCount() int {
+	if jj.aheadCountSet {
+		return jj.aheadCount
 	}
 
-	aheadIcon := jj.options.String(AheadIcon, "\u21e1")
-	marks := strings.Split(line, " ")
-	// String to return for status
-	var endString strings.Builder
+	jj.aheadCountSet = true
 
-	// Closest bookmarks are all the same distance away from the working copy
-	// so retrieve the distance to the first one and use it for all of them
+	// closest bookmarks all share the same distance from the working copy,
+	// so the first one measures for all of them - reusing ClosestBookmarks'
+	// memoized call instead of querying the bookmarks twice
+	line := jj.ClosestBookmarks()
+	if line == "" {
+		return 0
+	}
 
+	marks := strings.Split(line, " ")
 	rangeString := strings.Trim(marks[0], "*") + "..@"
 
 	aheadString, err := jj.getJujutsuCommandOutput("log", "--no-graph", "-T", "'.'", "-r", rangeString)
 	if err != nil {
-		return line
-	}
-
-	aheadCounter := len(aheadString)
-	aheadCounterString := ""
-
-	if aheadCounter != 0 {
-		aheadCounterString = aheadIcon + strconv.Itoa(aheadCounter)
+		return 0
 	}
 
-	log.Debug("distance to nearest jj bookmark:" + aheadCounterString)
+	jj.aheadCount = len(aheadString)
 
-	// Loop through each bookmark
-	for index, mark := range marks {
-		if index > 0 {
-			endString.WriteString(" ")
-		}
-
-		endString.WriteString(mark + aheadCounterString)
-	}
+	log.Debug("distance to nearest jj bookmark: " + strconv.Itoa(jj.aheadCount))
 
-	return endString.String()
+	return jj.aheadCount
 }
 
 func (jj *Jujutsu) shouldDisplay(displayStatus bool) bool {

src/segments/jujutsu_test.go

@@ -217,3 +217,153 @@ R {renamed_file => new_file}`,
 		})
 	}
 }
+
+func TestJujutsuClosestBookmarks(t *testing.T) {
+	cases := []struct {
+		Options  options.Map
+		Case     string
+		Output   string
+		Expected string
+		Error    bool
+	}{
+		{
+			Case:     "undecorated bookmark names",
+			Output:   "main feature/x\nnoise",
+			Expected: "main feature/x",
+		},
+		{
+			Case:  "command error",
+			Error: true,
+		},
+		{
+			Case: "no bookmarks",
+		},
+		{
+			// the fetch_ahead_counter/ahead_icon options no longer exist;
+			// leftover keys must parse silently and change nothing
+			Case:     "dead option keys are ignored",
+			Options:  options.Map{"fetch_ahead_counter": true, "ahead_icon": "⇡"},
+			Output:   "main",
+			Expected: "main",
+		},
+	}
+
+	for _, tc := range cases {
+		env := new(mock.Environment)
+
+		bookmarkArgs := []string{"--repository", "/repo", "--no-pager", "--color", "never", "--ignore-working-copy", "log", "-r", "heads(::@ & bookmarks())", "--no-graph", "-T", "bookmarks"} //nolint:lll
+		if tc.Error {
+			env.On("RunCommand", "jj", bookmarkArgs).Return("", errors.New("failed")).Once()
+		} else {
+			env.On("RunCommand", "jj", bookmarkArgs).Return(tc.Output, nil).Once()
+		}
+
+		opts := tc.Options
+		if opts == nil {
+			opts = options.Map{}
+		}
+
+		jj := &Jujutsu{
+			command:     JUJUTSUCOMMAND,
+			repoRootDir: "/repo",
+		}
+		jj.Init(opts, env)
+
+		// a second call must serve the memo, not a second jj invocation
+		// (the .Once() mock above panics otherwise)
+		assert.Equal(t, tc.Expected, jj.ClosestBookmarks(), tc.Case)
+		assert.Equal(t, tc.Expected, jj.ClosestBookmarks(), tc.Case)
+		env.AssertNumberOfCalls(t, "RunCommand", 1)
+	}
+}
+
+func TestJujutsuAheadCount(t *testing.T) {
+	cases := []struct {
+		Case          string
+		Bookmarks     string
+		ExpectedRange string
+		AheadOutput   string
+		Expected      int
+		AheadError    bool
+		Invoke        bool
+	}{
+		{
+			// referencing the method is the fetch trigger: without an
+			// invocation the distance query must never run
+			Case:      "not referenced, not fetched",
+			Bookmarks: "main",
+			Invoke:    false,
+		},
+		{
+			Case:          "distance to the closest bookmark",
+			Bookmarks:     "main feature/x",
+			ExpectedRange: "main..@",
+			AheadOutput:   "...",
+			Expected:      3,
+			Invoke:        true,
+		},
+		{
+			// conflicted bookmarks are marked with a trailing *
+			Case:          "conflicted bookmark marker is trimmed",
+			Bookmarks:     "main*",
+			ExpectedRange: "main..@",
+			AheadOutput:   ".",
+			Expected:      1,
+			Invoke:        true,
+		},
+		{
+			Case:      "no bookmarks skips the distance query",
+			Bookmarks: "",
+			Expected:  0,
+			Invoke:    true,
+		},
+		{
+			Case:          "distance query error",
+			Bookmarks:     "main",
+			ExpectedRange: "main..@",
+			AheadError:    true,
+			Expected:      0,
+			Invoke:        true,
+		},
+	}
+
+	for _, tc := range cases {
+		env := new(mock.Environment)
+
+		cli := []string{"--repository", "/repo", "--no-pager", "--color", "never", "--ignore-working-copy"}
+		bookmarkArgs := append(append([]string{}, cli...), "log", "-r", "heads(::@ & bookmarks())", "--no-graph", "-T", "bookmarks")
+		env.On("RunCommand", "jj", bookmarkArgs).Return(tc.Bookmarks, nil).Once()
+
+		aheadCalls := 0
+		if tc.ExpectedRange != "" {
+			aheadCalls = 1
+			aheadArgs := append(append([]string{}, cli...), "log", "--no-graph", "-T", "'.'", "-r", tc.ExpectedRange)
+
+			if tc.AheadError {
+				env.On("RunCommand", "jj", aheadArgs).Return("", errors.New("failed")).Once()
+			} else {
+				env.On("RunCommand", "jj", aheadArgs).Return(tc.AheadOutput, nil).Once()
+			}
+		}
+
+		jj := &Jujutsu{
+			command:     JUJUTSUCOMMAND,
+			repoRootDir: "/repo",
+		}
+		jj.Init(options.Map{}, env)
+
+		// the bookmarks memo is shared: AheadCount reuses ClosestBookmarks'
+		// single jj call instead of querying the bookmarks again
+		assert.Equal(t, tc.Bookmarks, jj.ClosestBookmarks(), tc.Case)
+
+		if !tc.Invoke {
+			env.AssertNumberOfCalls(t, "RunCommand", 1)
+			continue
+		}
+
+		// a second call must serve the memo (the .Once() mocks panic otherwise)
+		assert.Equal(t, tc.Expected, jj.AheadCount(), tc.Case)
+		assert.Equal(t, tc.Expected, jj.AheadCount(), tc.Case)
+		env.AssertNumberOfCalls(t, "RunCommand", 1+aheadCalls)
+	}
+}

themes/schema.json

@@ -2552,18 +2552,6 @@
                     "description": "Don't snapshot the working copy, and don't update it.",
                     "default": true
                   },
-                  "fetch_ahead_counter": {
-                    "type": "boolean",
-                    "title": "Fetch Ahead Counter",
-                    "description": "Fetch working copy # of changes ahead of the nearest bookmark.",
-                    "default": false
-                  },
-                  "ahead_icon": {
-                    "type": "string",
-                    "title": "Ahead icon",
-                    "description": "Icon to separate bookmark name and ahead counter.",
-                    "default": "\u21e1"
-                  },
                   "native_fallback": {
                     "$ref": "#/definitions/native_fallback"
                   },

website/docs/segments/scm/jujutsu.mdx

@@ -21,8 +21,6 @@ import Config from "@site/src/components/Config.js";
     background: "#ffeb3b",
     options: {
       ignore_working_copy: false,
-      fetch_ahead_counter: true,
-      ahead_icon: "\u21e1",
     },
   }}
 />
@@ -40,8 +38,6 @@ ignored silently in existing configs.
 | --------------------- | :-----------------: | :------: | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `change_id_min_len`   |        `int`        |   `0`    | `ChangeID` will be at least this many characters, even if a shorter one would be unique                                                                                                                                                                          |
 | `ignore_working_copy` |      `boolean`      |  `true`  | don't snapshot/update the working copy                                                                                                                                                                                                                           |
-| `fetch_ahead_counter` |      `boolean`      | `false`  | fetch a counter for number of changes between working copy and closest bookmark                                                                                                                                                                                  |
-| `ahead_icon`          |      `string`       | `\u21e1` | icon/character between bookmark and ahead counter                                                                                                                                                                                                                |
 | `native_fallback`     |      `boolean`      | `false`  | when set to `true` and `jj.exe` is not available when inside a WSL2 shared Windows drive, we will fallback to the native `jj` executable to fetch data. Not all information can be displayed in this case                                                        |
 | `status_formats`      | `map[string]string` |          | a key, value map allowing to override how individual status items are displayed. For example, `"status_formats": { "Added": "Added: %d" }` will display the added count as `Added: 1` instead of `+1`. See the [Status](#status) section for available overrides |
 
@@ -64,6 +60,7 @@ ignored silently in existing configs.
 | `.ChangeIDPrefix`   | `string` | The shortest unique prefix of the working copy change ID                                                                                                                         |
 | `.ChangeIDRest`     | `string` | The additional portion displayed after `.ChangeIDPrefix` to satisfy `change_id_min_len`; empty when the unique prefix already meets or exceeds that minimum                      |
 | `.ClosestBookmarks` | `string` | Closest bookmark(s) on ancestors                                                                                                                                                 |
+| `.AheadCount`       | `int`    | Number of changes between the working copy and the closest bookmark; fetched lazily when referenced, e.g. `{{ if gt .AheadCount 0 }}\u21e1{{ .AheadCount }}{{ end }}`            |
 
 `.ChangeIDRest` is not the remainder of the full canonical change ID and isn't independently usable as an identifier.
 

website/segment_data.json

@@ -1565,6 +1565,7 @@
     },
     "jujutsu": {
       "data": {
+        "AheadCount": 0,
         "ChangeID": "mzvwutnw",
         "ChangeIDPrefix": "mz",
         "ChangeIDRest": "vwutnw",