fastvex 0.0.1__py3-none-any.whl

fastvex/__init__.py

@@ -0,0 +1,2 @@
+__all__ = ["__version__"]
+__version__ = "0.1.0"

fastvex/cli.py

@@ -0,0 +1,383 @@
+from __future__ import annotations
+
+import sys
+from typing import Annotated
+
+import click
+import typer
+
+from .display import print_execution_result, print_history, print_show, print_upload_plan
+from .services import (
+    HistoryCleanReport,
+    UploadRequest,
+    clean_history,
+    get_history,
+    init_project,
+    plan_upload,
+    set_route,
+    show_project,
+    show_routes,
+    upload_slots,
+    validate_project,
+)
+from .storage import ValidationError
+from .theme import FAIL, INFO, OK, WARN, confirm, console
+
+CommonConfig = Annotated[str | None, typer.Option("--config", help="Config file path.")]
+CommonState = Annotated[str | None, typer.Option("--state", help="State file path.")]
+
+app = typer.Typer(
+    name="fastvex",
+    help="Fast VEX slot-oriented build/upload manager.",
+    invoke_without_command=True,
+)
+history_app = typer.Typer(help="Show or clean history.")
+route_app = typer.Typer(help="Show or set active route by route set.")
+app.add_typer(history_app, name="history")
+app.add_typer(route_app, name="route")
+
+
+def rprint(*args, **kwargs) -> None:
+    """Rich-aware print: uses console.print unless an explicit file= is given."""
+    file = kwargs.pop("file", None)
+    if file is not None:
+        kwargs.setdefault("sep", " ")
+        kwargs.setdefault("end", "\n")
+        kwargs.setdefault("flush", False)
+        print(*args, file=file, **kwargs)
+    else:
+        console.print(*args, **kwargs)
+
+
+def _ctx_options(ctx: typer.Context, config: str | None, state: str | None) -> dict[str, str | None]:
+    obj = ctx.obj or {}
+    return {
+        "config": config if config is not None else obj.get("config"),
+        "state": state if state is not None else obj.get("state"),
+    }
+
+
+def _print_legacy_warning(legacy_config: bool, config_path: object) -> None:
+    if legacy_config:
+        rprint(f"  [yellow]{WARN} using legacy config name:[/yellow] {config_path}")
+
+
+def _finish(code: int) -> None:
+    if code:
+        raise typer.Exit(code)
+
+
+def _upload_request(
+    *,
+    slots: str | None = None,
+    group: str | None = None,
+    all_enabled: bool = False,
+    robot_name: str | None = None,
+    port: str | None = None,
+    clean: bool = False,
+    quiet: bool = False,
+    dry_run: bool = False,
+    yes: bool = False,
+) -> UploadRequest:
+    return UploadRequest(
+        slots=slots,
+        group=group,
+        all_enabled=all_enabled,
+        robot_name=robot_name,
+        port=port,
+        clean=clean,
+        quiet=quiet,
+        dry_run=dry_run,
+        yes=yes,
+    )
+
+
+def run_default_interactive(config: str | None = None, state: str | None = None) -> int:
+    report = show_project(config=config, state=state)
+    _print_legacy_warning(report.paths.legacy_config, report.paths.config)
+    print_show(report.config, report.state)
+
+    rprint("  [bold cyan]Select upload target:[/bold cyan]")
+    rprint("    [dim]slot list[/dim]  e.g. [green]1,3,5[/green]")
+    rprint("    [dim]group:name[/dim]  e.g. [green]group:comp-default[/green]")
+    rprint("    [dim]all[/dim]         upload all enabled slots")
+    rprint("    [dim]q[/dim]           quit")
+    rprint()
+
+    raw = console.input("  [cyan]target[/cyan]> ").strip()
+    if not raw or raw.lower() in {"q", "quit", "exit"}:
+        rprint("\n  [blue]bye[/blue]\n")
+        return 0
+
+    request = _upload_request()
+    if raw.lower() == "all":
+        request = _upload_request(all_enabled=True)
+    elif raw.lower().startswith("group:"):
+        request = _upload_request(group=raw.split(":", 1)[1].strip())
+    else:
+        request = _upload_request(slots=raw)
+
+    planned = plan_upload(request, config=config, state=state)
+    paths, loaded_config, _, slots, _, _ = planned
+    _print_legacy_warning(paths.legacy_config, paths.config)
+    print_upload_plan(loaded_config, slots)
+    if not confirm(
+        "  [yellow]Continue upload?[/yellow] [[green]Y[/green]/[red]n[/red]] (Enter for 'Y'): ",
+        default_yes=True,
+    ):
+        rprint(f"\n  [yellow]{WARN} aborted[/yellow]\n")
+        return 0
+
+    report = upload_slots(request, config=config, state=state)
+    if report.execution:
+        print_execution_result(report.execution)
+    return 1 if report.failed_slots else 0
+
+
+@app.callback()
+def root(
+    ctx: typer.Context,
+    config: CommonConfig = None,
+    state: CommonState = None,
+) -> None:
+    ctx.obj = {"config": config, "state": state}
+    if ctx.invoked_subcommand is None:
+        _finish(run_default_interactive(config=config, state=state))
+
+
+@app.command("init")
+def init_command(
+    ctx: typer.Context,
+    config: CommonConfig = None,
+    state: CommonState = None,
+) -> None:
+    options = _ctx_options(ctx, config, state)
+    report = init_project(**options)
+
+    if report.config_exists:
+        rprint(f"  [cyan]config exists:[/cyan] {report.paths.config}")
+    elif report.legacy_config_exists:
+        rprint(f"  [yellow]{WARN} legacy config exists:[/yellow] {report.paths.root / 'vex_upload_config.yaml'}")
+        rprint("  [dim]fastvex init will not migrate or overwrite configs.[/dim]")
+    elif report.config_created:
+        rprint(f"  [green]created config:[/green] {report.paths.config}")
+
+    if report.state_exists:
+        rprint(f"  [cyan]state exists:[/cyan] {report.paths.state}")
+    elif report.state_created:
+        rprint(f"  [green]created state:[/green] {report.paths.state}")
+
+    rprint(f"\n  [bold green]{OK} init ok[/bold green]\n")
+
+
+@app.command("show")
+def show_command(
+    ctx: typer.Context,
+    config: CommonConfig = None,
+    state: CommonState = None,
+) -> None:
+    report = show_project(**_ctx_options(ctx, config, state))
+    _print_legacy_warning(report.paths.legacy_config, report.paths.config)
+    print_show(report.config, report.state)
+
+
+@app.command("validate")
+def validate_command(
+    ctx: typer.Context,
+    config: CommonConfig = None,
+    state: CommonState = None,
+) -> None:
+    report = validate_project(**_ctx_options(ctx, config, state))
+    _print_legacy_warning(report.paths.legacy_config, report.paths.config)
+    for warning in report.warnings:
+        rprint(f"  {WARN} {warning}")
+    rprint(f"\n  [bold green]{OK} validate ok[/bold green]\n")
+
+
+@app.command("upload")
+def upload_command(
+    ctx: typer.Context,
+    config: CommonConfig = None,
+    state: CommonState = None,
+    slots: Annotated[str | None, typer.Option("--slots", help="Slot list, e.g. '1,3,5'.")] = None,
+    group: Annotated[str | None, typer.Option("--group", help="Group name defined in config.")] = None,
+    all_enabled: Annotated[
+        bool,
+        typer.Option("--all-enabled", help="Target all configured slots."),
+    ] = False,
+    robot_name: Annotated[str | None, typer.Option("--robot-name", help="Override robot name.")] = None,
+    port: Annotated[str | None, typer.Option("--port", help="Override port. Empty means auto.")] = None,
+    clean: Annotated[bool, typer.Option("--clean", help="Run make clean before build.")] = False,
+    quiet: Annotated[bool, typer.Option("--quiet", help="Capture build/upload output.")] = False,
+    dry_run: Annotated[bool, typer.Option("--dry-run", help="Plan without build/upload.")] = False,
+    yes: Annotated[bool, typer.Option("-y", "--yes", help="Skip confirm prompt.")] = False,
+) -> None:
+    options = _ctx_options(ctx, config, state)
+    request = _upload_request(
+        slots=slots,
+        group=group,
+        all_enabled=all_enabled,
+        robot_name=robot_name,
+        port=port,
+        clean=clean,
+        quiet=quiet,
+        dry_run=dry_run,
+        yes=yes,
+    )
+    paths, loaded_config, _, selected_slots, _, _ = plan_upload(request, **options)
+    _print_legacy_warning(paths.legacy_config, paths.config)
+    print_upload_plan(loaded_config, selected_slots)
+
+    if not yes and not dry_run:
+        if not confirm(
+            "  [yellow]Continue upload?[/yellow] [[green]Y[/green]/[red]n[/red]] (Enter for 'Y'): ",
+            default_yes=True,
+        ):
+            rprint(f"\n  [yellow]{WARN} aborted[/yellow]\n")
+            return
+
+    report = upload_slots(request, **options)
+    if report.execution:
+        print_execution_result(report.execution)
+    _finish(1 if report.failed_slots else 0)
+
+
+@history_app.callback()
+def history_root(
+    ctx: typer.Context,
+    config: CommonConfig = None,
+    state: CommonState = None,
+) -> None:
+    parent = ctx.parent.obj if ctx.parent and ctx.parent.obj else {}
+    ctx.obj = {
+        "config": config if config is not None else parent.get("config"),
+        "state": state if state is not None else parent.get("state"),
+    }
+
+
+@history_app.command("show")
+def history_show_command(
+    ctx: typer.Context,
+    config: CommonConfig = None,
+    state: CommonState = None,
+) -> None:
+    report = get_history(**_ctx_options(ctx, config, state))
+    _print_legacy_warning(report.paths.legacy_config, report.paths.config)
+    rprint()
+    if not report.state.history:
+        rprint("  [dim](empty)[/dim]")
+    else:
+        print_history(report.state.history)
+
+
+@history_app.command("clean")
+def history_clean_command(
+    ctx: typer.Context,
+    config: CommonConfig = None,
+    state: CommonState = None,
+    keep: Annotated[int, typer.Option("--keep", help="Number of entries to keep.")] = 10,
+) -> None:
+    report: HistoryCleanReport = clean_history(**_ctx_options(ctx, config, state), keep=keep)
+    _print_legacy_warning(report.paths.legacy_config, report.paths.config)
+    if report.removed_count == 0:
+        rprint(f"  [dim]history has {report.kept_count} entries, no cleanup needed (keep={keep})[/dim]")
+    else:
+        rprint(
+            f"  [green]{OK} cleaned[/green] {report.removed_count} "
+            f"[dim]old entries, kept last[/dim] {report.kept_count}"
+        )
+
+
+@route_app.callback()
+def route_root(
+    ctx: typer.Context,
+    config: CommonConfig = None,
+    state: CommonState = None,
+) -> None:
+    parent = ctx.parent.obj if ctx.parent and ctx.parent.obj else {}
+    ctx.obj = {
+        "config": config if config is not None else parent.get("config"),
+        "state": state if state is not None else parent.get("state"),
+    }
+
+
+@route_app.command("show")
+def route_show_command(
+    ctx: typer.Context,
+    config: CommonConfig = None,
+    state: CommonState = None,
+) -> None:
+    from .theme import role_tone
+
+    report = show_routes(**_ctx_options(ctx, config, state))
+    _print_legacy_warning(report.paths.legacy_config, report.paths.config)
+    loaded_config = report.config
+
+    rprint()
+    route_items = []
+    for route_set in sorted(loaded_config.active_route.keys()):
+        color, _ = role_tone(route_set, "COMP")
+        key = loaded_config.active_route[route_set]
+        route_items.append(f"[bold {color}]{route_set}[/bold {color}]:[{color}]{key}[/{color}]")
+
+    rprint("  [bold cyan]Active Routes[/bold cyan]")
+    rprint(f"  {'   '.join(route_items)}")
+    rprint()
+
+    rprint("  [bold cyan]Available Routes[/bold cyan]")
+    for route_set in sorted(loaded_config.routes.keys()):
+        color, _ = role_tone(route_set, "COMP")
+        active_key = loaded_config.active_route.get(route_set)
+
+        rprint(f"\n  [bold {color}]{route_set}[/bold {color}]")
+        for key, opt in loaded_config.routes[route_set].items():
+            is_active = key == active_key
+            marker = f"[green]{OK}[/green] " if is_active else "    "
+            active_tag = " [green](active)[/green]" if is_active else ""
+            rprint(
+                f"    {marker}[cyan]{key}[/cyan]  "
+                f"route={opt.route}  routeName={opt.route_name}{active_tag}"
+            )
+    rprint()
+
+
+@route_app.command("set")
+def route_set_command(
+    ctx: typer.Context,
+    route_set: str,
+    route_key: str,
+    config: CommonConfig = None,
+    state: CommonState = None,
+) -> None:
+    from .theme import role_tone
+
+    report = set_route(route_set, route_key, **_ctx_options(ctx, config, state))
+    _print_legacy_warning(report.paths.legacy_config, report.paths.config)
+    if not report.changed:
+        rprint(f"\n  [dim]{INFO} route unchanged:[/dim] {report.route_set}={report.new_key}\n")
+        return
+
+    color, _ = role_tone(report.route_set, "COMP")
+    rprint(
+        f"\n  [bold green]{OK} updated active route:[/bold green] "
+        f"[bold {color}]{report.route_set}[/bold {color}] [dim]{report.old_key}[/dim] "
+        f"[cyan]→[/cyan] [bold {color}]{report.new_key}[/bold {color}]\n"
+    )
+
+
+def main(argv: list[str] | None = None) -> int:
+    try:
+        app(args=argv, prog_name="fastvex", standalone_mode=False)
+        return 0
+    except click.exceptions.Exit as exc:
+        return int(exc.exit_code)
+    except ValidationError as exc:
+        print(f"\n  [bold red]{FAIL} validation error:[/bold red] {exc}\n", file=sys.stderr)
+        return 2
+    except KeyboardInterrupt:
+        print(f"\n  [yellow]{WARN} interrupted[/yellow]\n", file=sys.stderr)
+        return 130
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

fastvex/config_edit.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from .storage import ValidationError
+
+
+def replace_active_route_in_text(text: str, route_set: str, route_key: str) -> str:
+    """Text-based replacement to keep YAML comments/formatting intact."""
+    lines = text.splitlines()
+    in_active = False
+    found = False
+    for idx, line in enumerate(lines):
+        stripped = line.strip()
+        if stripped == "activeRoute:":
+            in_active = True
+            continue
+        if in_active:
+            if stripped and not line.startswith("  "):
+                break
+            key_prefix = f"  {route_set}:"
+            if line.startswith(key_prefix):
+                lines[idx] = f"  {route_set}: {route_key}"
+                found = True
+                break
+    if not found:
+        raise ValidationError(f"failed to update activeRoute.{route_set} in config file")
+    return "\n".join(lines) + "\n"

fastvex/display.py

@@ -0,0 +1,197 @@
+from __future__ import annotations
+
+from typing import Any
+
+from rich.panel import Panel
+from rich.text import Text
+
+from .models import mode_to_camel, resolve_profile
+from .state_model import ExecutionRecord, State, StateSlotEntry
+from .theme import FAIL, OK, ROCKET, WARN, console, role_tone
+
+
+def _role_style(route_set: str, mode: str) -> str:
+    color, is_dim = role_tone(route_set, mode)
+    return f"bold {color}" if not is_dim else color
+
+
+def _render_program_name(config: Any, profile: Any) -> str:
+    """Render the same program name used by upload."""
+    mode_camel = mode_to_camel(profile.mode)
+    robot_name = config.defaults.robot_name
+    route_suffix = f"-{profile.route_name}" if profile.route > 0 and profile.route_name else ""
+    return config.defaults.name_template.format(
+        modeCamel=mode_camel,
+        routeSuffix=route_suffix,
+        robotName=robot_name,
+    )
+
+
+def print_show(config: Any, state: State) -> None:
+    """Display the full show output: routes, slot mapping, current slots, history."""
+    from .theme import role_tone as _rt
+
+    route_items = []
+    for route_set in sorted(config.active_route.keys()):
+        color, _ = _rt(route_set, "COMP")
+        key = config.active_route[route_set]
+        route_items.append(Text(f"{route_set}:{key}", style=f"bold {color}"))
+
+    print()
+    console.print("  [bold cyan]Active Routes[/bold cyan]")
+    for item in route_items:
+        console.print(f"  {item}", end="  ")
+    console.print()
+    print()
+
+    console.print("  [bold cyan]Slot Mapping[/bold cyan]")
+    _print_slot_table(config)
+    print()
+
+    console.print("  [bold cyan]Last Known Slots[/bold cyan]")
+    if not state.current_slots:
+        console.print("  [dim](empty)[/dim]")
+    else:
+        _print_current_slots(state.current_slots)
+    print()
+
+    console.print("  [bold cyan]Recent History[/bold cyan]")
+    if not state.history:
+        console.print("  [dim](empty)[/dim]")
+    else:
+        for i, item in enumerate(reversed(state.history), 1):
+            _print_history_compact(item, i)
+    print()
+
+
+def _print_slot_table(config: Any) -> None:
+    """Print slot mapping: slot -> program name, route key, route name."""
+    for slot in range(1, 9):
+        resolved = resolve_profile(config, slot)
+        prog_name = _render_program_name(config, resolved)
+        route_display = f"[{resolved.route_key}] {resolved.route_name}"
+        color, _ = role_tone(resolved.route_set, resolved.mode)
+
+        console.print(
+            f"  [white]Slot {slot}[/white]  "
+            f"[{color}]{prog_name}[/{color}]  "
+            f"[dim]{route_display}[/dim]"
+        )
+
+
+def _print_current_slots(current: dict[int, StateSlotEntry]) -> None:
+    """Print current slots as formatted lines."""
+    for slot in range(1, 9):
+        entry = current.get(slot)
+        if not entry:
+            console.print(f"  [dim]Slot {slot}: (unknown)[/dim]")
+        else:
+            style = _role_style(entry.route_set, entry.mode)
+            console.print(
+                f"  [bold {style}]Slot {slot}[/bold {style}]  "
+                f"[{style}]{entry.profile_id}[/{style}]  "
+                f"[green]{ROCKET}[/green]  "
+                f"[green]{entry.final_name}[/green]"
+            )
+
+
+def _print_history_compact(item: ExecutionRecord, index: int) -> None:
+    """Print one history entry as a compact single line."""
+    line = Text()
+    line.append(f"  #{index:<2}  ")
+
+    if item.status == "success":
+        line.append(OK, style="green")
+        line.append(" success   ")
+    elif item.status == "failed":
+        line.append(FAIL, style="bold red")
+        line.append(" failed    ")
+    else:
+        line.append(WARN, style="yellow")
+        line.append(f" {item.status:<8}")
+
+    time_str = item.started_at[11:19] if len(item.started_at) > 19 else ""
+    line.append(f"  {time_str:<8}", style="dim")
+    line.append(f"  {item.username:<15}")
+
+    slot_list = ",".join(str(slot) for slot in item.requested_slots) if item.requested_slots else "-"
+    line.append(f"  {slot_list:<5}", style="bold")
+    line.append(f"  {item.duration_sec}s")
+
+    for result in item.results:
+        if not result.build.ok:
+            line.append(f"  build={FAIL}", style="bold red")
+        if not result.upload.ok:
+            line.append(f"  upload={FAIL}", style="bold red")
+
+    if item.dry_run:
+        line.append("  [dry]", style="dim")
+
+    console.print(line)
+
+
+def print_history(hist: list[ExecutionRecord]) -> None:
+    """Print the full history list."""
+    if not hist:
+        console.print("  [dim](empty)[/dim]")
+        return
+    for i, item in enumerate(reversed(hist), 1):
+        _print_history_compact(item, i)
+
+
+def print_upload_plan(config: Any, slots: list[int]) -> None:
+    """Print the upload plan as a simple list."""
+    console.print()
+    for slot in slots:
+        profile = resolve_profile(config, slot)
+        prog_name = _render_program_name(config, profile)
+        route_display = f"[{profile.route_key}] {profile.route_name}"
+        color, _ = role_tone(profile.route_set, profile.mode)
+        console.print(
+            f"  [white]Slot {slot}[/white]  "
+            f"[{color}]{prog_name}[/{color}]  "
+            f"[dim]{route_display}[/dim]"
+        )
+    console.print()
+
+
+def print_execution_result(execution: ExecutionRecord) -> None:
+    """Print a summary panel after upload completes."""
+    failed = [result for result in execution.results if not (result.build.ok and result.upload.ok)]
+    user_info = f"{execution.username}@{execution.hostname}"
+
+    if execution.status == "success":
+        status_display = Text(f"{OK} success", style="bold green")
+    elif execution.status == "failed":
+        status_display = Text(f"{FAIL} failed", style="bold red")
+    else:
+        status_display = Text(f"{WARN} {execution.status}", style="yellow")
+
+    if execution.dry_run:
+        status_display.append(" [dry-run]", style="dim")
+
+    lines: list[Text] = [
+        status_display,
+        Text(f"{ROCKET}  [dim]{user_info}[/dim]"),
+        Text(f"Duration: {execution.duration_sec}s"),
+        Text(f"Slots: {len(execution.results)} total"),
+    ]
+
+    if failed:
+        lines.append(Text(""))
+        lines.append(Text(f"{FAIL} Failed slots:", style="bold red"))
+        for result in failed:
+            lines.append(Text(f"  slot {result.slot}:"))
+            if result.build.error:
+                lines.append(Text(f"    build: {result.build.error}", style="red"))
+            if result.upload.error:
+                lines.append(Text(f"    upload: {result.upload.error}", style="red"))
+    else:
+        lines.append(Text(f"{OK} All slots OK", style="green"))
+
+    panel = Panel(
+        Text("\n").join(lines),
+        border_style="cyan",
+        padding=(0, 1),
+    )
+    console.print(panel)