feat: add Jujutsu (jj) compatibility via VCSOperations abstraction

Adds end-to-end Jujutsu support for stacked PRs in colocated git+jj repos,
preserving jj change IDs across all spr operations and using jj-native
primitives (auto-rebase, conflicts as commits, non-blocking edits) instead
of mimicking git's rebase-session model.

Core architecture:
- New vcs.VCSOperations interface — the abstraction boundary for
  history-rewriting operations (FetchAndRebase, GetLocalCommitStack,
  AmendInto, EditStart/Finish/Abort, Fetch, PushBranches, etc.).
- vcs/git_ops.go: git implementation (extracted from spr.go, behavior-
  preserving). Improved EditFinish uses .git/REBASE_HEAD to distinguish
  conflict-resolution from initial edit stop and stages only tracked
  changes (subsumes upstream's 606df43 and 0767a45 fixes).
- vcs/jj_ops.go: jj implementation. Uses jj-native commands:
  jj git fetch + jj rebase, jj describe (for auto-added commit-id
  trailers), jj squash --into, jj edit, jj bookmark set + jj git push.
- Commit.ChangeID field (empty in git mode, populated in jj mode).
- vcs/detect.go: factory chooses JjOps when .jj/ exists and User.NoJJ
  is false; respects --no-jj flag and SPR_NOJJ env var.

Auto-revset (the key correctness fix):
- JjOps.GetLocalCommitStack queries trunk()..(@:: | ::@) — the
  connected component containing @, excluding trunk — rather than the
  position-dependent trunk()..@. Result: spr finds the full stack
  regardless of where @ is, so 'spr update' from a mid-stack @ no
  longer silently truncates the stack and closes PRs for the missing
  commits.
- JjOps.CheckStackCompleteness detects multi-head ambiguity via
  heads(trunk()..(@:: | ::@)) and refuses non-linear stacks with a
  clear error pointing at jj rebase / jj edit as the fix.
- checkStackUsable (renamed from confirmIfIncompleteStack, used as
  guard in update/merge/status/check/amend) blocks rather than prompts
  on ambiguity — no safe 'continue anyway' answer exists.

jj-mode behavioral divergences:
- spr edit (jj): announces the action then runs 'jj edit <change-id>'.
  No state file, no op-id snapshot, no rebase-session machinery —
  jj is non-blocking and 'jj undo' handles revert. --done and --abort
  are echo-only deprecations that point users at native jj.
- spr sync (jj): runs 'jj git fetch' (the literal 'git cherry-pick'
  was broken in jj). No rebase promise — that's spr update's job.

VCS-layer integrations:
- Configurable branch prefix (upstream feature b01881d): jj_ops
  threads cfg.User.BranchPrefix through PushBranches' bookmark glob.
- Stdout/stderr separation in vcs/jj_cmd.go: replaced
  cmd.CombinedOutput() with separate capture so jj's stderr messages
  (e.g. 'Rebased 1 descendant commits onto updated working copy')
  don't corrupt parsed log output. Caught by the conflicted-push
  integration test.

Testing:
- Two suites: unit (mockjj-based, fast) and integration (real jj via
  the new vcs/jjtest package + a colocated test repo).
- Integration build tag //go:build integration; SPR_SKIP_JJ_INTEGRATION=1
  env var to skip cleanly.
- jjtest.NewRepo creates a colocated git+jj repo in t.TempDir() with a
  bare-repo origin; helpers for stack topology (AddCommit, Edit, Fork,
  InsertAbove, SnapshotOpLog, AssertOpsSince).
- Headline regression: TestSprIntegration_StatusFromMidStack_ShowsFullStack
  pins that GetLocalCommitStack from mid-stack @ returns the whole stack.
- TestJjIntegration_PushBranches_ConflictedCommit_Refused pins jj's
  natural refusal to push conflicts (this is the test that revealed
  the stderr bug).
- 100% statement coverage on jj-related production code (jj_ops.go,
  jj_cmd.go, jj_parse.go).
- Op-log assertions verify that spr commands do exactly the expected
  jj operations and no destructive ones.

Coverage tooling:
- scripts/coverage-merge/main.go merges two coverprofile files (max
  hits per block, within and across profiles) and reports per-file
  attribution (unit %, integ %, merged %, plus 'only in X' sections).
- Makefile targets: test-unit, test-integration, test-all, coverage-html.
- CI installs pinned JJ_VERSION (0.40.0), runs both suites with
  -coverpkg=./..., merges, uploads as artifact.

Documentation:
- readme.md: new Jujutsu (jj) Support section covering setup, the
  jj spr command set, divergences for edit/sync, the multi-head error
  message, and the auto-revset behavior.
- docs/jj-mode-design.md: full design rationale including alternatives
  considered (spr-tip bookmark, 3-option prompt), the stderr bug fix,
  testing strategy, and what's deferred.

Files: +4500/-110 across 35 files.

Author: jucor

.github/workflows/ci.yml

@@ -2,6 +2,11 @@ name: golang build
 
 on: [push, pull_request, workflow_dispatch]
 
+env:
+  # Pin the jj version used by integration tests. Bump intentionally;
+  # jj's revset/template syntax can change between minor versions.
+  JJ_VERSION: 0.40.0
+
 jobs:
 
   build:
@@ -15,22 +20,52 @@ jobs:
       with:
         go-version: 1.21
 
+    - name: Install jj
+      run: |
+        set -euo pipefail
+        curl -fsSL \
+          "https://github.com/jj-vcs/jj/releases/download/v${JJ_VERSION}/jj-v${JJ_VERSION}-x86_64-unknown-linux-musl.tar.gz" \
+          | tar -xz -C /usr/local/bin/ jj
+        jj --version
+
     - name: Build
       working-directory: ./
       run: go build -v ./...
 
-    - name: Test
+    - name: Test (unit)
       working-directory: ./
-      run: go test -race -coverprofile=./coverage.txt -covermode=atomic ./...
+      run: go test -race -coverprofile=cov-unit.out -covermode=atomic ./...
+
+    - name: Test (integration)
+      working-directory: ./
+      run: |
+        # Configure a default git identity so jj's colocated git backend
+        # has something to use (the per-repo overrides in jjtest also set
+        # this, but a global default avoids any first-call edge cases).
+        git config --global user.name "spr-ci"
+        git config --global user.email "spr-ci@example.com"
+        go test -race -tags=integration -coverprofile=cov-integration.out -covermode=atomic ./...
+
+    - name: Merge coverage and report per-file attribution
+      working-directory: ./
+      run: go run ./scripts/coverage-merge cov-unit.out cov-integration.out cov-merged.out
+
+    - name: Upload coverage artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: coverage
+        path: |
+          cov-unit.out
+          cov-integration.out
+          cov-merged.out
 
     - name: Check goreleaser file
       uses: goreleaser/goreleaser-action@v6.2.1
       with:
         version: latest
         args: check
 
-    #- name: Upload coverage
+    #- name: Upload coverage to codecov
     #  uses: codecov/codecov-action@v2
     #  with:
-    #    files: ./coverage.txt
-
+    #    files: ./cov-merged.out

Makefile

@@ -1,4 +1,30 @@
+.PHONY: bin test test-unit test-integration test-all coverage-html
 
 bin:
 	goreleaser build --snapshot --clean --single-target
 
+# Default test target: unit tests only.
+test: test-unit
+
+# Unit tests — no integration build tag, no jj binary required.
+# -coverpkg=./... so coverage of cross-package calls is counted (e.g.
+# spr_test.go calls into vcs.JjOps, which we want reflected in vcs/jj_ops.go
+# coverage).
+test-unit:
+	go test -race -coverpkg=./... -coverprofile=cov-unit.out -covermode=atomic ./...
+
+# Integration tests — runs against a real `jj` binary. Set
+# SPR_SKIP_JJ_INTEGRATION=1 to skip cleanly when jj is unavailable.
+test-integration:
+	go test -race -tags=integration -coverpkg=./... -coverprofile=cov-integration.out -covermode=atomic ./...
+
+# Both suites, then merge profiles and print per-file attribution.
+test-all: test-unit test-integration
+	@go run ./scripts/coverage-merge cov-unit.out cov-integration.out cov-merged.out
+
+# Generate HTML coverage reports for both profiles plus the merged view.
+coverage-html: test-all
+	go tool cover -html=cov-unit.out -o cov-unit.html
+	go tool cover -html=cov-integration.out -o cov-integration.html
+	go tool cover -html=cov-merged.out -o cov-merged.html
+	@echo "Open cov-unit.html, cov-integration.html, cov-merged.html"

cmd/amend/main.go

@@ -10,6 +10,7 @@ import (
 	"github.com/ejoffe/spr/git/realgit"
 	"github.com/ejoffe/spr/github/githubclient"
 	"github.com/ejoffe/spr/spr"
+	"github.com/ejoffe/spr/vcs"
 	"github.com/jessevdk/go-flags"
 	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/log"
@@ -62,7 +63,8 @@ func main() {
 	client := githubclient.NewGitHubClient(ctx, cfg)
 	gitcmd = realgit.NewGitCmd(cfg)
 
-	sd := spr.NewStackedPR(cfg, client, gitcmd)
+	vcsOps := vcs.NewVCSOperations(cfg, gitcmd)
+	sd := spr.NewStackedPR(cfg, client, gitcmd, vcsOps)
 	sd.AmendCommit(ctx)
 
 	if opts.Update {

cmd/spr/main.go

@@ -5,6 +5,7 @@ import (
 	"context"
 	"fmt"
 	"os"
+	"os/exec"
 	"strings"
 
 	"github.com/ejoffe/rake"
@@ -13,6 +14,7 @@ import (
 	"github.com/ejoffe/spr/git/realgit"
 	"github.com/ejoffe/spr/github/githubclient"
 	"github.com/ejoffe/spr/spr"
+	"github.com/ejoffe/spr/vcs"
 	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/log"
 
@@ -95,9 +97,21 @@ func main() {
 	}
 	gitcmd = realgit.NewGitCmd(cfg)
 
+	// Check for --no-jj flag or SPR_NOJJ env var before creating VCS operations.
+	// This must happen before app.Run() since vcsOps is created here.
+	for _, arg := range os.Args[1:] {
+		if arg == "--no-jj" {
+			cfg.User.NoJJ = true
+		}
+	}
+	if os.Getenv("SPR_NOJJ") == "true" {
+		cfg.User.NoJJ = true
+	}
+
 	ctx := context.Background()
 	client := githubclient.NewGitHubClient(ctx, cfg)
-	stackedpr := spr.NewStackedPR(cfg, client, gitcmd)
+	vcsOps := vcs.NewVCSOperations(cfg, gitcmd)
+	stackedpr := spr.NewStackedPR(cfg, client, gitcmd, vcsOps)
 
 	detailFlag := &cli.BoolFlag{
 		Name:  "detail",
@@ -160,6 +174,12 @@ VERSION: fork of {{.Version}}
 				Value: false,
 				Usage: "Show runtime debug info",
 			},
+			&cli.BoolFlag{
+				Name:    "no-jj",
+				Value:   false,
+				Usage:   "Disable jj (Jujutsu) mode even in jj-colocated repos",
+				EnvVars: []string{"SPR_NOJJ"},
+			},
 		},
 		Before: func(c *cli.Context) error {
 			if c.IsSet("debug") {
@@ -346,6 +366,25 @@ VERSION: fork of {{.Version}}
 				return nil
 			},
 		},
+			{
+				Name:  "jj-setup",
+				Usage: "Register 'jj spr' alias for use in Jujutsu repos",
+				Action: func(c *cli.Context) error {
+					cmd := exec.Command("jj", "config", "set", "--user",
+						"aliases.spr", `["util", "exec", "--", "git-spr"]`)
+					cmd.Stdout = os.Stdout
+					cmd.Stderr = os.Stderr
+					err := cmd.Run()
+					if err != nil {
+						return cli.Exit(fmt.Sprintf("Failed to set jj alias: %s", err), 1)
+					}
+					fmt.Println("jj alias registered. You can now use:")
+					fmt.Println("  jj spr update")
+					fmt.Println("  jj spr status")
+					fmt.Println("  jj spr merge")
+					return nil
+				},
+			},
 			{
 				Name:  "version",
 				Usage: "Show version info",

config/config.go

@@ -41,6 +41,7 @@ type RepoConfig struct {
 	ForceFetchTags bool `default:"false" yaml:"forceFetchTags"`
 
 	ShowPrTitlesInStack    bool `default:"false" yaml:"showPrTitlesInStack"`
+	ShowStackNumberInTitle bool `default:"false" yaml:"showStackNumberInTitle"`
 	BranchPushIndividually bool `default:"false" yaml:"branchPushIndividually"`
 }
 
@@ -55,6 +56,7 @@ type UserConfig struct {
 	PreserveTitleAndBody bool `default:"false" yaml:"preserveTitleAndBody"`
 	NoRebase             bool `default:"false" yaml:"noRebase"`
 	NoFetch              bool `default:"false" yaml:"noFetch"`
+	NoJJ                 bool `default:"false" yaml:"noJJ"`
 	DeleteMergedBranches bool `default:"false" yaml:"deleteMergedBranches"`
 	ShortPRLink          bool `default:"false" yaml:"shortPRLink"`
 	ShowCommitID         bool `default:"false" yaml:"showCommitID"`