cricinfo-cli-go 0.1.0 → 0.1.2

package/internal/cricinfo/normalize_entities.go

@@ -1033,6 +1033,16 @@ func NormalizePartnership(data []byte) (*Partnership, error) {
 		),
 	}
 
+	if partnership.WicketNumber == 0 {
+		partnership.WicketNumber = parseInt(ids["partnershipId"])
+	}
+	if partnership.Runs == 0 && partnership.End.Runs > partnership.Start.Runs {
+		partnership.Runs = partnership.End.Runs - partnership.Start.Runs
+	}
+	if partnership.Overs == 0 && partnership.End.Overs > partnership.Start.Overs {
+		partnership.Overs = partnership.End.Overs - partnership.Start.Overs
+	}
+
 	return partnership, nil
 }
 
@@ -1097,6 +1107,12 @@ func NormalizeFallOfWicket(data []byte) (*FallOfWicket, error) {
 	if fow.WicketNumber == 0 {
 		fow.WicketNumber = parseInt(ids["fowId"])
 	}
+	if fow.Runs == 0 && fow.RunsScored > 0 {
+		fow.Runs = fow.RunsScored
+	}
+	if fow.RunsScored == 0 && fow.Runs > 0 {
+		fow.RunsScored = fow.Runs
+	}
 
 	return fow, nil
 }

package/internal/cricinfo/render_contract.go

@@ -16,6 +16,7 @@ const (
 	EntityMatch           EntityKind = "match"
 	EntityMatchScorecard  EntityKind = "match_scorecard"
 	EntityMatchSituation  EntityKind = "match_situation"
+	EntityMatchPhases     EntityKind = "match_phases"
 	EntityCompetition     EntityKind = "competition"
 	EntityCompOfficial    EntityKind = "competition_official"
 	EntityCompBroadcast   EntityKind = "competition_broadcast"
@@ -118,6 +119,43 @@ type MatchScorecard struct {
 	Extensions       map[string]any    `json:"extensions,omitempty"`
 }
 
+// MatchPhases is a fan-oriented phase/momentum breakdown for each innings.
+type MatchPhases struct {
+	MatchID       string             `json:"matchId,omitempty"`
+	LeagueID      string             `json:"leagueId,omitempty"`
+	EventID       string             `json:"eventId,omitempty"`
+	CompetitionID string             `json:"competitionId,omitempty"`
+	Fixture       string             `json:"fixture,omitempty"`
+	Result        string             `json:"result,omitempty"`
+	Innings       []MatchPhaseInning `json:"innings,omitempty"`
+}
+
+// MatchPhaseInning captures phase splits and momentum points for one innings.
+type MatchPhaseInning struct {
+	TeamID              string       `json:"teamId,omitempty"`
+	TeamName            string       `json:"teamName,omitempty"`
+	InningsNumber       int          `json:"inningsNumber,omitempty"`
+	Period              int          `json:"period,omitempty"`
+	Score               string       `json:"score,omitempty"`
+	Target              int          `json:"target,omitempty"`
+	Powerplay           PhaseSummary `json:"powerplay,omitempty"`
+	Middle              PhaseSummary `json:"middle,omitempty"`
+	Death               PhaseSummary `json:"death,omitempty"`
+	BestScoringOver     int          `json:"bestScoringOver,omitempty"`
+	BestScoringOverRuns int          `json:"bestScoringOverRuns,omitempty"`
+	CollapseOver        int          `json:"collapseOver,omitempty"`
+	CollapseWickets     int          `json:"collapseWickets,omitempty"`
+}
+
+// PhaseSummary is a normalized run/wicket split across a phase bucket.
+type PhaseSummary struct {
+	Name    string  `json:"name,omitempty"`
+	Runs    int     `json:"runs,omitempty"`
+	Wickets int     `json:"wickets,omitempty"`
+	Overs   float64 `json:"overs,omitempty"`
+	RunRate float64 `json:"runRate,omitempty"`
+}
+
 // BattingCard is a normalized batting card section from matchcards.
 type BattingCard struct {
 	InningsNumber int                `json:"inningsNumber,omitempty"`
@@ -774,18 +812,18 @@ type FallOfWicket struct {
 
 // AnalysisScope captures the resolved analysis traversal scope.
 type AnalysisScope struct {
-	Mode            string           `json:"mode"`
-	RequestedLeagueID string         `json:"requestedLeagueId,omitempty"`
-	LeagueID        string           `json:"leagueId,omitempty"`
-	LeagueName      string           `json:"leagueName,omitempty"`
-	Seasons         []string         `json:"seasons,omitempty"`
-	MatchIDs        []string         `json:"matchIds,omitempty"`
-	MatchCount      int              `json:"matchCount"`
-	DateFrom        string           `json:"dateFrom,omitempty"`
-	DateTo          string           `json:"dateTo,omitempty"`
-	TypeQuery       string           `json:"type,omitempty"`
-	GroupQuery      string           `json:"group,omitempty"`
-	HydrationMetric HydrationMetrics `json:"hydrationMetrics,omitempty"`
+	Mode              string           `json:"mode"`
+	RequestedLeagueID string           `json:"requestedLeagueId,omitempty"`
+	LeagueID          string           `json:"leagueId,omitempty"`
+	LeagueName        string           `json:"leagueName,omitempty"`
+	Seasons           []string         `json:"seasons,omitempty"`
+	MatchIDs          []string         `json:"matchIds,omitempty"`
+	MatchCount        int              `json:"matchCount"`
+	DateFrom          string           `json:"dateFrom,omitempty"`
+	DateTo            string           `json:"dateTo,omitempty"`
+	TypeQuery         string           `json:"type,omitempty"`
+	GroupQuery        string           `json:"group,omitempty"`
+	HydrationMetric   HydrationMetrics `json:"hydrationMetrics,omitempty"`
 }
 
 // AnalysisFilters captures user-level row filters.
@@ -924,6 +962,8 @@ func kindPlural(kind EntityKind) string {
 		return "match scorecards"
 	case EntityMatchSituation:
 		return "match situations"
+	case EntityMatchPhases:
+		return "match phase reports"
 	case EntityCompetition:
 		return "competitions"
 	case EntityCompOfficial:

package/internal/cricinfo/renderer.go

@@ -255,6 +255,15 @@ 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)
+		}
 
 		itemMap, err := toMap(result.Data, opts.AllFields)
 		if err != nil {
@@ -274,13 +283,41 @@ 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 == EntityDeliveryEvent || result.Kind == EntityPlayerDelivery {
+		lines = append(lines, fmt.Sprintf("%s (%d)", titleize(kindPlural(result.Kind)), len(result.Items)))
+		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 +332,53 @@ 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))
+		}
+		if kind == EntityPlayerDelivery {
+			return joinParts(short, strings.Join(typed.Involvement, ","), overBallString(typed.OverNumber, typed.BallNumber))
+		}
+		return short
+	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 kind == EntityPlayerDelivery {
+			return joinParts(short, involvementLabel(typed), overBallLabel(typed))
+		}
+		return short
+	default:
+		return ""
+	}
+}
+
+func overBallString(over, ball int) string {
+	if over <= 0 || ball <= 0 {
+		return ""
+	}
+	return fmt.Sprintf("over %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 sanitizeValue(value any, allFields bool) (any, error) {
 	blob, err := json.Marshal(value)
 	if err != nil {
@@ -380,6 +464,11 @@ func summarizeEntity(entity map[string]any, kind EntityKind, verbose bool) strin
 			return joinParts("situation", data)
 		}
 		return joinParts("situation", valueString(entity, "competitionId"))
+	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")),
@@ -470,16 +559,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 +588,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 +724,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 +832,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 +871,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 != "" {
@@ -867,6 +992,66 @@ func formatMatchView(entity map[string]any) []string {
 	return lines
 }
 
+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)
 

package/internal/cricinfo/resolver.go

@@ -375,6 +375,15 @@ func (r *Resolver) seedCompetitionMap(ctx context.Context, comp map[string]any,
 	matchName := nonEmpty(stringField(comp, "shortDescription"), stringField(comp, "description"), stringField(comp, "note"), eventName, stringField(comp, "date"))
 	matchShort := nonEmpty(stringField(comp, "shortDescription"), eventName)
 
+	competitors := mapSliceField(comp, "competitors")
+	teamAliases := make([]string, 0)
+	for _, competitor := range competitors {
+		if err := r.seedCompetitorMap(ctx, competitor, leagueID, eventID, competitionID); err != nil {
+			return err
+		}
+		teamAliases = append(teamAliases, r.matchTeamAliasesFromCompetitor(ctx, competitor, leagueID, competitionID)...)
+	}
+
 	if err := r.index.Upsert(IndexedEntity{
 		Kind:      EntityMatch,
 		ID:        competitionID,
@@ -384,32 +393,67 @@ func (r *Resolver) seedCompetitionMap(ctx context.Context, comp map[string]any,
 		LeagueID:  leagueID,
 		EventID:   eventID,
 		MatchID:   competitionID,
-		Aliases: []string{
+		Aliases: append([]string{
 			stringField(comp, "description"),
 			stringField(comp, "shortDescription"),
 			stringField(comp, "note"),
 			eventName,
 			competitionID,
 			eventID,
-		},
+		}, teamAliases...),
 		UpdatedAt: r.now(),
 	}); err != nil {
 		return err
 	}
 
-	competitors := mapSliceField(comp, "competitors")
-	for _, competitor := range competitors {
-		if err := r.seedCompetitorMap(ctx, competitor, leagueID, eventID, competitionID); err != nil {
-			return err
-		}
-	}
-
 	if compRef != "" {
 		r.markHydrated(r.absoluteRef(compRef))
 	}
 	return nil
 }
 
+func (r *Resolver) matchTeamAliasesFromCompetitor(ctx context.Context, competitor map[string]any, leagueID, matchID string) []string {
+	aliases := []string{
+		stringField(mapField(competitor, "team"), "displayName"),
+		stringField(mapField(competitor, "team"), "name"),
+		stringField(mapField(competitor, "team"), "shortDisplayName"),
+		stringField(mapField(competitor, "team"), "shortName"),
+		stringField(mapField(competitor, "team"), "abbreviation"),
+	}
+
+	teamRef := refFromField(competitor, "team")
+	teamID := nonEmpty(
+		refIDs(teamRef)["teamId"],
+		stringField(mapField(competitor, "team"), "id"),
+		stringField(competitor, "id"),
+	)
+	if teamID == "" {
+		return aliases
+	}
+
+	if existing, ok := r.index.FindByID(EntityTeam, teamID); ok {
+		aliases = append(aliases, existing.Name, existing.ShortName)
+	}
+	if hasNonEmptyAlias(aliases...) {
+		return aliases
+	}
+
+	_ = r.seedTeamByID(ctx, teamID, leagueID, matchID)
+	if existing, ok := r.index.FindByID(EntityTeam, teamID); ok {
+		aliases = append(aliases, existing.Name, existing.ShortName)
+	}
+	return aliases
+}
+
+func hasNonEmptyAlias(values ...string) bool {
+	for _, value := range values {
+		if strings.TrimSpace(value) != "" {
+			return true
+		}
+	}
+	return false
+}
+
 func (r *Resolver) seedCompetitorMap(ctx context.Context, competitor map[string]any, leagueID, eventID, matchID string) error {
 	competitorRef := stringField(competitor, "$ref")
 	teamRef := refFromField(competitor, "team")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cricinfo-cli-go",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Cricinfo command line interface",
   "license": "MIT",
   "author": "amxv",