Improve performance and reliability with native git CLI and better error handling

daemon/cc_info_timer.go

@@ -45,6 +45,9 @@ type CCInfoTimerService struct {
 	stopChan     chan struct{}
 	wg           sync.WaitGroup
 
+	// Guards concurrent fetchRateLimit goroutines
+	rateLimitFetchMu sync.Mutex
+
 	// Git info cache (per working directory)
 	gitCache map[string]*GitCacheEntry
 
@@ -160,7 +163,15 @@ func (s *CCInfoTimerService) timerLoop() {
 	// Fetch immediately on start
 	s.fetchActiveRanges(context.Background())
 	s.fetchGitInfo()
-	go s.fetchRateLimit(context.Background())
+	go func() {
+		if !s.rateLimitFetchMu.TryLock() {
+			return
+		}
+		defer s.rateLimitFetchMu.Unlock()
+		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+		defer cancel()
+		s.fetchRateLimit(ctx)
+	}()
 	go s.fetchUserProfile(context.Background())
 
 	for {
@@ -175,7 +186,15 @@ func (s *CCInfoTimerService) timerLoop() {
 			}
 			s.fetchActiveRanges(context.Background())
 			s.fetchGitInfo()
-			go s.fetchRateLimit(context.Background())
+			go func() {
+				if !s.rateLimitFetchMu.TryLock() {
+					return
+				}
+				defer s.rateLimitFetchMu.Unlock()
+				ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+				defer cancel()
+				s.fetchRateLimit(ctx)
+			}()
 
 		case <-s.stopChan:
 			return

daemon/chan.go

@@ -2,7 +2,9 @@ package daemon
 
 import (
 	"context"
+	"fmt"
 	"sync"
+	"time"
 
 	"github.com/lithammer/shortuuid/v3"
 	"github.com/pkg/errors"
@@ -344,6 +346,9 @@ func (s *subscriber) sendMessageToSubscriber(msg *message.Message, logFields wat
 	ctx, cancelCtx := context.WithCancel(s.ctx)
 	defer cancelCtx()
 
+	const maxRetries = 3
+	retryCount := 0
+
 SendToSubscriber:
 	for {
 		// copy the message to prevent ack/nack propagation to other consumers
@@ -371,8 +376,20 @@ SendToSubscriber:
 			s.logger.Trace("Message acked", logFields)
 			return
 		case <-msgToSend.Nacked():
-			s.logger.Trace("Nack received, resending message", logFields)
-			continue SendToSubscriber
+			retryCount++
+			if retryCount > maxRetries {
+				s.logger.Error("Max retries reached, dropping message", errors.New("max retries reached"), logFields)
+				return
+			}
+			backoff := time.Duration(100<<uint(retryCount-1)) * time.Millisecond
+			s.logger.Trace(fmt.Sprintf("Nack received, retrying after %s (%d/%d)", backoff, retryCount, maxRetries), logFields)
+			select {
+			case <-time.After(backoff):
+				continue SendToSubscriber
+			case <-s.closing:
+				s.logger.Trace("Closing during backoff, message discarded", logFields)
+				return
+			}
 		case <-s.closing:
 			s.logger.Trace("Closing, message discarded", logFields)
 			return

daemon/git.go

@@ -1,9 +1,14 @@
 package daemon
 
 import (
-	"github.com/go-git/go-git/v5"
+	"context"
+	"os/exec"
+	"strings"
+	"time"
 )
 
+const gitCmdTimeout = 2 * time.Second
+
 // GitInfo contains git repository information
 type GitInfo struct {
 	Branch string
@@ -12,34 +17,31 @@ type GitInfo struct {
 }
 
 // GetGitInfo returns git branch and dirty status for a directory.
-// It walks up the directory tree to find the git repository root.
+// It uses the native git CLI which is significantly faster and more memory-efficient
+// than the pure-Go go-git implementation, especially on large repositories.
 func GetGitInfo(workingDir string) GitInfo {
 	if workingDir == "" {
 		return GitInfo{}
 	}
 
-	repo, err := git.PlainOpenWithOptions(workingDir, &git.PlainOpenOptions{
-		DetectDotGit: true, // Walk up to find .git
-	})
-	if err != nil {
-		return GitInfo{} // Not a git repo
+	ctx, cancel := context.WithTimeout(context.Background(), gitCmdTimeout)
+	defer cancel()
+
+	// Check if this is a git repo
+	if err := exec.CommandContext(ctx, "git", "-C", workingDir, "rev-parse", "--git-dir").Run(); err != nil {
+		return GitInfo{}
 	}
 
 	info := GitInfo{IsRepo: true}
 
 	// Get branch name from HEAD
-	head, err := repo.Head()
-	if err == nil {
-		info.Branch = head.Name().Short()
+	if out, err := exec.CommandContext(ctx, "git", "-C", workingDir, "rev-parse", "--abbrev-ref", "HEAD").Output(); err == nil {
+		info.Branch = strings.TrimSpace(string(out))
 	}
 
-	// Check dirty status by examining worktree status
-	worktree, err := repo.Worktree()
-	if err == nil {
-		status, err := worktree.Status()
-		if err == nil {
-			info.Dirty = !status.IsClean()
-		}
+	// Check dirty status via porcelain output (empty = clean)
+	if out, err := exec.CommandContext(ctx, "git", "-C", workingDir, "status", "--porcelain").Output(); err == nil {
+		info.Dirty = len(strings.TrimSpace(string(out))) > 0
 	}
 
 	return info

daemon/socket.go

@@ -127,21 +127,22 @@ func (p *SocketHandler) Stop() {
 
 func (p *SocketHandler) acceptConnections() {
 	for {
-		select {
-		case <-p.stopChan:
-			return
-		default:
-			conn, err := p.listener.Accept()
-			if err != nil {
-				continue
+		conn, err := p.listener.Accept()
+		if err != nil {
+			select {
+			case <-p.stopChan:
+				return
+			default:
 			}
-			go p.handleConnection(conn)
+			continue
 		}
+		go p.handleConnection(conn)
 	}
 }
 
 func (p *SocketHandler) handleConnection(conn net.Conn) {
 	defer conn.Close()
+	conn.SetDeadline(time.Now().Add(5 * time.Second))
 	decoder := json.NewDecoder(conn)
 	var msg SocketMessage
 	if err := decoder.Decode(&msg); err != nil {