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

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
       ])
       ++

walk/jujutsu.go

@@ -0,0 +1,163 @@
+package walk
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+
+	"github.com/charmbracelet/log"
+	"github.com/numtide/treefmt/v2/jujutsu"
+	"github.com/numtide/treefmt/v2/stats"
+	"golang.org/x/sync/errgroup"
+)
+
+type JujutsuReader struct {
+	root string
+	path string
+
+	log   *log.Logger
+	stats *stats.Stats
+
+	eg      *errgroup.Group
+	scanner *bufio.Scanner
+}
+
+func (j *JujutsuReader) Read(ctx context.Context, files []*File) (n int, err error) {
+	// ensure we record how many files we traversed
+	defer func() {
+		j.stats.Add(stats.Traversed, n)
+	}()
+
+	if j.scanner == nil {
+		// create a pipe to capture the command output
+		r, w := io.Pipe()
+
+		// create a command which will execute from the specified sub path within root
+		// --ignore-working-copy: Don't snapshot the working copy, and don't update it. This prevents that the user has to enter a password for singning the commit. New files also won't be added to the index and not displayed in the output.
+		cmd := exec.Command("jj", "file", "list", "--ignore-working-copy")
+		cmd.Dir = filepath.Join(j.root, j.path)
+		cmd.Stdout = w
+
+		// execute the command in the background
+		j.eg.Go(func() error {
+			return w.CloseWithError(cmd.Run())
+		})
+
+		// create a new scanner for reading the output
+		j.scanner = bufio.NewScanner(r)
+	}
+
+	nextLine := func() (string, error) {
+		line := j.scanner.Text()
+
+		if len(line) == 0 || line[0] != '"' {
+			return line, nil
+		}
+
+		unquoted, err := strconv.Unquote(line)
+		if err != nil {
+			return "", fmt.Errorf("failed to unquote line %s: %w", line, err)
+		}
+
+		return unquoted, nil
+	}
+
+LOOP:
+
+	for n < len(files) {
+		select {
+		// exit early if the context was cancelled
+		case <-ctx.Done():
+			err = ctx.Err()
+			if err == nil {
+				return n, fmt.Errorf("context cancelled: %w", ctx.Err())
+			}
+
+			return n, nil
+
+		default:
+			// read the next file
+			if j.scanner.Scan() {
+				entry, err := nextLine()
+				if err != nil {
+					return n, err
+				}
+
+				path := filepath.Join(j.root, j.path, entry)
+
+				j.log.Debugf("processing file: %s", path)
+
+				info, err := os.Lstat(path)
+
+				switch {
+				case os.IsNotExist(err):
+					// the underlying file might have been removed
+					j.log.Warnf(
+						"Path %s is in the worktree but appears to have been removed from the filesystem", path,
+					)
+
+					continue
+				case err != nil:
+					return n, fmt.Errorf("failed to stat %s: %w", path, err)
+				case info.Mode()&os.ModeSymlink == os.ModeSymlink:
+					// we skip reporting symlinks stored in Jujutsu, they should
+					// point to local files which we would list anyway.
+					continue
+				}
+
+				files[n] = &File{
+					Path:    path,
+					RelPath: filepath.Join(j.path, entry),
+					Info:    info,
+				}
+
+				n++
+			} else {
+				// nothing more to read
+				err = io.EOF
+
+				break LOOP
+			}
+		}
+	}
+
+	return n, err
+}
+
+func (g *JujutsuReader) Close() error {
+	err := g.eg.Wait()
+	if err != nil {
+		return fmt.Errorf("failed to wait for jujutsu command to complete: %w", err)
+	}
+
+	return nil
+}
+
+func NewJujutsuReader(
+	root string,
+	path string,
+	statz *stats.Stats,
+) (*JujutsuReader, error) {
+	// check if the root is a jujutsu repository
+	isJujutsu, err := jujutsu.IsInsideWorktree(root)
+	if err != nil {
+		return nil, fmt.Errorf("failed to check if %s is a jujutsu repository: %w", root, err)
+	}
+
+	if !isJujutsu {
+		return nil, fmt.Errorf("%s is not a jujutsu repository", root)
+	}
+
+	return &JujutsuReader{
+		root:  root,
+		path:  path,
+		stats: statz,
+		eg:    &errgroup.Group{},
+		log:   log.WithPrefix("walk | jujutsu"),
+	}, nil
+}

walk/jujutsu_test.go

@@ -0,0 +1,76 @@
+package walk_test
+
+import (
+	"context"
+	"errors"
+	"io"
+	"os/exec"
+	"testing"
+	"time"
+
+	"github.com/numtide/treefmt/v2/stats"
+	"github.com/numtide/treefmt/v2/test"
+	"github.com/numtide/treefmt/v2/walk"
+	"github.com/stretchr/testify/require"
+)
+
+func TestJujutsuReader(t *testing.T) {
+	as := require.New(t)
+
+	tempDir := test.TempExamples(t)
+
+	// init a jujutsu repo (disable signing for testing)
+	cmd := exec.Command("jj", "git", "init", "--config", "signing.backend=none")
+	cmd.Dir = tempDir
+	as.NoError(cmd.Run(), "failed to init jujutsu repository")
+
+	// read empty worktree
+	statz := stats.New()
+	reader, err := walk.NewJujutsuReader(tempDir, "", &statz)
+	as.NoError(err)
+
+	files := make([]*walk.File, 33)
+	ctx, cancel := context.WithTimeout(t.Context(), 100*time.Millisecond)
+	n, err := reader.Read(ctx, files)
+
+	cancel()
+	as.Equal(0, n)
+	as.ErrorIs(err, io.EOF)
+
+	// track new files (disable signing for testing), this step is required based on the jujutsu configuration. I prefer `snapshot.auto-track=none()`, which doesn't track new files automatically.
+	cmd = exec.Command("jj", "file", "track", "--config", "signing.backend=none", ".")
+	cmd.Dir = tempDir
+	as.NoError(cmd.Run(), "failed to add everything to the index")
+
+	// update jujutsu's index (disable signing for testing)
+	cmd = exec.Command("jj", "--config", "signing.backend=none")
+	cmd.Dir = tempDir
+	as.NoError(cmd.Run(), "failed to update the index")
+
+	statz = stats.New()
+	reader, err = walk.NewJujutsuReader(tempDir, "", &statz)
+	as.NoError(err)
+
+	count := 0
+
+	for {
+		ctx, cancel := context.WithTimeout(t.Context(), 100*time.Millisecond)
+
+		files := make([]*walk.File, 8)
+		n, err := reader.Read(ctx, files)
+
+		count += n
+
+		cancel()
+
+		if errors.Is(err, io.EOF) {
+			break
+		}
+	}
+
+	as.Equal(32, count)
+	as.Equal(32, statz.Value(stats.Traversed))
+	as.Equal(0, statz.Value(stats.Matched))
+	as.Equal(0, statz.Value(stats.Formatted))
+	as.Equal(0, statz.Value(stats.Changed))
+}