cricinfo-cli-go 0.1.1 → 0.1.4

package/internal/cricinfo/renderer.go

@@ -6,6 +6,7 @@ import (
 	"io"
 	"regexp"
 	"sort"
+	"strconv"
 	"strings"
 )
 
@@ -201,6 +202,15 @@ func renderText(w io.Writer, result NormalizedResult, opts RenderOptions) error
 			lines = append(lines, formatInningsTimelines(itemMap)...)
 			return writeTextLines(w, lines)
 		}
+		if result.Kind == EntityMatchSituation {
+			itemMap, err := toMap(result.Data, opts.AllFields)
+			if err != nil {
+				return err
+			}
+			lines = append(lines, "Match Situation")
+			lines = append(lines, formatMatchSituation(itemMap)...)
+			return writeTextLines(w, lines)
+		}
 		if result.Kind == EntityPlayerStats {
 			itemMap, err := toMap(result.Data, opts.AllFields)
 			if err != nil {
@@ -255,6 +265,24 @@ func renderText(w io.Writer, result NormalizedResult, opts RenderOptions) error
 			lines = append(lines, formatMatchView(itemMap)...)
 			return writeTextLines(w, lines)
 		}
+		if result.Kind == EntityMatchPhases {
+			itemMap, err := toMap(result.Data, opts.AllFields)
+			if err != nil {
+				return err
+			}
+			lines = append(lines, "Match Phases")
+			lines = append(lines, formatMatchPhases(itemMap)...)
+			return writeTextLines(w, lines)
+		}
+		if result.Kind == EntityMatchDuel {
+			itemMap, err := toMap(result.Data, opts.AllFields)
+			if err != nil {
+				return err
+			}
+			lines = append(lines, "Match Duel")
+			lines = append(lines, formatMatchDuel(itemMap)...)
+			return writeTextLines(w, lines)
+		}
 
 		itemMap, err := toMap(result.Data, opts.AllFields)
 		if err != nil {
@@ -274,13 +302,68 @@ func renderText(w io.Writer, result NormalizedResult, opts RenderOptions) error
 		return writeTextLines(w, lines)
 	}
 
-	lines = append(lines, fmt.Sprintf("%s (%d)", titleize(kindPlural(result.Kind)), len(result.Items)))
-	for i, item := range result.Items {
+	if result.Kind == EntityTeamStatistics || result.Kind == EntityTeamRecords {
+		title := "Team Statistics"
+		if result.Kind == EntityTeamRecords {
+			title = "Team Records"
+		}
+		lines = append(lines, fmt.Sprintf("%s Categories (%d)", title, len(result.Items)))
+		lines = append(lines, formatStatCategoryList(result.Items)...)
+		return writeTextLines(w, lines)
+	}
+
+	if result.Kind == EntityStandingsGroup {
+		lines = append(lines, formatStandingsGroupList(result.Items)...)
+		return writeTextLines(w, lines)
+	}
+
+	if result.Kind == EntityDeliveryEvent || result.Kind == EntityPlayerDelivery {
+		lines = append(lines, fmt.Sprintf("%s (%d)", titleize(kindPlural(result.Kind)), len(result.Items)))
+		if result.Kind == EntityDeliveryEvent {
+			source := ""
+			switch {
+			case strings.Contains(result.RequestedRef, "/details"):
+				source = "details"
+			case strings.Contains(result.RequestedRef, "/plays"):
+				source = "plays"
+			}
+			if source != "" {
+				lines = append(lines, "Source: "+source)
+			}
+		}
+		for i, item := range result.Items {
+			summary := summarizeDeliveryListItem(item, result.Kind)
+			if strings.TrimSpace(summary) == "" {
+				continue
+			}
+			lines = append(lines, fmt.Sprintf("%d. %s", i+1, summary))
+		}
+		return writeTextLines(w, lines)
+	}
+
+	summaries := make([]string, 0, len(result.Items))
+	for _, item := range result.Items {
 		itemMap, err := toMap(item, opts.AllFields)
 		if err != nil {
 			return err
 		}
-		lines = append(lines, fmt.Sprintf("%d. %s", i+1, summarizeEntity(itemMap, result.Kind, opts.Verbose)))
+		summary := summarizeEntity(itemMap, result.Kind, opts.Verbose)
+		if strings.TrimSpace(summary) == "" {
+			continue
+		}
+		summaries = append(summaries, summary)
+	}
+	if len(summaries) == 0 {
+		message := result.Message
+		if message == "" {
+			message = fmt.Sprintf("No %s found.", kindPlural(result.Kind))
+		}
+		lines = append(lines, sentenceCase(message))
+		return writeTextLines(w, lines)
+	}
+	lines = append(lines, fmt.Sprintf("%s (%d)", titleize(kindPlural(result.Kind)), len(summaries)))
+	for i, summary := range summaries {
+		lines = append(lines, fmt.Sprintf("%d. %s", i+1, summary))
 	}
 
 	return writeTextLines(w, lines)
@@ -295,6 +378,71 @@ func writeTextLines(w io.Writer, lines []string) error {
 	return nil
 }
 
+func summarizeDeliveryListItem(item any, kind EntityKind) string {
+	switch typed := item.(type) {
+	case DeliveryEvent:
+		short := firstNonEmpty(strings.TrimSpace(typed.ShortText), strings.TrimSpace(typed.Text))
+		if short == "" {
+			short = joinParts("over "+intString(typed.OverNumber), "ball "+intString(typed.BallNumber))
+		}
+		lead := firstNonEmpty(overBallString(typed.OverNumber, typed.BallNumber), "")
+		score := firstNonEmpty(scoreLabel(typed.HomeScore), scoreLabel(typed.AwayScore))
+		if kind == EntityPlayerDelivery {
+			return joinParts(lead, short, score, strings.Join(typed.Involvement, ","))
+		}
+		return joinParts(lead, short, score)
+	case map[string]any:
+		short := firstNonEmpty(valueString(typed, "shortText"), valueString(typed, "text"))
+		if short == "" {
+			short = joinParts("over "+valueString(typed, "overNumber"), "ball "+valueString(typed, "ballNumber"))
+		}
+		if strings.TrimSpace(short) == "/" || strings.TrimSpace(short) == "-" {
+			return ""
+		}
+		lead := overBallLabel(typed)
+		score := firstNonEmpty(scoreLabel(valueString(typed, "homeScore")), scoreLabel(valueString(typed, "awayScore")))
+		if kind == EntityPlayerDelivery {
+			return joinParts(lead, short, score, involvementLabel(typed))
+		}
+		return joinParts(lead, short, score)
+	default:
+		return ""
+	}
+}
+
+func overBallString(over, ball int) string {
+	if over <= 0 || ball <= 0 {
+		return ""
+	}
+	return fmt.Sprintf("%d.%d", over, ball)
+}
+
+func intString(value int) string {
+	if value <= 0 {
+		return ""
+	}
+	return fmt.Sprintf("%d", value)
+}
+
+func defaultNumeric(raw string) string {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return "0"
+	}
+	return raw
+}
+
+func scoreLabel(raw string) string {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return ""
+	}
+	if strings.Contains(raw, "/") {
+		return raw
+	}
+	return ""
+}
+
 func sanitizeValue(value any, allFields bool) (any, error) {
 	blob, err := json.Marshal(value)
 	if err != nil {
@@ -339,6 +487,25 @@ func toMap(value any, allFields bool) (map[string]any, error) {
 	return mapped, nil
 }
 
+func mapFromAny(value any) map[string]any {
+	if value == nil {
+		return nil
+	}
+	if mapped, ok := value.(map[string]any); ok {
+		return mapped
+	}
+
+	blob, err := json.Marshal(value)
+	if err != nil {
+		return nil
+	}
+	var mapped map[string]any
+	if err := json.Unmarshal(blob, &mapped); err != nil {
+		return nil
+	}
+	return mapped
+}
+
 func summarizeEntity(entity map[string]any, kind EntityKind, verbose bool) string {
 	switch kind {
 	case EntityMatch:
@@ -380,6 +547,20 @@ func summarizeEntity(entity map[string]any, kind EntityKind, verbose bool) strin
 			return joinParts("situation", data)
 		}
 		return joinParts("situation", valueString(entity, "competitionId"))
+	case EntityMatchDuel:
+		duelLabel := strings.TrimSpace(fmt.Sprintf("%s vs %s",
+			firstNonEmpty(valueString(entity, "batterName"), valueString(entity, "batterId")),
+			firstNonEmpty(valueString(entity, "bowlerName"), valueString(entity, "bowlerId")),
+		))
+		return joinParts(
+			duelLabel,
+			fmt.Sprintf("%s off %s", valueString(entity, "runs"), valueString(entity, "balls")),
+		)
+	case EntityMatchPhases:
+		return joinParts(
+			"match "+firstNonEmpty(valueString(entity, "matchId"), valueString(entity, "competitionId")),
+			fmt.Sprintf("%d innings", len(sliceValue(entity, "innings"))),
+		)
 	case EntityCompetition:
 		return joinParts(
 			firstNonEmpty(valueString(entity, "shortDescription"), valueString(entity, "description"), valueString(entity, "id")),
@@ -431,7 +612,15 @@ func summarizeEntity(entity map[string]any, kind EntityKind, verbose bool) strin
 		name := firstNonEmpty(valueString(entity, "name"), valueString(entity, "shortName"), valueString(entity, "id"))
 		return joinParts(name, bracket(valueString(entity, "homeAway")))
 	case EntityTeamRoster:
-		name := firstNonEmpty(valueString(entity, "displayName"), valueString(entity, "playerId"), valueString(entity, "athleteId"))
+		name := strings.TrimSpace(valueString(entity, "displayName"))
+		if name == "" {
+			playerID := firstNonEmpty(valueString(entity, "playerId"), valueString(entity, "athleteId"))
+			if playerID != "" {
+				name = "Unknown player (" + playerID + ")"
+			} else {
+				name = "Unknown player"
+			}
+		}
 		badges := []string{}
 		if valueString(entity, "captain") == "true" {
 			badges = append(badges, "captain")
@@ -439,7 +628,7 @@ func summarizeEntity(entity map[string]any, kind EntityKind, verbose bool) strin
 		if valueString(entity, "active") == "true" {
 			badges = append(badges, "active")
 		}
-		return joinParts(name, strings.Join(badges, ", "))
+		return joinParts(name, firstNonEmpty(valueString(entity, "teamName"), valueString(entity, "teamId")), strings.Join(badges, ", "))
 	case EntityTeamScore:
 		return joinParts(valueString(entity, "displayValue"), valueString(entity, "value"), bracket(valueString(entity, "source")))
 	case EntityTeamLeaders:
@@ -470,16 +659,26 @@ func summarizeEntity(entity map[string]any, kind EntityKind, verbose bool) strin
 	case EntityStandingsGroup:
 		return joinParts(valueString(entity, "id"), "season "+valueString(entity, "seasonId"))
 	case EntityInnings:
+		if valueString(entity, "score") == "" &&
+			valueString(entity, "runs") == "" &&
+			valueString(entity, "wickets") == "" &&
+			valueString(entity, "target") == "" &&
+			valueString(entity, "isBatting") == "false" {
+			return ""
+		}
 		score := valueString(entity, "score")
 		if score == "" {
 			score = joinParts(valueString(entity, "runs")+"/"+valueString(entity, "wickets"), valueString(entity, "overs")+" ov")
 		}
-		return joinParts(
+		parts := []string{
 			firstNonEmpty(valueString(entity, "teamName"), valueString(entity, "teamId")),
-			"innings "+valueString(entity, "inningsNumber")+"/"+valueString(entity, "period"),
+			"innings " + valueString(entity, "inningsNumber") + "/" + valueString(entity, "period"),
 			score,
-			fmt.Sprintf("%d wickets", len(sliceValue(entity, "wicketTimeline"))),
-		)
+		}
+		if wc := len(sliceValue(entity, "wicketTimeline")); wc > 0 {
+			parts = append(parts, fmt.Sprintf("%d wickets", wc))
+		}
+		return joinParts(parts...)
 	case EntityDeliveryEvent:
 		short := firstNonEmpty(valueString(entity, "shortText"), valueString(entity, "text"))
 		if short == "" {
@@ -489,16 +688,32 @@ func summarizeEntity(entity map[string]any, kind EntityKind, verbose bool) strin
 	case EntityStatCategory:
 		return joinParts(firstNonEmpty(valueString(entity, "displayName"), valueString(entity, "name")), fmt.Sprintf("%d stats", len(sliceValue(entity, "stats"))))
 	case EntityPartnership:
+		runsText := ""
+		if runs := valueString(entity, "runs"); runs != "" {
+			runsText = runs + " runs"
+		} else if valueString(entity, "overs") != "" {
+			runsText = "0 runs"
+		}
+		oversText := ""
+		if overs := valueString(entity, "overs"); overs != "" {
+			oversText = overs + " ov"
+		}
 		return joinParts(
 			firstNonEmpty(valueString(entity, "wicketName"), "partnership "+valueString(entity, "id")),
-			valueString(entity, "runs")+" runs",
-			valueString(entity, "overs")+" ov",
+			runsText,
+			oversText,
 			"innings "+valueString(entity, "inningsId")+"/"+valueString(entity, "period"),
 		)
 	case EntityFallOfWicket:
+		scoreText := ""
+		if runs := valueString(entity, "runs"); runs != "" {
+			scoreText = runs + "/" + valueString(entity, "wicketNumber")
+		} else if valueString(entity, "wicketNumber") == "1" {
+			scoreText = "0/1"
+		}
 		return joinParts(
 			"wicket "+valueString(entity, "wicketNumber"),
-			valueString(entity, "runs")+"/"+valueString(entity, "wicketNumber"),
+			scoreText,
 			valueString(entity, "wicketOver")+" ov",
 			"innings "+valueString(entity, "inningsId")+"/"+valueString(entity, "period"),
 		)
@@ -609,6 +824,8 @@ func formatSingleEntity(entity map[string]any, kind EntityKind, opts RenderOptio
 		order = []string{"matchId", "competitionId", "eventId", "leagueId", "battingCards", "bowlingCards", "partnershipCards"}
 	case EntityMatchSituation:
 		order = []string{"matchId", "competitionId", "eventId", "leagueId", "oddsRef", "data"}
+	case EntityMatchPhases:
+		order = []string{"matchId", "competitionId", "eventId", "leagueId", "fixture", "result", "innings"}
 	case EntityStatCategory:
 		order = []string{"name", "displayName", "abbreviation"}
 	case EntityPartnership:
@@ -715,7 +932,7 @@ func formatInningsTimelines(entity map[string]any) []string {
 			row := joinParts(
 				"Over "+valueString(over, "number"),
 				valueString(over, "runs")+" runs",
-				valueString(over, "wicketCount")+" wkts",
+				wicketCountLabel(valueString(over, "wicketCount")),
 			)
 			if row != "" {
 				lines = append(lines, "  "+row)
@@ -754,6 +971,14 @@ func formatInningsTimelines(entity map[string]any) []string {
 	return lines
 }
 
+func wicketCountLabel(raw string) string {
+	raw = strings.TrimSpace(raw)
+	if raw == "" || raw == "0" {
+		return ""
+	}
+	return raw + " wkts"
+}
+
 func formatPlayerProfile(entity map[string]any) []string {
 	lines := make([]string, 0, 16)
 	if name := firstNonEmpty(valueString(entity, "displayName"), valueString(entity, "fullName"), valueString(entity, "name")); name != "" {
@@ -790,7 +1015,7 @@ func formatPlayerProfile(entity map[string]any) []string {
 }
 
 func formatPlayerMatchView(entity map[string]any) []string {
-	lines := make([]string, 0, 16)
+	lines := make([]string, 0, 48)
 	if player := valueString(entity, "playerName"); player != "" {
 		lines = append(lines, "Player: "+player)
 	}
@@ -806,13 +1031,21 @@ func formatPlayerMatchView(entity map[string]any) []string {
 		}
 	}
 	if batting := sliceValue(entity, "batting"); len(batting) > 0 {
-		lines = append(lines, fmt.Sprintf("Batting Categories: %d", len(batting)))
+		lines = append(lines, "Batting")
+		lines = append(lines, formatStatCategoryList(batting)...)
 	}
 	if bowling := sliceValue(entity, "bowling"); len(bowling) > 0 {
-		lines = append(lines, fmt.Sprintf("Bowling Categories: %d", len(bowling)))
+		lines = append(lines, "Bowling")
+		lines = append(lines, formatStatCategoryList(bowling)...)
 	}
 	if fielding := sliceValue(entity, "fielding"); len(fielding) > 0 {
-		lines = append(lines, fmt.Sprintf("Fielding Categories: %d", len(fielding)))
+		lines = append(lines, "Fielding")
+		lines = append(lines, formatStatCategoryList(fielding)...)
+	}
+	if len(sliceValue(entity, "batting")) == 0 &&
+		len(sliceValue(entity, "bowling")) == 0 &&
+		len(sliceValue(entity, "fielding")) == 0 {
+		lines = append(lines, "No match statistics categories available.")
 	}
 	return lines
 }
@@ -867,6 +1100,224 @@ func formatMatchView(entity map[string]any) []string {
 	return lines
 }
 
+func formatMatchSituation(entity map[string]any) []string {
+	lines := make([]string, 0, 64)
+	if matchID := firstNonEmpty(valueString(entity, "matchId"), valueString(entity, "competitionId")); matchID != "" {
+		lines = append(lines, "Match: "+matchID)
+	}
+
+	live, _ := entity["live"].(map[string]any)
+	if live == nil {
+		if oddsRef := valueString(entity, "oddsRef"); oddsRef != "" {
+			lines = append(lines, "Odds Ref: "+oddsRef)
+		}
+		if data, ok := entity["data"].(map[string]any); ok && len(data) > 0 {
+			lines = append(lines, "Data: "+printableValue(data))
+		}
+		if len(lines) <= 1 {
+			lines = append(lines, "No situation data available for this match.")
+		}
+		return lines
+	}
+
+	if fixture := valueString(live, "fixture"); fixture != "" {
+		lines = append(lines, "Fixture: "+fixture)
+	}
+	if status := valueString(live, "status"); status != "" {
+		lines = append(lines, "Status: "+status)
+	}
+	scoreLine := joinParts(valueString(live, "score"), valueString(live, "overs"))
+	if scoreLine != "" {
+		lines = append(lines, "Score: "+scoreLine)
+	}
+	teamsLine := joinParts(
+		"Batting "+valueString(live, "battingTeam"),
+		"Bowling "+valueString(live, "bowlingTeam"),
+	)
+	if teamsLine != "" {
+		lines = append(lines, teamsLine)
+	}
+	if snapshotAt := valueString(live, "snapshotAt"); snapshotAt != "" {
+		lines = append(lines, "Snapshot: "+snapshotAt)
+	}
+	if stale := valueString(live, "stale"); stale == "true" {
+		lines = append(lines, "Stale: true")
+		if reason := valueString(live, "staleReason"); reason != "" {
+			lines = append(lines, "Stale Reason: "+reason)
+		}
+	}
+
+	batters := sliceValue(live, "batters")
+	if len(batters) > 0 {
+		lines = append(lines, "Batters")
+		for i, raw := range batters {
+			batter, ok := raw.(map[string]any)
+			if !ok {
+				continue
+			}
+			score := fmt.Sprintf("%s(%s)", defaultNumeric(valueString(batter, "runs")), defaultNumeric(valueString(batter, "balls")))
+			boundaries := joinParts("4s "+defaultNumeric(valueString(batter, "fours")), "6s "+defaultNumeric(valueString(batter, "sixes")))
+			row := joinParts(
+				firstNonEmpty(valueString(batter, "playerName"), valueString(batter, "playerId")),
+				score,
+				"SR "+defaultNumeric(valueString(batter, "strikeRate")),
+				boundaries,
+			)
+			if strings.EqualFold(valueString(batter, "onStrike"), "true") {
+				row = joinParts(row, "*")
+			}
+			lines = append(lines, fmt.Sprintf("  %d. %s", i+1, row))
+		}
+	}
+
+	bowlers := sliceValue(live, "bowlers")
+	if len(bowlers) > 0 {
+		lines = append(lines, "Bowlers")
+		for i, raw := range bowlers {
+			bowler, ok := raw.(map[string]any)
+			if !ok {
+				continue
+			}
+			figures := fmt.Sprintf("%s-%s-%s-%s",
+				oversLabelFromFields(valueString(bowler, "overs"), valueString(bowler, "balls")),
+				defaultNumeric(valueString(bowler, "maidens")),
+				defaultNumeric(valueString(bowler, "conceded")),
+				defaultNumeric(valueString(bowler, "wickets")),
+			)
+			row := joinParts(
+				firstNonEmpty(valueString(bowler, "playerName"), valueString(bowler, "playerId")),
+				figures,
+				"Econ "+defaultNumeric(valueString(bowler, "economy")),
+			)
+			lines = append(lines, fmt.Sprintf("  %d. %s", i+1, row))
+		}
+	}
+
+	balls := sliceValue(live, "recentBalls")
+	if len(balls) == 0 {
+		balls = sliceValue(live, "currentOverBalls")
+	}
+	if len(balls) > 0 {
+		lines = append(lines, "Recent Balls")
+		for i, raw := range balls {
+			lines = append(lines, fmt.Sprintf("  %d. %s", i+1, summarizeDeliveryListItem(raw, EntityDeliveryEvent)))
+		}
+	}
+	return lines
+}
+
+func formatMatchDuel(entity map[string]any) []string {
+	lines := make([]string, 0, 48)
+	if matchID := valueString(entity, "matchId"); matchID != "" {
+		lines = append(lines, "Match: "+matchID)
+	}
+	if fixture := valueString(entity, "fixture"); fixture != "" {
+		lines = append(lines, "Fixture: "+fixture)
+	}
+	if score := valueString(entity, "score"); score != "" {
+		lines = append(lines, "Score: "+score)
+	}
+	lines = append(lines, "Duel: "+firstNonEmpty(valueString(entity, "batterName"), valueString(entity, "batterId"))+" vs "+firstNonEmpty(valueString(entity, "bowlerName"), valueString(entity, "bowlerId")))
+	summary := joinParts(
+		fmt.Sprintf("%s off %s", defaultNumeric(valueString(entity, "runs")), defaultNumeric(valueString(entity, "balls"))),
+		"SR "+defaultNumeric(valueString(entity, "strikeRate")),
+		"dots "+defaultNumeric(valueString(entity, "dots")),
+		"4s "+defaultNumeric(valueString(entity, "fours")),
+		"6s "+defaultNumeric(valueString(entity, "sixes")),
+		"wkts "+defaultNumeric(valueString(entity, "wickets")),
+	)
+	if strings.TrimSpace(summary) != "" {
+		lines = append(lines, "Summary: "+summary)
+	}
+	if snapshot := valueString(entity, "snapshotAt"); snapshot != "" {
+		lines = append(lines, "Snapshot: "+snapshot)
+	}
+	balls := sliceValue(entity, "recentBalls")
+	if len(balls) > 0 {
+		lines = append(lines, "Recent Duel Balls")
+		for i, raw := range balls {
+			lines = append(lines, fmt.Sprintf("  %d. %s", i+1, summarizeDeliveryListItem(raw, EntityDeliveryEvent)))
+		}
+	}
+	return lines
+}
+
+func oversLabelFromFields(overs string, balls string) string {
+	overs = strings.TrimSpace(overs)
+	if overs != "" && overs != "0" {
+		return overs
+	}
+	balls = strings.TrimSpace(balls)
+	if balls == "" || balls == "0" {
+		return "0.0"
+	}
+	b, err := strconv.Atoi(balls)
+	if err != nil || b < 0 {
+		return "0.0"
+	}
+	return fmt.Sprintf("%d.%d", b/6, b%6)
+}
+
+func formatMatchPhases(entity map[string]any) []string {
+	lines := make([]string, 0, 64)
+	if matchID := firstNonEmpty(valueString(entity, "matchId"), valueString(entity, "competitionId")); matchID != "" {
+		lines = append(lines, "Match: "+matchID)
+	}
+	if fixture := valueString(entity, "fixture"); fixture != "" {
+		lines = append(lines, "Fixture: "+fixture)
+	}
+	if result := valueString(entity, "result"); result != "" {
+		lines = append(lines, "Result: "+result)
+	}
+
+	for _, raw := range sliceValue(entity, "innings") {
+		inn, ok := raw.(map[string]any)
+		if !ok {
+			continue
+		}
+		lines = append(lines, "")
+		lines = append(lines, joinParts(
+			firstNonEmpty(valueString(inn, "teamName"), valueString(inn, "teamId")),
+			"innings "+valueString(inn, "inningsNumber")+"/"+valueString(inn, "period"),
+			valueString(inn, "score"),
+		))
+
+		lines = append(lines, "  Phases")
+		for _, key := range []string{"powerplay", "middle", "death"} {
+			phaseMap, ok := inn[key].(map[string]any)
+			if !ok {
+				continue
+			}
+			name := firstNonEmpty(valueString(phaseMap, "name"), strings.Title(key))
+			runs := defaultNumeric(valueString(phaseMap, "runs"))
+			wickets := defaultNumeric(valueString(phaseMap, "wickets"))
+			overs := defaultNumeric(valueString(phaseMap, "overs"))
+			runRate := defaultNumeric(valueString(phaseMap, "runRate"))
+			phaseLine := joinParts(
+				name,
+				"runs "+runs,
+				"wkts "+wickets,
+				"ov "+overs,
+				"rr "+runRate,
+			)
+			lines = append(lines, "  - "+phaseLine)
+		}
+
+		bestOver := valueString(inn, "bestScoringOver")
+		bestRuns := valueString(inn, "bestScoringOverRuns")
+		if bestOver != "" && bestRuns != "" {
+			lines = append(lines, "  Best Over: over "+bestOver+" ("+bestRuns+" runs)")
+		}
+		collapseOver := valueString(inn, "collapseOver")
+		collapseWickets := valueString(inn, "collapseWickets")
+		if collapseOver != "" && collapseWickets != "" && collapseWickets != "0" {
+			lines = append(lines, "  Pressure Over: over "+collapseOver+" ("+collapseWickets+" wickets)")
+		}
+	}
+
+	return lines
+}
+
 func formatPlayerStatistics(entity map[string]any) []string {
 	lines := make([]string, 0, 64)
 
@@ -1081,6 +1532,149 @@ func formatTeamLeaders(entity map[string]any) []string {
 	return lines
 }
 
+func formatStatCategoryList(items []any) []string {
+	lines := make([]string, 0, len(items)*4)
+	for i, rawCategory := range items {
+		category := mapFromAny(rawCategory)
+		if category == nil {
+			continue
+		}
+
+		categoryName := firstNonEmpty(valueString(category, "displayName"), valueString(category, "name"), "Category")
+		lines = append(lines, fmt.Sprintf("  %d. %s", i+1, categoryName))
+
+		stats := sliceValue(category, "stats")
+		if len(stats) == 0 {
+			continue
+		}
+
+		limit := len(stats)
+		if limit > 16 {
+			limit = 16
+		}
+		for j := 0; j < limit; j++ {
+			statMap, ok := stats[j].(map[string]any)
+			if !ok {
+				continue
+			}
+			label := firstNonEmpty(valueString(statMap, "displayName"), valueString(statMap, "name"), valueString(statMap, "abbreviation"))
+			value := firstNonEmpty(valueString(statMap, "displayValue"), valueString(statMap, "value"))
+			row := joinParts(label, value, bracket(valueString(statMap, "abbreviation")))
+			if row == "" {
+				continue
+			}
+			lines = append(lines, fmt.Sprintf("     - %s", row))
+		}
+		if len(stats) > limit {
+			lines = append(lines, fmt.Sprintf("     - ... %d more", len(stats)-limit))
+		}
+	}
+	return lines
+}
+
+func formatStandingsGroupList(items []any) []string {
+	lines := make([]string, 0, len(items)*8+1)
+	lines = append(lines, fmt.Sprintf("Standings Groups (%d)", len(items)))
+
+	for i, rawGroup := range items {
+		group := mapFromAny(rawGroup)
+		if group == nil {
+			continue
+		}
+
+		groupID := firstNonEmpty(valueString(group, "groupId"), valueString(group, "id"), fmt.Sprintf("%d", i+1))
+		seasonID := valueString(group, "seasonId")
+		header := "Group " + groupID
+		if seasonID != "" {
+			header = joinParts(header, "Season "+seasonID)
+		}
+		lines = append(lines, header)
+
+		entries := sliceValue(group, "entries")
+		if len(entries) == 0 {
+			lines = append(lines, "  No standings entries available.")
+			continue
+		}
+
+		for entryIndex, rawEntry := range entries {
+			team := mapFromAny(rawEntry)
+			if team == nil {
+				continue
+			}
+
+			rank := standingsStatValueFromTeam(team, "rank", "position")
+			if rank == "" {
+				rank = fmt.Sprintf("%d", entryIndex+1)
+			}
+			teamName := firstNonEmpty(valueString(team, "shortName"), valueString(team, "name"), valueString(team, "id"))
+			played := standingsStatValueFromTeam(team, "matchesplayed", "played", "matches")
+			won := standingsStatValueFromTeam(team, "wins", "won")
+			lost := standingsStatValueFromTeam(team, "losses", "lost")
+			points := standingsStatValueFromTeam(team, "matchpoints", "points", "pts")
+			nrr := standingsStatValueFromTeam(team, "netrunrate", "nrr", "runrate")
+
+			row := joinParts(
+				fmt.Sprintf("#%s %s", rank, teamName),
+				nonEmptyLabel("P", played),
+				nonEmptyLabel("W", won),
+				nonEmptyLabel("L", lost),
+				nonEmptyLabel("Pts", points),
+				nonEmptyLabel("NRR", nrr),
+			)
+			if strings.TrimSpace(row) == "" {
+				row = joinParts(fmt.Sprintf("#%s %s", rank, teamName), valueString(team, "scoreSummary"))
+			}
+			lines = append(lines, "  "+row)
+		}
+	}
+	return lines
+}
+
+func standingsStatValueFromTeam(team map[string]any, names ...string) string {
+	if len(names) == 0 || team == nil {
+		return ""
+	}
+
+	targets := map[string]struct{}{}
+	for _, name := range names {
+		key := normalizeStatName(name)
+		if key != "" {
+			targets[key] = struct{}{}
+		}
+	}
+
+	extensions, ok := team["extensions"].(map[string]any)
+	if !ok || extensions == nil {
+		return ""
+	}
+	records, ok := extensions["records"].([]any)
+	if !ok || len(records) == 0 {
+		return ""
+	}
+
+	for _, rawRecord := range records {
+		record := mapFromAny(rawRecord)
+		if record == nil {
+			continue
+		}
+		for _, rawStat := range sliceValue(record, "stats") {
+			stat := mapFromAny(rawStat)
+			if stat == nil {
+				continue
+			}
+			nameKey := normalizeStatName(firstNonEmpty(valueString(stat, "name"), valueString(stat, "type")))
+			if _, ok := targets[nameKey]; !ok {
+				continue
+			}
+			value := firstNonEmpty(valueString(stat, "displayValue"), valueString(stat, "value"))
+			if value != "" {
+				return value
+			}
+		}
+	}
+	return ""
+}
+
 func formatAnalysisView(entity map[string]any) []string {
 	lines := make([]string, 0, 64)
 	if command := valueString(entity, "command"); command != "" {
@@ -1350,9 +1944,9 @@ func overBallLabel(entity map[string]any) string {
 		return ""
 	}
 	if ball == "" {
-		return "over " + over
+		return over
 	}
-	return "over " + over + "." + ball
+	return over + "." + ball
 }
 
 func involvementLabel(entity map[string]any) string {