feat(walk): add jujutsu walker

- added jujutsu module similar to the git module, which provides the `IsInsideWorktree` function
- added jujutsu walker, with the following differences to the git walker
  - the list command does not update the index. thus, new files are not listed, the user has to add them to the index first by running a `jj` command
- added jujutsu walker test
- added jujutsu walker root test
- adapted config and docs

Author: delafthi

cmd/init/init.toml

@@ -48,7 +48,7 @@
 # verbose = 2
 
 # The method used to traverse the files within the tree root
-# Currently, we support 'auto', 'git' or 'filesystem'
+# Currently, we support 'auto', 'git', 'jujutsu', or 'filesystem'
 # Env $TREEFMT_WALK
 # walk = "filesystem"
 
@@ -64,4 +64,4 @@ excludes = []
 # Controls the order of application when multiple formatters match the same file
 # Lower the number, the higher the precedence
 # Default is 0
-priority = 0
+priority = 0

cmd/root_test.go

@@ -1536,6 +1536,218 @@ func TestGit(t *testing.T) {
 	)
 }
 
+func TestJujutsu(t *testing.T) {
+	as := require.New(t)
+
+	tempDir := test.TempExamples(t)
+	configPath := filepath.Join(tempDir, "/treefmt.toml")
+
+	test.ChangeWorkDir(t, tempDir)
+
+	// basic config
+	cfg := &config.Config{
+		FormatterConfigs: map[string]*config.Formatter{
+			"echo": {
+				Command:  "echo", // will not generate any underlying changes in the file
+				Includes: []string{"*"},
+			},
+		},
+	}
+
+	test.WriteConfig(t, configPath, cfg)
+
+	// init a jujutsu repo (disable signing for testing)
+	jjCmd := exec.Command("jj", "git", "init", "--config", "signing.backend=none")
+	as.NoError(jjCmd.Run(), "failed to init jujutsu repository")
+
+	// run before adding anything to the index
+	// we shouldn't pick up untracked files, because here the jujutsu walker differs from the git walker
+	treefmt(t,
+		withConfig(configPath, cfg),
+		withNoError(t),
+		withStats(t, map[stats.Type]int{
+			stats.Traversed: 0,
+			stats.Matched:   0,
+			stats.Formatted: 0,
+			stats.Changed:   0,
+		}),
+	)
+
+	// add everything to the index (disable signing for testing)
+	jjCmd = exec.Command("jj", "file", "track", "--config", "signing.backend=none", ".")
+	as.NoError(jjCmd.Run(), "failed to add everything to the index")
+
+	// update jujutsu's index (disable signing for testing)
+	jjCmd = exec.Command("jj", "--config", "signing.backend=none")
+	as.NoError(jjCmd.Run(), "failed to update the index")
+
+	treefmt(t,
+		withConfig(configPath, cfg),
+		withNoError(t),
+		withStats(t, map[stats.Type]int{
+			stats.Traversed: 32,
+			stats.Matched:   32,
+			stats.Formatted: 0,
+			stats.Changed:   0,
+		}),
+	)
+
+	// create a file which should be in .gitignore
+	f, err := os.CreateTemp(tempDir, "test-*.txt")
+	as.NoError(err, "failed to create temp file")
+
+	// add everything to the index (disable signing for testing), this command shoud ignore files in .gitignore
+	jjCmd = exec.Command("jj", "file", "track", "--config", "signing.backend=none", ".")
+	as.NoError(jjCmd.Run(), "failed to add everything to the index")
+
+	// update jujutsu's index (disable signing for testing)
+	jjCmd = exec.Command("jj", "--config", "signing.backend=none")
+	as.NoError(jjCmd.Run(), "failed to update the index")
+
+	t.Cleanup(func() {
+		_ = f.Close()
+	})
+
+	treefmt(t,
+		withConfig(configPath, cfg),
+		withNoError(t),
+		withStats(t, map[stats.Type]int{
+			stats.Traversed: 32,
+			stats.Matched:   32,
+			stats.Formatted: 0,
+			stats.Changed:   0,
+		}),
+	)
+
+	// remove python directory
+	as.NoError(os.RemoveAll(filepath.Join(tempDir, "python")), "failed to remove python directory")
+
+	// update jujutsu's index (disable signing for testing)
+	jjCmd = exec.Command("jj", "--config", "signing.backend=none")
+	as.NoError(jjCmd.Run(), "failed to update the index")
+
+	// we should traverse and match against fewer files, but no formatting should occur as no formatting signatures
+	// are impacted
+	treefmt(t,
+		withConfig(configPath, cfg),
+		withNoError(t),
+		withStats(t, map[stats.Type]int{
+			stats.Traversed: 29,
+			stats.Matched:   29,
+			stats.Formatted: 0,
+			stats.Changed:   0,
+		}),
+	)
+
+	// remove nixpkgs.toml from the filesystem but leave it in the index
+	as.NoError(os.Remove(filepath.Join(tempDir, "nixpkgs.toml")))
+
+	// walk with filesystem instead of with jujutsu
+	// the .jj folder contains 104 additional files
+	// when added to the 30 we started with (34 minus nixpkgs.toml which we removed from the filesystem), we should
+	// traverse 134 files.
+	treefmt(t,
+		withArgs("--walk", "filesystem"),
+		withConfig(configPath, cfg),
+		withNoError(t),
+		withStats(t, map[stats.Type]int{
+			stats.Traversed: 134,
+			stats.Matched:   134,
+			stats.Formatted: 106, // the echo formatter should only be applied to the new files
+			stats.Changed:   0,
+		}),
+	)
+
+	// format specific sub paths
+	// we should traverse and match against those files, but without any underlying change to their files or their
+	// formatting config, we will not format them
+
+	treefmt(t,
+		withArgs("go"),
+		withConfig(configPath, cfg),
+		withNoError(t),
+		withStats(t, map[stats.Type]int{
+			stats.Traversed: 2,
+			stats.Matched:   2,
+			stats.Formatted: 0,
+			stats.Changed:   0,
+		}),
+	)
+
+	treefmt(t,
+		withArgs("go", "haskell"),
+		withConfig(configPath, cfg),
+		withNoError(t),
+		withStats(t, map[stats.Type]int{
+			stats.Traversed: 9,
+			stats.Matched:   9,
+			stats.Formatted: 0,
+			stats.Changed:   0,
+		}),
+	)
+
+	treefmt(t,
+		withArgs("-C", tempDir, "go", "haskell", "ruby"),
+		withConfig(configPath, cfg),
+		withNoError(t),
+		withStats(t, map[stats.Type]int{
+			stats.Traversed: 10,
+			stats.Matched:   10,
+			stats.Formatted: 0,
+			stats.Changed:   0,
+		}),
+	)
+
+	// try with a bad path
+	treefmt(t,
+		withArgs("-C", tempDir, "haskell", "foo"),
+		withConfig(configPath, cfg),
+		withError(func(as *require.Assertions, err error) {
+			as.ErrorContains(err, "foo not found")
+		}),
+	)
+
+	// try with a path not in the git index
+	_, err = os.Create(filepath.Join(tempDir, "foo.txt"))
+	as.NoError(err)
+
+	treefmt(t,
+		withArgs("haskell", "foo.txt", "-vv"),
+		withConfig(configPath, cfg),
+		withNoError(t),
+		withStats(t, map[stats.Type]int{
+			stats.Traversed: 8,
+			stats.Matched:   8,
+			stats.Formatted: 1, // we only format foo.txt, which is new to the cache
+			stats.Changed:   0,
+		}),
+	)
+
+	treefmt(t,
+		withArgs("go", "foo.txt"),
+		withConfig(configPath, cfg),
+		withNoError(t),
+		withStats(t, map[stats.Type]int{
+			stats.Traversed: 3,
+			stats.Matched:   3,
+			stats.Formatted: 0,
+			stats.Changed:   0,
+		}),
+	)
+
+	treefmt(t,
+		withArgs("foo.txt"),
+		withConfig(configPath, cfg),
+		withNoError(t),
+		withStats(t, map[stats.Type]int{
+			stats.Traversed: 1,
+			stats.Matched:   1,
+			stats.Formatted: 0,
+			stats.Changed:   0,
+		}),
+	)
+}
+
 func TestTreeRootCmd(t *testing.T) {
 	as := require.New(t)
 

config/config.go

@@ -17,6 +17,7 @@ import (
 	"github.com/charmbracelet/log"
 	"github.com/google/shlex"
 	"github.com/numtide/treefmt/v2/git"
+	"github.com/numtide/treefmt/v2/jujutsu"
 	"github.com/numtide/treefmt/v2/walk"
 	"github.com/spf13/pflag"
 	"github.com/spf13/viper"
@@ -113,7 +114,7 @@ func SetFlags(fs *pflag.FlagSet) {
 	fs.String(
 		"tree-root", "",
 		"The root directory from which treefmt will start walking the filesystem. "+
-			"Defaults to the root of the current git worktree. If not in a git repo, defaults to the directory "+
+			"Defaults to the root of the current git or jujutsu worktree. If not in a git or jujutsu repo, defaults to the directory "+
 			"containing the config file. (env $TREEFMT_TREE_ROOT)",
 	)
 	fs.String(
@@ -136,7 +137,7 @@ func SetFlags(fs *pflag.FlagSet) {
 	fs.String(
 		"walk", "auto",
 		"The method used to traverse the files within the tree root. Currently supports "+
-			"<auto|git|filesystem>. (env $TREEFMT_WALK)",
+			"<auto|git|jujutsu|filesystem>. (env $TREEFMT_WALK)",
 	)
 	fs.StringP(
 		"working-dir", "C", ".",
@@ -329,6 +330,21 @@ func determineTreeRoot(v *viper.Viper, cfg *Config, logger *log.Logger) error {
 			}
 		}
 
+		// attempt to resolve with jujutsu
+		if cfg.Walk == walk.Auto.String() || cfg.Walk == walk.Jujutsu.String() {
+			logger.Infof("attempting to resolve tree root using jujutsu: %s", jujutsu.TreeRootCmd)
+
+			// attempt to resolve the tree root with jujutsu
+			cfg.TreeRoot, err = execTreeRootCmd(jujutsu.TreeRootCmd, cfg.WorkingDirectory)
+			if err != nil && cfg.Walk == walk.Git.String() {
+				return fmt.Errorf("failed to resolve tree root with jujutsu: %w", err)
+			}
+
+			if err != nil {
+				logger.Infof("failed to resolve tree root with jujutsu: %v", err)
+			}
+		}
+
 		if cfg.TreeRoot == "" {
 			// fallback to the directory containing the config file
 			logger.Infof(

docs/site/getting-started/configure.md

@@ -317,8 +317,13 @@ If you wish to pass arguments containing quotes, you should use nested quotes e.
     If [walk](#walk) is set to `git` and no tree root option has been defined, `tree-root-cmd` will be defaulted to
     `git rev-parse --show-toplevel`.
 
+    If [walk](#walk) is set to `jujutsu` and no tree root option has been defined, `tree-root-cmd` will be defaulted to
+    `jj workspace root`.
+
     if [walk](#walk) is set to `auto` (the default), `treefmt` will check if the [working directory](#working-dir) is
-    inside a git worktree. If it is, `tree-root-cmd` will be defaulted as described above for `git`.
+    inside a git worktree. If it is, `tree-root-cmd` will be defaulted as described above for `git`. If the [working
+    directory](#working-dir) is inside a jujutsu worktree the `tree-root-cmd` will be defaulted as described above for
+    `jujutsu`.
 
 === "Flag"
 
@@ -391,7 +396,7 @@ Set the verbosity level of logs:
 ### `walk`
 
 The method used to traverse the files within the tree root.
-Currently, we support 'auto', 'git' or 'filesystem'
+Currently, we support 'auto', 'git', 'jujutsu' or 'filesystem'
 
 === "Flag"
 

jujutsu/jujutsu.go

@@ -0,0 +1,28 @@
+package jujutsu
+
+import (
+	"errors"
+	"fmt"
+	"os/exec"
+	"strings"
+)
+
+const TreeRootCmd = "jj workspace root"
+
+func IsInsideWorktree(path string) (bool, error) {
+	// check if the root is a jujutsu repository
+	cmd := exec.Command("jj", "workspace", "root")
+	cmd.Dir = path
+
+	err := cmd.Run()
+	if err != nil {
+		var exitErr *exec.ExitError
+		if errors.As(err, &exitErr) && strings.Contains(string(exitErr.Stderr), "There is no jj repo in \".\"") {
+			return false, nil
+		}
+
+		return false, fmt.Errorf("failed to check if %s is a jujutsu repository: %w", path, err)
+	}
+	// is a jujutsu repo
+	return true, nil
+}

nix/packages/treefmt/default.nix

@@ -46,6 +46,7 @@ in
     nativeBuildInputs =
       (with pkgs; [
         git
+        jujutsu
         installShellFiles
       ])
       ++