cricinfo-cli-go 0.1.2 → 0.1.4

package/internal/cricinfo/analysis.go

@@ -19,6 +19,7 @@ const (
 	analysisMetricSixesConceded = "sixes-conceded"
 	analysisMetricFours         = "fours"
 	analysisMetricSixes         = "sixes"
+	analysisMetricRuns          = "runs"
 	analysisMetricStrikeRate    = "strike-rate"
 )
 
@@ -349,54 +350,62 @@ func (s *AnalysisService) Bowling(ctx context.Context, opts AnalysisMetricOption
 
 	agg := map[string]*analysisAggregate{}
 	warnings := append([]string{}, run.warnings...)
-	for _, match := range run.session.ScopedMatches() {
-		seasonID := seasonForMatch(match, run.seasonHint)
-		players, playerWarnings, hydrateErr := run.session.HydratePlayerMatchSummaries(ctx, match.ID)
-		if hydrateErr != nil {
-			if statusErr := analysisTransportResult(EntityAnalysisBowl, match.ID, hydrateErr); statusErr != nil {
-				return *statusErr, nil
-			}
-			warnings = append(warnings, fmt.Sprintf("match %s player summary: %v", match.ID, hydrateErr))
-			continue
+	if run.mode == analysisScopeMatch {
+		if fastAgg, fastWarnings, used := s.hydrateMatchScopeBowlingFromScorecard(ctx, run, filters, groupBy); used {
+			agg = fastAgg
+			warnings = append(warnings, fastWarnings...)
 		}
-		warnings = append(warnings, playerWarnings...)
-
-		for _, player := range players {
-			totals := extractBowlingTotals(player)
-			playerName := analysisDisplayPlayerName(s.resolver, player.PlayerID, player.PlayerName)
-			teamName := analysisDisplayTeamName(s.resolver, player.TeamID, player.TeamName)
-			row := analysisSourceRow{
-				MatchID:       strings.TrimSpace(player.MatchID),
-				LeagueID:      strings.TrimSpace(player.LeagueID),
-				SeasonID:      seasonID,
-				TeamID:        strings.TrimSpace(player.TeamID),
-				TeamName:      strings.TrimSpace(teamName),
-				PlayerID:      strings.TrimSpace(player.PlayerID),
-				PlayerName:    strings.TrimSpace(playerName),
-				CountValue:    1,
-				Dots:          totals.dots,
-				SixesConceded: totals.sixesConceded,
-				Balls:         totals.balls,
-				RunsConceded:  totals.conceded,
-				EconomySample: totals.economy,
-			}
-			if !filters.matches(row) {
+	}
+	if len(agg) == 0 {
+		for _, match := range run.session.ScopedMatches() {
+			seasonID := seasonForMatch(match, run.seasonHint)
+			players, playerWarnings, hydrateErr := run.session.HydratePlayerMatchSummaries(ctx, match.ID)
+			if hydrateErr != nil {
+				if statusErr := analysisTransportResult(EntityAnalysisBowl, match.ID, hydrateErr); statusErr != nil {
+					return *statusErr, nil
+				}
+				warnings = append(warnings, fmt.Sprintf("match %s player summary: %v", match.ID, hydrateErr))
 				continue
 			}
-			key, dims := buildAnalysisGroup(row, groupBy)
-			entry := agg[key]
-			if entry == nil {
-				entry = &analysisAggregate{row: dims, matchIDs: map[string]struct{}{}}
-				agg[key] = entry
-			}
-			entry.matchIDs[row.MatchID] = struct{}{}
-			entry.dots += row.Dots
-			entry.sixesConceded += row.SixesConceded
-			entry.balls += row.Balls
-			entry.runsConceded += row.RunsConceded
-			if row.EconomySample > 0 {
-				entry.economyTotal += row.EconomySample
-				entry.economyCount++
+			warnings = append(warnings, playerWarnings...)
+
+			for _, player := range players {
+				totals := extractBowlingTotals(player)
+				playerName := analysisDisplayPlayerName(s.resolver, player.PlayerID, player.PlayerName)
+				teamName := analysisDisplayTeamName(s.resolver, player.TeamID, player.TeamName)
+				row := analysisSourceRow{
+					MatchID:       strings.TrimSpace(player.MatchID),
+					LeagueID:      strings.TrimSpace(player.LeagueID),
+					SeasonID:      seasonID,
+					TeamID:        strings.TrimSpace(player.TeamID),
+					TeamName:      strings.TrimSpace(teamName),
+					PlayerID:      strings.TrimSpace(player.PlayerID),
+					PlayerName:    strings.TrimSpace(playerName),
+					CountValue:    1,
+					Dots:          totals.dots,
+					SixesConceded: totals.sixesConceded,
+					Balls:         totals.balls,
+					RunsConceded:  totals.conceded,
+					EconomySample: totals.economy,
+				}
+				if !filters.matches(row) {
+					continue
+				}
+				key, dims := buildAnalysisGroup(row, groupBy)
+				entry := agg[key]
+				if entry == nil {
+					entry = &analysisAggregate{row: dims, matchIDs: map[string]struct{}{}}
+					agg[key] = entry
+				}
+				entry.matchIDs[row.MatchID] = struct{}{}
+				entry.dots += row.Dots
+				entry.sixesConceded += row.SixesConceded
+				entry.balls += row.Balls
+				entry.runsConceded += row.RunsConceded
+				if row.EconomySample > 0 {
+					entry.economyTotal += row.EconomySample
+					entry.economyCount++
+				}
 			}
 		}
 	}
@@ -447,6 +456,103 @@ func (s *AnalysisService) Bowling(ctx context.Context, opts AnalysisMetricOption
 	return analysisResult(EntityAnalysisBowl, view, warnings), nil
 }
 
+func (s *AnalysisService) hydrateMatchScopeBowlingFromScorecard(
+	ctx context.Context,
+	run *analysisScopeRun,
+	filters analysisFilterSpec,
+	groupBy []string,
+) (map[string]*analysisAggregate, []string, bool) {
+	if run == nil || run.session == nil {
+		return nil, nil, false
+	}
+	matches := run.session.ScopedMatches()
+	if len(matches) != 1 {
+		return nil, nil, false
+	}
+	match := matches[0]
+	scorecardRef := matchSubresourceRef(match, "matchcards", "matchcards")
+	if strings.TrimSpace(scorecardRef) == "" {
+		return nil, nil, false
+	}
+	resolved, err := s.client.ResolveRefChain(ctx, scorecardRef)
+	if err != nil {
+		return nil, nil, false
+	}
+	scorecard, err := NormalizeMatchScorecard(resolved.Body, match)
+	if err != nil {
+		return nil, nil, false
+	}
+	if len(scorecard.BowlingCards) == 0 {
+		return nil, nil, false
+	}
+
+	teamIDByAlias := map[string]string{}
+	for _, team := range match.Teams {
+		teamID := strings.TrimSpace(team.ID)
+		for _, raw := range []string{team.Name, team.ShortName, team.Abbreviation} {
+			alias := normalizeAlias(raw)
+			if alias == "" {
+				continue
+			}
+			if _, exists := teamIDByAlias[alias]; !exists {
+				teamIDByAlias[alias] = teamID
+			}
+		}
+	}
+
+	seasonID := seasonForMatch(match, run.seasonHint)
+	agg := map[string]*analysisAggregate{}
+	for _, card := range scorecard.BowlingCards {
+		teamName := strings.TrimSpace(card.TeamName)
+		teamID := teamIDByAlias[normalizeAlias(teamName)]
+		teamName = analysisDisplayTeamName(s.resolver, teamID, teamName)
+
+		for _, player := range card.Players {
+			conceded := analysisNumericString(player.Conceded)
+			wickets := analysisNumericString(player.Wickets)
+			balls := oversToBalls(player.Overs)
+			econ := 0.0
+			if balls > 0 {
+				econ = float64(conceded) / (float64(balls) / 6.0)
+			}
+			row := analysisSourceRow{
+				MatchID:       strings.TrimSpace(match.ID),
+				LeagueID:      strings.TrimSpace(nonEmpty(match.LeagueID, run.scope.League.ID)),
+				SeasonID:      seasonID,
+				TeamID:        teamID,
+				TeamName:      teamName,
+				PlayerID:      strings.TrimSpace(player.PlayerID),
+				PlayerName:    analysisDisplayPlayerName(s.resolver, player.PlayerID, player.PlayerName),
+				CountValue:    1,
+				Balls:         balls,
+				RunsConceded:  conceded,
+				EconomySample: econ,
+			}
+			if wickets > 0 {
+				row.Dots = 0
+			}
+			if !filters.matches(row) {
+				continue
+			}
+
+			key, dims := buildAnalysisGroup(row, groupBy)
+			entry := agg[key]
+			if entry == nil {
+				entry = &analysisAggregate{row: dims, matchIDs: map[string]struct{}{}}
+				agg[key] = entry
+			}
+			entry.matchIDs[row.MatchID] = struct{}{}
+			entry.balls += row.Balls
+			entry.runsConceded += row.RunsConceded
+			if row.EconomySample > 0 {
+				entry.economyTotal += row.EconomySample
+				entry.economyCount++
+			}
+		}
+	}
+	return agg, nil, true
+}
+
 // Batting ranks batting metrics over match or season scope.
 func (s *AnalysisService) Batting(ctx context.Context, opts AnalysisMetricOptions) (NormalizedResult, error) {
 	metric, err := normalizeBattingMetric(opts.Metric)
@@ -541,6 +647,9 @@ func (s *AnalysisService) Batting(ctx context.Context, opts AnalysisMetricOption
 		case analysisMetricSixes:
 			row.Value = float64(entry.battingSixes)
 			row.Count = entry.battingSixes
+		case analysisMetricRuns:
+			row.Value = float64(entry.runsScored)
+			row.Count = entry.runsScored
 		case analysisMetricStrikeRate:
 			row.Value = strikeRateFromAggregate(entry)
 		}
@@ -993,10 +1102,10 @@ func normalizeBattingMetric(raw string) (string, error) {
 	metric = strings.ReplaceAll(metric, "_", "-")
 	metric = strings.ReplaceAll(metric, " ", "-")
 	switch metric {
-	case analysisMetricFours, analysisMetricSixes, analysisMetricStrikeRate:
+	case analysisMetricFours, analysisMetricSixes, analysisMetricRuns, analysisMetricStrikeRate:
 		return metric, nil
 	default:
-		return "", fmt.Errorf("--metric must be one of: fours, sixes, strike-rate")
+		return "", fmt.Errorf("--metric must be one of: fours, sixes, runs, strike-rate")
 	}
 }
 
@@ -1437,6 +1546,27 @@ func analysisNumericString(raw string) int {
 	return value
 }
 
+func oversToBalls(raw string) int {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return 0
+	}
+	if strings.Contains(raw, ".") {
+		parts := strings.SplitN(raw, ".", 2)
+		whole, errWhole := strconv.Atoi(strings.TrimSpace(parts[0]))
+		frac, errFrac := strconv.Atoi(strings.TrimSpace(parts[1]))
+		if errWhole != nil || errFrac != nil || whole < 0 || frac < 0 || frac > 6 {
+			return 0
+		}
+		return whole*6 + frac
+	}
+	value, err := strconv.Atoi(raw)
+	if err != nil || value < 0 {
+		return 0
+	}
+	return value * 6
+}
+
 func analysisDisplayPlayerName(resolver *Resolver, playerID, fallback string) string {
 	name := strings.TrimSpace(fallback)
 	if name != "" {

package/internal/cricinfo/client.go

@@ -8,6 +8,7 @@ import (
 	"io"
 	"math"
 	"math/rand"
+	"net"
 	"net/http"
 	"net/url"
 	"strings"
@@ -138,7 +139,18 @@ func NewClient(cfg Config) (*Client, error) {
 
 	httpClient := cfg.HTTPClient
 	if httpClient == nil {
-		httpClient = &http.Client{}
+		httpClient = &http.Client{
+			Transport: &http.Transport{
+				Proxy:                 http.ProxyFromEnvironment,
+				DialContext:           (&net.Dialer{Timeout: 5 * time.Second, KeepAlive: 30 * time.Second}).DialContext,
+				ForceAttemptHTTP2:     true,
+				MaxIdleConns:          128,
+				MaxIdleConnsPerHost:   32,
+				IdleConnTimeout:       90 * time.Second,
+				TLSHandshakeTimeout:   5 * time.Second,
+				ExpectContinueTimeout: 1 * time.Second,
+			},
+		}
 	}
 
 	sleep := cfg.Sleep
@@ -207,7 +219,7 @@ func (c *Client) Fetch(ctx context.Context, ref string) (*Document, error) {
 			return nil, fmt.Errorf("read response %q: %w", requestURL, readErr)
 		}
 
-		if resp.StatusCode >= defaultRetryStatusCode && attempt < c.maxRetries {
+		if c.shouldRetryStatus(resp.StatusCode) && attempt < c.maxRetries {
 			if sleepErr := c.sleep(ctx, c.retryDelay(attempt)); sleepErr != nil {
 				return nil, sleepErr
 			}
@@ -348,6 +360,15 @@ func (c *Client) shouldRetryError(err error, parentCtx context.Context) bool {
 	return parentCtx.Err() == nil
 }
 
+func (c *Client) shouldRetryStatus(statusCode int) bool {
+	switch statusCode {
+	case http.StatusRequestTimeout, http.StatusTooManyRequests:
+		return true
+	default:
+		return statusCode >= defaultRetryStatusCode
+	}
+}
+
 func (c *Client) retryDelay(attempt int) time.Duration {
 	delay := float64(c.retryBaseDelay)
 	delay *= math.Pow(2, float64(attempt))

package/internal/cricinfo/coverage_ledger_test.go

@@ -137,7 +137,7 @@ func TestFieldPathFamilyCoverageLedgerKnownFamiliesMapped(t *testing.T) {
 func researchedTemplatesFromTSV(t *testing.T) []string {
 	t.Helper()
 
-	path := filepath.Join(repoRoot(t), "gg", "agent-outputs", "cricinfo-working-templates.tsv")
+	path := filepath.Join("testdata", "coverage", "cricinfo-working-templates.tsv")
 	file, err := os.Open(path)
 	if err != nil {
 		t.Fatalf("open working templates TSV %q: %v", path, err)
@@ -177,7 +177,7 @@ func researchedTemplatesFromTSV(t *testing.T) []string {
 func researchedFieldPathFamilies(t *testing.T) map[string]struct{} {
 	t.Helper()
 
-	path := filepath.Join(repoRoot(t), "gg", "agent-outputs", "cricinfo-field-path-catalog.txt")
+	path := filepath.Join("testdata", "coverage", "cricinfo-field-path-catalog.txt")
 	file, err := os.Open(path)
 	if err != nil {
 		t.Fatalf("open field-path catalog %q: %v", path, err)
@@ -231,23 +231,3 @@ func isNumericToken(value string) bool {
 	}
 	return true
 }
-
-func repoRoot(t *testing.T) string {
-	t.Helper()
-
-	dir, err := os.Getwd()
-	if err != nil {
-		t.Fatalf("getwd: %v", err)
-	}
-
-	for {
-		if _, err := os.Stat(filepath.Join(dir, "go.mod")); err == nil {
-			return dir
-		}
-		parent := filepath.Dir(dir)
-		if parent == dir {
-			t.Fatalf("unable to locate repository root from %q", dir)
-		}
-		dir = parent
-	}
-}

package/internal/cricinfo/entity_index.go

@@ -472,12 +472,39 @@ func mergeAliasSlices(slices ...[]string) []string {
 			}
 			seen[normalized] = struct{}{}
 			out = append(out, value)
+			if acronym := aliasAcronym(normalized); acronym != "" {
+				if _, ok := seen[acronym]; !ok {
+					seen[acronym] = struct{}{}
+					out = append(out, acronym)
+				}
+			}
 		}
 	}
 	sort.Strings(out)
 	return out
 }
 
+func aliasAcronym(normalized string) string {
+	tokens := strings.Fields(strings.TrimSpace(normalized))
+	if len(tokens) < 2 {
+		return ""
+	}
+
+	var builder strings.Builder
+	for _, token := range tokens {
+		if token == "" {
+			continue
+		}
+		builder.WriteByte(token[0])
+	}
+
+	acronym := strings.TrimSpace(builder.String())
+	if len(acronym) < 2 {
+		return ""
+	}
+	return acronym
+}
+
 func aliasSet(aliases []string) map[string]struct{} {
 	set := map[string]struct{}{}
 	for _, alias := range aliases {