fix: fallback to CWD/.bin when no git repo or envs (#108)

## Summary
- `GetBinaryPath()` now falls back to `$PWD/.bin` when `PATH_BIN`,
`PATH_BASE`, and git root are all unavailable
- Improved `ErrNoBinaryPath` error message with actionable hint
- Added 3 unit tests for `GetBinaryPath` (CWD fallback, env override,
git root)

Closes #86

## Test plan
- [x] `TestGetBinaryPath_FallbackCWD` — verifies CWD/.bin fallback in
non-git directory
- [x] `TestGetBinaryPath_EnvOverride` — verifies PATH_BIN takes priority
- [x] `TestGetBinaryPath_GitRoot` — verifies git root detection still
works
- [x] Existing test suite passes

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: fentas

pkg/cli/errors.go

@@ -4,7 +4,7 @@ import "errors"
 
 var (
 	// ErrNoBinaryPath indicates that no suitable binary installation path was found
-	ErrNoBinaryPath = errors.New("could not find a suitable path to install binaries")
+	ErrNoBinaryPath = errors.New("could not determine a suitable path to install binaries (current working directory could not be determined)")
 
 	// ErrUnknownBinary indicates that the specified binary is not available
 	ErrUnknownBinary = errors.New("unknown binary")

pkg/path/path.go

@@ -14,19 +14,23 @@ func GetDefaultConfigPath() string {
 	return filepath.Join(path, "b.yaml")
 }
 
-// GetBinaryPath returns the binary path without importing pkg/binary to avoid import cycle
+// GetBinaryPath returns the binary path without importing pkg/binary to avoid import cycle.
+// Priority: PATH_BIN > PATH_BASE > <git-root>/.bin > <cwd>/.bin
 func GetBinaryPath() string {
-	var path string
-
-	if os.Getenv("PATH_BIN") != "" {
-		path = os.Getenv("PATH_BIN")
-	} else if os.Getenv("PATH_BASE") != "" {
-		path = os.Getenv("PATH_BASE")
-	} else if gitRoot, err := GetGitRootDirectory(); err == nil {
-		path = gitRoot + "/.bin"
+	if p := os.Getenv("PATH_BIN"); p != "" {
+		return p
 	}
-
-	return path
+	if p := os.Getenv("PATH_BASE"); p != "" {
+		return p
+	}
+	if gitRoot, err := GetGitRootDirectory(); err == nil {
+		return filepath.Join(gitRoot, ".bin")
+	}
+	// Fallback: use CWD/.bin so `b install` works outside a git repo.
+	if cwd, err := os.Getwd(); err == nil {
+		return filepath.Join(cwd, ".bin")
+	}
+	return ""
 }
 
 // FindConfigFile searches for b.yaml file in current directory and parent directories

pkg/path/path_test.go

@@ -0,0 +1,148 @@
+package path
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// realDir resolves symlinks so tests pass on macOS where
+// /var is a symlink to /private/var.
+func realDir(t *testing.T, dir string) string {
+	t.Helper()
+	real, err := filepath.EvalSymlinks(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return real
+}
+
+// clearPathEnvs uses t.Setenv to clear PATH_BIN and PATH_BASE,
+// automatically restoring (or unsetting) them when the test finishes.
+func clearPathEnvs(t *testing.T) {
+	t.Helper()
+	t.Setenv("PATH_BIN", "")
+	t.Setenv("PATH_BASE", "")
+	os.Unsetenv("PATH_BIN")
+	os.Unsetenv("PATH_BASE")
+}
+
+// TestGetBinaryPath_FallbackCWD verifies that GetBinaryPath falls back to
+// CWD/.bin when no env vars are set and no git root is found (issue #86).
+func TestGetBinaryPath_FallbackCWD(t *testing.T) {
+	clearPathEnvs(t)
+
+	// Work in a temp dir that has no .git
+	tmp := realDir(t, t.TempDir())
+	origDir, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.Chdir(origDir)
+
+	if err := os.Chdir(tmp); err != nil {
+		t.Fatal(err)
+	}
+
+	got := GetBinaryPath()
+	want := filepath.Join(tmp, ".bin")
+	if got != want {
+		t.Errorf("GetBinaryPath() = %q, want %q (CWD fallback)", got, want)
+	}
+}
+
+// TestGetBinaryPath_EnvOverride verifies that PATH_BIN takes priority.
+func TestGetBinaryPath_EnvOverride(t *testing.T) {
+	t.Setenv("PATH_BIN", "/custom/bin")
+	got := GetBinaryPath()
+	if got != "/custom/bin" {
+		t.Errorf("GetBinaryPath() = %q, want %q", got, "/custom/bin")
+	}
+}
+
+// TestGetBinaryPath_GitRoot verifies that git root is used when available.
+func TestGetBinaryPath_GitRoot(t *testing.T) {
+	clearPathEnvs(t)
+
+	// Create a temp dir with a .git directory
+	tmp := realDir(t, t.TempDir())
+	if err := os.Mkdir(filepath.Join(tmp, ".git"), 0755); err != nil {
+		t.Fatal(err)
+	}
+
+	origDir, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.Chdir(origDir)
+
+	if err := os.Chdir(tmp); err != nil {
+		t.Fatal(err)
+	}
+
+	got := GetBinaryPath()
+	want := filepath.Join(tmp, ".bin")
+	if got != want {
+		t.Errorf("GetBinaryPath() = %q, want %q (git root)", got, want)
+	}
+}
+
+// TestGetBinaryPath_PathBaseFallback verifies PATH_BASE is used when PATH_BIN is unset.
+func TestGetBinaryPath_PathBaseFallback(t *testing.T) {
+	clearPathEnvs(t)
+	t.Setenv("PATH_BASE", "/project/base")
+
+	got := GetBinaryPath()
+	if got != "/project/base" {
+		t.Errorf("GetBinaryPath() = %q, want %q (PATH_BASE)", got, "/project/base")
+	}
+}
+
+// TestGetBinaryPath_PathBinOverridesAll verifies PATH_BIN wins over PATH_BASE and git root.
+func TestGetBinaryPath_PathBinOverridesAll(t *testing.T) {
+	// Set both — PATH_BIN should win
+	t.Setenv("PATH_BIN", "/priority/bin")
+	t.Setenv("PATH_BASE", "/base/bin")
+
+	// Even inside a git repo
+	tmp := realDir(t, t.TempDir())
+	if err := os.Mkdir(filepath.Join(tmp, ".git"), 0755); err != nil {
+		t.Fatal(err)
+	}
+	origDir, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.Chdir(origDir)
+
+	if err := os.Chdir(tmp); err != nil {
+		t.Fatal(err)
+	}
+
+	got := GetBinaryPath()
+	if got != "/priority/bin" {
+		t.Errorf("GetBinaryPath() = %q, want %q (PATH_BIN should override all)", got, "/priority/bin")
+	}
+}
+
+// TestGetDefaultConfigPath_FallbackCWD verifies config path uses CWD fallback.
+func TestGetDefaultConfigPath_FallbackCWD(t *testing.T) {
+	clearPathEnvs(t)
+
+	tmp := realDir(t, t.TempDir())
+	origDir, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.Chdir(origDir)
+
+	if err := os.Chdir(tmp); err != nil {
+		t.Fatal(err)
+	}
+
+	got := GetDefaultConfigPath()
+	want := filepath.Join(tmp, ".bin", "b.yaml")
+	if got != want {
+		t.Errorf("GetDefaultConfigPath() = %q, want %q", got, want)
+	}
+}