refactor(git): align native status engine with Go conventions

Apply the project's Go skill end to end: modernize and fieldalignment
rewrites, switch instead of else in the index name decoder, errors.New
for static errors, restored field docs the alignment pass dropped, a
log.Trace on Load, and test cleanups — the three fallback trigger tests
merge into one table, and the benchmark reuses the parity test helpers
through testing.TB instead of duplicating them.

Also fold in the review's simplifications: drop the dead rehash
counter, parse only the cache-tree root record, key the pack object
cache by struct instead of a formatted string, skip the walk entirely
when the flat pool runs with untracked detection off, search a single
sorted-path list per platform, and turn the ahead/behind termination
flag into a plain break.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: JanDeDobbeleer

src/gitstatus/aheadbehind.go

@@ -14,8 +14,8 @@ const (
 )
 
 type queuedCommit struct {
-	hash plumbing.Hash
 	info *commitInfo
+	hash plumbing.Hash
 }
 
 type commitPQ []queuedCommit
@@ -73,9 +73,8 @@ func aheadBehind(store *objectStore, ours, theirs plumbing.Hash) (int, int, erro
 	}
 
 	ahead, behind := 0, 0
-	interesting := 2
 
-	for queue.Len() > 0 && interesting > 0 {
+	for queue.Len() > 0 {
 		commit := heap.Pop(&queue).(queuedCommit)
 		flag := flags[commit.hash]
 
@@ -114,8 +113,8 @@ func aheadBehind(store *objectStore, ours, theirs plumbing.Hash) (int, int, erro
 			}
 		}
 
-		// Termination heuristic: once every queued commit is flagged on
-		// both sides, nothing one-sided remains to discover.
+		// Termination: once every queued commit is flagged on both sides,
+		// nothing one-sided remains to discover.
 		allShared := true
 		for _, qc := range queue {
 			f := flags[qc.hash]
@@ -125,7 +124,7 @@ func aheadBehind(store *objectStore, ours, theirs plumbing.Hash) (int, int, erro
 			}
 		}
 		if allShared {
-			interesting = 0
+			break
 		}
 	}
 

src/gitstatus/bench_test.go

@@ -1,48 +1,40 @@
 package gitstatus
 
 import (
-	"context"
 	"fmt"
-	"os"
-	"os/exec"
 	"path/filepath"
-	"strings"
 	"testing"
-
-	"github.com/stretchr/testify/require"
 )
 
 // BenchmarkLoad runs Load against a repo with ~1k committed files, a small
 // mix of unstaged/staged/untracked changes, and reports allocations.
 func BenchmarkLoad(b *testing.B) {
-	if _, err := exec.LookPath("git"); err != nil {
-		b.Skip("git not found on PATH")
-	}
+	skipIfNoGit(b)
 
 	dir := b.TempDir()
 
-	runBenchGit(b, dir, "init", "-q", "-b", "main", ".")
-	runBenchGit(b, dir, "config", "user.email", "bench@example.com")
-	runBenchGit(b, dir, "config", "user.name", "Bench")
+	runGit(b, dir, "init", "-q", "-b", "main", ".")
+	runGit(b, dir, "config", "user.email", "bench@example.com")
+	runGit(b, dir, "config", "user.name", "Bench")
 
 	const fileCount = 1000
 	for i := range fileCount {
 		rel := filepath.Join("pkg", fmt.Sprintf("dir%d", i%20), fmt.Sprintf("file%d.txt", i))
-		writeBenchFile(b, dir, rel, fmt.Sprintf("content %d\n", i))
+		writeFile(b, dir, rel, fmt.Sprintf("content %d\n", i))
 	}
-	runBenchGit(b, dir, "add", ".")
-	runBenchGit(b, dir, "commit", "-q", "-m", "seed")
+	runGit(b, dir, "add", ".")
+	runGit(b, dir, "commit", "-q", "-m", "seed")
 
 	// a small, realistic mix of changes on top of the committed tree
-	writeBenchFile(b, dir, "pkg/dir0/file0.txt", "modified\n")
-	writeBenchFile(b, dir, "untracked.txt", "u\n")
-	writeBenchFile(b, dir, "pkg/dir1/staged-add.txt", "new\n")
-	runBenchGit(b, dir, "add", "pkg/dir1/staged-add.txt")
+	writeFile(b, dir, "pkg/dir0/file0.txt", "modified\n")
+	writeFile(b, dir, "untracked.txt", "u\n")
+	writeFile(b, dir, "pkg/dir1/staged-add.txt", "new\n")
+	runGit(b, dir, "add", "pkg/dir1/staged-add.txt")
 
 	opts := Options{
-		WorktreeGitDir: gitBenchPath(b, dir, "--git-dir"),
-		CommonGitDir:   gitBenchPath(b, dir, "--git-common-dir"),
-		RepoRoot:       gitBenchPath(b, dir, "--show-toplevel"),
+		WorktreeGitDir: gitPath(b, dir, "--git-dir"),
+		CommonGitDir:   gitPath(b, dir, "--git-common-dir"),
+		RepoRoot:       gitPath(b, dir, "--show-toplevel"),
 	}
 
 	b.ReportAllocs()
@@ -54,28 +46,3 @@ func BenchmarkLoad(b *testing.B) {
 		}
 	}
 }
-
-func writeBenchFile(b *testing.B, dir, rel, content string) {
-	b.Helper()
-	full := filepath.Join(dir, filepath.FromSlash(rel))
-	require.NoError(b, os.MkdirAll(filepath.Dir(full), 0o755))
-	require.NoError(b, os.WriteFile(full, []byte(content), 0o644))
-}
-
-func runBenchGit(b *testing.B, dir string, args ...string) {
-	b.Helper()
-	cmd := exec.CommandContext(context.Background(), "git", args...)
-	cmd.Dir = dir
-	cmd.Env = append(os.Environ(), "GIT_CONFIG_NOSYSTEM=1")
-	out, err := cmd.CombinedOutput()
-	require.NoErrorf(b, err, "git %s failed: %s", strings.Join(args, " "), out)
-}
-
-func gitBenchPath(b *testing.B, dir, arg string) string {
-	b.Helper()
-	cmd := exec.CommandContext(context.Background(), "git", "rev-parse", "--path-format=absolute", arg)
-	cmd.Dir = dir
-	out, err := cmd.Output()
-	require.NoError(b, err)
-	return filepath.FromSlash(strings.TrimSpace(string(out)))
-}

src/gitstatus/gitstatus.go

@@ -14,6 +14,8 @@ import (
 	"os"
 	"path/filepath"
 	"time"
+
+	"github.com/jandedobbeleer/oh-my-posh/src/log"
 )
 
 // Detached is the branch name reported when HEAD is not on a branch. It must
@@ -33,11 +35,14 @@ type Counts struct {
 
 // Result is the outcome of a successful Load.
 type Result struct {
+	// Hash is the full HEAD hash, or "(initial)" on an unborn branch.
+	Hash string
+	// Ref is the branch name, or Detached.
+	Ref string
+	// Upstream is "origin/main"-style, empty when not configured.
+	Upstream     string
 	Working      Counts
 	Staging      Counts
-	Hash         string // full HEAD hash, "(initial)" when unborn
-	Ref          string // branch name, or Detached
-	Upstream     string // "origin/main"-style, "" when not configured
 	Ahead        int
 	Behind       int
 	UpstreamGone bool
@@ -55,6 +60,8 @@ type Options struct {
 // Load computes the working tree and staging area status for the repository
 // described by opts. Any error means the caller must fall back to exec git.
 func Load(opts Options) (*Result, error) {
+	defer log.Trace(time.Now(), opts.RepoRoot)
+
 	untrackedMode := opts.UntrackedMode
 	if untrackedMode == "" {
 		untrackedMode = "normal"

src/gitstatus/gitstatus_test.go

@@ -357,7 +357,7 @@ func setupIntentToAdd(t *testing.T, dir string) {
 
 // --- test infrastructure -----------------------------------------------
 
-func skipIfNoGit(t *testing.T) {
+func skipIfNoGit(t testing.TB) {
 	t.Helper()
 	if _, err := exec.LookPath("git"); err != nil {
 		t.Skip("git not found on PATH")
@@ -368,30 +368,30 @@ func skipIfNoGit(t *testing.T) {
 // directory for the duration of the test, so neither the native engine nor
 // the real git CLI pick up the developer machine's actual global gitconfig
 // or excludes file.
-func hermeticHome(t *testing.T) {
+func hermeticHome(t testing.TB) {
 	t.Helper()
 	home := t.TempDir()
 	t.Setenv("HOME", home)
 	t.Setenv("USERPROFILE", home)
 	t.Setenv("XDG_CONFIG_HOME", filepath.Join(home, ".config"))
 }
 
-func initGitRepo(t *testing.T, dir string) {
+func initGitRepo(t testing.TB, dir string) {
 	t.Helper()
 	runGit(t, dir, "init", "-q", "-b", "main", ".")
 	runGit(t, dir, "config", "user.email", "test@example.com")
 	runGit(t, dir, "config", "user.name", "Test")
 	runGit(t, dir, "config", "core.autocrlf", "false")
 }
 
-func writeFile(t *testing.T, dir, rel, content string) {
+func writeFile(t testing.TB, dir, rel, content string) {
 	t.Helper()
 	full := filepath.Join(dir, filepath.FromSlash(rel))
 	require.NoError(t, os.MkdirAll(filepath.Dir(full), 0o755))
 	require.NoError(t, os.WriteFile(full, []byte(content), 0o644))
 }
 
-func runGit(t *testing.T, dir string, args ...string) string {
+func runGit(t testing.TB, dir string, args ...string) string {
 	t.Helper()
 	out, err := gitCommand(dir, args...)
 	require.NoErrorf(t, err, "git %s failed: %s", strings.Join(args, " "), out)
@@ -400,7 +400,7 @@ func runGit(t *testing.T, dir string, args ...string) string {
 
 // runGitAllowFail runs git and returns its output even on a non-zero exit,
 // for commands like `git merge` that legitimately fail on conflict.
-func runGitAllowFail(t *testing.T, dir string, args ...string) string {
+func runGitAllowFail(t testing.TB, dir string, args ...string) string {
 	t.Helper()
 	out, _ := gitCommand(dir, args...)
 	return out
@@ -414,7 +414,7 @@ func gitCommand(dir string, args ...string) (string, error) {
 	return string(out), err
 }
 
-func gitPath(t *testing.T, dir, arg string) string {
+func gitPath(t testing.TB, dir, arg string) string {
 	t.Helper()
 	out := runGit(t, dir, "rev-parse", "--path-format=absolute", arg)
 	return filepath.FromSlash(strings.TrimSpace(out))

src/gitstatus/index.go

@@ -48,7 +48,7 @@ type indexEntry struct {
 	IntentToAdd  bool
 }
 
-// cacheTree is one entry of the TREE extension. Entries < 0 marks the span
+// cacheTree is the root record of the TREE extension. Entries < 0 marks it
 // invalidated.
 type cacheTree struct {
 	Path    string
@@ -57,8 +57,11 @@ type cacheTree struct {
 }
 
 type gitIndex struct {
-	Entries   []indexEntry
-	CacheTree []cacheTree
+	// CacheTreeRoot holds the first TREE extension record (the repository
+	// root); the staging fast path needs nothing else, so subtree records
+	// are never parsed. Nil when the extension is absent.
+	CacheTreeRoot *cacheTree
+	Entries       []indexEntry
 }
 
 // decodeIndex parses an index file. It fails on unsupported versions and on
@@ -119,16 +122,16 @@ func decodeEntries(data []byte, version, count uint32, idx *gitIndex) ([]byte, e
 
 		var name []byte
 		var err error
-		if version == 4 {
+
+		switch version {
+		case 4:
 			name, data, err = decodeNameV4(data[consumed:], prevName)
-			if err != nil {
-				return nil, err
-			}
-		} else {
+		default:
 			name, data, err = decodeNamePadded(data, consumed, nameLen)
-			if err != nil {
-				return nil, err
-			}
+		}
+
+		if err != nil {
+			return nil, err
 		}
 
 		prevName = name
@@ -257,48 +260,51 @@ func decodeExtensions(data []byte, idx *gitIndex) error {
 	return nil
 }
 
-// decodeTreeExtension parses the cache-tree extension: a sequence of
-// "path NUL entry-count SP subtree-count LF [hash]" records, hash present
-// only for valid (non-negative entry-count) records.
+// decodeTreeExtension parses only the first record of the cache-tree
+// extension — "path NUL entry-count SP subtree-count LF [hash]", hash
+// present only when the entry-count is non-negative. The first record is
+// the repository root, the only one the staging fast path consumes; the
+// remaining subtree records are skipped wholesale (the extension block is
+// length-delimited, so nothing after it depends on parsing them).
 func decodeTreeExtension(data []byte, idx *gitIndex) error {
-	for len(data) > 0 {
-		nul := -1
-		for i := range data {
-			if data[i] == 0 {
-				nul = i
-				break
-			}
-		}
-		if nul < 0 {
-			return errIndexMalformed
+	if len(data) == 0 {
+		return nil
+	}
+
+	nul := -1
+	for i := range data {
+		if data[i] == 0 {
+			nul = i
+			break
 		}
+	}
+	if nul < 0 {
+		return errIndexMalformed
+	}
 
-		entry := cacheTree{Path: string(data[:nul])}
-		data = data[nul+1:]
+	root := cacheTree{Path: string(data[:nul])}
+	data = data[nul+1:]
 
-		count, rest, err := readASCIIInt(data, ' ')
-		if err != nil {
-			return err
-		}
-		entry.Entries = count
+	count, rest, err := readASCIIInt(data, ' ')
+	if err != nil {
+		return err
+	}
+	root.Entries = count
 
-		_, rest, err = readASCIIInt(rest, '\n')
-		if err != nil {
-			return err
-		}
-		data = rest
+	_, rest, err = readASCIIInt(rest, '\n')
+	if err != nil {
+		return err
+	}
+	data = rest
 
-		if count >= 0 {
-			if len(data) < 20 {
-				return errIndexMalformed
-			}
-			copy(entry.Hash[:], data[:20])
-			data = data[20:]
+	if count >= 0 {
+		if len(data) < 20 {
+			return errIndexMalformed
 		}
-
-		idx.CacheTree = append(idx.CacheTree, entry)
+		copy(root.Hash[:], data[:20])
 	}
 
+	idx.CacheTreeRoot = &root
 	return nil
 }
 

src/gitstatus/objects.go

@@ -11,9 +11,10 @@ import (
 
 // commitInfo is the subset of a commit object the status engine needs.
 type commitInfo struct {
+	Parents []plumbing.Hash
+	// CommitterWhen is the committer timestamp in unix seconds.
+	CommitterWhen int64
 	Tree          plumbing.Hash
-	Parents       []plumbing.Hash
-	CommitterWhen int64 // unix seconds
 }
 
 func readCommit(store *objectStore, h plumbing.Hash) (*commitInfo, error) {