Optimize who: parallel git calls, remove N per-author last-active lookups

Author: mubbie

cmd/who.go

@@ -25,11 +25,12 @@ func init() {
 }
 
 type contributor struct {
-	name    string
-	emails  map[string]bool
-	commits int
-	added   int
-	deleted int
+	name       string
+	emails     map[string]bool
+	commits    int
+	added      int
+	deleted    int
+	lastActive string // ISO date
 }
 
 func runWho(cmd *cobra.Command, args []string) error {
@@ -51,19 +52,25 @@ func runWho(cmd *cobra.Command, args []string) error {
 func whoRepo(n int, since string) error {
 	sp := ui.StartSpinner("Analyzing contributors (this may take a moment)...")
 
-	// Get commit counts + emails
+	// Run both git commands in parallel
 	shortlogArgs := []string{"shortlog", "-sne", "--all"}
 	if since != "" {
 		shortlogArgs = append(shortlogArgs, "--since="+since)
 	}
-	shortlogOut, err := git.Run(shortlogArgs...)
-
-	// Get line stats per author (added/deleted)
-	numstatArgs := []string{"log", "--all", "--numstat", "--format=%aE"}
+	shortstatArgs := []string{"log", "--all", "--shortstat", "--format=%aE|%aI"}
 	if since != "" {
-		numstatArgs = append(numstatArgs, "--since="+since)
+		shortstatArgs = append(shortstatArgs, "--since="+since)
 	}
-	numstatOut := git.RunUnchecked(numstatArgs...)
+
+	var shortlogOut, numstatOut string
+	var err error
+	done := make(chan struct{})
+	go func() {
+		shortlogOut, err = git.Run(shortlogArgs...)
+		close(done)
+	}()
+	numstatOut = git.RunUnchecked(shortstatArgs...)
+	<-done
 
 	// Parse shortlog
 	type rawEntry struct {
@@ -97,26 +104,44 @@ func whoRepo(n int, since string) error {
 		}
 	}
 
-	// Parse numstat to get lines per email
-	linesByEmail := map[string][2]int{} // email -> [added, deleted]
+	// Parse shortstat to get lines and last-active per email
+	linesByEmail := map[string][2]int{}    // email -> [added, deleted]
+	lastActiveByEmail := map[string]string{} // email -> ISO date (first seen = most recent)
 	if numstatOut != "" {
-		var currentEmail string
+		var currentEmail, currentDate string
 		for _, line := range strings.Split(numstatOut, "\n") {
 			line = strings.TrimSpace(line)
 			if line == "" {
 				continue
 			}
-			// Email lines from --format=%aE
-			if !strings.Contains(line, "\t") && strings.Contains(line, "@") {
-				currentEmail = strings.ToLower(line)
+			// Format lines: "email|date" from --format=%aE|%aI
+			if strings.Contains(line, "@") && strings.Contains(line, "|") {
+				parts := strings.SplitN(line, "|", 2)
+				currentEmail = strings.ToLower(parts[0])
+				if len(parts) > 1 {
+					currentDate = parts[1]
+				}
+				// Track first (most recent) date per email
+				if _, exists := lastActiveByEmail[currentEmail]; !exists {
+					lastActiveByEmail[currentEmail] = currentDate
+				}
 				continue
 			}
-			// Numstat lines: "added\tdeleted\tfile"
-			parts := strings.SplitN(line, "\t", 3)
-			if len(parts) >= 2 && currentEmail != "" {
+			// Shortstat lines
+			if strings.Contains(line, "file") && strings.Contains(line, "changed") && currentEmail != "" {
 				var a, d int
-				fmt.Sscanf(parts[0], "%d", &a)
-				fmt.Sscanf(parts[1], "%d", &d)
+				if idx := strings.Index(line, "insertion"); idx > 0 {
+					sub := strings.TrimSpace(line[:idx])
+					if ci := strings.LastIndex(sub, " "); ci >= 0 {
+						fmt.Sscanf(strings.TrimSpace(sub[ci+1:]), "%d", &a)
+					}
+				}
+				if idx := strings.Index(line, "deletion"); idx > 0 {
+					sub := strings.TrimSpace(line[:idx])
+					if ci := strings.LastIndex(sub, " "); ci >= 0 {
+						fmt.Sscanf(strings.TrimSpace(sub[ci+1:]), "%d", &d)
+					}
+				}
 				stats := linesByEmail[currentEmail]
 				stats[0] += a
 				stats[1] += d
@@ -192,12 +217,16 @@ func whoRepo(n int, since string) error {
 	}
 	for root, emails := range groupEmails {
 		groups[root].emails = emails
-		// Sum line stats across all emails in this group
 		for email := range emails {
 			if stats, ok := linesByEmail[email]; ok {
 				groups[root].added += stats[0]
 				groups[root].deleted += stats[1]
 			}
+			if date, ok := lastActiveByEmail[email]; ok {
+				if groups[root].lastActive == "" || date > groups[root].lastActive {
+					groups[root].lastActive = date
+				}
+			}
 		}
 	}
 
@@ -255,7 +284,10 @@ func whoRepo(n int, since string) error {
 		}
 		sort.Strings(emailList)
 
-		lastActive := getAuthorLastEdit(c.name, ".")
+		lastActive := "unknown"
+		if c.lastActive != "" {
+			lastActive = git.TimeAgo(c.lastActive)
+		}
 
 		// Lines and percentage
 		linesStr := ui.AddStyle.Render(fmt.Sprintf("+%d", c.added)) + " " + ui.DelStyle.Render(fmt.Sprintf("-%d", c.deleted))
@@ -290,10 +322,3 @@ func whoRepo(n int, since string) error {
 	return nil
 }
 
-func getAuthorLastEdit(author, path string) string {
-	out := git.RunUnchecked("log", "-1", "--author="+author, "--format=%aI", "--", path)
-	if out == "" {
-		return "unknown"
-	}
-	return git.TimeAgo(out)
-}

internal/stack/tree.go

@@ -55,7 +55,12 @@ func BuildTree() *BranchStack {
 	}
 
 	// Self-heal: detect parents for unknown branches
+	// Only check against trunk and existing stack parents (not all branches - avoids O(N^2))
 	changed := false
+	candidates := map[string]bool{mainBranch: true}
+	for _, meta := range cfg.Branches {
+		candidates[meta.Parent] = true
+	}
 	for branch := range branchSHAs {
 		if branch == mainBranch {
 			continue
@@ -65,7 +70,9 @@ func BuildTree() *BranchStack {
 				continue
 			}
 		}
-		if detected := detectParent(branch, branchSHAs); detected != "" {
+		// Only check against trunk and known parents, not all branches
+		detected := detectParentFast(branch, mainBranch, candidates, branchSHAs)
+		if detected != "" {
 			parentHead, _ := git.MergeBase(branch, detected)
 			cfg.Branches[branch] = &BranchMeta{Parent: detected, ParentHead: parentHead}
 			changed = true
@@ -91,19 +98,29 @@ func BuildTree() *BranchStack {
 		}
 	}
 
-	// Calculate ahead/behind
+	// Calculate ahead/behind and merged status
+	// Batch merged check: one call per unique parent instead of per child
+	mergedCache := map[string]map[string]bool{} // parent -> set of merged branches
 	for childName, meta := range cfg.Branches {
 		child, childOK := nodes[childName]
 		_, parentOK := nodes[meta.Parent]
 		if childOK && parentOK {
 			child.Ahead, child.Behind = git.AheadBehind(childName, meta.Parent)
 
-			merged := git.RunUnchecked("branch", "--merged", meta.Parent)
-			for _, line := range strings.Split(merged, "\n") {
-				if strings.TrimSpace(strings.TrimLeft(line, "* ")) == childName {
-					child.IsMerged = true
-					break
+			// Cache merged branches per parent
+			if _, ok := mergedCache[meta.Parent]; !ok {
+				mergedSet := map[string]bool{}
+				out := git.RunUnchecked("branch", "--merged", meta.Parent)
+				for _, line := range strings.Split(out, "\n") {
+					name := strings.TrimSpace(strings.TrimLeft(line, "* "))
+					if name != "" {
+						mergedSet[name] = true
+					}
 				}
+				mergedCache[meta.Parent] = mergedSet
+			}
+			if mergedCache[meta.Parent][childName] {
+				child.IsMerged = true
 			}
 		}
 	}
@@ -162,12 +179,22 @@ func BuildTree() *BranchStack {
 	}
 }
 
-func detectParent(branch string, branchSHAs map[string]string) string {
+// detectParentFast checks only trunk and known stack parents (not all branches).
+func detectParentFast(branch, mainBranch string, candidates map[string]bool, branchSHAs map[string]string) string {
+	// Try trunk first (most common case)
+	if _, exists := branchSHAs[mainBranch]; exists {
+		if mb, err := git.MergeBase(branch, mainBranch); err == nil && mb != "" {
+			return mainBranch
+		}
+	}
+	// Try other known parents
 	var bestParent string
-	bestDistance := int(^uint(0) >> 1) // max int
-
-	for candidate := range branchSHAs {
-		if candidate == branch {
+	bestDistance := int(^uint(0) >> 1)
+	for candidate := range candidates {
+		if candidate == branch || candidate == mainBranch {
+			continue
+		}
+		if _, exists := branchSHAs[candidate]; !exists {
 			continue
 		}
 		mb, err := git.MergeBase(branch, candidate)
@@ -186,5 +213,8 @@ func detectParent(branch string, branchSHAs map[string]string) string {
 			}
 		}
 	}
-	return bestParent
+	if bestParent != "" {
+		return bestParent
+	}
+	return mainBranch
 }