Entire Enable performance optimzations

cmd/entire/cli/agent/claudecode/hooks.go

@@ -66,7 +66,7 @@ func (c *ClaudeCodeAgent) InstallHooks(localDev bool, force bool) (int, error) {
 	// rawPermissions preserves unknown permission fields (e.g., "ask")
 	var rawPermissions map[string]json.RawMessage
 
-	existingData, readErr := os.ReadFile(settingsPath) //nolint:gosec // path is constructed from cwd + fixed path
+	existingData, readErr := os.ReadFile(settingsPath) //nolint:gosec // path is constructed from repo root + settings file name
 	if readErr == nil {
 		if err := json.Unmarshal(existingData, &rawSettings); err != nil {
 			return 0, fmt.Errorf("failed to parse existing settings.json: %w", err)

cmd/entire/cli/bench_enable_test.go

@@ -0,0 +1,69 @@
+package cli
+
+import (
+	"bytes"
+	"os"
+	"testing"
+
+	"github.com/entireio/cli/cmd/entire/cli/agent"
+	"github.com/entireio/cli/cmd/entire/cli/benchutil"
+	"github.com/entireio/cli/cmd/entire/cli/paths"
+	"github.com/entireio/cli/cmd/entire/cli/strategy"
+)
+
+// BenchmarkEnableCommand benchmarks the non-interactive enable path
+// (setupAgentHooksNonInteractive) which is the hot path for `entire enable --agent claude-code`.
+//
+// Cannot use t.Parallel() because os.Chdir is process-global state.
+func BenchmarkEnableCommand(b *testing.B) {
+	ag, err := agent.Get(agent.AgentNameClaudeCode)
+	if err != nil {
+		b.Fatalf("get agent: %v", err)
+	}
+
+	b.Run("NewRepo_ClaudeCode", func(b *testing.B) {
+		for b.Loop() {
+			b.StopTimer()
+			repo := benchutil.NewBenchRepo(b, benchutil.RepoOpts{})
+			//nolint:usetesting // b.Chdir() restores only once at cleanup; we need a fresh dir each iteration
+			if err := os.Chdir(repo.Dir); err != nil {
+				b.Fatalf("chdir: %v", err)
+			}
+			paths.ClearRepoRootCache()
+			strategy.ClearHooksDirCache()
+			b.StartTimer()
+
+			w := &bytes.Buffer{}
+			if err := setupAgentHooksNonInteractive(w, ag, "", true, false, false, false); err != nil {
+				b.Fatalf("setupAgentHooksNonInteractive: %v", err)
+			}
+		}
+	})
+
+	b.Run("ReEnable_ClaudeCode", func(b *testing.B) {
+		b.StopTimer()
+		repo := benchutil.NewBenchRepo(b, benchutil.RepoOpts{})
+		b.Chdir(repo.Dir)
+		paths.ClearRepoRootCache()
+		strategy.ClearHooksDirCache()
+
+		// First enable to set up everything
+		w := &bytes.Buffer{}
+		if err := setupAgentHooksNonInteractive(w, ag, "", true, false, false, false); err != nil {
+			b.Fatalf("initial enable: %v", err)
+		}
+		b.StartTimer()
+
+		for b.Loop() {
+			b.StopTimer()
+			paths.ClearRepoRootCache()
+			strategy.ClearHooksDirCache()
+			b.StartTimer()
+
+			w.Reset()
+			if err := setupAgentHooksNonInteractive(w, ag, "", true, false, false, false); err != nil {
+				b.Fatalf("setupAgentHooksNonInteractive: %v", err)
+			}
+		}
+	})
+}

cmd/entire/cli/setup.go

@@ -12,6 +12,7 @@ import (
 	"github.com/entireio/cli/cmd/entire/cli/agent"
 	"github.com/entireio/cli/cmd/entire/cli/paths"
 	"github.com/entireio/cli/cmd/entire/cli/session"
+	"github.com/entireio/cli/cmd/entire/cli/settings"
 	"github.com/entireio/cli/cmd/entire/cli/strategy"
 
 	"github.com/charmbracelet/huh"
@@ -265,11 +266,10 @@ func runEnableWithStrategy(w io.Writer, agents []agent.Agent, selectedStrategy s
 		}
 	}
 
-	// Install git hooks AFTER saving settings (InstallGitHook reads local_dev from settings)
-	if _, err := strategy.InstallGitHook(true); err != nil {
+	if _, err := strategy.InstallGitHook(true, localDev); err != nil {
 		return fmt.Errorf("failed to install git hooks: %w", err)
 	}
-	strategy.CheckAndWarnHookManagers(w)
+	strategy.CheckAndWarnHookManagers(w, localDev)
 	fmt.Fprintln(w, "✓ Hooks installed")
 	fmt.Fprintf(w, "✓ Project configured (%s)\n", configDisplay)
 
@@ -351,11 +351,10 @@ func runEnableInteractive(w io.Writer, agents []agent.Agent, localDev, useLocalS
 		return fmt.Errorf("failed to save settings: %w", err)
 	}
 
-	// Install git hooks AFTER saving settings (InstallGitHook reads local_dev from settings)
-	if _, err := strategy.InstallGitHook(true); err != nil {
+	if _, err := strategy.InstallGitHook(true, localDev); err != nil {
 		return fmt.Errorf("failed to install git hooks: %w", err)
 	}
-	strategy.CheckAndWarnHookManagers(w)
+	strategy.CheckAndWarnHookManagers(w, localDev)
 	fmt.Fprintln(w, "✓ Hooks installed")
 
 	configDisplay := configDisplayProject
@@ -769,11 +768,10 @@ func setupAgentHooksNonInteractive(w io.Writer, ag agent.Agent, strategyName str
 		return fmt.Errorf("failed to save settings: %w", err)
 	}
 
-	// Install git hooks AFTER saving settings (InstallGitHook reads local_dev from settings)
-	if _, err := strategy.InstallGitHook(true); err != nil {
+	if _, err := strategy.InstallGitHook(true, localDev); err != nil {
 		return fmt.Errorf("failed to install git hooks: %w", err)
 	}
-	strategy.CheckAndWarnHookManagers(w)
+	strategy.CheckAndWarnHookManagers(w, localDev)
 
 	if installedHooks == 0 {
 		msg := fmt.Sprintf("Hooks for %s already installed", ag.Description())
@@ -870,13 +868,12 @@ func setupEntireDirectory() (bool, error) { //nolint:unparam // already present
 
 // setupGitHook installs the prepare-commit-msg hook for context trailers.
 func setupGitHook() error {
-	// Use shared implementation from strategy package
-	// The localDev setting is read from settings.json
-	_, err := strategy.InstallGitHook(false) // not silent - show output during setup
-	if err != nil {
+	s, err := settings.Load()
+	localDev := err == nil && s.LocalDev
+	if _, err := strategy.InstallGitHook(false, localDev); err != nil {
 		return fmt.Errorf("failed to install git hook: %w", err)
 	}
-	strategy.CheckAndWarnHookManagers(os.Stderr)
+	strategy.CheckAndWarnHookManagers(os.Stderr, localDev)
 	return nil
 }
 

cmd/entire/cli/setup_test.go

@@ -483,7 +483,7 @@ func TestRunUninstall_Force_RemovesGitHooks(t *testing.T) {
 	writeSettings(t, testSettingsEnabled)
 
 	// Install git hooks
-	if _, err := strategy.InstallGitHook(true); err != nil {
+	if _, err := strategy.InstallGitHook(true, false); err != nil {
 		t.Fatalf("InstallGitHook() error = %v", err)
 	}
 

cmd/entire/cli/strategy/auto_commit.go

@@ -476,7 +476,7 @@ func (s *AutoCommitStrategy) EnsureSetup() error {
 
 	// Install generic hooks if missing (they delegate to strategy at runtime)
 	if !IsGitHookInstalled() {
-		if _, err := InstallGitHook(true); err != nil {
+		if _, err := InstallGitHook(true, isLocalDev()); err != nil {
 			return fmt.Errorf("failed to install git hooks: %w", err)
 		}
 	}

cmd/entire/cli/strategy/common.go

@@ -558,9 +558,7 @@ func GetRemoteMetadataBranchTree(repo *git.Repository) (*object.Tree, error) {
 // The function first uses 'git rev-parse --show-toplevel' to find the repository
 // root, which works correctly even when called from a subdirectory within the repo.
 func OpenRepository() (*git.Repository, error) {
-	// First, find the repository root using git rev-parse --show-toplevel
-	// This works correctly from any subdirectory within the repository
-	repoRoot, err := GetWorktreePath()
+	repoRoot, err := paths.RepoRoot()
 	if err != nil {
 		// Fallback to current directory if git command fails
 		// (e.g., if git is not installed or we're not in a repo)

cmd/entire/cli/strategy/hook_managers.go

@@ -111,7 +111,8 @@ func extractCommandLine(hookContent string) string {
 
 // CheckAndWarnHookManagers detects external hook managers and writes a warning
 // to w if any are found.
-func CheckAndWarnHookManagers(w io.Writer) {
+// localDev controls whether the warning references "go run" or the "entire" binary.
+func CheckAndWarnHookManagers(w io.Writer, localDev bool) {
 	repoRoot, err := paths.RepoRoot()
 	if err != nil {
 		return
@@ -122,7 +123,7 @@ func CheckAndWarnHookManagers(w io.Writer) {
 		return
 	}
 
-	warning := hookManagerWarning(managers, hookCmdPrefix())
+	warning := hookManagerWarning(managers, hookCmdPrefix(localDev))
 	if warning != "" {
 		fmt.Fprintln(w)
 		fmt.Fprint(w, warning)

cmd/entire/cli/strategy/hook_managers_test.go

@@ -380,7 +380,7 @@ func TestCheckAndWarnHookManagers_NoManagers(t *testing.T) {
 	initHooksTestRepo(t)
 
 	var buf bytes.Buffer
-	CheckAndWarnHookManagers(&buf)
+	CheckAndWarnHookManagers(&buf, false)
 
 	if buf.Len() != 0 {
 		t.Errorf("expected no output, got %q", buf.String())
@@ -397,7 +397,7 @@ func TestCheckAndWarnHookManagers_WithHusky(t *testing.T) {
 	}
 
 	var buf bytes.Buffer
-	CheckAndWarnHookManagers(&buf)
+	CheckAndWarnHookManagers(&buf, false)
 
 	output := buf.String()
 	if !strings.Contains(output, "Warning: Husky detected") {

cmd/entire/cli/strategy/hooks.go

@@ -8,6 +8,7 @@ import (
 	"os/exec"
 	"path/filepath"
 	"strings"
+	"sync"
 
 	"github.com/entireio/cli/cmd/entire/cli/settings"
 )
@@ -40,11 +41,52 @@ func GetGitDir() (string, error) {
 	return getGitDirInPath(".")
 }
 
+// hooksDirCache caches the hooks directory to avoid repeated git subprocess spawns.
+// Keyed by current working directory to handle directory changes.
+var (
+	hooksDirMu       sync.RWMutex
+	hooksDirCache    string
+	hooksDirCacheDir string
+)
+
 // GetHooksDir returns the active hooks directory path.
 // This respects core.hooksPath and correctly resolves to the common hooks
 // directory when called from a linked worktree.
+// The result is cached per working directory.
 func GetHooksDir() (string, error) {
-	return getHooksDirInPath(".")
+	cwd, err := os.Getwd() //nolint:forbidigo // cache key for hooks dir, same pattern as paths.RepoRoot()
+	if err != nil {
+		cwd = ""
+	}
+
+	hooksDirMu.RLock()
+	if hooksDirCache != "" && hooksDirCacheDir == cwd {
+		cached := hooksDirCache
+		hooksDirMu.RUnlock()
+		return cached, nil
+	}
+	hooksDirMu.RUnlock()
+
+	result, err := getHooksDirInPath(".")
+	if err != nil {
+		return "", err
+	}
+
+	hooksDirMu.Lock()
+	hooksDirCache = result
+	hooksDirCacheDir = cwd
+	hooksDirMu.Unlock()
+
+	return result, nil
+}
+
+// ClearHooksDirCache clears the cached hooks directory.
+// This is primarily useful for testing when changing directories.
+func ClearHooksDirCache() {
+	hooksDirMu.Lock()
+	hooksDirCache = ""
+	hooksDirCacheDir = ""
+	hooksDirMu.Unlock()
 }
 
 // getGitDirInPath returns the git directory for a repository at the given path.
@@ -165,8 +207,9 @@ func buildHookSpecs(cmdPrefix string) []hookSpec {
 // InstallGitHook installs generic git hooks that delegate to `entire hook` commands.
 // These hooks work with any strategy - the strategy is determined at runtime.
 // If silent is true, no output is printed (except backup notifications, which always print).
+// localDev controls whether hooks use "go run" (true) or the "entire" binary (false).
 // Returns the number of hooks that were installed (0 if all already up to date).
-func InstallGitHook(silent bool) (int, error) {
+func InstallGitHook(silent bool, localDev bool) (int, error) {
 	hooksDir, err := GetHooksDir()
 	if err != nil {
 		return 0, err
@@ -176,7 +219,7 @@ func InstallGitHook(silent bool) (int, error) {
 		return 0, fmt.Errorf("failed to create hooks directory: %w", err)
 	}
 
-	specs := buildHookSpecs(hookCmdPrefix())
+	specs := buildHookSpecs(hookCmdPrefix(localDev))
 	installedCount := 0
 
 	for _, spec := range specs {
@@ -298,8 +341,8 @@ fi
 
 // hookCmdPrefix returns the command prefix for hook scripts and warning messages.
 // Returns "go run ./cmd/entire/main.go" when local_dev is enabled, "entire" otherwise.
-func hookCmdPrefix() string {
-	if isLocalDev() {
+func hookCmdPrefix(localDev bool) string {
+	if localDev {
 		return "go run ./cmd/entire/main.go"
 	}
 	return "entire"