lucky-cli 0.0.3__py3-none-any.whl

lucky/cli.py

@@ -0,0 +1,48 @@
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as pkg_version
+
+import typer
+
+import lucky.lottery  # noqa: F401  -- side effect: registers powerball + mega-millions
+
+from .commands.check import check
+from .commands.pick import pick
+from .commands.show import show
+from .database.db import get_session
+from .updater.updater import sync_all
+
+app = typer.Typer(no_args_is_help=True, add_completion=False)
+
+
+def _version_callback(value: bool) -> None:
+    if not value:
+        return
+    try:
+        v = pkg_version("lucky-cli")
+    except PackageNotFoundError:
+        v = "0.0.0+dev"
+    typer.echo(v)
+    raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(
+        False,
+        "--version",
+        callback=_version_callback,
+        is_eager=True,
+        help="Show the installed version and exit.",
+    ),
+) -> None:
+    """lucky — lottery ticket generator, checker, and stats CLI."""
+    session = get_session()
+    try:
+        sync_all(session)
+    finally:
+        session.close()
+
+
+app.command()(pick)
+app.command()(check)
+app.command()(show)

lucky/commands/check.py

@@ -0,0 +1,50 @@
+from typing import Annotated
+
+import typer
+
+from ..console.rich import fail, render_check_result
+from ..database import repository
+from ..database.db import get_session
+from ..lottery.base import game_metavar, get_game
+from ..lottery.checker import check_ticket
+
+
+def check(
+    game: Annotated[
+        str,
+        typer.Argument(
+            metavar=game_metavar(),
+            help="Game slug",
+        ),
+    ],
+    numbers: Annotated[list[int], typer.Argument(help="Your main numbers")],
+    special: Annotated[list[int], typer.Option("--special", help="Your special number(s)")] = [],  # noqa: B006
+) -> None:
+    """Check NUMBERS against the latest draw for GAME."""
+    try:
+        resolved_game = get_game(game)
+    except ValueError as exc:
+        fail(str(exc))
+        return
+
+    try:
+        resolved_game.validate_ticket(numbers, special)
+    except ValueError as exc:
+        usage = (
+            f"Usage: lucky check {resolved_game.slug} "
+            f"<{resolved_game.main_count} main numbers> "
+            f"--special <{resolved_game.special_count} number(s)>"
+        )
+        fail(f"{exc}\n{usage}")
+        return
+
+    session = get_session()
+    draw = repository.latest_draw(session, resolved_game.slug)
+    if draw is None:
+        session.close()
+        fail(f"No draw data available for {resolved_game.slug} yet.")
+        return
+
+    result = check_ticket(numbers, special, draw.main, draw.special)
+    render_check_result(numbers, special, draw.main, draw.special, result)
+    session.close()

lucky/commands/pick.py

@@ -0,0 +1,28 @@
+from typing import Annotated
+
+import typer
+
+from ..console.rich import fail, render_tickets
+from ..lottery.base import game_metavar, get_game
+from ..lottery.generator import generate_ticket
+
+
+def pick(
+    game: Annotated[
+        str,
+        typer.Argument(
+            metavar=game_metavar(),
+            help="Game slug",
+        ),
+    ],
+    count: Annotated[int, typer.Option("--count", min=1, help="Number of tickets to generate")] = 1,
+) -> None:
+    """Generate one or more valid random tickets for GAME."""
+    try:
+        resolved_game = get_game(game)
+    except ValueError as exc:
+        fail(str(exc))
+        return
+
+    tickets = [generate_ticket(resolved_game) for _ in range(count)]
+    render_tickets(resolved_game.name, tickets)

lucky/commands/show.py

@@ -0,0 +1,55 @@
+from typing import Annotated
+
+import typer
+
+from ..console.rich import fail, render_draw_panel, render_history_table, render_stats
+from ..database import repository
+from ..database.db import get_session
+from ..lottery.base import game_metavar, get_game
+from ..lottery.stats import compute_stats
+
+
+def show(
+    game: Annotated[
+        str,
+        typer.Argument(
+            metavar=game_metavar(),
+            help="Game slug",
+        ),
+    ],
+    history: Annotated[bool, typer.Option("--history", help="Show draw history")] = False,
+    stats: Annotated[bool, typer.Option("--stats", help="Show number frequency stats")] = False,
+    limit: Annotated[int, typer.Option("--limit", min=1, help="Number of draws to show in history")] = 10,
+) -> None:
+    """Show the latest draw for GAME, or its --history / --stats."""
+    if history and stats:
+        fail("--history and --stats are mutually exclusive")
+        return
+
+    try:
+        resolved_game = get_game(game)
+    except ValueError as exc:
+        fail(str(exc))
+        return
+
+    session = get_session()
+
+    if stats:
+        draws = repository.all_draws(session, resolved_game.slug)
+        render_stats(resolved_game.name, compute_stats(draws))
+        session.close()
+        return
+
+    if history:
+        draws = repository.history(session, resolved_game.slug, limit)
+        render_history_table(resolved_game.name, draws)
+        session.close()
+        return
+
+    draw = repository.latest_draw(session, resolved_game.slug)
+    if draw is None:
+        session.close()
+        fail(f"No draw data available for {resolved_game.slug} yet.")
+        return
+    render_draw_panel(resolved_game.name, draw)
+    session.close()

lucky/config.py

@@ -0,0 +1,9 @@
+import os
+from pathlib import Path
+
+
+def get_db_path() -> Path:
+    override = os.environ.get("LUCKY_DB_PATH")
+    if override:
+        return Path(override)
+    return Path.home() / ".lucky-cli" / "lucky.db"

lucky/console/rich.py

@@ -0,0 +1,129 @@
+from collections.abc import Callable, Iterator
+from contextlib import contextmanager
+from typing import NoReturn
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import Progress
+from rich.table import Table
+
+console = Console()
+
+
+def print_error(message: str) -> None:
+    console.print(f"[bold red]Error:[/bold red] {message}")
+
+
+def fail(message: str) -> NoReturn:
+    print_error(message)
+    raise typer.Exit(code=1)
+
+
+@contextmanager
+def update_progress(label: str, total: int) -> Iterator[Callable[[], None]]:
+    with Progress(console=console) as progress:
+        task_id = progress.add_task(f"Updating {label}...", total=total)
+
+        def advance() -> None:
+            progress.update(task_id, advance=1)
+
+        yield advance
+
+
+def render_tickets(game_name: str, tickets) -> None:
+    table = Table(title=f"{game_name} — Picks")
+    table.add_column("#")
+    table.add_column("Main Numbers")
+    table.add_column("Special")
+    for i, ticket in enumerate(tickets, start=1):
+        table.add_row(
+            str(i),
+            ", ".join(map(str, ticket.main)),
+            ", ".join(map(str, ticket.special)) or "—",
+        )
+    console.print(table)
+
+
+def render_draw_panel(game_name: str, draw) -> None:
+    body = (
+        f"Date: {draw.date}\n"
+        f"Numbers: {', '.join(map(str, draw.main))}\n"
+        f"Special: {', '.join(map(str, draw.special)) or 'N/A'}\n"
+        f"Jackpot: {draw.jackpot or 'N/A'}"
+    )
+    console.print(Panel(body, title=f"{game_name} — Latest Draw"))
+
+
+def render_history_table(game_name: str, draws) -> None:
+    table = Table(title=f"{game_name} — History")
+    table.add_column("Date")
+    table.add_column("Main Numbers")
+    table.add_column("Special")
+    table.add_column("Jackpot")
+    for draw in draws:
+        table.add_row(
+            draw.date,
+            ", ".join(map(str, draw.main)),
+            ", ".join(map(str, draw.special)) or "—",
+            draw.jackpot or "—",
+        )
+    console.print(table)
+
+
+def render_stats(game_name: str, stats) -> None:
+    table = Table(title=f"{game_name} — Number Frequency")
+    table.add_column("Number")
+    table.add_column("Frequency")
+    for number, freq in sorted(stats.main_frequency.items()):
+        table.add_row(str(number), str(freq))
+    console.print(table)
+
+    if stats.special_frequency:
+        special_table = Table(title=f"{game_name} — Special Number Frequency")
+        special_table.add_column("Number")
+        special_table.add_column("Frequency")
+        for number, freq in sorted(stats.special_frequency.items()):
+            special_table.add_row(str(number), str(freq))
+        console.print(special_table)
+
+    console.print(f"[green]Hot:[/green] {stats.hot_main}")
+    console.print(f"[blue]Cold:[/blue] {stats.cold_main}")
+    console.print(f"Odd/Even: {stats.odd_count}/{stats.even_count}")
+
+
+def render_check_result(your_main, your_special, draw_main, draw_special, result) -> None:
+    your_main_sorted = sorted(your_main)
+    draw_main_sorted = sorted(draw_main)
+    your_special_sorted = sorted(your_special)
+    draw_special_sorted = sorted(draw_special)
+
+    your_main_set = set(your_main)
+    your_special_set = set(your_special)
+    draw_main_set = set(draw_main)
+    draw_special_set = set(draw_special)
+
+    def fmt(value: int, hit: bool) -> str:
+        return f"[bold green]{value}[/bold green]" if hit else str(value)
+
+    table = Table(title="Ticket Comparison")
+    table.add_column("")
+    for i in range(len(your_main_sorted)):
+        table.add_column(f"Main {i + 1}")
+    for i in range(len(your_special_sorted)):
+        table.add_column(f"Special {i + 1}")
+
+    table.add_row(
+        "Your Numbers",
+        *[fmt(n, n in draw_main_set) for n in your_main_sorted],
+        *[fmt(n, n in draw_special_set) for n in your_special_sorted],
+    )
+    table.add_row(
+        "Winning Numbers",
+        *[fmt(n, n in your_main_set) for n in draw_main_sorted],
+        *[fmt(n, n in your_special_set) for n in draw_special_sorted],
+    )
+    console.print(table)
+
+    console.print(f"Main matches: {result.main_matches}/{result.main_count}")
+    console.print(f"Special matches: {result.special_matches}/{result.special_count}")

lucky/database/db.py

@@ -0,0 +1,19 @@
+from sqlalchemy import create_engine
+from sqlalchemy.engine import Engine
+from sqlalchemy.orm import Session, sessionmaker
+
+from ..config import get_db_path
+from .models import Base
+
+
+def get_engine() -> Engine:
+    db_path = get_db_path()
+    db_path.parent.mkdir(parents=True, exist_ok=True)
+    engine = create_engine(f"sqlite:///{db_path}")
+    Base.metadata.create_all(engine)
+    return engine
+
+
+def get_session() -> Session:
+    factory = sessionmaker(bind=get_engine())
+    return factory()

lucky/database/models.py

@@ -0,0 +1,34 @@
+import json
+
+from sqlalchemy import TEXT, String, UniqueConstraint
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+from sqlalchemy.types import TypeDecorator
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+class JSONIntList(TypeDecorator):
+    """Stores a list[int] as a JSON-encoded TEXT column."""
+
+    impl = TEXT
+    cache_ok = True
+
+    def process_bind_param(self, value, dialect):
+        return json.dumps(value if value is not None else [])
+
+    def process_result_value(self, value, dialect):
+        return json.loads(value) if value is not None else []
+
+
+class Draw(Base):
+    __tablename__ = "draws"
+    __table_args__ = (UniqueConstraint("game", "date", name="uq_draws_game_date"),)
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    game: Mapped[str] = mapped_column(String, nullable=False)
+    date: Mapped[str] = mapped_column(String, nullable=False)
+    main: Mapped[list[int]] = mapped_column(JSONIntList, nullable=False)
+    special: Mapped[list[int]] = mapped_column(JSONIntList, nullable=False)
+    jackpot: Mapped[str | None] = mapped_column(String, nullable=True)

lucky/database/repository.py

@@ -0,0 +1,57 @@
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from .models import Draw
+
+
+def latest_draw(session: Session, game: str) -> Draw | None:
+    stmt = select(Draw).where(Draw.game == game).order_by(Draw.date.desc()).limit(1)
+    return session.scalars(stmt).first()
+
+
+def history(session: Session, game: str, limit: int) -> list[Draw]:
+    stmt = select(Draw).where(Draw.game == game).order_by(Draw.date.desc()).limit(limit)
+    return list(session.scalars(stmt))
+
+
+def all_draws(session: Session, game: str) -> list[Draw]:
+    stmt = select(Draw).where(Draw.game == game).order_by(Draw.date.asc())
+    return list(session.scalars(stmt))
+
+
+def existing_dates(session: Session, game: str) -> set[str]:
+    stmt = select(Draw.date).where(Draw.game == game)
+    return set(session.scalars(stmt))
+
+
+def add_draw(session: Session, game: str, record) -> None:
+    session.add(
+        Draw(
+            game=game,
+            date=record.date,
+            main=record.main,
+            special=record.special,
+            jackpot=record.jackpot,
+        )
+    )
+
+
+def filter_new_records(session: Session, game: str, records: list) -> list:
+    existing = existing_dates(session, game)
+    seen: set[str] = set()
+    new_records = []
+    for r in records:
+        if r.date in existing or r.date in seen:
+            continue
+        seen.add(r.date)
+        new_records.append(r)
+    return new_records
+
+
+def upsert_draws(session: Session, game: str, records: list) -> int:
+    new_records = filter_new_records(session, game, records)
+    for record in new_records:
+        add_draw(session, game, record)
+    if new_records:
+        session.commit()
+    return len(new_records)

lucky/lottery/__init__.py

@@ -0,0 +1 @@
+from . import mega, powerball  # noqa: F401  -- side effect: registers both games

lucky/lottery/base.py

@@ -0,0 +1,57 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Game:
+    slug: str
+    name: str
+    main_count: int
+    main_range: tuple[int, int]
+    special_count: int
+    special_range: tuple[int, int] | None
+
+    def validate_ticket(self, main: list[int], special: list[int]) -> None:
+        if len(main) != self.main_count:
+            raise ValueError(
+                f"{self.name} requires exactly {self.main_count} main numbers, got {len(main)}"
+            )
+        if len(set(main)) != len(main):
+            raise ValueError("main numbers must be unique")
+        lo, hi = self.main_range
+        if any(not (lo <= n <= hi) for n in main):
+            raise ValueError(f"main numbers must be in range {lo}-{hi}")
+
+        if len(special) != self.special_count:
+            raise ValueError(
+                f"{self.name} requires exactly {self.special_count} special number(s), got {len(special)}"
+            )
+        if self.special_range is not None:
+            slo, shi = self.special_range
+            if any(not (slo <= n <= shi) for n in special):
+                raise ValueError(f"special numbers must be in range {slo}-{shi}")
+
+
+@dataclass(frozen=True)
+class Ticket:
+    main: list[int]
+    special: list[int]
+
+
+GAMES: dict[str, Game] = {}
+
+
+def register(game: Game) -> Game:
+    GAMES[game.slug] = game
+    return game
+
+
+def get_game(slug: str) -> Game:
+    try:
+        return GAMES[slug]
+    except KeyError:
+        choices = ", ".join(sorted(GAMES)) or "(none registered)"
+        raise ValueError(f"Unknown game '{slug}'. Choices: {choices}") from None
+
+
+def game_metavar() -> str:
+    return f"[{'|'.join(sorted(GAMES))}]"

lucky/lottery/checker.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class CheckResult:
+    main_matches: int
+    main_count: int
+    special_matches: int
+    special_count: int
+
+
+def check_ticket(
+    main: list[int],
+    special: list[int],
+    draw_main: list[int],
+    draw_special: list[int],
+) -> CheckResult:
+    return CheckResult(
+        main_matches=len(set(main) & set(draw_main)),
+        main_count=len(draw_main),
+        special_matches=len(set(special) & set(draw_special)),
+        special_count=len(draw_special),
+    )

lucky/lottery/generator.py

@@ -0,0 +1,16 @@
+import random
+
+from .base import Game, Ticket
+
+
+def generate_ticket(game: Game) -> Ticket:
+    main_lo, main_hi = game.main_range
+    main = sorted(random.sample(range(main_lo, main_hi + 1), game.main_count))
+
+    special: list[int] = []
+    if game.special_count:
+        assert game.special_range is not None
+        special_lo, special_hi = game.special_range
+        special = sorted(random.sample(range(special_lo, special_hi + 1), game.special_count))
+
+    return Ticket(main=main, special=special)

lucky/lottery/mega.py

@@ -0,0 +1,12 @@
+from .base import Game, register
+
+MEGA_MILLIONS = register(
+    Game(
+        slug="mega-millions",
+        name="Mega Millions",
+        main_count=5,
+        main_range=(1, 70),
+        special_count=1,
+        special_range=(1, 25),
+    )
+)

lucky/lottery/powerball.py

@@ -0,0 +1,12 @@
+from .base import Game, register
+
+POWERBALL = register(
+    Game(
+        slug="powerball",
+        name="Powerball",
+        main_count=5,
+        main_range=(1, 69),
+        special_count=1,
+        special_range=(1, 26),
+    )
+)

lucky/lottery/stats.py

@@ -0,0 +1,48 @@
+from collections import Counter
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class GameStats:
+    main_frequency: dict[int, int]
+    special_frequency: dict[int, int]
+    hot_main: list[int]
+    cold_main: list[int]
+    odd_count: int
+    even_count: int
+    total_draws: int
+
+
+def compute_stats(draws, top_n: int = 5) -> GameStats:
+    main_counter: Counter[int] = Counter()
+    special_counter: Counter[int] = Counter()
+    odd_count = 0
+    even_count = 0
+
+    for draw in draws:
+        main_counter.update(draw.main)
+        special_counter.update(draw.special)
+        for n in draw.main:
+            if n % 2 == 0:
+                even_count += 1
+            else:
+                odd_count += 1
+
+    def ranked(reverse: bool) -> list[int]:
+        return [
+            number
+            for number, _ in sorted(main_counter.items(), key=lambda item: (-item[1] if reverse else item[1], item[0]))
+        ]
+
+    hot_main = ranked(reverse=True)[:top_n]
+    cold_main = ranked(reverse=False)[:top_n]
+
+    return GameStats(
+        main_frequency=dict(main_counter),
+        special_frequency=dict(special_counter),
+        hot_main=hot_main,
+        cold_main=cold_main,
+        odd_count=odd_count,
+        even_count=even_count,
+        total_draws=len(draws),
+    )

lucky/updater/client.py

@@ -0,0 +1,7 @@
+from .sources import DataSource, DrawRecord, FixtureSource
+
+_source: DataSource = FixtureSource()
+
+
+def get_draws(game_slug: str) -> list[DrawRecord]:
+    return _source.fetch(game_slug)

lucky/updater/fixtures/mega-millions.json

@@ -0,0 +1,4 @@
+[
+  {"date": "2026-06-13", "main": [5, 19, 27, 41, 63], "special": [22], "jackpot": "$89,000,000"},
+  {"date": "2026-06-17", "main": [3, 11, 24, 36, 58], "special": [15], "jackpot": "$96,000,000"}
+]

lucky/updater/fixtures/powerball.json

@@ -0,0 +1,5 @@
+[
+  {"date": "2026-06-14", "main": [12, 18, 33, 44, 61], "special": [9], "jackpot": "$135,000,000"},
+  {"date": "2026-06-16", "main": [5, 9, 27, 41, 63], "special": [21], "jackpot": "$142,000,000"},
+  {"date": "2026-06-18", "main": [2, 14, 29, 38, 55], "special": [3], "jackpot": "$150,000,000"}
+]

lucky/updater/sources.py

@@ -0,0 +1,35 @@
+import json
+from dataclasses import dataclass
+from importlib.resources import files
+from typing import Protocol
+
+
+@dataclass(frozen=True)
+class DrawRecord:
+    date: str
+    main: list[int]
+    special: list[int]
+    jackpot: str | None
+
+
+class DataSource(Protocol):
+    def fetch(self, game_slug: str) -> list[DrawRecord]: ...
+
+
+class FixtureSource:
+    """Reads bundled per-game JSON fixtures as if they were a remote API response."""
+
+    def fetch(self, game_slug: str) -> list[DrawRecord]:
+        resource = files("lucky.updater.fixtures").joinpath(f"{game_slug}.json")
+        if not resource.is_file():
+            raise FileNotFoundError(f"No fixture data for game '{game_slug}'")
+        rows = json.loads(resource.read_text())
+        return [
+            DrawRecord(
+                date=row["date"],
+                main=row["main"],
+                special=row["special"],
+                jackpot=row.get("jackpot"),
+            )
+            for row in rows
+        ]

lucky/updater/updater.py

@@ -0,0 +1,32 @@
+import logging
+
+from sqlalchemy.orm import Session
+
+from ..console.rich import update_progress
+from ..database import repository
+from ..lottery.base import GAMES
+from . import client
+
+logger = logging.getLogger(__name__)
+
+
+def sync_game(session: Session, slug: str) -> int:
+    records = client.get_draws(slug)
+    new_records = repository.filter_new_records(session, slug, records)
+    if not new_records:
+        return 0
+
+    with update_progress(slug, total=len(new_records)) as advance:
+        for record in new_records:
+            repository.add_draw(session, slug, record)
+            advance()
+        session.commit()
+    return len(new_records)
+
+
+def sync_all(session: Session) -> None:
+    for slug in GAMES:
+        try:
+            sync_game(session, slug)
+        except Exception:
+            logger.debug("Update failed for %s; falling back to cached data", slug, exc_info=True)

lucky_cli-0.0.3.dist-info/METADATA

@@ -0,0 +1,141 @@
+Metadata-Version: 2.4
+Name: lucky-cli
+Version: 0.0.3
+Summary: A lottery CLI tool built with Python for fun
+License: MIT License
+        
+        Copyright (c) 2026 PyDeployer
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: rich>=15.0.0
+Requires-Dist: sqlalchemy>=2.0
+Requires-Dist: typer>=0.26.7
+Dynamic: license-file
+
+# lucky-cli
+
+A lottery CLI tool built with Python for fun. Installed command: `lucky`.
+
+Supports Powerball (5 numbers 1–69 + special 1–26) and Mega Millions (5 numbers 1–70 + special 1–25).
+
+## Install (dev)
+
+```bash
+uv sync
+uv run lucky --help
+```
+
+## Usage
+
+| Command | Description |
+|---|---|
+| `lucky pick <game> [--count N]` | Generate N valid random tickets |
+| `lucky check <game> <n1..n5> --special <s>` | Check a ticket against the latest draw |
+| `lucky show <game>` | Show the latest draw (date, numbers, special, jackpot) — default view |
+| `lucky show <game> --history [--limit N]` | Show the last N draws |
+| `lucky show <game> --stats` | Show number frequency, hot/cold numbers, odd/even distribution |
+| `lucky --version` | Show the installed version |
+
+Example:
+
+```bash
+lucky check powerball 12 18 33 44 61 --special 9
+```
+
+On every run, `lucky` checks for new draws and updates its local SQLite cache (`~/.lucky-cli/lucky.db`) before executing your command. If offline, it silently falls back to the cached data.
+
+## Project layout
+
+```
+src/lucky/
+├── cli.py            # Typer app entrypoint
+├── commands/         # one module per subcommand
+├── lottery/          # game rules + ticket generator
+├── database/         # SQLAlchemy models/repository
+├── updater/          # remote source + sync logic
+└── console/          # Rich rendering helpers
+tests/
+```
+
+See [CLAUDE.md](CLAUDE.md) for the full architecture spec.
+
+## Development
+
+```bash
+uv sync              # install deps
+uv run pytest        # run tests
+uv run lucky <cmd>   # exercise the CLI locally
+```
+
+## Contributing
+
+- Commits follow [Conventional Commits](https://www.conventionalcommits.org/): `feat:`, `fix:`, `docs:`, `refactor:`, `test:`, `chore:`. Use `feat!:` or a `BREAKING CHANGE:` footer for breaking changes.
+- Versioning is automated from git tags (`setuptools-scm`) — never hand-edit a version string.
+- Route all CLI output through `src/lucky/console/`; avoid raw `print()`.
+- Add/update tests under `tests/` for any change to generator, stats, checker, or database logic.
+- CI publishes to PyPI on `v*` tags via `.github/workflows/release.yml`.
+
+## Releasing / Versioning
+
+Version numbers are never hand-edited — they're derived from git tags via `setuptools-scm`. To cut a release:
+
+1. Find the last release tag (skip if this is the first release):
+   ```bash
+   git describe --tags --abbrev=0
+   ```
+2. Review commits since that tag:
+   ```bash
+   git log <last-tag>..HEAD --oneline
+   ```
+3. Classify them by [Conventional Commits](https://www.conventionalcommits.org/) prefix to decide the version bump:
+   - `feat:` → MINOR
+   - `fix:` → PATCH
+   - `feat!:` or a `BREAKING CHANGE:` footer → MAJOR
+   - (first release with no prior tag: start at `v0.1.0`)
+4. Add a new section to `CHANGELOG.md`, grouped by category:
+   ```md
+   ## v0.3.0
+
+   ### Features
+   - add stats command
+
+   ### Fixes
+   - fix check logic
+   ```
+5. Commit the changelog update, then create and push the tag:
+   ```bash
+   git add CHANGELOG.md
+   git commit -m "chore: release v0.3.0"
+   git tag v0.3.0
+   git push origin main v0.3.0
+   ```
+6. Pushing the tag triggers `.github/workflows/release.yml`, which runs the test suite, builds the package, and publishes to PyPI using the `PYPI_API_TOKEN` secret — nothing else to do manually.
+
+## Development process
+
+This project is built with [Claude Code](https://claude.com/claude-code) using the Superpowers plugin as its development framework — brainstorming a design spec, writing an implementation plan, then executing it task-by-task with subagent-driven TDD and code review before each merge.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

lucky_cli-0.0.3.dist-info/RECORD

@@ -0,0 +1,34 @@
+lucky/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lucky/cli.py,sha256=NUQCRtmyoTlW3xr0x-y-HGzMwEZXL82Np-eH4MVa8B0,1130
+lucky/config.py,sha256=jmXivLKSgE3WWFzPVvmiIZWLdZMeHS5Pcaqtd76YzoY,209
+lucky/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lucky/commands/check.py,sha256=6lL6NRD3RhKIembtUZlTIMC_jQ__F2R-JWS6s3aM3gE,1530
+lucky/commands/pick.py,sha256=E1UoO4taUEbTs9s55BCjWyx7nM48tcbQ-F7eYMNP9DA,752
+lucky/commands/show.py,sha256=lzQRO0fMhUbnLO4fFY0zjJkCx70En4Ji1hV5JpoHnGE,1700
+lucky/console/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lucky/console/rich.py,sha256=BC8aSdWmPfsVAC5KeO0BqfgkBq7qig1WFge4OxeeP3Y,4255
+lucky/database/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lucky/database/db.py,sha256=f9T8SyDckbUPpgUTeqKV6_cOx4ISSliAQQPp855tiEo,499
+lucky/database/models.py,sha256=AQBHsDPHHinWYdsnEUQBvnj_wA2Q4yMxLmUBZkrHlJA,1108
+lucky/database/repository.py,sha256=mbXasRZnhgIVzEwrBbS3u1M0pZiuWkFq5kHTFgk1tjU,1687
+lucky/lottery/__init__.py,sha256=MT3dhjv9bafpKopFOPSV3UZWTPWt_P91kFUJLdhjWKQ,82
+lucky/lottery/base.py,sha256=DZ8ez4yNbg87zMyydqK81IViN7VbkvP2ga_ww0OdogA,1661
+lucky/lottery/checker.py,sha256=h4x-IVEPyatUxG7zUJehpUVjiOnZNeyHuoQt7aFOhA4,530
+lucky/lottery/generator.py,sha256=UiM7OBrdfdrH7lBsAdGzEEbdN5RXXIfq9ayssa9D8rQ,505
+lucky/lottery/mega.py,sha256=2HZecjIG9LNXXZy6UqyrqNitHQYUvXlCOIzz5oh3lSU,244
+lucky/lottery/powerball.py,sha256=CtnYs-ke5LP78w2CMMHIfusEr0_grX4HjG7EiS2bkNk,232
+lucky/lottery/stats.py,sha256=mm_NvtM4q_OOAwX_6b5K070d5u8jV7vjFn5tMDoGDFY,1289
+lucky/updater/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lucky/updater/client.py,sha256=iXuSTzKJfOXDKPX_JJ2o_bguqlBUBanmDY6qpNwPdbM,187
+lucky/updater/sources.py,sha256=eerYD3Vtd5sTY9VDihFdrI5Y0VMOh-1RLR4jzPPwv_U,983
+lucky/updater/updater.py,sha256=B5Tf6ET5mZ98c-4z194_HhncB8h8L-9qfkr_gy1k_Wc,897
+lucky/updater/fixtures/mega-millions.json,sha256=iG4wPzMOnNe95T2pncU5s-LAoEcwrLrINaHGFshylZA,199
+lucky/updater/fixtures/powerball.json,sha256=RLsEGahCLeRe4ngJCQf4U8CM3RP13ej4Ly6E_gwoKbU,298
+lucky_cli-0.0.3.dist-info/licenses/LICENSE,sha256=qqF1Zf1Z0TinvV92LGdwefIOPedisg9Eut7nrMFRKms,1067
+lucky_cli-0.0.3.dist-info/METADATA,sha256=IyC1y2DK5fxsPXpC65qHNmLVdeVk-d9VMC9fSa181n8,5307
+lucky_cli-0.0.3.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+lucky_cli-0.0.3.dist-info/entry_points.txt,sha256=81gNUKt-U-x2nbT0AU9kScWulDzMWGhbzzCNhwF_iIg,40
+lucky_cli-0.0.3.dist-info/scm_file_list.json,sha256=nz6yoBqqevDlHTJb6nn3SZeglniyNnYSgi4v9Y_GW3M,1743
+lucky_cli-0.0.3.dist-info/scm_version.json,sha256=x9sIn6TrwxSWq1vxhGPRLE3e9qrll_LI-Kg5ZaQ2ujA,160
+lucky_cli-0.0.3.dist-info/top_level.txt,sha256=qC4BUwFImNyKkiZlGP2y4HecuUv4DppyIXN7wTt1TlI,6
+lucky_cli-0.0.3.dist-info/RECORD,,

lucky_cli-0.0.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

lucky_cli-0.0.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+lucky = lucky.cli:app

lucky_cli-0.0.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PyDeployer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lucky_cli-0.0.3.dist-info/scm_file_list.json

@@ -0,0 +1,58 @@
+{
+  "files": [
+    "README.md",
+    "uv.lock",
+    ".python-version",
+    "LICENSE",
+    "pyproject.toml",
+    "AGENTS.md",
+    "CLAUDE.md",
+    ".gitignore",
+    "docs/superpowers/specs/2026-06-21-lucky-cli-design.md",
+    "docs/superpowers/plans/2026-06-21-lucky-cli-v1.md",
+    "src/lucky/__init__.py",
+    "src/lucky/config.py",
+    "src/lucky/cli.py",
+    "src/lucky/commands/__init__.py",
+    "src/lucky/commands/pick.py",
+    "src/lucky/commands/show.py",
+    "src/lucky/commands/check.py",
+    "src/lucky/updater/updater.py",
+    "src/lucky/updater/__init__.py",
+    "src/lucky/updater/sources.py",
+    "src/lucky/updater/client.py",
+    "src/lucky/updater/fixtures/powerball.json",
+    "src/lucky/updater/fixtures/mega-millions.json",
+    "src/lucky/console/__init__.py",
+    "src/lucky/console/rich.py",
+    "src/lucky/lottery/mega.py",
+    "src/lucky/lottery/generator.py",
+    "src/lucky/lottery/powerball.py",
+    "src/lucky/lottery/__init__.py",
+    "src/lucky/lottery/stats.py",
+    "src/lucky/lottery/checker.py",
+    "src/lucky/lottery/base.py",
+    "src/lucky/database/__init__.py",
+    "src/lucky/database/repository.py",
+    "src/lucky/database/models.py",
+    "src/lucky/database/db.py",
+    "tests/test_command_pick.py",
+    "tests/test_models.py",
+    "tests/test_repository.py",
+    "tests/test_command_check.py",
+    "tests/test_client.py",
+    "tests/test_console.py",
+    "tests/test_command_show.py",
+    "tests/test_stats.py",
+    "tests/conftest.py",
+    "tests/test_base.py",
+    "tests/test_updater.py",
+    "tests/test_games.py",
+    "tests/test_sources.py",
+    "tests/test_generator.py",
+    "tests/test_cli.py",
+    "tests/test_checker.py",
+    "tests/test_db.py",
+    ".github/workflows/release.yml"
+  ]
+}

lucky_cli-0.0.3.dist-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.0.3",
+  "distance": 0,
+  "node": "g6e695db495be1678ad07637936dbcbabc4ef8f68",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-06-25"
+}

lucky_cli-0.0.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+lucky