gardusig-cli 0.1.0__py3-none-any.whl

cli/__init__.py

@@ -0,0 +1,3 @@
+"""cli: git shortcuts and backup/sync workflows."""
+
+__version__ = "0.1.0"

cli/__main__.py

@@ -0,0 +1,4 @@
+from cli.cli import run
+
+if __name__ == "__main__":
+    run()

cli/cli.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+import typer
+
+from cli import __version__
+from cli.commands.backup import backup_app
+from cli.commands.bookmarks import bookmarks_app
+from cli.commands.chrome import chrome_app
+from cli.commands.contest import contest_app
+from cli.commands.docker import docker_app
+from cli.commands.drive import drive_app
+from cli.commands.gh import gh_app
+from cli.commands.git import git_app
+from cli.commands.links import links_app
+from cli.commands.notion import notion_app
+from cli.commands.publish import publish_app
+from cli.commands.restore import restore_app
+from cli.utils.logger import setup_logging
+
+app = typer.Typer(
+    name="cli",
+    help="Git shortcuts and drive (tag zips) for macOS. Run `cli links` for docs and scripts.",
+    no_args_is_help=True,
+)
+
+app.add_typer(links_app, name="links")
+app.add_typer(git_app, name="git")
+app.add_typer(gh_app, name="gh")
+app.add_typer(backup_app, name="backup", hidden=True)
+app.add_typer(restore_app, name="restore")
+app.add_typer(drive_app, name="drive")
+app.add_typer(notion_app, name="notion")
+app.add_typer(chrome_app, name="chrome")
+app.add_typer(bookmarks_app, name="bookmarks", hidden=True)
+app.add_typer(docker_app, name="docker")
+app.add_typer(contest_app, name="contest")
+app.add_typer(publish_app, name="publish")
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    version: bool = typer.Option(False, "--version", "-V", help="Show version and exit."),
+    verbose: bool = typer.Option(False, "--verbose", "-v"),
+) -> None:
+    setup_logging(verbose=verbose)
+    if version:
+        typer.echo(__version__)
+        raise typer.Exit()
+    if ctx.invoked_subcommand is None and not version:
+        typer.echo(ctx.get_help())
+        typer.echo("\nFull index: cli links  |  docs/README.md")
+        raise typer.Exit()
+    ctx.obj = {"verbose": verbose}
+
+
+def run() -> None:
+    """CLI entrypoint — surfaces ExternalCallError as a clean user message."""
+    from cli.utils.config import load_local_env
+    from cli.utils.external_client import ExternalCallError
+
+    load_local_env()
+    try:
+        app()
+    except ExternalCallError as exc:
+        typer.echo(exc.user_message, err=True)
+        raise typer.Exit(1) from exc
+
+
+# Short alias: cli g <cmd> == cli git <cmd>
+app.add_typer(git_app, name="g", hidden=True)

cli/commands/__init__.py

@@ -0,0 +1 @@
+"""CLI command modules."""

cli/commands/backup.py

@@ -0,0 +1,49 @@
+"""Hidden aliases for legacy `cli backup` → use `cli drive` instead."""
+
+from __future__ import annotations
+
+import typer
+
+from cli.commands.drive import delete_cmd, ingest_cmd, list_cmd, status_cmd
+
+backup_app = typer.Typer(
+    help="(deprecated) use cli drive",
+    no_args_is_help=True,
+    hidden=True,
+)
+repository_app = typer.Typer(help="(deprecated)", hidden=True)
+
+
+@backup_app.command("status")
+def backup_status_alias() -> None:
+    """Deprecated: use `cli drive status`."""
+    status_cmd()
+
+
+@repository_app.command("sync")
+def repository_sync_alias(
+    path: str | None = typer.Argument(None),
+) -> None:
+    """Deprecated: use `cli drive ingest`."""
+    ingest_cmd(path)
+
+
+@repository_app.command("list")
+def repository_list_alias(
+    path: str | None = typer.Argument(None),
+) -> None:
+    """Deprecated: use `cli drive list`."""
+    list_cmd(path)
+
+
+@repository_app.command("delete")
+def repository_delete_alias(
+    path: str = typer.Argument(...),
+    tag: str = typer.Argument(...),
+    yes: bool = typer.Option(False, "--yes", "-y"),
+) -> None:
+    """Deprecated: use `cli drive delete`."""
+    delete_cmd(path, tag, yes=yes)
+
+
+backup_app.add_typer(repository_app, name="repository")

cli/commands/bookmarks.py

@@ -0,0 +1,21 @@
+"""Hidden legacy alias: `cli bookmarks` → `cli chrome bookmarks`."""
+
+from __future__ import annotations
+
+import typer
+
+from cli.commands.chrome import bookmarks_deploy_to_chrome, bookmarks_ingest_from_chrome
+
+bookmarks_app = typer.Typer(help="(deprecated) use cli chrome bookmarks", hidden=True)
+
+
+@bookmarks_app.command("export")
+def legacy_export() -> None:
+    """Deprecated: remote-centric Chrome→local; use `cli chrome bookmarks ingest`."""
+    bookmarks_ingest_from_chrome()
+
+
+@bookmarks_app.command("import")
+def legacy_import() -> None:
+    """Deprecated: remote-centric local→Chrome; use `cli chrome bookmarks deploy`."""
+    bookmarks_deploy_to_chrome()

cli/commands/chrome.py

@@ -0,0 +1,77 @@
+"""Chrome browser integrations (bookmarks today; more later)."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+
+import typer
+from rich import print as rprint
+
+from cli.utils.config import bookmarks_file_path, chrome_downloads_dir, project_root
+
+chrome_app = typer.Typer(help="Chrome browser — bookmarks and future integrations.", no_args_is_help=True)
+bookmarks_app = typer.Typer(help="Bookmark ingest / deploy (local-centric).", no_args_is_help=True)
+
+
+def _bookmarks_env() -> dict[str, str]:
+    env = os.environ.copy()
+    env["CLI_ROOT"] = str(project_root())
+    env["CLI_BOOKMARKS_FILE"] = str(bookmarks_file_path())
+    env["CLI_DOWNLOADS_DIR"] = str(chrome_downloads_dir())
+    return env
+
+
+def _run_bookmarks_script(name: str) -> None:
+    script = project_root() / "scripts" / "chrome" / name
+    if not script.is_file():
+        raise typer.Exit(f"Script not found: {script}")
+    try:
+        subprocess.run([str(script)], env=_bookmarks_env(), check=True)
+    except subprocess.CalledProcessError as exc:
+        raise typer.Exit(exc.returncode) from exc
+
+
+def bookmarks_ingest_from_chrome() -> None:
+    """Chrome → local: ingest bookmarks HTML into configured path."""
+    dest = bookmarks_file_path()
+    _run_bookmarks_script("export-bookmarks.sh")
+    rprint(f"[green]ingested[/green] → {dest}")
+
+
+def bookmarks_deploy_to_chrome() -> None:
+    """Local → Chrome: deploy backup file into Chrome."""
+    src = bookmarks_file_path()
+    if not src.is_file():
+        raise typer.Exit(
+            f"Backup not found: {src}\nRun `cli chrome bookmarks ingest` first."
+        )
+    _run_bookmarks_script("import-bookmarks.sh")
+    rprint(f"[green]deployed[/green] to Chrome from {src}")
+
+
+@bookmarks_app.command("ingest")
+def bookmarks_ingest_cmd() -> None:
+    """Chrome → local: ingest bookmarks HTML to configured path."""
+    bookmarks_ingest_from_chrome()
+
+
+@bookmarks_app.command("deploy")
+def bookmarks_deploy_cmd() -> None:
+    """Local → Chrome: deploy backup into Chrome."""
+    bookmarks_deploy_to_chrome()
+
+
+@bookmarks_app.command("import", hidden=True)
+def legacy_import_cmd() -> None:
+    """Deprecated: remote-centric local→Chrome; use `cli chrome bookmarks deploy`."""
+    bookmarks_deploy_to_chrome()
+
+
+@bookmarks_app.command("export", hidden=True)
+def legacy_export_cmd() -> None:
+    """Deprecated: remote-centric Chrome→local; use `cli chrome bookmarks ingest`."""
+    bookmarks_ingest_from_chrome()
+
+
+chrome_app.add_typer(bookmarks_app, name="bookmarks")

cli/commands/contest.py

@@ -0,0 +1,120 @@
+"""Competitive programming validation."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from rich import print as rprint
+from rich.table import Table
+
+from cli.services.contest_docker import RunStatus
+from cli.services.contest_runner import (
+    ContestValidateResult,
+    resolve_options,
+    validate_contest,
+)
+
+contest_app = typer.Typer(
+    help="Competitive programming validation (generator, brute, fast).",
+    no_args_is_help=True,
+)
+
+
+def _status_style(status: RunStatus) -> str:
+    if status == RunStatus.OK:
+        return "green"
+    if status == RunStatus.TLE:
+        return "yellow"
+    return "red"
+
+
+def _print_outcome_row(
+    table: Table,
+    tier: str,
+    role: str,
+    outcome,
+) -> None:
+    table.add_row(
+        tier,
+        role,
+        f"[{_status_style(outcome.status)}]{outcome.status.value}[/]",
+        f"{outcome.seconds:.2f}s",
+    )
+
+
+def _print_result(result: ContestValidateResult) -> None:
+    if result.error and result.small is None and result.large is None:
+        rprint(f"[red]error:[/red] {result.error}")
+        rprint("[red]FAIL[/red]")
+        return
+
+    table = Table(title="Contest validate", show_header=True, header_style="bold")
+    table.add_column("Tier")
+    table.add_column("Role")
+    table.add_column("Status")
+    table.add_column("Time", justify="right")
+
+    if result.small:
+        _print_outcome_row(table, "small", "brute", result.small.brute)
+        _print_outcome_row(table, "small", "fast", result.small.fast)
+        match = result.small.outputs_match
+        if match is not None:
+            style = "green" if match else "red"
+            table.add_row(
+                "small",
+                "compare",
+                f"[{style}]{'match' if match else 'mismatch'}[/]",
+                "",
+            )
+
+    if result.large:
+        _print_outcome_row(table, "large", "brute", result.large.brute)
+        _print_outcome_row(table, "large", "fast", result.large.fast)
+
+    rprint(table)
+
+    if result.small_diff:
+        rprint("\n[red]small tier diff:[/red]")
+        rprint(result.small_diff)
+
+    for warning in result.warnings:
+        rprint(f"[yellow]warning:[/yellow] {warning}")
+
+    if result.error:
+        rprint(f"[red]error:[/red] {result.error}")
+
+    if result.passed:
+        rprint("[green]PASS[/green]")
+    else:
+        rprint("[red]FAIL[/red]")
+
+
+@contest_app.command("validate")
+def validate_cmd(
+    fast: Path | None = typer.Option(None, "--fast", help="Path to fast C++ solution."),
+    brute: Path | None = typer.Option(None, "--brute", help="Path to Python brute solution."),
+    generator: Path | None = typer.Option(None, "--generator", help="Path to Python input generator."),
+    config: Path | None = typer.Option(None, "--config", help="Optional YAML config with paths and limits."),
+    timeout: float | None = typer.Option(None, "--timeout", help="Per-container time limit in seconds."),
+    memory_mb: int | None = typer.Option(None, "--memory-mb", help="Per-container memory limit in MB."),
+    image: str | None = typer.Option(None, "--image", help="Docker image for solution runs."),
+) -> None:
+    """Validate fast C++ vs brute Python on small (compare) and large (stress) tiers."""
+    try:
+        options = resolve_options(
+            fast=fast,
+            brute=brute,
+            generator=generator,
+            config=config,
+            timeout=timeout,
+            memory_mb=memory_mb,
+            image=image,
+        )
+    except (ValueError, FileNotFoundError) as exc:
+        rprint(f"[red]error:[/red] {exc}")
+        raise typer.Exit(1) from exc
+
+    result = validate_contest(options)
+    _print_result(result)
+    raise typer.Exit(0 if result.passed else 1)