cricinfo-cli-go 0.1.0

package/internal/cli/analysis.go

@@ -0,0 +1,262 @@
+package cli
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/amxv/cricinfo-cli/internal/cricinfo"
+	"github.com/spf13/cobra"
+)
+
+type analysisCommandService interface {
+	Close() error
+	Dismissals(ctx context.Context, opts cricinfo.AnalysisDismissalOptions) (cricinfo.NormalizedResult, error)
+	Bowling(ctx context.Context, opts cricinfo.AnalysisMetricOptions) (cricinfo.NormalizedResult, error)
+	Batting(ctx context.Context, opts cricinfo.AnalysisMetricOptions) (cricinfo.NormalizedResult, error)
+	Partnerships(ctx context.Context, opts cricinfo.AnalysisMetricOptions) (cricinfo.NormalizedResult, error)
+}
+
+type analysisRuntimeOptions struct {
+	leagueID   string
+	typeQuery  string
+	groupQuery string
+	dateFrom   string
+	dateTo     string
+	matchLimit int
+}
+
+var newAnalysisService = func() (analysisCommandService, error) {
+	return cricinfo.NewAnalysisService(cricinfo.AnalysisServiceConfig{})
+}
+
+func newAnalysisCommand(global *globalOptions) *cobra.Command {
+	base := &analysisRuntimeOptions{}
+
+	cmd := &cobra.Command{
+		Use:   "analysis",
+		Short: "Derived cricket analysis over normalized real-time hydrated data.",
+		Long: strings.Join([]string{
+			"Run ranking and grouping analysis over live scoped Cricinfo data.",
+			"Analysis reuses in-process hydration for the active command execution only.",
+			"No persistent analysis cache is written.",
+			"",
+			"Next steps:",
+			"  cricinfo analysis dismissals --league 19138 --seasons 2024-2025",
+			"  cricinfo analysis bowling --metric economy --scope season:2025 --league 19138",
+			"  cricinfo analysis batting --metric strike-rate --scope match:1529474",
+			"  cricinfo analysis partnerships --scope season:2025 --league 19138",
+		}, "\n"),
+		Args: cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			return cmd.Help()
+		},
+	}
+
+	cmd.PersistentFlags().StringVar(&base.leagueID, "league", "", "League ID/ref/alias (required for season scope and dismissals)")
+	cmd.PersistentFlags().StringVar(&base.typeQuery, "type", "", "Optional season type scope for season traversal")
+	cmd.PersistentFlags().StringVar(&base.groupQuery, "group", "", "Optional season group scope for season traversal")
+	cmd.PersistentFlags().StringVar(&base.dateFrom, "date-from", "", "Optional lower date bound (RFC3339 or YYYY-MM-DD)")
+	cmd.PersistentFlags().StringVar(&base.dateTo, "date-to", "", "Optional upper date bound (RFC3339 or YYYY-MM-DD)")
+	cmd.PersistentFlags().IntVar(&base.matchLimit, "match-limit", 0, "Optional cap on scoped matches before analysis")
+
+	type dismissRuntime struct {
+		seasons       string
+		groupBy       string
+		team          string
+		player        string
+		dismissalType string
+		innings       int
+		period        int
+		top           int
+	}
+	dismiss := &dismissRuntime{}
+	dismissalsCmd := &cobra.Command{
+		Use:   "dismissals",
+		Short: "Rank dismissal patterns across league seasons",
+		Args:  cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			if strings.TrimSpace(base.leagueID) == "" {
+				return fmt.Errorf("--league is required")
+			}
+			if strings.TrimSpace(dismiss.seasons) == "" {
+				return fmt.Errorf("--seasons is required")
+			}
+			return runAnalysisCommand(cmd, global, func(ctx context.Context, service analysisCommandService) (cricinfo.NormalizedResult, error) {
+				return service.Dismissals(ctx, cricinfo.AnalysisDismissalOptions{
+					LeagueQuery:   base.leagueID,
+					Seasons:       dismiss.seasons,
+					TypeQuery:     base.typeQuery,
+					GroupQuery:    base.groupQuery,
+					DateFrom:      base.dateFrom,
+					DateTo:        base.dateTo,
+					MatchLimit:    base.matchLimit,
+					GroupBy:       dismiss.groupBy,
+					TeamQuery:     dismiss.team,
+					PlayerQuery:   dismiss.player,
+					DismissalType: dismiss.dismissalType,
+					Innings:       dismiss.innings,
+					Period:        dismiss.period,
+					Top:           dismiss.top,
+				})
+			})
+		},
+	}
+	dismissalsCmd.Flags().StringVar(&dismiss.seasons, "seasons", "", "Required: season range (for example 2023-2025 or 2024,2025)")
+	dismissalsCmd.Flags().StringVar(&dismiss.groupBy, "group-by", "dismissal-type", "Grouping fields (comma-separated): player,team,league,season,dismissal-type,innings")
+	dismissalsCmd.Flags().StringVar(&dismiss.team, "team", "", "Optional team filter (id or alias)")
+	dismissalsCmd.Flags().StringVar(&dismiss.player, "player", "", "Optional player filter (id or alias)")
+	dismissalsCmd.Flags().StringVar(&dismiss.dismissalType, "dismissal-type", "", "Optional dismissal type filter (for example caught, bowled)")
+	dismissalsCmd.Flags().IntVar(&dismiss.innings, "innings", 0, "Optional innings filter")
+	dismissalsCmd.Flags().IntVar(&dismiss.period, "period", 0, "Optional period filter")
+	dismissalsCmd.Flags().IntVar(&dismiss.top, "top", 20, "Maximum ranked rows to return")
+
+	type metricRuntime struct {
+		scope   string
+		metric  string
+		groupBy string
+		team    string
+		player  string
+		top     int
+	}
+	bowling := &metricRuntime{}
+	bowlingCmd := &cobra.Command{
+		Use:   "bowling",
+		Short: "Rank bowling metrics by match or season scope",
+		Args:  cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			if strings.TrimSpace(bowling.scope) == "" {
+				return fmt.Errorf("--scope is required")
+			}
+			if strings.TrimSpace(bowling.metric) == "" {
+				return fmt.Errorf("--metric is required")
+			}
+			return runAnalysisCommand(cmd, global, func(ctx context.Context, service analysisCommandService) (cricinfo.NormalizedResult, error) {
+				return service.Bowling(ctx, cricinfo.AnalysisMetricOptions{
+					Metric:      bowling.metric,
+					Scope:       bowling.scope,
+					LeagueQuery: base.leagueID,
+					TypeQuery:   base.typeQuery,
+					GroupQuery:  base.groupQuery,
+					DateFrom:    base.dateFrom,
+					DateTo:      base.dateTo,
+					MatchLimit:  base.matchLimit,
+					GroupBy:     bowling.groupBy,
+					TeamQuery:   bowling.team,
+					PlayerQuery: bowling.player,
+					Top:         bowling.top,
+				})
+			})
+		},
+	}
+	bowlingCmd.Flags().StringVar(&bowling.scope, "scope", "", "Required: match:<match> or season:<season>")
+	bowlingCmd.Flags().StringVar(&bowling.metric, "metric", "", "Required: economy, dots, or sixes-conceded")
+	bowlingCmd.Flags().StringVar(&bowling.groupBy, "group-by", "player", "Grouping fields (comma-separated): player,team,league,season")
+	bowlingCmd.Flags().StringVar(&bowling.team, "team", "", "Optional team filter")
+	bowlingCmd.Flags().StringVar(&bowling.player, "player", "", "Optional player filter")
+	bowlingCmd.Flags().IntVar(&bowling.top, "top", 20, "Maximum ranked rows to return")
+
+	batting := &metricRuntime{}
+	battingCmd := &cobra.Command{
+		Use:   "batting",
+		Short: "Rank batting metrics by match or season scope",
+		Args:  cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			if strings.TrimSpace(batting.scope) == "" {
+				return fmt.Errorf("--scope is required")
+			}
+			if strings.TrimSpace(batting.metric) == "" {
+				return fmt.Errorf("--metric is required")
+			}
+			return runAnalysisCommand(cmd, global, func(ctx context.Context, service analysisCommandService) (cricinfo.NormalizedResult, error) {
+				return service.Batting(ctx, cricinfo.AnalysisMetricOptions{
+					Metric:      batting.metric,
+					Scope:       batting.scope,
+					LeagueQuery: base.leagueID,
+					TypeQuery:   base.typeQuery,
+					GroupQuery:  base.groupQuery,
+					DateFrom:    base.dateFrom,
+					DateTo:      base.dateTo,
+					MatchLimit:  base.matchLimit,
+					GroupBy:     batting.groupBy,
+					TeamQuery:   batting.team,
+					PlayerQuery: batting.player,
+					Top:         batting.top,
+				})
+			})
+		},
+	}
+	battingCmd.Flags().StringVar(&batting.scope, "scope", "", "Required: match:<match> or season:<season>")
+	battingCmd.Flags().StringVar(&batting.metric, "metric", "", "Required: fours, sixes, or strike-rate")
+	battingCmd.Flags().StringVar(&batting.groupBy, "group-by", "player", "Grouping fields (comma-separated): player,team,league,season")
+	battingCmd.Flags().StringVar(&batting.team, "team", "", "Optional team filter")
+	battingCmd.Flags().StringVar(&batting.player, "player", "", "Optional player filter")
+	battingCmd.Flags().IntVar(&batting.top, "top", 20, "Maximum ranked rows to return")
+
+	type partnershipRuntime struct {
+		scope   string
+		groupBy string
+		team    string
+		innings int
+		top     int
+	}
+	partners := &partnershipRuntime{}
+	partnershipsCmd := &cobra.Command{
+		Use:   "partnerships",
+		Short: "Rank partnerships by match or season scope",
+		Args:  cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			if strings.TrimSpace(partners.scope) == "" {
+				return fmt.Errorf("--scope is required")
+			}
+			return runAnalysisCommand(cmd, global, func(ctx context.Context, service analysisCommandService) (cricinfo.NormalizedResult, error) {
+				return service.Partnerships(ctx, cricinfo.AnalysisMetricOptions{
+					Scope:       partners.scope,
+					LeagueQuery: base.leagueID,
+					TypeQuery:   base.typeQuery,
+					GroupQuery:  base.groupQuery,
+					DateFrom:    base.dateFrom,
+					DateTo:      base.dateTo,
+					MatchLimit:  base.matchLimit,
+					GroupBy:     partners.groupBy,
+					TeamQuery:   partners.team,
+					Innings:     partners.innings,
+					Top:         partners.top,
+				})
+			})
+		},
+	}
+	partnershipsCmd.Flags().StringVar(&partners.scope, "scope", "", "Required: match:<match> or season:<season>")
+	partnershipsCmd.Flags().StringVar(&partners.groupBy, "group-by", "innings", "Grouping fields (comma-separated): innings,team,league,season")
+	partnershipsCmd.Flags().StringVar(&partners.team, "team", "", "Optional team filter")
+	partnershipsCmd.Flags().IntVar(&partners.innings, "innings", 0, "Optional innings filter")
+	partnershipsCmd.Flags().IntVar(&partners.top, "top", 20, "Maximum ranked rows to return")
+
+	cmd.AddCommand(dismissalsCmd, bowlingCmd, battingCmd, partnershipsCmd)
+	return cmd
+}
+
+func runAnalysisCommand(
+	cmd *cobra.Command,
+	global *globalOptions,
+	fn func(ctx context.Context, service analysisCommandService) (cricinfo.NormalizedResult, error),
+) error {
+	service, err := newAnalysisService()
+	if err != nil {
+		return err
+	}
+	defer func() {
+		_ = service.Close()
+	}()
+
+	result, err := fn(cmd.Context(), service)
+	if err != nil {
+		return err
+	}
+
+	return cricinfo.Render(cmd.OutOrStdout(), result, cricinfo.RenderOptions{
+		Format:    global.format,
+		Verbose:   global.verbose,
+		AllFields: global.allFields,
+	})
+}

package/internal/cli/analysis_test.go

@@ -0,0 +1,175 @@
+package cli
+
+import (
+	"bytes"
+	"context"
+	"strings"
+	"testing"
+
+	"github.com/amxv/cricinfo-cli/internal/cricinfo"
+)
+
+type fakeAnalysisService struct {
+	dismissalsResult  cricinfo.NormalizedResult
+	bowlingResult     cricinfo.NormalizedResult
+	battingResult     cricinfo.NormalizedResult
+	partnershipResult cricinfo.NormalizedResult
+
+	dismissOpts []cricinfo.AnalysisDismissalOptions
+	bowlingOpts []cricinfo.AnalysisMetricOptions
+	battingOpts []cricinfo.AnalysisMetricOptions
+	partnerOpts []cricinfo.AnalysisMetricOptions
+}
+
+func (f *fakeAnalysisService) Close() error { return nil }
+
+func (f *fakeAnalysisService) Dismissals(_ context.Context, opts cricinfo.AnalysisDismissalOptions) (cricinfo.NormalizedResult, error) {
+	f.dismissOpts = append(f.dismissOpts, opts)
+	return f.dismissalsResult, nil
+}
+
+func (f *fakeAnalysisService) Bowling(_ context.Context, opts cricinfo.AnalysisMetricOptions) (cricinfo.NormalizedResult, error) {
+	f.bowlingOpts = append(f.bowlingOpts, opts)
+	return f.bowlingResult, nil
+}
+
+func (f *fakeAnalysisService) Batting(_ context.Context, opts cricinfo.AnalysisMetricOptions) (cricinfo.NormalizedResult, error) {
+	f.battingOpts = append(f.battingOpts, opts)
+	return f.battingResult, nil
+}
+
+func (f *fakeAnalysisService) Partnerships(_ context.Context, opts cricinfo.AnalysisMetricOptions) (cricinfo.NormalizedResult, error) {
+	f.partnerOpts = append(f.partnerOpts, opts)
+	return f.partnershipResult, nil
+}
+
+func TestAnalysisCommandsCallServiceWithScopedOptions(t *testing.T) {
+	service := &fakeAnalysisService{
+		dismissalsResult:  cricinfo.NewDataResult(cricinfo.EntityAnalysisDismiss, cricinfo.AnalysisView{Command: "dismissals"}),
+		bowlingResult:     cricinfo.NewDataResult(cricinfo.EntityAnalysisBowl, cricinfo.AnalysisView{Command: "bowling", Metric: "economy"}),
+		battingResult:     cricinfo.NewDataResult(cricinfo.EntityAnalysisBat, cricinfo.AnalysisView{Command: "batting", Metric: "strike-rate"}),
+		partnershipResult: cricinfo.NewDataResult(cricinfo.EntityAnalysisPart, cricinfo.AnalysisView{Command: "partnerships"}),
+	}
+
+	originalFactory := newAnalysisService
+	newAnalysisService = func() (analysisCommandService, error) { return service, nil }
+	defer func() {
+		newAnalysisService = originalFactory
+	}()
+
+	var dismissOut bytes.Buffer
+	var dismissErr bytes.Buffer
+	if err := Run([]string{
+		"analysis", "dismissals",
+		"--league", "19138",
+		"--seasons", "2024-2025",
+		"--group-by", "dismissal-type,team",
+		"--team", "BOOST",
+		"--dismissal-type", "caught",
+		"--innings", "1",
+		"--top", "12",
+		"--format", "json",
+	}, &dismissOut, &dismissErr); err != nil {
+		t.Fatalf("Run analysis dismissals error: %v", err)
+	}
+	dismissPayload := decodeCLIJSONMap(t, dismissOut.Bytes())
+	if dismissPayload["kind"] != string(cricinfo.EntityAnalysisDismiss) {
+		t.Fatalf("expected kind %q, got %#v", cricinfo.EntityAnalysisDismiss, dismissPayload["kind"])
+	}
+	if len(service.dismissOpts) != 1 {
+		t.Fatalf("expected one dismissals call, got %d", len(service.dismissOpts))
+	}
+	if service.dismissOpts[0].LeagueQuery != "19138" || service.dismissOpts[0].Seasons != "2024-2025" {
+		t.Fatalf("unexpected dismissals opts: %+v", service.dismissOpts[0])
+	}
+
+	var bowlingOut bytes.Buffer
+	var bowlingErr bytes.Buffer
+	if err := Run([]string{
+		"analysis", "bowling",
+		"--scope", "season:2025",
+		"--league", "19138",
+		"--metric", "economy",
+		"--group-by", "player,team",
+		"--player", "1361257",
+		"--top", "5",
+		"--format", "json",
+	}, &bowlingOut, &bowlingErr); err != nil {
+		t.Fatalf("Run analysis bowling error: %v", err)
+	}
+	if len(service.bowlingOpts) != 1 {
+		t.Fatalf("expected one bowling call, got %d", len(service.bowlingOpts))
+	}
+	if service.bowlingOpts[0].Metric != "economy" || service.bowlingOpts[0].Scope != "season:2025" {
+		t.Fatalf("unexpected bowling opts: %+v", service.bowlingOpts[0])
+	}
+
+	var battingOut bytes.Buffer
+	var battingErr bytes.Buffer
+	if err := Run([]string{
+		"analysis", "batting",
+		"--scope", "match:1529474",
+		"--metric", "strike-rate",
+		"--group-by", "player",
+		"--top", "7",
+		"--format", "json",
+	}, &battingOut, &battingErr); err != nil {
+		t.Fatalf("Run analysis batting error: %v", err)
+	}
+	if len(service.battingOpts) != 1 {
+		t.Fatalf("expected one batting call, got %d", len(service.battingOpts))
+	}
+	if service.battingOpts[0].Metric != "strike-rate" || service.battingOpts[0].Scope != "match:1529474" {
+		t.Fatalf("unexpected batting opts: %+v", service.battingOpts[0])
+	}
+
+	var partnershipsOut bytes.Buffer
+	var partnershipsErr bytes.Buffer
+	if err := Run([]string{
+		"analysis", "partnerships",
+		"--scope", "season:2025",
+		"--league", "19138",
+		"--group-by", "innings,team",
+		"--innings", "1",
+		"--top", "9",
+		"--format", "json",
+	}, &partnershipsOut, &partnershipsErr); err != nil {
+		t.Fatalf("Run analysis partnerships error: %v", err)
+	}
+	if len(service.partnerOpts) != 1 {
+		t.Fatalf("expected one partnerships call, got %d", len(service.partnerOpts))
+	}
+	if service.partnerOpts[0].Scope != "season:2025" || service.partnerOpts[0].Innings != 1 {
+		t.Fatalf("unexpected partnerships opts: %+v", service.partnerOpts[0])
+	}
+}
+
+func TestAnalysisCommandsValidateRequiredFlags(t *testing.T) {
+	service := &fakeAnalysisService{}
+
+	originalFactory := newAnalysisService
+	newAnalysisService = func() (analysisCommandService, error) { return service, nil }
+	defer func() {
+		newAnalysisService = originalFactory
+	}()
+
+	assertErrContains := func(args []string, want string) {
+		t.Helper()
+		var out bytes.Buffer
+		var errBuf bytes.Buffer
+		err := Run(args, &out, &errBuf)
+		if err == nil {
+			t.Fatalf("expected error for %v", args)
+		}
+		if !strings.Contains(err.Error(), want) {
+			t.Fatalf("expected %q in error for %v, got %v", want, args, err)
+		}
+	}
+
+	assertErrContains([]string{"analysis", "dismissals", "--seasons", "2025"}, "--league is required")
+	assertErrContains([]string{"analysis", "dismissals", "--league", "19138"}, "--seasons is required")
+	assertErrContains([]string{"analysis", "bowling", "--metric", "economy"}, "--scope is required")
+	assertErrContains([]string{"analysis", "bowling", "--scope", "match:1529474"}, "--metric is required")
+	assertErrContains([]string{"analysis", "batting", "--scope", "match:1529474"}, "--metric is required")
+	assertErrContains([]string{"analysis", "partnerships"}, "--scope is required")
+}

package/internal/cli/competitions.go

@@ -0,0 +1,154 @@
+package cli
+
+import (
+	"context"
+	"strings"
+
+	"github.com/amxv/cricinfo-cli/internal/cricinfo"
+	"github.com/spf13/cobra"
+)
+
+type competitionCommandService interface {
+	Close() error
+	Show(ctx context.Context, query string, opts cricinfo.CompetitionLookupOptions) (cricinfo.NormalizedResult, error)
+	Officials(ctx context.Context, query string, opts cricinfo.CompetitionLookupOptions) (cricinfo.NormalizedResult, error)
+	Broadcasts(ctx context.Context, query string, opts cricinfo.CompetitionLookupOptions) (cricinfo.NormalizedResult, error)
+	Tickets(ctx context.Context, query string, opts cricinfo.CompetitionLookupOptions) (cricinfo.NormalizedResult, error)
+	Odds(ctx context.Context, query string, opts cricinfo.CompetitionLookupOptions) (cricinfo.NormalizedResult, error)
+	Metadata(ctx context.Context, query string, opts cricinfo.CompetitionLookupOptions) (cricinfo.NormalizedResult, error)
+}
+
+type competitionRuntimeOptions struct {
+	leagueID string
+}
+
+var newCompetitionService = func() (competitionCommandService, error) {
+	return cricinfo.NewCompetitionService(cricinfo.CompetitionServiceConfig{})
+}
+
+func newCompetitionsCommand(global *globalOptions) *cobra.Command {
+	opts := &competitionRuntimeOptions{}
+
+	cmd := &cobra.Command{
+		Use:   "competitions",
+		Short: "Competition metadata including officials, broadcasts, tickets, odds, and aggregate views.",
+		Long: strings.Join([]string{
+			"Resolve a match/competition and drill into auxiliary competition metadata routes.",
+			"Empty-but-valid metadata collections are rendered as clean zero-result views.",
+			"",
+			"Next steps:",
+			"  cricinfo competitions show <match>",
+			"  cricinfo competitions officials <match>",
+			"  cricinfo competitions broadcasts <match>",
+			"  cricinfo competitions tickets <match>",
+			"  cricinfo competitions odds <match>",
+			"  cricinfo competitions metadata <match>",
+		}, "\n"),
+		Args: cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			return cmd.Help()
+		},
+	}
+
+	cmd.PersistentFlags().StringVar(&opts.leagueID, "league", "", "Preferred league ID for match resolution context")
+
+	showCmd := &cobra.Command{
+		Use:   "show <match>",
+		Short: "Show one competition summary",
+		Args:  cobra.MinimumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			query := strings.TrimSpace(strings.Join(args, " "))
+			return runCompetitionCommand(cmd, global, func(ctx context.Context, service competitionCommandService) (cricinfo.NormalizedResult, error) {
+				return service.Show(ctx, query, cricinfo.CompetitionLookupOptions{LeagueID: opts.leagueID})
+			})
+		},
+	}
+
+	officialsCmd := &cobra.Command{
+		Use:   "officials <match>",
+		Short: "Show competition officials entries",
+		Args:  cobra.MinimumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			query := strings.TrimSpace(strings.Join(args, " "))
+			return runCompetitionCommand(cmd, global, func(ctx context.Context, service competitionCommandService) (cricinfo.NormalizedResult, error) {
+				return service.Officials(ctx, query, cricinfo.CompetitionLookupOptions{LeagueID: opts.leagueID})
+			})
+		},
+	}
+
+	broadcastsCmd := &cobra.Command{
+		Use:   "broadcasts <match>",
+		Short: "Show competition broadcast entries",
+		Args:  cobra.MinimumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			query := strings.TrimSpace(strings.Join(args, " "))
+			return runCompetitionCommand(cmd, global, func(ctx context.Context, service competitionCommandService) (cricinfo.NormalizedResult, error) {
+				return service.Broadcasts(ctx, query, cricinfo.CompetitionLookupOptions{LeagueID: opts.leagueID})
+			})
+		},
+	}
+
+	ticketsCmd := &cobra.Command{
+		Use:   "tickets <match>",
+		Short: "Show competition ticket entries",
+		Args:  cobra.MinimumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			query := strings.TrimSpace(strings.Join(args, " "))
+			return runCompetitionCommand(cmd, global, func(ctx context.Context, service competitionCommandService) (cricinfo.NormalizedResult, error) {
+				return service.Tickets(ctx, query, cricinfo.CompetitionLookupOptions{LeagueID: opts.leagueID})
+			})
+		},
+	}
+
+	oddsCmd := &cobra.Command{
+		Use:   "odds <match>",
+		Short: "Show competition odds entries",
+		Args:  cobra.MinimumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			query := strings.TrimSpace(strings.Join(args, " "))
+			return runCompetitionCommand(cmd, global, func(ctx context.Context, service competitionCommandService) (cricinfo.NormalizedResult, error) {
+				return service.Odds(ctx, query, cricinfo.CompetitionLookupOptions{LeagueID: opts.leagueID})
+			})
+		},
+	}
+
+	metadataCmd := &cobra.Command{
+		Use:   "metadata <match>",
+		Short: "Show aggregated competition metadata across officials, broadcasts, tickets, and odds",
+		Args:  cobra.MinimumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			query := strings.TrimSpace(strings.Join(args, " "))
+			return runCompetitionCommand(cmd, global, func(ctx context.Context, service competitionCommandService) (cricinfo.NormalizedResult, error) {
+				return service.Metadata(ctx, query, cricinfo.CompetitionLookupOptions{LeagueID: opts.leagueID})
+			})
+		},
+	}
+
+	cmd.AddCommand(showCmd, officialsCmd, broadcastsCmd, ticketsCmd, oddsCmd, metadataCmd)
+	return cmd
+}
+
+func runCompetitionCommand(
+	cmd *cobra.Command,
+	global *globalOptions,
+	fn func(ctx context.Context, service competitionCommandService) (cricinfo.NormalizedResult, error),
+) error {
+	service, err := newCompetitionService()
+	if err != nil {
+		return err
+	}
+	defer func() {
+		_ = service.Close()
+	}()
+
+	result, err := fn(cmd.Context(), service)
+	if err != nil {
+		return err
+	}
+
+	return cricinfo.Render(cmd.OutOrStdout(), result, cricinfo.RenderOptions{
+		Format:    global.format,
+		Verbose:   global.verbose,
+		AllFields: global.allFields,
+	})
+}