cricinfo-cli-go 0.1.0

package/internal/cli/competitions_test.go

@@ -0,0 +1,165 @@
+package cli
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"strings"
+	"testing"
+
+	"github.com/amxv/cricinfo-cli/internal/cricinfo"
+)
+
+type fakeCompetitionService struct {
+	showResult       cricinfo.NormalizedResult
+	officialsResult  cricinfo.NormalizedResult
+	broadcastsResult cricinfo.NormalizedResult
+	ticketsResult    cricinfo.NormalizedResult
+	oddsResult       cricinfo.NormalizedResult
+	metadataResult   cricinfo.NormalizedResult
+
+	showQueries       []string
+	officialsQueries  []string
+	broadcastsQueries []string
+	metadataQueries   []string
+	showOpts          []cricinfo.CompetitionLookupOptions
+	officialsOpts     []cricinfo.CompetitionLookupOptions
+	broadcastsOpts    []cricinfo.CompetitionLookupOptions
+	metadataOpts      []cricinfo.CompetitionLookupOptions
+}
+
+func (f *fakeCompetitionService) Close() error { return nil }
+
+func (f *fakeCompetitionService) Show(_ context.Context, query string, opts cricinfo.CompetitionLookupOptions) (cricinfo.NormalizedResult, error) {
+	f.showQueries = append(f.showQueries, query)
+	f.showOpts = append(f.showOpts, opts)
+	return f.showResult, nil
+}
+
+func (f *fakeCompetitionService) Officials(_ context.Context, query string, opts cricinfo.CompetitionLookupOptions) (cricinfo.NormalizedResult, error) {
+	f.officialsQueries = append(f.officialsQueries, query)
+	f.officialsOpts = append(f.officialsOpts, opts)
+	return f.officialsResult, nil
+}
+
+func (f *fakeCompetitionService) Broadcasts(_ context.Context, query string, opts cricinfo.CompetitionLookupOptions) (cricinfo.NormalizedResult, error) {
+	f.broadcastsQueries = append(f.broadcastsQueries, query)
+	f.broadcastsOpts = append(f.broadcastsOpts, opts)
+	return f.broadcastsResult, nil
+}
+
+func (f *fakeCompetitionService) Tickets(context.Context, string, cricinfo.CompetitionLookupOptions) (cricinfo.NormalizedResult, error) {
+	return f.ticketsResult, nil
+}
+
+func (f *fakeCompetitionService) Odds(context.Context, string, cricinfo.CompetitionLookupOptions) (cricinfo.NormalizedResult, error) {
+	return f.oddsResult, nil
+}
+
+func (f *fakeCompetitionService) Metadata(_ context.Context, query string, opts cricinfo.CompetitionLookupOptions) (cricinfo.NormalizedResult, error) {
+	f.metadataQueries = append(f.metadataQueries, query)
+	f.metadataOpts = append(f.metadataOpts, opts)
+	return f.metadataResult, nil
+}
+
+func TestCompetitionsCommandsRenderAndPreserveLookupInputs(t *testing.T) {
+	service := &fakeCompetitionService{
+		showResult: cricinfo.NewDataResult(cricinfo.EntityCompetition, cricinfo.Competition{
+			ID:               "1529474",
+			CompetitionID:    "1529474",
+			LeagueID:         "19138",
+			EventID:          "1529474",
+			Description:      "3rd Match",
+			ShortDescription: "3rd Match",
+			OfficialsRef:     "http://core.espnuk.org/v2/sports/cricket/leagues/19138/events/1529474/competitions/1529474/officials",
+		}),
+		officialsResult: cricinfo.NewListResult(cricinfo.EntityCompOfficial, []any{
+			cricinfo.CompetitionMetadataEntry{DisplayName: "Anil Chaugai", Role: "umpire", Order: 1},
+		}),
+		broadcastsResult: cricinfo.NewListResult(cricinfo.EntityCompBroadcast, []any{}),
+		ticketsResult:    cricinfo.NewListResult(cricinfo.EntityCompTicket, []any{}),
+		oddsResult: cricinfo.NewListResult(cricinfo.EntityCompOdds, []any{
+			cricinfo.CompetitionMetadataEntry{Name: "Win Probability", Value: "0.61"},
+		}),
+		metadataResult: cricinfo.NewDataResult(cricinfo.EntityCompMetadata, cricinfo.CompetitionMetadataSummary{
+			Competition: cricinfo.Competition{ID: "1529474"},
+			Officials:   []cricinfo.CompetitionMetadataEntry{{DisplayName: "Anil Chaugai"}},
+			Broadcasts:  []cricinfo.CompetitionMetadataEntry{},
+			Tickets:     []cricinfo.CompetitionMetadataEntry{},
+			Odds:        []cricinfo.CompetitionMetadataEntry{{Name: "Win Probability", Value: "0.61"}},
+		}),
+	}
+
+	originalFactory := newCompetitionService
+	newCompetitionService = func() (competitionCommandService, error) { return service, nil }
+	defer func() {
+		newCompetitionService = originalFactory
+	}()
+
+	var showOut bytes.Buffer
+	var showErr bytes.Buffer
+	if err := Run([]string{"competitions", "show", "3rd", "Match", "--league", "19138", "--format", "json"}, &showOut, &showErr); err != nil {
+		t.Fatalf("Run competitions show error: %v", err)
+	}
+
+	var showPayload map[string]any
+	if err := json.Unmarshal(showOut.Bytes(), &showPayload); err != nil {
+		t.Fatalf("decode competitions show payload: %v", err)
+	}
+	if showPayload["kind"] != string(cricinfo.EntityCompetition) {
+		t.Fatalf("expected kind %q, got %#v", cricinfo.EntityCompetition, showPayload["kind"])
+	}
+
+	var officialsOut bytes.Buffer
+	var officialsErr bytes.Buffer
+	if err := Run([]string{"competitions", "officials", "1529474", "--league", "19138", "--format", "text"}, &officialsOut, &officialsErr); err != nil {
+		t.Fatalf("Run competitions officials error: %v", err)
+	}
+	if !strings.Contains(officialsOut.String(), "Anil Chaugai") {
+		t.Fatalf("expected officials text output to include official name, got %q", officialsOut.String())
+	}
+
+	var broadcastsOut bytes.Buffer
+	var broadcastsErr bytes.Buffer
+	if err := Run([]string{"competitions", "broadcasts", "1529474", "--league", "19138", "--format", "text"}, &broadcastsOut, &broadcastsErr); err != nil {
+		t.Fatalf("Run competitions broadcasts error: %v", err)
+	}
+	if !strings.Contains(strings.ToLower(broadcastsOut.String()), "no competition broadcasts found") {
+		t.Fatalf("expected clean zero-result message for broadcasts, got %q", broadcastsOut.String())
+	}
+
+	var metadataOut bytes.Buffer
+	var metadataErr bytes.Buffer
+	if err := Run([]string{"competitions", "metadata", "3rd", "Match", "--league", "19138", "--format", "json"}, &metadataOut, &metadataErr); err != nil {
+		t.Fatalf("Run competitions metadata error: %v", err)
+	}
+	var metadataPayload map[string]any
+	if err := json.Unmarshal(metadataOut.Bytes(), &metadataPayload); err != nil {
+		t.Fatalf("decode competitions metadata payload: %v", err)
+	}
+	if metadataPayload["kind"] != string(cricinfo.EntityCompMetadata) {
+		t.Fatalf("expected kind %q, got %#v", cricinfo.EntityCompMetadata, metadataPayload["kind"])
+	}
+
+	if len(service.showQueries) != 1 || service.showQueries[0] != "3rd Match" {
+		t.Fatalf("expected joined show query, got %+v", service.showQueries)
+	}
+	if len(service.officialsQueries) != 1 || service.officialsQueries[0] != "1529474" {
+		t.Fatalf("expected officials query 1529474, got %+v", service.officialsQueries)
+	}
+	if len(service.metadataQueries) != 1 || service.metadataQueries[0] != "3rd Match" {
+		t.Fatalf("expected joined metadata query, got %+v", service.metadataQueries)
+	}
+	if len(service.showOpts) != 1 || service.showOpts[0].LeagueID != "19138" {
+		t.Fatalf("expected show league option to propagate, got %+v", service.showOpts)
+	}
+	if len(service.officialsOpts) != 1 || service.officialsOpts[0].LeagueID != "19138" {
+		t.Fatalf("expected officials league option to propagate, got %+v", service.officialsOpts)
+	}
+	if len(service.broadcastsOpts) != 1 || service.broadcastsOpts[0].LeagueID != "19138" {
+		t.Fatalf("expected broadcasts league option to propagate, got %+v", service.broadcastsOpts)
+	}
+	if len(service.metadataOpts) != 1 || service.metadataOpts[0].LeagueID != "19138" {
+		t.Fatalf("expected metadata league option to propagate, got %+v", service.metadataOpts)
+	}
+}

package/internal/cli/leagues.go

@@ -0,0 +1,297 @@
+package cli
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/amxv/cricinfo-cli/internal/cricinfo"
+	"github.com/spf13/cobra"
+)
+
+type leagueCommandService interface {
+	Close() error
+	List(ctx context.Context, opts cricinfo.LeagueListOptions) (cricinfo.NormalizedResult, error)
+	Show(ctx context.Context, leagueQuery string) (cricinfo.NormalizedResult, error)
+	Events(ctx context.Context, leagueQuery string, opts cricinfo.LeagueListOptions) (cricinfo.NormalizedResult, error)
+	Calendar(ctx context.Context, leagueQuery string) (cricinfo.NormalizedResult, error)
+	Athletes(ctx context.Context, leagueQuery string, opts cricinfo.LeagueListOptions) (cricinfo.NormalizedResult, error)
+	Standings(ctx context.Context, leagueQuery string) (cricinfo.NormalizedResult, error)
+	Seasons(ctx context.Context, leagueQuery string) (cricinfo.NormalizedResult, error)
+	SeasonShow(ctx context.Context, leagueQuery string, opts cricinfo.SeasonLookupOptions) (cricinfo.NormalizedResult, error)
+	SeasonTypes(ctx context.Context, leagueQuery string, opts cricinfo.SeasonLookupOptions) (cricinfo.NormalizedResult, error)
+	SeasonGroups(ctx context.Context, leagueQuery string, opts cricinfo.SeasonLookupOptions) (cricinfo.NormalizedResult, error)
+}
+
+type leagueRuntimeOptions struct {
+	limit  int
+	season string
+	typ    string
+}
+
+var newLeagueService = func() (leagueCommandService, error) {
+	return cricinfo.NewLeagueService(cricinfo.LeagueServiceConfig{})
+}
+
+func newLeaguesCommand(global *globalOptions) *cobra.Command {
+	opts := &leagueRuntimeOptions{}
+
+	cmd := &cobra.Command{
+		Use:   "leagues",
+		Short: "League discovery and navigation across events, calendar, athletes, standings, and seasons.",
+		Long: strings.Join([]string{
+			"Resolve leagues by ID/ref/alias and drill into events, calendar views, athletes, standings, and season navigation.",
+			"",
+			"Next steps:",
+			"  cricinfo leagues list",
+			"  cricinfo leagues show <league>",
+			"  cricinfo leagues events <league>",
+			"  cricinfo leagues calendar <league>",
+			"  cricinfo leagues athletes <league>",
+			"  cricinfo leagues standings <league>",
+			"  cricinfo leagues seasons <league>",
+		}, "\n"),
+		Args: cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			return cmd.Help()
+		},
+	}
+
+	listCmd := &cobra.Command{
+		Use:   "list",
+		Short: "List leagues from /leagues",
+		Args:  cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			return runLeagueCommand(cmd, global, func(ctx context.Context, service leagueCommandService) (cricinfo.NormalizedResult, error) {
+				return service.List(ctx, cricinfo.LeagueListOptions{Limit: opts.limit})
+			})
+		},
+	}
+	listCmd.Flags().IntVar(&opts.limit, "limit", 20, "Maximum number of leagues to return")
+
+	showCmd := &cobra.Command{
+		Use:   "show <league>",
+		Short: "Show one league summary",
+		Args:  cobra.MinimumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			leagueQuery := strings.TrimSpace(strings.Join(args, " "))
+			return runLeagueCommand(cmd, global, func(ctx context.Context, service leagueCommandService) (cricinfo.NormalizedResult, error) {
+				return service.Show(ctx, leagueQuery)
+			})
+		},
+	}
+
+	eventsCmd := &cobra.Command{
+		Use:   "events <league>",
+		Short: "List matches/events for one league",
+		Args:  cobra.MinimumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			leagueQuery := strings.TrimSpace(strings.Join(args, " "))
+			return runLeagueCommand(cmd, global, func(ctx context.Context, service leagueCommandService) (cricinfo.NormalizedResult, error) {
+				return service.Events(ctx, leagueQuery, cricinfo.LeagueListOptions{Limit: opts.limit})
+			})
+		},
+	}
+	eventsCmd.Flags().IntVar(&opts.limit, "limit", 20, "Maximum number of league events/matches to return")
+
+	calendarCmd := &cobra.Command{
+		Use:   "calendar <league>",
+		Short: "Show normalized league calendar day entries",
+		Args:  cobra.MinimumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			leagueQuery := strings.TrimSpace(strings.Join(args, " "))
+			return runLeagueCommand(cmd, global, func(ctx context.Context, service leagueCommandService) (cricinfo.NormalizedResult, error) {
+				return service.Calendar(ctx, leagueQuery)
+			})
+		},
+	}
+
+	athletesCmd := &cobra.Command{
+		Use:   "athletes <league>",
+		Short: "Show league athlete views, with roster-driven fallback when direct pages are sparse",
+		Args:  cobra.MinimumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			leagueQuery := strings.TrimSpace(strings.Join(args, " "))
+			return runLeagueCommand(cmd, global, func(ctx context.Context, service leagueCommandService) (cricinfo.NormalizedResult, error) {
+				return service.Athletes(ctx, leagueQuery, cricinfo.LeagueListOptions{Limit: opts.limit})
+			})
+		},
+	}
+	athletesCmd.Flags().IntVar(&opts.limit, "limit", 20, "Maximum number of athletes to return")
+
+	standingsCmd := &cobra.Command{
+		Use:   "standings <league>",
+		Short: "Show normalized standings groups for one league",
+		Args:  cobra.MinimumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			leagueQuery := strings.TrimSpace(strings.Join(args, " "))
+			return runLeagueCommand(cmd, global, func(ctx context.Context, service leagueCommandService) (cricinfo.NormalizedResult, error) {
+				return service.Standings(ctx, leagueQuery)
+			})
+		},
+	}
+
+	seasonsCmd := &cobra.Command{
+		Use:   "seasons <league>",
+		Short: "Show season refs for one league",
+		Args:  cobra.MinimumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			leagueQuery := strings.TrimSpace(strings.Join(args, " "))
+			return runLeagueCommand(cmd, global, func(ctx context.Context, service leagueCommandService) (cricinfo.NormalizedResult, error) {
+				return service.Seasons(ctx, leagueQuery)
+			})
+		},
+	}
+
+	cmd.AddCommand(
+		listCmd,
+		showCmd,
+		eventsCmd,
+		calendarCmd,
+		athletesCmd,
+		standingsCmd,
+		seasonsCmd,
+	)
+	return cmd
+}
+
+func newSeasonsCommand(global *globalOptions) *cobra.Command {
+	opts := &leagueRuntimeOptions{}
+
+	cmd := &cobra.Command{
+		Use:   "seasons",
+		Short: "Season navigation across league season, type, and group hierarchies.",
+		Long: strings.Join([]string{
+			"Resolve seasons, types, and groups by league while hiding pointer-heavy upstream traversal.",
+			"",
+			"Next steps:",
+			"  cricinfo seasons show <league> --season <season>",
+			"  cricinfo seasons types <league> --season <season>",
+			"  cricinfo seasons groups <league> --season <season> --type <type>",
+		}, "\n"),
+		Args: cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			return cmd.Help()
+		},
+	}
+
+	showCmd := &cobra.Command{
+		Use:   "show <league>",
+		Short: "Show one selected league season",
+		Args:  cobra.MinimumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if strings.TrimSpace(opts.season) == "" {
+				return fmt.Errorf("--season is required")
+			}
+			leagueQuery := strings.TrimSpace(strings.Join(args, " "))
+			return runLeagueCommand(cmd, global, func(ctx context.Context, service leagueCommandService) (cricinfo.NormalizedResult, error) {
+				return service.SeasonShow(ctx, leagueQuery, cricinfo.SeasonLookupOptions{
+					SeasonQuery: opts.season,
+				})
+			})
+		},
+	}
+	showCmd.Flags().StringVar(&opts.season, "season", "", "Required: season ID/ref (for example 2025)")
+
+	typesCmd := &cobra.Command{
+		Use:   "types <league>",
+		Short: "List normalized season types for a selected league season",
+		Args:  cobra.MinimumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if strings.TrimSpace(opts.season) == "" {
+				return fmt.Errorf("--season is required")
+			}
+			leagueQuery := strings.TrimSpace(strings.Join(args, " "))
+			return runLeagueCommand(cmd, global, func(ctx context.Context, service leagueCommandService) (cricinfo.NormalizedResult, error) {
+				return service.SeasonTypes(ctx, leagueQuery, cricinfo.SeasonLookupOptions{
+					SeasonQuery: opts.season,
+				})
+			})
+		},
+	}
+	typesCmd.Flags().StringVar(&opts.season, "season", "", "Required: season ID/ref (for example 2025)")
+
+	groupsCmd := &cobra.Command{
+		Use:   "groups <league>",
+		Short: "List normalized season groups for a selected season type",
+		Args:  cobra.MinimumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if strings.TrimSpace(opts.season) == "" {
+				return fmt.Errorf("--season is required")
+			}
+			if strings.TrimSpace(opts.typ) == "" {
+				return fmt.Errorf("--type is required")
+			}
+			leagueQuery := strings.TrimSpace(strings.Join(args, " "))
+			return runLeagueCommand(cmd, global, func(ctx context.Context, service leagueCommandService) (cricinfo.NormalizedResult, error) {
+				return service.SeasonGroups(ctx, leagueQuery, cricinfo.SeasonLookupOptions{
+					SeasonQuery: opts.season,
+					TypeQuery:   opts.typ,
+				})
+			})
+		},
+	}
+	groupsCmd.Flags().StringVar(&opts.season, "season", "", "Required: season ID/ref (for example 2025)")
+	groupsCmd.Flags().StringVar(&opts.typ, "type", "", "Required: type ID/ref/name (for example 1)")
+
+	cmd.AddCommand(showCmd, typesCmd, groupsCmd)
+	return cmd
+}
+
+func newStandingsCommand(global *globalOptions) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "standings",
+		Short: "Standings traversal by league.",
+		Long: strings.Join([]string{
+			"Traverse league standings routes and normalize ref-heavy standings resources into group entries.",
+			"",
+			"Next steps:",
+			"  cricinfo standings show <league>",
+			"  cricinfo leagues standings <league>",
+		}, "\n"),
+		Args: cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			return cmd.Help()
+		},
+	}
+
+	showCmd := &cobra.Command{
+		Use:   "show <league>",
+		Short: "Show normalized standings groups for one league",
+		Args:  cobra.MinimumNArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			leagueQuery := strings.TrimSpace(strings.Join(args, " "))
+			return runLeagueCommand(cmd, global, func(ctx context.Context, service leagueCommandService) (cricinfo.NormalizedResult, error) {
+				return service.Standings(ctx, leagueQuery)
+			})
+		},
+	}
+
+	cmd.AddCommand(showCmd)
+	return cmd
+}
+
+func runLeagueCommand(
+	cmd *cobra.Command,
+	global *globalOptions,
+	fn func(ctx context.Context, service leagueCommandService) (cricinfo.NormalizedResult, error),
+) error {
+	service, err := newLeagueService()
+	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/leagues_test.go

@@ -0,0 +1,194 @@
+package cli
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"strings"
+	"testing"
+
+	"github.com/amxv/cricinfo-cli/internal/cricinfo"
+)
+
+type fakeLeagueService struct {
+	listResult      cricinfo.NormalizedResult
+	showResult      cricinfo.NormalizedResult
+	eventsResult    cricinfo.NormalizedResult
+	calendarResult  cricinfo.NormalizedResult
+	athletesResult  cricinfo.NormalizedResult
+	standingsResult cricinfo.NormalizedResult
+	seasonsResult   cricinfo.NormalizedResult
+	seasonShow      cricinfo.NormalizedResult
+	seasonTypes     cricinfo.NormalizedResult
+	seasonGroups    cricinfo.NormalizedResult
+
+	showQueries        []string
+	standingsQueries   []string
+	seasonShowQueries  []string
+	seasonTypeQueries  []string
+	seasonGroupQueries []string
+	seasonShowOpts     []cricinfo.SeasonLookupOptions
+	seasonTypeOpts     []cricinfo.SeasonLookupOptions
+	seasonGroupOpts    []cricinfo.SeasonLookupOptions
+}
+
+func (f *fakeLeagueService) Close() error { return nil }
+
+func (f *fakeLeagueService) List(context.Context, cricinfo.LeagueListOptions) (cricinfo.NormalizedResult, error) {
+	return f.listResult, nil
+}
+
+func (f *fakeLeagueService) Show(_ context.Context, leagueQuery string) (cricinfo.NormalizedResult, error) {
+	f.showQueries = append(f.showQueries, leagueQuery)
+	return f.showResult, nil
+}
+
+func (f *fakeLeagueService) Events(context.Context, string, cricinfo.LeagueListOptions) (cricinfo.NormalizedResult, error) {
+	return f.eventsResult, nil
+}
+
+func (f *fakeLeagueService) Calendar(context.Context, string) (cricinfo.NormalizedResult, error) {
+	return f.calendarResult, nil
+}
+
+func (f *fakeLeagueService) Athletes(context.Context, string, cricinfo.LeagueListOptions) (cricinfo.NormalizedResult, error) {
+	return f.athletesResult, nil
+}
+
+func (f *fakeLeagueService) Standings(_ context.Context, leagueQuery string) (cricinfo.NormalizedResult, error) {
+	f.standingsQueries = append(f.standingsQueries, leagueQuery)
+	return f.standingsResult, nil
+}
+
+func (f *fakeLeagueService) Seasons(context.Context, string) (cricinfo.NormalizedResult, error) {
+	return f.seasonsResult, nil
+}
+
+func (f *fakeLeagueService) SeasonShow(_ context.Context, leagueQuery string, opts cricinfo.SeasonLookupOptions) (cricinfo.NormalizedResult, error) {
+	f.seasonShowQueries = append(f.seasonShowQueries, leagueQuery)
+	f.seasonShowOpts = append(f.seasonShowOpts, opts)
+	return f.seasonShow, nil
+}
+
+func (f *fakeLeagueService) SeasonTypes(_ context.Context, leagueQuery string, opts cricinfo.SeasonLookupOptions) (cricinfo.NormalizedResult, error) {
+	f.seasonTypeQueries = append(f.seasonTypeQueries, leagueQuery)
+	f.seasonTypeOpts = append(f.seasonTypeOpts, opts)
+	return f.seasonTypes, nil
+}
+
+func (f *fakeLeagueService) SeasonGroups(_ context.Context, leagueQuery string, opts cricinfo.SeasonLookupOptions) (cricinfo.NormalizedResult, error) {
+	f.seasonGroupQueries = append(f.seasonGroupQueries, leagueQuery)
+	f.seasonGroupOpts = append(f.seasonGroupOpts, opts)
+	return f.seasonGroups, nil
+}
+
+func TestLeaguesAndStandingsCommandsResolveLeagueName(t *testing.T) {
+	service := &fakeLeagueService{
+		showResult: cricinfo.NewDataResult(cricinfo.EntityLeague, cricinfo.League{
+			ID:   "19138",
+			Name: "Mirwais Nika Provincial 3-Day",
+			Slug: "19138",
+		}),
+		standingsResult: cricinfo.NewListResult(cricinfo.EntityStandingsGroup, []any{
+			cricinfo.StandingsGroup{ID: "1", SeasonID: "2026", GroupID: "1"},
+		}),
+	}
+
+	originalFactory := newLeagueService
+	newLeagueService = func() (leagueCommandService, error) { return service, nil }
+	defer func() {
+		newLeagueService = originalFactory
+	}()
+
+	var showOut bytes.Buffer
+	var showErr bytes.Buffer
+	if err := Run([]string{"leagues", "show", "Mirwais", "Nika", "--format", "json"}, &showOut, &showErr); err != nil {
+		t.Fatalf("Run leagues show error: %v", err)
+	}
+	if len(service.showQueries) != 1 || service.showQueries[0] != "Mirwais Nika" {
+		t.Fatalf("expected joined league alias query, got %+v", service.showQueries)
+	}
+
+	var showPayload map[string]any
+	if err := json.Unmarshal(showOut.Bytes(), &showPayload); err != nil {
+		t.Fatalf("decode leagues show payload: %v", err)
+	}
+	if showPayload["kind"] != string(cricinfo.EntityLeague) {
+		t.Fatalf("expected kind %q, got %#v", cricinfo.EntityLeague, showPayload["kind"])
+	}
+
+	var standingsOut bytes.Buffer
+	var standingsErr bytes.Buffer
+	if err := Run([]string{"standings", "show", "Mirwais", "Nika", "--format", "json"}, &standingsOut, &standingsErr); err != nil {
+		t.Fatalf("Run standings show error: %v", err)
+	}
+	if len(service.standingsQueries) != 1 || service.standingsQueries[0] != "Mirwais Nika" {
+		t.Fatalf("expected joined standings league query, got %+v", service.standingsQueries)
+	}
+}
+
+func TestSeasonsCommandsRequireAndPropagateSelectors(t *testing.T) {
+	service := &fakeLeagueService{
+		seasonShow: cricinfo.NewDataResult(cricinfo.EntitySeason, cricinfo.Season{
+			ID:       "2025",
+			Year:     2025,
+			LeagueID: "19138",
+		}),
+		seasonTypes: cricinfo.NewListResult(cricinfo.EntitySeasonType, []any{
+			cricinfo.SeasonType{ID: "1", SeasonID: "2025", LeagueID: "19138", Name: "Regular Season"},
+		}),
+		seasonGroups: cricinfo.NewListResult(cricinfo.EntitySeasonGroup, []any{
+			cricinfo.SeasonGroup{ID: "1", SeasonID: "2025", TypeID: "1", LeagueID: "1479935"},
+		}),
+	}
+
+	originalFactory := newLeagueService
+	newLeagueService = func() (leagueCommandService, error) { return service, nil }
+	defer func() {
+		newLeagueService = originalFactory
+	}()
+
+	var showOut bytes.Buffer
+	var showErr bytes.Buffer
+	if err := Run([]string{"seasons", "show", "Mirwais", "Nika", "--season", "2025", "--format", "json"}, &showOut, &showErr); err != nil {
+		t.Fatalf("Run seasons show error: %v", err)
+	}
+	if len(service.seasonShowOpts) != 1 || service.seasonShowOpts[0].SeasonQuery != "2025" {
+		t.Fatalf("expected season selector to be propagated, got %+v", service.seasonShowOpts)
+	}
+
+	var typesOut bytes.Buffer
+	var typesErr bytes.Buffer
+	if err := Run([]string{"seasons", "types", "Mirwais", "Nika", "--season", "2025", "--format", "json"}, &typesOut, &typesErr); err != nil {
+		t.Fatalf("Run seasons types error: %v", err)
+	}
+	if len(service.seasonTypeOpts) != 1 || service.seasonTypeOpts[0].SeasonQuery != "2025" {
+		t.Fatalf("expected season selector for types, got %+v", service.seasonTypeOpts)
+	}
+
+	var groupsOut bytes.Buffer
+	var groupsErr bytes.Buffer
+	if err := Run([]string{"seasons", "groups", "Mirwais", "Nika", "--season", "2025", "--type", "1", "--format", "json"}, &groupsOut, &groupsErr); err != nil {
+		t.Fatalf("Run seasons groups error: %v", err)
+	}
+	if len(service.seasonGroupOpts) != 1 {
+		t.Fatalf("expected one season groups invocation, got %+v", service.seasonGroupOpts)
+	}
+	if service.seasonGroupOpts[0].SeasonQuery != "2025" || service.seasonGroupOpts[0].TypeQuery != "1" {
+		t.Fatalf("expected season/type selectors to be propagated, got %+v", service.seasonGroupOpts[0])
+	}
+
+	var missingSeasonOut bytes.Buffer
+	var missingSeasonErr bytes.Buffer
+	err := Run([]string{"seasons", "show", "Mirwais", "Nika"}, &missingSeasonOut, &missingSeasonErr)
+	if err == nil || !strings.Contains(err.Error(), "--season is required") {
+		t.Fatalf("expected --season required error, got %v", err)
+	}
+
+	var missingTypeOut bytes.Buffer
+	var missingTypeErr bytes.Buffer
+	err = Run([]string{"seasons", "groups", "Mirwais", "Nika", "--season", "2025"}, &missingTypeOut, &missingTypeErr)
+	if err == nil || !strings.Contains(err.Error(), "--type is required") {
+		t.Fatalf("expected --type required error, got %v", err)
+	}
+}