fix: use pure Go filesystem traversal for git repo detection (fixes macOS ARM64 / Rosetta 2 failure)

[Copilot]

gh aw init (and any command calling isGitRepo() / FindGitRoot()) fails with "not in a git repository" on macOS ARM64 when the x86_64 binary runs under Rosetta 2 — the exec.Command("git", "rev-parse", ...) subprocess call silently fails in that environment even when the user is inside a valid git repo.

Changes

• pkg/gitutil/gitutil.go — Replace FindGitRoot() implementation: swap exec.Command("git", "rev-parse", "--show-toplevel") for os.Stat + filepath.Dir upward traversal. FindGitRootFrom(startDir string) now normalizes startDir to an absolute path via filepath.Abs, surfaces non-ErrNotExist stat errors (e.g. permission denied), and validates .git as either a directory (normal repo) or a regular file beginning with gitdir: (worktree / submodule pointer) — surfacing read errors instead of silently skipping an unreadable .git file.

• pkg/cli/git.go — isGitRepo() now delegates to gitutil.FindGitRoot() instead of its own exec.Command("git", "rev-parse", "--git-dir") call. findGitRootForPath() uses gitutil.FindGitRootFrom(dir).

• pkg/gitutil/gitutil_test.go — TestFindGitRootFrom extended to cover: start from repo root, start from nested subdir, start outside any repo, .git is a valid worktree marker file (detected from root and subdirectory), .git file without gitdir: prefix is not accepted, and relative path input (".") resolves correctly.

All actual git operations (commit, push, status, add, log) still invoke the git binary — only repository detection is changed.

// Before — fails silently under Rosetta 2
func isGitRepo() bool {
    cmd := exec.Command("git", "rev-parse", "--git-dir")
    return cmd.Run() == nil
}

// After — pure Go, no subprocess
func isGitRepo() bool {
    _, err := gitutil.FindGitRoot()
    return err == nil
}

[!WARNING]

[Copilot]

Pull request overview

Updates git repository detection to avoid invoking the git executable (addressing macOS ARM64 Rosetta 2 failures) by switching to filesystem-based traversal and centralizing the logic in pkg/gitutil.

Changes:

• Replaced FindGitRoot() implementation to locate repo roots by walking up the directory tree looking for a .git entry.
• Added FindGitRootFrom(startDir) and updated CLI git-repo detection helpers to use gitutil instead of subprocess calls.
• Added tests for FindGitRootFrom and updated the public API spec text accordingly; lockfile workflows were also modified.

Show a summary per file

File	Description
pkg/gitutil/gitutil.go	Implements filesystem-based git root discovery and adds FindGitRootFrom.
pkg/cli/git.go	Switches repo detection/root lookup to gitutil.FindGitRoot* helpers.
pkg/gitutil/gitutil_test.go	Adds test coverage for FindGitRootFrom.
pkg/gitutil/spec_test.go	Updates the spec wording for FindGitRoot to match new behavior.
.github/workflows/spec-librarian.lock.yml	Updates pinned action version annotations/manifest metadata (now inconsistent in-file).
.github/workflows/copilot-pr-nlp-analysis.lock.yml	Updates pinned action version annotations/manifest metadata (now inconsistent/duplicated in-file).

Copilot's findings

Tip

Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

Comments suppressed due to low confidence (3)

.github/workflows/spec-librarian.lock.yml:470

• This step is annotated as # v9 while other actions/github-script steps in the same lockfile are annotated # v9.0.0 (e.g., line 452). Please keep the version annotations consistent (ideally by regenerating the lockfile) to avoid confusion and drift.

      - name: Determine automatic lockdown mode for GitHub MCP Server
        id: determine-automatic-lockdown
        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9

.github/workflows/copilot-pr-nlp-analysis.lock.yml:53

• The "Custom actions used" section now lists the same actions/github-script SHA twice with different versions (v9 and v9.0.0). This looks like an inconsistent regeneration and should be deduplicated/standardized so the lockfile accurately describes what is pinned.

#   - actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
#   - actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
#   - actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9
#   - actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0

.github/workflows/copilot-pr-nlp-analysis.lock.yml:522

• This step is annotated as # v9 while other actions/github-script steps in the same lockfile are annotated # v9.0.0. Please keep version annotations consistent (ideally via lockfile regeneration) to avoid drift.

      - name: Determine automatic lockdown mode for GitHub MCP Server
        id: determine-automatic-lockdown
        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9

• Files reviewed: 6/6 changed files
• Comments generated: 4

[github-actions]

🧪 Test Quality Sentinel Report

Test Quality Score: 90/100

✅ Excellent test quality

Metric	Value
New/modified tests analyzed	3 top-level functions (7 subtests)
✅ Design tests (behavioral contracts)	3 (100%)
⚠️ Implementation tests (low value)	0 (0%)
Tests with error/edge cases	2 of 3 (67%)
Duplicate test clusters	0
Test inflation detected	No (ratio 1.06×)
🚨 Coding-guideline violations	None

---

Test Classification Details

The PR modifies pkg/gitutil/gitutil_test.go (+38 lines) and pkg/gitutil/spec_test.go (+3/-2 lines). The core fix replaces git rev-parse subprocess calls with pure Go .git directory traversal; the new tests validate that new behaviour.

View per-test classification table

Test	File	Classification	Issues Detected
TestFindGitRoot	pkg/gitutil/gitutil_test.go	✅ Design	Happy-path only; error path delegated to TestFindGitRootFrom
TestFindGitRootFrom (from root)	pkg/gitutil/gitutil_test.go	✅ Design	Verifies idempotency: starting at root returns root
TestFindGitRootFrom (from subdir)	pkg/gitutil/gitutil_test.go	✅ Design	Verifies upward traversal from a temp subdir
TestFindGitRootFrom (error – non-repo dir)	pkg/gitutil/gitutil_test.go	✅ Design	Edge case: explicit error path + error message assertion
TestReadFileFromHEADWithRoot (reads file)	pkg/gitutil/gitutil_test.go	✅ Design	Verifies correct content returned from HEAD
TestReadFileFromHEADWithRoot (path outside root)	pkg/gitutil/gitutil_test.go	✅ Design	Edge case: path-traversal rejection
TestReadFileFromHEADWithRoot (empty gitRoot)	pkg/gitutil/gitutil_test.go	✅ Design	Edge case: empty-string input guard

---

Flagged Tests — Requires Review

i️ TestFindGitRoot — happy-path only

Classification: Design test (high value), but missing an explicit error path.

Issue: FindGitRoot() is a thin wrapper around FindGitRootFrom(os.Getwd()). Its own error path ("not in a git repo") is tested indirectly via TestFindGitRootFrom. This is acceptable given the function's simplicity, but a direct error test (e.g., changing the working directory to t.TempDir() before calling) would make the contract self-contained.

Impact if deleted: Low — TestFindGitRootFrom already covers the error branch. Deleting TestFindGitRoot would leave the wrapper itself untested.

Suggested improvement (non-blocking): Add a subtest that changes os.Chdir to a temp directory with no .git ancestor and asserts the returned error, or explicitly document that the error path is covered by TestFindGitRootFrom.

---

Score Breakdown

Component	Points	Notes
Behavioral Coverage (40 pts)	40	3/3 tests are design tests (100%)
Error/Edge Case Coverage (30 pts)	20	2/3 top-level functions explicitly test error paths
Low Duplication (20 pts)	20	No copy-paste clusters detected
Proportional Growth (10 pts)	10	Test:prod ratio = 1.06 (well below 2:1 threshold)

---

Language Support

Tests analyzed:

• 🐹 Go (*_test.go): 7 subtests across 3 functions — unit (//go:build !integration) ✅
• 🟨 JavaScript (*.test.cjs, *.test.js): 0 tests changed in this PR

---

Verdict

✅ Check passed. 0% of new tests are implementation tests (threshold: 30%). Build tags are present on all new/modified test files. No mock libraries detected. All tests exercise observable behavioral contracts of the new pure-Go git root detection.

---

📖 Understanding Test Classifications

Design Tests (High Value) verify what the system does:

• Assert on observable outputs, return values, or state changes
• Cover error paths and boundary conditions
• Would catch a behavioral regression if deleted
• Remain valid even after internal refactoring

Implementation Tests (Low Value) verify how the system does it:

• Assert on internal function calls (mocking internals)
• Only test the happy path with typical inputs
• Break during legitimate refactoring even when behavior is correct
• Give false assurance: they pass even when the system is wrong

Goal: Shift toward tests that describe the system's behavioral contract — the promises it makes to its users and collaborators.

References: §25568904322

🧪 Test quality analysis by Test Quality Sentinel · ● 7.3M · ◷

[github-actions]

✅ Test Quality Sentinel: 90/100. Test quality is excellent — 0% of new tests are implementation tests (threshold: 30%). All 7 new subtests exercise behavioral contracts of the new pure-Go git root detection. Build tags present, no mock libraries used.

[pelikhan]

@copilot merge main and recompile

[Copilot]

@copilot merge main and recompile

Done — merged latest main (8 commits) and ran make build && make recompile. All 217 workflow lock files were regenerated and tests pass.

[pelikhan]

@copilot add integration tests for git repos and worktrees

[Copilot]

@copilot add integration tests for git repos and worktrees

Done in the latest commit. Added four new test cases to TestFindGitRootFrom:

• Worktree marker file — .git is a regular file starting with gitdir:, detected from both the root and a subdirectory
• Invalid .git file — a .git file without the gitdir: prefix is not treated as a valid repo root
• Relative path input — FindGitRootFrom(".") resolves correctly via filepath.Abs

Also fixed FindGitRootFrom itself: it now normalizes startDir to an absolute path up front, surfaces non-ErrNotExist stat errors, and propagates os.ReadFile errors instead of silently continuing past an unreadable .git file.