fplkit 2.7.3__tar.gz → 2.7.4__tar.gz

{fplkit-2.7.3 → fplkit-2.7.4}/.agents/TOOLS.md

@@ -39,7 +39,7 @@ with `2>/dev/null` without losing the table, whichever command it runs.
 | `player` | Look up a player's stats, xG, ownership and fixture run. Before GW10 `quality_score` blends last season's pedigree in and JSON `metadata.warnings` says so (`early_season_prior_informed`, or `early_season_small_sample` when history could not be loaded), same as `fpl stats --value`; `understat_team_unmatched` joins it for any club Understat carried no players for, whose whole squad loses xG enrichment. JSON includes `ep_next` (predicted pts next GW) and `ep_this` (current GW), emitting `null` when FPL has no projection; panel shows `xPts` (ep_next) when available, omits the segment when FPL has no projection. `--detail` (`-d`) shows GW-by-GW performance and, for FWD/MID with sufficient history, xGI sustainability (per-match GI-xGI divergence -> form modifier). With `custom_analysis`: JSON adds `info.adjusted_npxg_per_90` (fixture-adjusted) and `info.raw_npxg_per_90` (Understat season avg); panel shows `adj. npxG/90: X.XXX (raw: Y.YYY)` | Yes | General | No | direct-api |
 | `stats` | List players with filtering and sorting. `--value` adds quality/value per £m columns; `--window N` sets rolling lookback (3-10) for `rolling_pts_per_m`. Before GW10, `--value` quality scores blend last season's pts/90 pedigree with this season's observation and the command says so (stderr notice quoting the observation's weight band; JSON `metadata.warnings` code `early_season_prior_informed`); when last season's history cannot be loaded they are pure observation and the notice says that instead (`early_season_small_sample`, before GW6). `understat_team_unmatched` is raised once per club Understat carried no players for, whose whole squad scores without xG. GK ceilings scale with the calendar-possible sample, reaching full scale at GW6. Sortable by `ep_next`/`ep_this` (FPL predicted points; `ep_this` is only meaningful before the gameweek's first kickoff — FPL rolls it forward to `ep_next` as each player's match finishes); both in JSON output (emit `null` when FPL has no projection; table renders `—`). Players with no projection sort to the bottom in either direction | Yes | General | No | direct-api |
 | `history` | Show historical player performance across seasons. A provider that refuses exits 1 in both output formats, carrying the upstream's own reason: the error envelope used to say only `Failed to fetch historical data` while the cause went to stderr, and table mode printed the cause to stdout and exited 0 | Yes | General | No | direct-api |
-| `league` | Show live league standings for Classic and Draft leagues. Classic positions are competition-ranked from cumulative totals — managers level on points share a place and the next distinct total skips the places they consumed — matching `fpl review` and the league history ledger rather than the standings API's sequential rank, which splits such a tie on fewest transfers season-to-date, a figure no column shows. Draft keeps the league's own rank, which already applies the head-to-head points-for tie-break | No | General | No | direct-api |
+| `league` | Show live league standings for Classic and Draft leagues. Classic positions are competition-ranked from cumulative totals — managers level on points share a place and the next distinct total skips the places they consumed — matching `fpl review` and the league history ledger rather than the standings API's sequential rank, which splits such a tie on fewest transfers season-to-date, a figure no column shows. Draft keeps the league's own rank, which already applies the head-to-head points-for tie-break. The Best/Worst GW Performers lists (top three; bottom five classic, bottom three draft) are the ones `fpl review` prints: managers level on the gameweek share a place (`3=`) and a tie at the cut keeps every manager in it, a hit reads `29 net pts (33 gross, -4 hit)`, and a classic user above the bottom five gets a `Your GW rank: R of N` line beside the list | No | General | No | direct-api |
 | `fdr` | Analyse fixture difficulty - easy runs, blanks, doubles. Three payloads, not one: the default call runs the agent and returns the full analysis plus `data.ratings_warning` (the team-ratings quality verdict, and with `--my-squad` also `data.predictions_stale` / `data.prediction_warnings` / `data.squad_exposure`); with custom analysis off it returns raw 1-5 FPL API difficulty (`data.easy_fixture_runs` only, `metadata.custom_analysis: false`, no ratings and so no warning); `--blanks` bypasses the agent for a schedule-only payload carrying neither the FDR analysis nor `ratings_warning`. `--blanks` mixes confirmed fixtures with predictions; when those predictions are stale, table mode warns on stderr and JSON adds a `fixture_predictions_stale` entry to `metadata.warnings` | Yes | General | No | via-agent |
 | `xg` | Analyse underlying stats: xG, xA, overperformers. The minutes floor and the window scale to the gameweeks played (`min(60 x window, 45 x gameweeks played)`, so 90 minutes over 2 GWs rather than an unreachable 360 over 6); the configured bar binds from GW9, or GW11 for `--all`. JSON `metadata` carries `window_label`, `gameweeks_played` and `min_minutes`, and `metadata.warnings` an `early_season_minutes_floor` notice while the bar is scaled, plus `understat_team_unmatched` for any club Understat carried no players for. When nothing qualifies, `data.empty_reason` says whether the floor (`below_minutes_floor`) or the data (`no_minutes_played`) caused it | Yes | General | No | via-agent |
 | `price-changes` | Show price changes and transfer activity | No | General | No | via-agent |

{fplkit-2.7.3 → fplkit-2.7.4}/CHANGELOG.md

@@ -1,6 +1,21 @@
 # Changelog
 
 All notable changes to this project will be documented in this file.
+## [2.7.3] - 2026-10-09
+
+### Bug Fixes
+
+- default synthesis model moves to claude-sonnet-5-5 (#362)
+- stop streak notes calling a fully recorded gameweek "not recorded" (#363)
+- show correct ranks and scores in the gameweek review report (#365)
+- review no longer drops the transfers summary on a net-zero total (#366)
+- draft review no longer misreports rendering errors as a failed fetch (#369)
+- stop gw-prep, squad-builder and FPL Mate ruling out a legal 5-2-3 (#370)
+- flag a recap editorial that misnames who lost a contested waiver (#368)
+- draft review no longer crashes on bracketed player or manager names (#373)
+- classic review no longer crashes on bracketed names (#378)
+- flag recap editorials that misplace a transfer net or invent a tie (#374)
+
 ## [2.7.2] - 2026-09-16
 
 ### Bug Fixes

{fplkit-2.7.3 → fplkit-2.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: fplkit
-Version: 2.7.3
+Version: 2.7.4
 Summary: CLI tool for Fantasy Premier League analysis - classic and draft formats
 Project-URL: Homepage, https://github.com/rossgroomio/fpl-cli
 Project-URL: Repository, https://github.com/rossgroomio/fpl-cli

{fplkit-2.7.3 → fplkit-2.7.4}/docs/architecture.md

@@ -597,7 +597,7 @@ fpl_cli/
 │   ├── review.py                 # Review research + synthesis prompts. Squad and transfer lines in the synthesis data block carry each player's full club name, and the hard constraints bind club affiliation and blanket scored/blanked claims to that supplied data — an LLM's own club knowledge goes stale every transfer window. The synthesis prompt also carries a `<next_gameweek>` block — every club's next fixture and each squad player's positional FDR, built by `_review_next_gameweek` / `_format_next_gameweek` — and the "Next Week" instruction switches on whether it is there: grounded advice when it is, fixture-independent observations pointing at `fpl gw-prep` when it is not, because a results-only review was issuing confident fixture-dependent calls with no fixture data behind them (#191), with `check_next_week_grounding` checking the answer back against that block -- a cited FDR figure the block never printed, or any fixture claim on a run that had no block -- so the grounding claim is not left resting on prompt prose alone, the way the research half's rules are backed by `validate_research_teams`, which folds both the supplied name and the model's cell through `normalise_name` before the allowlist search so a reformat is not read as an invention, and leaves a `[table trimmed: N unlisted row(s) removed]` line under a table it did shorten — the strip notice otherwise reaching stderr and `--debug` only, both gone by the time the markdown is read (#343). Also the synthesis half's post-generation guard (`check_synthesis_completeness`, `required_synthesis_sections`), which reads the required `## ` headings back off the prompt that was actually sent rather than restating them as a constant. The research half's counts are grounded the same way: `fixture_aggregates()` computes the fixture, goal, clean-sheet and goalless-draw totals once, `FixtureAggregates.summary_line()` pins them at the top of the GW Results block as the narrative's only permitted source, and `validate_research_counts` checks the narrative back against the same object — a count the prompt pins cannot drift from the count the check enforces. It rewrites a contradicting figure in place rather than scrubbing the sentence, and corrects one only when neither its sentence nor the one before it names anyone the count could belong to — a club, a nickname, a player, a pronoun standing in for one — because a round-wide total is exactly the sentence that names nobody. The guard errs towards leaving prose alone: a missed correction ships the model's own words, while a wrong one fabricates a claim in prose that was true. That blind spot is why the check was needed at all — the narrative that reported six clean sheets as four (#324) named no player, so all three name-based validators passed it
 │   ├── returnees.py              # Return-intel search prompt for `fpl returnees --enrich` (one player per query, so a citation list belongs to a single player)
 │   ├── league_recap.py           # League recap synthesis prompts, including the anchored League History section, its never-infer-history rule (emitted even when the pack is empty), and the season-phase framing instruction. The GW Standings section leads with an explicit "Previous gameweek's leader" fact (issue #189) so a "topped the table"/"fell from the top" claim is checkable against a stated name instead of inferred from the Prev column or the size of a fall, and the rules forbid merging two managers' separate League History entries into a shared record or "club". `collect_player_clubs()` regroups the club each squad/transfer row already resolved off its `team_id` by the name the prose uses, feeding both a `## Player Clubs` roster and the club printed inline on each captain group, so club claims bind to supplied data instead of recall; a name the data gives two clubs for is dropped rather than guessed at, since the prose can't tell the two players apart. Transfers get the same full-roster treatment as captains and chips (issue #71): `format_recap_transfers_context()` lists every manager who transferred with each move, the hit and the post-hit net, names who made none, and keeps a manager whose moves the collector could not capture among the movers with the moves marked unknown, so the rule pins transfer narration to that section rather than to the two award winners — the only transfer data the model used to see, which it read as the whole story. `format_recap_waivers_context()` is the draft half (issue #301): every waiver and free-agent move as it was made, never chain-contracted (that is the awards' display compression, not a record of activity), each tagged by kind through the shared `draft_transaction_kind_label()` / `draft_transaction_kind_counts()` in `_league_recap_types.py` so the roster and the waiver awards never describe one move in two vocabularies; the rule names that section as draft's source of truth and only falls back to "say nothing about moves" when neither roster is present. It states three groups rather than two (issue #329): movers, the managers who claimed a player and lost him to a rival, and the managers who did neither. A waiver is a competition, so an outbid manager ends the gameweek with no accepted move and used to be indistinguishable from one who submitted nothing -- the editorial read that absence as inactivity and assigned a motive for it, so the rule now forbids calling anyone in the outbid group idle. The section closes with the gameweek's contested players (issue #330) — one sentence per player more than one manager claimed, from `contested_draft_claims()` / `format_contested_claim()` in `_league_recap_types.py`, the same sentence the Most Contested award prints for a pile-up of `MOST_CONTESTED_MIN_CLAIMANTS` or more that a recapped manager won (a race nobody can be seen to have won is context, never the award), with a rule pinning who-wanted-whom to those lines and limiting what may be said of anyone's waiver order to the winner having stood higher in it. `format_recap_prior_seasons_context()` (issue #131) is the opener's one source of history: each classic manager's FPL-wide seasons before this one, folded once by `summarise_prior_seasons()` (`_league_recap_types.py`) so the saved report and the prompt read the same lines, with an explicit count, the no-record and unfetched managers named rather than omitted, and a rule pinning tenure to FPL-wide phrasing — entry and league IDs are reissued each season, so "Nth season in this league" is unknowable and the section says so. The report's title is not the model's (issue #349): `recap_title()` (`_league_recap_types.py`) is the one H1, read by the template that renders it and the prompt that names it as already written; the prompt asks for a `## ` headline beneath it and no title, and `normalise_recap_editorial()` holds the reply to that shape in one fence-aware pass over every heading — one that only restates the title is dropped wherever it sits, the opening one is kept at H2 with the title's parts taken off (emphasis unwrapped through `unwrap_emphasis()` in `utils/markdown.py`, balanced pairs only, so what is printed again stays well-formed), a later `# ` is demoted, and a title-shaped part is removed only behind a colon, pipe or spaced dash so a hook's own words are never edited — since an instruction is not a contract and the model had mirrored, restyled, renamed and skipped the heading in turn. For the same reason the finished editorial is checked against its own data afterwards, by `league_recap_checks.py` beside this module; what the checks hold "joint" to is stated here, in `_standings_tie_lines()`: the week's highest and lowest scores, every gameweek score and Pos position more than one manager holds, any shared Prev position, and any season totals the league's tie-break placed apart (a head-to-head draft table ranks managers level on league points by points scored)
-│   └── league_recap_checks.py    # Post-generation checks on the league-recap editorial, kept out of the prompt module so it stays about prompts. `EDITORIAL_CHECKS` is the one registry -- each check's `RECAP_WARNING_*` code, the lead of its JSON warning (`editorial_warning_message()`, one sentence per claim), its retry instruction and the checker -- so a new check is one record. `check_contested_attributions()` (issue #357) reads who a sentence says won or was beaten to a contested player; `check_net_attributions()` (issue #359) reads a "net" figure said of one named move and flags it when it is another figure on that manager's roster line, attaching it to whichever of the move and its manager is named nearer before it; `check_tie_claims()` (issue #359) reads a tie word fused to a rank ("joint-lowest", "tied for last", "joint-seventh") against the GW Pts column, or the table's Pos, Prev and Total columns. Each reads only the clauses it can pin down and lets the rest pass, so a problem is a sentence the data contradicts and a false alarm (which costs a retry and a warning above a correct editorial) is the failure it is built against. `check_recap_editorial()` runs them all; the command regenerates once with `get_recap_editorial_retry_prompt()` (the wrong claims plus an instruction per kind that failed), saves a still-failing editorial as written with one JSON warning per code and the claims in a callout above it, and ships the editorial unchecked if a check itself raises
+│   └── league_recap_checks.py    # Post-generation checks on the league-recap editorial, kept out of the prompt module so it stays about prompts. `EDITORIAL_CHECKS` is the one registry -- each check's `RECAP_WARNING_*` code, the lead of its JSON warning (`editorial_warning_message()`, one sentence per claim), its retry instruction and the checker -- so a new check is one record. `check_contested_attributions()` (issue #357) reads who a sentence says won or was beaten to a contested player; `check_net_attributions()` (issue #359) reads a "net" figure said of one named move and flags it when it is another figure on that manager's roster line, attaching it to whichever of the move and its manager is named nearer before it; `check_tie_claims()` (issue #359) reads a tie word fused to a rank ("joint-lowest", "tied for last", "joint-seventh") against the GW Pts column, or the table's Pos, Prev and Total columns. All three read names the same way: `check_recap_editorial()` builds one `RecapNames` per editorial -- a longest-first alternation over every name the data carries (every squad, captain, move and lost claim's players, the managers and their unique short forms) -- and each check takes it as a required argument and keeps only the matches it is after, so a manager's surname is never read inside a hyphenated player ("White" in "Gibbs-White") nor a player inside a manager's full name (issue #379). Each reads only the clauses it can pin down and lets the rest pass, so a problem is a sentence the data contradicts and a false alarm (which costs a retry and a warning above a correct editorial) is the failure it is built against. `check_recap_editorial()` runs them all; the command regenerates once with `get_recap_editorial_retry_prompt()` (the wrong claims plus an instruction per kind that failed), saves a still-failing editorial as written with one JSON warning per code and the claims in a callout above it, and ships the editorial unchecked if a check itself raises
 ├── parsers/
 │   └── recommendations.py        # Parse gw{N}-recommendations.md into structured decisions
 ├── scraper/

{fplkit-2.7.3 → fplkit-2.7.4}/docs/command-reference.md

@@ -760,6 +760,15 @@ A waiver claim a rival won is reported under **Claims Lost** rather than discard
 
 **LLM summary** (`--summarise`): Community narrative via research provider, personal analysis via synthesis provider. The summary is an add-on: the review itself needs no key, so a role whose provider has no usable key is skipped with the reason on stderr (`Community narrative skipped: ...` / `Personal analysis skipped: ...`) and the review still prints, still saves its report and still exits **0**. The two roles resolve independently, so one key buys the half it belongs to rather than nothing. A saved report generated from such a run names each skipped half and why in a warning callout above the summary, so a section absent for want of a key never reads as one deliberately left out.
 
+**Trimmed tables:** the community narrative's Standout Performers and Disappointments tables are
+checked against the player lists the research prompt was given. A row naming a player who is not
+on those lists is removed, and the table then carries `[table trimmed: N unlisted row(s)
+removed]` beneath it, counted per table. "Unlisted" means not on the supplied lists, and the
+guard removed the rows, not the model, so a shortened table is not the model's own choice.
+Style differences (spacing, apostrophes, accents, case) are never grounds for removal. Under
+`--debug`, each removed row is named in `data/debug/research_corrections.txt` as
+`<player>: stripped (not in provided list)`.
+
 **Next Week:** the personal analysis is given next gameweek's fixtures — every club's opponent
 and venue, and each of your own players' FDR for their own position — so the section's start,
 bench and transfer calls are grounded in what the squad actually plays rather than extrapolated
@@ -826,6 +835,13 @@ a season with nothing finished yet — is refused with the reason on **stderr**
 with the reason on stdout, as did `league-recap`, which shares the resolver. A missing provider
 key was refused the same way until it stopped being a refusal at all — see the LLM summary above.
 
+**Notices** — the line that says an entry id is not configured or not found in the draft league,
+the pair that says why a past gameweek has no league table, the note that a new mini-league's
+standings are not published yet, and the `Fetching your team data...` progress line — go to
+**stderr**, for classic and draft alike. A section heading stays on stdout only with the content it
+introduces: for a past gameweek, or a mini-league whose table is not published yet, there is no
+League section on stdout at all and stderr says why.
+
 ### League Recap
 
 Entertainment-first post-gameweek report for the whole league.

{fplkit-2.7.3 → fplkit-2.7.4}/fpl_cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.7.3'
-__version_tuple__ = version_tuple = (2, 7, 3)
+__version__ = version = '2.7.4'
+__version_tuple__ = version_tuple = (2, 7, 4)
 
 __commit_id__ = commit_id = None

{fplkit-2.7.3 → fplkit-2.7.4}/fpl_cli/cli/_helpers.py

@@ -6,9 +6,12 @@ import asyncio
 import logging
 from collections import Counter
 from collections.abc import Callable, Mapping
+from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
-from fpl_cli.cli._context import fpl_config
+from rich.markup import escape as rich_escape
+
+from fpl_cli.cli._context import console, error_console, fpl_config
 
 if TYPE_CHECKING:
     from fpl_cli.api.fpl import FPLClient
@@ -121,6 +124,157 @@ def your_gw_rank_line(gw_rank: str | None, field_size: int | None, row: Mapping[
     return f"Your GW rank: {gw_rank or '?'}{field} - {performer_score(row)}"
 
 
+def print_historical_league_notice(gw: int) -> None:
+    """Say why a past gameweek's review carries no league table (#377, #382).
+
+    The classic and draft blocks print the same two lines under their own
+    `## League` heading. They are commentary on the review, not part of it, so
+    they go to stderr and the heading stays on stdout with the content it
+    introduces.
+    """
+    error_console.print(f"[dim]League standings not shown for historical GW{gw} review[/dim]")
+    error_console.print("[dim]Use 'fpl league' for current standings[/dim]")
+
+
+def _performer_row(e: Mapping[str, Any]) -> dict[str, Any]:
+    """A classic standings entry as a Best/Worst GW Performers row.
+
+    Takes an entry from `_fetch_standings_with_costs` after `_assign_tie_ranks`.
+    `points` is the score the row was ranked on (net when the league plays
+    net), which is what `performer_score` and the last-place fine read.
+    """
+    return {
+        "name": e["name"],
+        "points": e["net_points"],
+        "gross_points": e["gross_points"],
+        "transfer_cost": e["transfer_cost"],
+        "rank_str": e["rank_str"],
+        "is_user": e.get("is_user", False),
+    }
+
+
+def _draft_performer_row(e: Mapping[str, Any], user_entry_id: int | None) -> dict[str, Any]:
+    """A draft standings entry as a Best/Worst GW Performers row.
+
+    Draft has no hits, so `points` is the gameweek score as it stands and
+    `performer_score` states it without a gross or a hit beside it.
+    """
+    return {
+        "name": e["manager_name"],
+        "points": e["event_total"],
+        "rank_str": e["rank_str"],
+        # An unset draft_entry_id must not match an entry the league details
+        # left without an entry id, which would print a rival as "You".
+        "is_user": user_entry_id is not None and e["entry_id"] == user_entry_id,
+    }
+
+
+def _print_performer(perf: Mapping[str, Any]) -> None:
+    """Print one Best/Worst GW Performers row to the terminal.
+
+    The one renderer `fpl review` and `fpl league` share, for both formats:
+    `fpl league` kept its own copy, which numbered a tie as a placing and
+    worded a hit its own way (#381).
+    """
+    name = "[bold cyan]You[/bold cyan]" if perf["is_user"] else rich_escape(perf["name"])
+    console.print(f"  {perf['rank_str']}. {name} - {performer_score(perf)}")
+
+
+@dataclass(frozen=True)
+class GwPerformers:
+    """A league's Best/Worst GW Performers, ranked for every command that shows them.
+
+    `best` and `worst` are performer rows. `user_gw_rank` is the user's
+    place on the gameweek ("3="), None when they are not in the standings
+    handed over. `user_context_row` is the user's own row when they sit
+    above the worst list: it is shown beside the list as a "Your GW rank"
+    line, never as a numbered row in it that reads as a bottom placing
+    (#360). `field_size` is None when the standings were one page of a
+    larger league.
+    """
+
+    best: list[dict[str, Any]]
+    worst: list[dict[str, Any]]
+    user_gw_rank: str | None
+    user_context_row: dict[str, Any] | None
+    field_size: int | None
+
+
+def _gw_performers(
+    entries: list[dict[str, Any]],
+    score_key: str,
+    to_row: Callable[[Mapping[str, Any]], dict[str, Any]],
+    *,
+    worst_n: int,
+    complete: bool,
+    with_context_row: bool,
+) -> GwPerformers:
+    """Rank *entries* on *score_key* into the top three and the bottom *worst_n*.
+
+    Each list runs past its cut to keep a tie whole, numbered as a shared
+    place. Both passes rank the same dicts in place, so each pass's rows
+    are built before the next one re-ranks them.
+    """
+    desc = sorted(entries, key=lambda e: e[score_key], reverse=True)
+    _assign_tie_ranks(desc, score_key)
+    best = [to_row(e) for e in _slice_with_ties(desc, 3)]
+    user_row = next((row for row in map(to_row, desc) if row["is_user"]), None)
+
+    asc = sorted(entries, key=lambda e: e[score_key])
+    _assign_tie_ranks(asc, score_key)
+    worst = [to_row(e) for e in _slice_with_ties(asc, worst_n)]
+
+    user_in_worst = any(row["is_user"] for row in worst)
+    return GwPerformers(
+        best=best,
+        worst=worst,
+        user_gw_rank=user_row["rank_str"] if user_row else None,
+        user_context_row=user_row if with_context_row and not user_in_worst else None,
+        field_size=len(entries) if complete else None,
+    )
+
+
+def classic_gw_performers(standings_with_costs: list[dict[str, Any]], *, complete: bool) -> GwPerformers:
+    """Classic Best/Worst GW Performers: top three and bottom five plus ties, on net points.
+
+    Takes `_fetch_standings_with_costs` output. `complete` is False when the
+    standings were one 50-entry page of a larger league: the GW ranks then
+    cover only that page, so no field size is named that would read as the
+    whole league. `fpl review` and `fpl league` both rank through here: they
+    each ran this sequence themselves and drifted apart on it (#381).
+    """
+    return _gw_performers(
+        standings_with_costs, "net_points", _performer_row,
+        worst_n=5, complete=complete, with_context_row=True,
+    )
+
+
+def draft_gw_performers(standings_with_names: list[dict[str, Any]], user_entry_id: int | None) -> GwPerformers:
+    """Draft Best/Worst GW Performers: top and bottom three plus ties, on the GW score.
+
+    Takes standings rows carrying `manager_name`, `entry_id` and
+    `event_total`. Draft review has never printed a "Your GW rank" line, so
+    neither does this, and `user_context_row` is always None.
+    """
+    return _gw_performers(
+        standings_with_names, "event_total", lambda e: _draft_performer_row(e, user_entry_id),
+        worst_n=3, complete=True, with_context_row=False,
+    )
+
+
+def _print_gw_performers(performers: GwPerformers, *, header_suffix: str = "") -> None:
+    """Print both performer lists, and the user's GW rank line when they sit above the worst one."""
+    console.print(f"\n[bold]### Best GW Performers{header_suffix}[/bold]")
+    for perf in performers.best:
+        _print_performer(perf)
+    console.print(f"\n[bold]### Worst GW Performers{header_suffix}[/bold]")
+    for perf in performers.worst:
+        _print_performer(perf)
+    if performers.user_context_row:
+        line = your_gw_rank_line(performers.user_gw_rank, performers.field_size, performers.user_context_row)
+        console.print(f"  {line}")
+
+
 def _gw_position_with_half(position: int | str, total: int) -> str:
     """Return position string annotated with pre-computed half classification.
 

{fplkit-2.7.3 → fplkit-2.7.4}/fpl_cli/cli/_review_classic.py

@@ -12,17 +12,16 @@ from rich.table import Table
 
 from fpl_cli.cli._context import console, error_console
 from fpl_cli.cli._helpers import (
-    _assign_tie_ranks,
     _center_window_with_ties,
     _fetch_standings_with_costs,
     _format_pts_display,
     _format_review_player,
     _live_player_stats,
     _net_transfer_ids,
-    _slice_with_ties,
-    performer_score,
+    _print_gw_performers,
+    classic_gw_performers,
+    print_historical_league_notice,
     signed_net_markup,
-    your_gw_rank_line,
 )
 from fpl_cli.cli._league_recap_data import derive_point_in_time_positions
 from fpl_cli.services.fixture_predictions import is_blank_gameweek, is_double_gameweek
@@ -74,7 +73,7 @@ async def _review_classic_team(
 
     if entry_id:
         try:
-            console.print("[dim]Fetching your team data...[/dim]")
+            error_console.print("[dim]Fetching your team data...[/dim]")
             picks_response = await client.get_manager_picks(entry_id, gw)
 
             entry_history = picks_response.get("entry_history", {})
@@ -262,7 +261,7 @@ async def _review_classic_team(
     elif entry_id:
         error_console.print("[yellow]Could not fetch your team data[/yellow]")
     else:
-        console.print("[dim]Set classic_entry_id in config/settings.yaml to see your squad[/dim]")
+        error_console.print("[dim]Set classic_entry_id in config/settings.yaml to see your squad[/dim]")
 
     return {
         "my_entry_summary": my_entry_summary,
@@ -391,27 +390,6 @@ async def _review_classic_transfers(
     return classic_transfers_data
 
 
-def _performer_row(e: dict[str, Any]) -> dict[str, Any]:
-    """A standings entry as a Best/Worst GW Performers row.
-
-    `points` is the score the row was ranked on (net when the league plays
-    net), which is what `performer_score` and the last-place fine read.
-    """
-    return {
-        "name": e["name"],
-        "points": e["net_points"],
-        "gross_points": e["gross_points"],
-        "transfer_cost": e["transfer_cost"],
-        "rank_str": e["rank_str"],
-        "is_user": e.get("is_user", False),
-    }
-
-
-def _print_performer(perf: dict[str, Any]) -> None:
-    name = "[bold cyan]You[/bold cyan]" if perf["is_user"] else rich_escape(perf["name"])
-    console.print(f"  {perf['rank_str']}. {name} - {performer_score(perf)}")
-
-
 async def _review_classic_league(
     client: FPLClient,
     classic_league_id: int | None,
@@ -444,12 +422,12 @@ async def _review_classic_league(
         league_name = standings_data.get("league", {}).get("name", "Classic League")
         standings = standings_data.get("standings", {}).get("results", [])
 
-        # Check if we're reviewing a historical GW (league data would be stale)
+        # Check if we're reviewing a historical GW (league data would be stale).
+        # The heading is printed only on the path that has a table for it to
+        # introduce: the two below say why there is none, on stderr.
         is_historical_review = api_current_gw_id is not None and gw != api_current_gw_id
         if is_historical_review:
-            console.print("\n[bold]## League[/bold]")
-            console.print(f"[dim]League standings not shown for historical GW{gw} review[/dim]")
-            console.print("[dim]Use 'fpl league' for current standings[/dim]")
+            print_historical_league_notice(gw)
             return {"league_name": league_name}
 
         # FPL builds a mini-league's table for the first time only once the
@@ -457,12 +435,11 @@ async def _review_classic_league(
         # `new_entries` and `results` is empty. Rendering the sections anyway
         # printed bare headings and handed the report a 0-point, 0-entry league.
         if not standings:
-            console.print("\n[bold]## League[/bold]")
-            console.print(
+            error_console.print(
                 f"[dim]{rich_escape(league_name)}: standings not published yet"
                 " -- FPL builds mini-league tables after the opening gameweek is finalised[/dim]"
             )
-            console.print("[dim]Re-run once the table appears, or use 'fpl league'[/dim]")
+            error_console.print("[dim]Re-run once the table appears, or use 'fpl league'[/dim]")
             return {"league_name": league_name, "standings_pending": True}
 
         console.print("\n[bold]## League[/bold]")
@@ -540,54 +517,20 @@ async def _review_classic_league(
             client, standings, entry_id, gw, fetch_costs=use_net_points,
         )
 
-        # Best GW performers (top 3 + ties)
-        header_suffix = " (Net Points)" if use_net_points else ""
-        sorted_by_net_desc = sorted(standings_with_costs, key=lambda x: x["net_points"], reverse=True)
-        _assign_tie_ranks(sorted_by_net_desc, "net_points")
-
-        # Snapshot best performer report data before ascending sort overwrites ranks
-        best_performers_for_report = [
-            _performer_row(e) for e in _slice_with_ties(sorted_by_net_desc, 3)
-        ]
-
-        console.print(f"\n[bold]### Best GW Performers{header_suffix}[/bold]")
-        for perf in best_performers_for_report:
-            _print_performer(perf)
-
-        # Capture user's GW rank within the classic league (by net points)
-        user_gw_entry = next(
-            (e for e in sorted_by_net_desc if e["is_user"]), None
-        )
-        classic_user_gw_rank = user_gw_entry["rank_str"] if user_gw_entry else None
-        # One page of standings is 50 entries; past that the ranks above
-        # cover only the page fetched, so the report must not name a field
-        # size that reads as the whole league
+        # One page of standings is 50 entries; past that the GW ranks cover
+        # only the page fetched (see `classic_gw_performers`)
         standings_complete = not standings_data.get("standings", {}).get("has_next", False)
-        gw_field_size = len(sorted_by_net_desc) if standings_complete else None
-
-        # Worst performers (bottom 5 + ties)
-        sorted_by_net_asc = sorted(standings_with_costs, key=lambda x: x["net_points"])
-        _assign_tie_ranks(sorted_by_net_asc, "net_points")
-
-        worst_performers_data = _slice_with_ties(sorted_by_net_asc, 5)
-        user_in_bottom = any(p["is_user"] for p in worst_performers_data)
+        performers = classic_gw_performers(standings_with_costs, complete=standings_complete)
         user_entry_data = next((p for p in standings_with_costs if p["is_user"]), None)
-        # The user's own row when they sit above the bottom five, shown beside
-        # the table rather than in it: a numbered row there read as a bottom
-        # placing (#360). Its `rank_str` is the ascending one, so it is
-        # labelled with the GW rank instead.
-        user_context_row = (
-            _performer_row(user_entry_data) if user_entry_data and not user_in_bottom else None
-        )
 
         # Calculate transfer impact narrative (only when net points are tracked)
         transfer_impact = None
-        if use_net_points and len(worst_performers_data) >= 2:
-            last_place = worst_performers_data[0]
+        if use_net_points and len(performers.worst) >= 2:
+            last_place = performers.worst[0]
 
             if user_entry_data:
                 user_transfer_cost = user_entry_data["transfer_cost"]
-                user_is_last = user_entry_data == last_place
+                user_is_last = last_place["is_user"]
                 if user_is_last and user_transfer_cost > 0:
                     sorted_by_gross = sorted(standings_with_costs, key=lambda x: x["gross_points"])
                     user_gross_rank = sorted_by_gross.index(user_entry_data)
@@ -600,13 +543,7 @@ async def _review_classic_league(
                             f"{last_place['name']}'s -{last_place['transfer_cost']} hit saved you from last place"
                         )
 
-        worst_performers_for_report = [_performer_row(e) for e in worst_performers_data]
-
-        console.print(f"\n[bold]### Worst GW Performers{header_suffix}[/bold]")
-        for perf in worst_performers_for_report:
-            _print_performer(perf)
-        if user_context_row:
-            console.print(f"  {your_gw_rank_line(classic_user_gw_rank, gw_field_size, user_context_row)}")
+        _print_gw_performers(performers, header_suffix=" (Net Points)" if use_net_points else "")
 
         if transfer_impact:
             error_console.print(f"\n[yellow]  ⚠ {rich_escape(transfer_impact)}[/yellow]")
@@ -615,8 +552,8 @@ async def _review_classic_league(
         classic_league_data = {
             "league_name": league_name,
             "user_position": user_rank,
-            "user_gw_rank": classic_user_gw_rank,
-            "gw_field_size": gw_field_size,
+            "user_gw_rank": performers.user_gw_rank,
+            "gw_field_size": performers.field_size,
             "total_entries": total_entries,
             "user_gw_points": user_gw_pts,
             "user_total": user_total,
@@ -635,9 +572,9 @@ async def _review_classic_league(
             ],
             "nearby_rivals_omitted": nearby_omitted,
             "use_net_points": use_net_points,
-            "best_performers": best_performers_for_report,
-            "worst_performers": worst_performers_for_report,
-            "user_context_row": user_context_row,
+            "best_performers": performers.best,
+            "worst_performers": performers.worst,
+            "user_context_row": performers.user_context_row,
             "transfer_impact": transfer_impact,
         }
         if use_net_points and user_entry_data:

{fplkit-2.7.3 → fplkit-2.7.4}/fpl_cli/cli/_review_draft.py

@@ -11,12 +11,13 @@ from rich.table import Table
 
 from fpl_cli.cli._context import console, error_console
 from fpl_cli.cli._helpers import (
-    _assign_tie_ranks,
     _format_pts_display,
     _format_review_player,
     _live_player_stats,
     _net_transfer_ids,
-    _slice_with_ties,
+    _print_gw_performers,
+    draft_gw_performers,
+    print_historical_league_notice,
     signed_net_markup,
 )
 from fpl_cli.models.player import POSITION_MAP
@@ -444,9 +445,7 @@ async def _review_draft(
                 # ## League section - only show for current GW (live data)
                 is_historical_review = api_current_gw_id is not None and gw != api_current_gw_id
                 if is_historical_review:
-                    console.print("\n[bold]## League[/bold]")
-                    console.print(f"[dim]League standings not shown for historical GW{gw} review[/dim]")
-                    console.print("[dim]Use 'fpl league' for current standings[/dim]")
+                    print_historical_league_notice(gw)
                 else:
                     console.print("\n[bold]## League[/bold]")
                     console.print(f"- Position: {user_rank} of {total_entries}")
@@ -468,71 +467,31 @@ async def _review_draft(
                             "event_total": s.get("event_total", 0),
                         })
 
-                    # Best GW performers in draft league (top 3 + ties)
-                    sorted_by_gw = sorted(standings_with_names, key=lambda x: x["event_total"], reverse=True)
-                    _assign_tie_ranks(sorted_by_gw, "event_total")
-                    best_gw_display = _slice_with_ties(sorted_by_gw, 3)
-
-                    console.print("\n[bold]### Best GW Performers[/bold]")
-                    for entry in best_gw_display:
-                        name = entry["manager_name"]
-                        gw_pts = entry["event_total"]
-                        rank = entry["rank_str"]
-                        is_user = entry["entry_id"] == draft_entry_id
-                        if is_user:
-                            console.print(f"  {rank}. [bold cyan]You[/bold cyan] - {gw_pts} pts")
-                        else:
-                            console.print(f"  {rank}. {rich_escape(name)} - {gw_pts} pts")
-
-                    # Snapshot best data and user GW rank before worst sort overwrites ranks
-                    best_for_report = [
-                        {"name": e["manager_name"], "points": e["event_total"], "rank_str": e["rank_str"]}
-                        for e in best_gw_display
-                    ]
-                    user_entry = next(
-                        (e for e in sorted_by_gw if e["entry_id"] == draft_entry_id),
-                        None,
-                    )
-                    user_gw_rank = user_entry["rank_str"] if user_entry else None
-
-                    # Worst performers: sorted ascending (bottom 3 + ties)
-                    worst_sorted = sorted(standings_with_names, key=lambda x: x["event_total"])
-                    _assign_tie_ranks(worst_sorted, "event_total")
-                    worst_gw_display = _slice_with_ties(worst_sorted, 3)
-
-                    console.print("\n[bold]### Worst GW Performers[/bold]")
-                    for entry in worst_gw_display:
-                        name = entry["manager_name"]
-                        gw_pts = entry["event_total"]
-                        rank = entry["rank_str"]
-                        is_user = entry["entry_id"] == draft_entry_id
-                        if is_user:
-                            console.print(f"  {rank}. [bold cyan]You[/bold cyan] - {gw_pts} pts")
-                        else:
-                            console.print(f"  {rank}. {rich_escape(name)} - {gw_pts} pts")
+                    # Top and bottom three plus ties, ranked and printed by the
+                    # code `fpl league` uses (#381)
+                    performers = draft_gw_performers(standings_with_names, draft_entry_id)
+                    _print_gw_performers(performers)
 
                     # Store for report (worst_performers sorted ascending - lowest first)
                     draft_league_data = {
                         "league_name": draft_league_name,
                         "user_position": user_rank,
-                        "user_gw_rank": user_gw_rank,
+                        "user_gw_rank": performers.user_gw_rank,
                         "total_entries": total_entries,
                         "user_gw_points": user_gw_pts,
                         "user_total": user_total,
-                        "best_performers": best_for_report,
-                        "worst_performers": [
-                            {
-                                "name": e["manager_name"],
-                                "points": e["event_total"],
-                                "rank_str": e["rank_str"],
-                                "is_user": e["entry_id"] == draft_entry_id,
-                            }
-                            for e in worst_gw_display
-                        ],
+                        "best_performers": performers.best,
+                        "worst_performers": performers.worst,
                     }
 
             elif not draft_entry_id:
-                console.print("[dim]Set draft_entry_id in config/settings.yaml to see your draft squad[/dim]")
+                error_console.print("[dim]Set draft_entry_id in config/settings.yaml to see your draft squad[/dim]")
+            else:
+                error_console.print(
+                    f"[yellow]Could not find draft_entry_id {draft_entry_id} in the standings of"
+                    f" {rich_escape(draft_league_name)} -- check draft_entry_id and draft_league_id"
+                    " in config/settings.yaml[/yellow]"
+                )
 
     except Exception as e:  # noqa: BLE001 — display resilience
         error_console.print(f"[yellow]Could not fetch draft league data: {rich_escape(str(e))}[/yellow]")