refactor(diff): normalize git argument ordering in workspaceTrackedDiff

Cosmetic consistency per alibaba#374, discovered in alibaba#365 review. Reorders the two
runGit calls so all option flags precede positional args, matching the file's
other diff call sites (GetDiff ranges/commit, computeMergeBase). The HEAD call
now places --end-of-options before the HEAD ref, hardening against
ref-looking filenames; --staged stays with the option flags (it is a flag,
not a ref, so no --end-of-options). Pure reordering plus one
--end-of-options addition; no flag or value changed. All diff tests pass.

Author: chethanuk

internal/diff/git.go

@@ -261,14 +261,19 @@ func (p *Provider) computeMergeBase(ctx context.Context, from, to string) string
 }
 
 func (p *Provider) workspaceTrackedDiff(ctx context.Context) (string, error) {
-	out, err := p.runGit(ctx, "-c", "core.quotepath=false", "diff", "--no-ext-diff", "--no-textconv", "--find-renames", "--src-prefix=a/", "--dst-prefix=b/", "HEAD", "--no-color", "-U"+fmt.Sprint(DiffContextLines), "--")
+	out, err := p.runGit(ctx, "-c", "core.quotepath=false", "diff", "--no-ext-diff", "--no-textconv", "--find-renames", "--src-prefix=a/", "--dst-prefix=b/", "--no-color", "-U"+fmt.Sprint(DiffContextLines), "--end-of-options", "HEAD", "--")
 	if err == nil && out != "" {
 		return out, nil
 	}
 	if ctx.Err() != nil {
 		return "", ctx.Err()
 	}
-	return p.runGit(ctx, "-c", "core.quotepath=false", "diff", "--no-ext-diff", "--no-textconv", "--find-renames", "--src-prefix=a/", "--dst-prefix=b/", "--staged", "--no-color", "-U"+fmt.Sprint(DiffContextLines), "--")
+	// Fall back to the staged diff when `git diff HEAD` errored or was empty. This is
+	// not redundant with the call above: in a repository with no commits yet there is no
+	// HEAD, so `git diff HEAD` fails with "bad revision 'HEAD'", but `git diff --staged`
+	// still surfaces staged changes by diffing the index against the empty tree — the only
+	// way to review a workspace before its first commit.
+	return p.runGit(ctx, "-c", "core.quotepath=false", "diff", "--no-ext-diff", "--no-textconv", "--find-renames", "--src-prefix=a/", "--dst-prefix=b/", "--no-color", "-U"+fmt.Sprint(DiffContextLines), "--staged", "--")
 }
 
 func (p *Provider) untrackedFileDiffs(ctx context.Context) ([]string, error) {

internal/diff/git_test.go

@@ -205,6 +205,38 @@ func TestWorkspaceDiffSurvivesExternalDiffTool(t *testing.T) {
 	}
 }
 
+// TestWorkspaceDiffNoCommitsUsesStagedFallback pins the second runGit call in
+// workspaceTrackedDiff: in a repository with no commits there is no HEAD, so
+// `git diff HEAD` fails, and the staged diff is the only way to review the
+// workspace. Removing the `--staged` fallback (as an over-eager "simplification"
+// might) makes this return zero diffs.
+func TestWorkspaceDiffNoCommitsUsesStagedFallback(t *testing.T) {
+	repo := t.TempDir()
+	runGitTest(t, repo, "init", "-q")
+	runGitTest(t, repo, "config", "user.email", "test@example.com")
+	runGitTest(t, repo, "config", "user.name", "Test User")
+	runGitTest(t, repo, "config", "commit.gpgsign", "false")
+
+	// Staged file, no commit yet -> no HEAD.
+	file := filepath.Join(repo, "staged.txt")
+	if err := os.WriteFile(file, []byte("alpha\nbeta\n"), 0o644); err != nil {
+		t.Fatalf("write staged.txt: %v", err)
+	}
+	runGitTest(t, repo, "add", "staged.txt")
+
+	runner := gitcmd.New(0)
+	provider := NewWorkspaceProvider(repo, runner)
+
+	diffs, err := provider.GetDiff(context.Background())
+	if err != nil {
+		t.Fatalf("GetDiff returned error: %v", err)
+	}
+	if len(diffs) == 0 {
+		t.Fatalf("expected staged changes to be surfaced in a repo with no commits " +
+			"(the --staged fallback in workspaceTrackedDiff), got 0 diffs")
+	}
+}
+
 // TestCommitDiffSurvivesExternalDiffTool covers the ModeCommit call site
 // (git show <commit>), which likewise must pass --no-ext-diff so that a
 // user's external diff tool does not break single-commit analysis.