lovarch-cli 0.2.1__py3-none-any.whl

lovarch_cli/commands/status.py

@@ -0,0 +1,243 @@
+"""lovarch status — Inspect project state and recent runs.
+
+Two modes:
+  - lovarch status            → list all projects + their last_audit / last_dossier
+  - lovarch status <project>  → drill into one project: full last_audit detail,
+                                  last_dossier, output/ file listing
+
+Reads project.yaml metadata (no Lovarch backend required), so this works
+identically in Free and Premium modes. For executions persisted via the
+DataPersistenceClient (Story 1.3), a future revision will fetch step-level
+status from the persistence layer; today we surface what the file system
++ project.yaml reveal.
+"""
+from __future__ import annotations
+
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Annotated
+
+import typer
+import yaml
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from lovarch_cli.config import DEFAULT_HOME
+from lovarch_cli.i18n import current_lang, set_current_lang, t
+
+console = Console()
+err_console = Console(stderr=True)
+
+
+def _load_project_meta(proj_dir: Path) -> dict:
+    yaml_path = proj_dir / "project.yaml"
+    if not yaml_path.exists():
+        return {}
+    try:
+        return yaml.safe_load(yaml_path.read_text(encoding="utf-8")) or {}
+    except yaml.YAMLError:
+        return {}
+
+
+def _format_relative_age(iso_ts: str | None) -> str:
+    """Convert ISO 8601 → 'Xm ago' / 'Xh ago' / 'Xd ago'."""
+    if not iso_ts:
+        return "-"
+    try:
+        dt = datetime.fromisoformat(iso_ts.replace("Z", "+00:00"))
+    except ValueError:
+        return iso_ts
+    delta = datetime.now(timezone.utc) - dt
+    seconds = int(delta.total_seconds())
+    if seconds < 0:
+        return "just now"
+    if seconds < 60:
+        return f"{seconds}s ago"
+    if seconds < 3600:
+        return f"{seconds // 60}m ago"
+    if seconds < 86_400:
+        return f"{seconds // 3600}h ago"
+    return f"{seconds // 86_400}d ago"
+
+
+_VERDICT_STYLE = {
+    "PASS": "[bold green]PASS[/bold green]",
+    "CONCERNS": "[bold yellow]CONCERNS[/bold yellow]",
+    "FAIL": "[bold red]FAIL[/bold red]",
+    None: "[dim]—[/dim]",
+}
+
+
+def _render_project_list(projects_root: Path, lang: str) -> Table:
+    """Table view: all projects with their audit+dossier state."""
+    table = Table(
+        title=t("status.list_title", lang=lang),
+        title_style="bold gold1",
+        header_style="bold",
+    )
+    table.add_column(t("status.col_project", lang=lang), no_wrap=True)
+    table.add_column(t("status.col_workflow", lang=lang))
+    table.add_column(t("status.col_audit", lang=lang), no_wrap=True)
+    table.add_column(t("status.col_dossier", lang=lang), no_wrap=True)
+    table.add_column(t("status.col_age", lang=lang), no_wrap=True)
+
+    for proj_dir in sorted(projects_root.iterdir()):
+        if not proj_dir.is_dir():
+            continue
+        meta = _load_project_meta(proj_dir)
+        last_audit = meta.get("last_audit") or {}
+        last_dossier = meta.get("last_dossier") or {}
+        verdict_label = _VERDICT_STYLE.get(
+            last_audit.get("verdict"), _VERDICT_STYLE[None]
+        )
+        dossier_label = (
+            f"[green]✓[/green] {last_dossier.get('files', 0)} files"
+            if last_dossier
+            else "[dim]—[/dim]"
+        )
+        # Age is the freshest of created_at / last_audit / last_dossier
+        most_recent = max(
+            (
+                ts for ts in [
+                    meta.get("created_at"),
+                    last_dossier.get("created_at"),
+                ]
+                if ts
+            ),
+            default=None,
+        )
+        table.add_row(
+            proj_dir.name,
+            meta.get("workflow", "-"),
+            verdict_label,
+            dossier_label,
+            _format_relative_age(most_recent),
+        )
+    return table
+
+
+def _render_project_detail(proj_dir: Path, lang: str) -> None:
+    """Drill-down view for a single project."""
+    meta = _load_project_meta(proj_dir)
+    name = proj_dir.name
+
+    body_lines = [
+        f"[dim]{t('status.label_workflow', lang=lang)}:[/dim] [bold]{meta.get('workflow', '-')}[/bold]",
+        f"[dim]{t('status.label_created', lang=lang)}:[/dim] {meta.get('created_at', '-')}",
+        f"[dim]{t('status.label_sample', lang=lang)}:[/dim] {meta.get('sample', False)}",
+    ]
+
+    # Audit section
+    last_audit = meta.get("last_audit")
+    if last_audit:
+        verdict = last_audit.get("verdict")
+        body_lines.append("")
+        body_lines.append(
+            f"[bold]{t('status.section_audit', lang=lang)}:[/bold] "
+            f"{_VERDICT_STYLE.get(verdict, _VERDICT_STYLE[None])} — "
+            f"PASS={last_audit.get('pass_count', 0)} · "
+            f"CONCERNS={last_audit.get('concerns_count', 0)} · "
+            f"FAIL={last_audit.get('fail_count', 0)}"
+        )
+    else:
+        body_lines.append("")
+        body_lines.append(
+            f"[bold]{t('status.section_audit', lang=lang)}:[/bold] "
+            f"[dim]{t('status.no_audit_yet', lang=lang)}[/dim]"
+        )
+
+    # Dossier section
+    last_dossier = meta.get("last_dossier")
+    if last_dossier:
+        size_kb = (last_dossier.get("size_bytes", 0)) // 1024
+        body_lines.append(
+            f"[bold]{t('status.section_dossier', lang=lang)}:[/bold] "
+            f"[green]{last_dossier.get('files', 0)} files · {size_kb} KB[/green] "
+            f"[dim]({_format_relative_age(last_dossier.get('created_at'))})[/dim]"
+        )
+        body_lines.append(f"  [dim]{last_dossier.get('path')}[/dim]")
+    else:
+        body_lines.append(
+            f"[bold]{t('status.section_dossier', lang=lang)}:[/bold] "
+            f"[dim]{t('status.no_dossier_yet', lang=lang)}[/dim]"
+        )
+
+    # Output dir glance: count files
+    output_dir = proj_dir / "output"
+    if output_dir.is_dir():
+        n_output = sum(1 for _ in output_dir.rglob("*") if _.is_file())
+        body_lines.append("")
+        body_lines.append(
+            f"[bold]{t('status.section_output', lang=lang)}:[/bold] "
+            f"{n_output} files in [dim]{output_dir}[/dim]"
+        )
+
+    console.print()
+    console.print(
+        Panel(
+            Text.from_markup("\n".join(body_lines)),
+            title=f"[bold gold1]📋 {t('status.detail_title', lang=lang, name=name)}[/bold gold1]",
+            border_style="gold1",
+            padding=(1, 2),
+        )
+    )
+    console.print()
+
+
+def status_command(
+    project: Annotated[
+        str | None,
+        typer.Argument(
+            help="Project name to inspect (omit to list all projects).",
+        ),
+    ] = None,
+    lang_flag: Annotated[
+        str | None,
+        typer.Option("--lang", "-l", help="Override language (it/pt/en/es)."),
+    ] = None,
+    home_override: Annotated[
+        Path | None,
+        typer.Option(
+            "--home",
+            help="Override $HOME/.lovarch root (mainly for tests).",
+            hidden=True,
+        ),
+    ] = None,
+) -> None:
+    """Inspect project state and recent runs."""
+    if lang_flag is not None:
+        set_current_lang(lang_flag)
+    lang = current_lang()
+
+    home = home_override or DEFAULT_HOME
+    projects_root = home / "projects"
+    if not projects_root.is_dir():
+        err_console.print(
+            f"\n[yellow]{t('status.no_projects', lang=lang)}[/yellow]\n"
+        )
+        sys.exit(0)
+
+    if project is None:
+        # List all projects in a table
+        table = _render_project_list(projects_root, lang)
+        console.print()
+        console.print(table)
+        # Empty-state hint
+        if projects_root.exists() and not any(projects_root.iterdir()):
+            console.print(
+                f"\n[dim]{t('status.no_projects_hint', lang=lang)}[/dim]\n"
+            )
+        else:
+            console.print()
+        return
+
+    proj_dir = projects_root / project
+    if not proj_dir.is_dir():
+        err_console.print(
+            f"\n[red]✗ {t('status.project_not_found', lang=lang, name=project)}[/red]\n"
+        )
+        sys.exit(2)
+    _render_project_detail(proj_dir, lang)

lovarch_cli/commands/upgrade.py

@@ -0,0 +1,108 @@
+"""arch upgrade — CTA from Free to Premium.
+
+State-aware:
+  - none    → instruct user to run `arch signup` first
+  - free    → show benefits + open browser to /cli-upgrade
+  - premium → already-premium acknowledgment + open /settings/credits
+
+This is a thin CLI surface around a web page; no backend interaction. The
+goal is to keep the upgrade funnel discoverable in-terminal and route the
+user to the same web flow Lovarch uses for in-app upgrades.
+"""
+from __future__ import annotations
+
+import sys
+import webbrowser
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+from lovarch_cli.config import load_credentials
+from lovarch_cli.i18n import current_lang, set_current_lang, t
+
+console = Console()
+err_console = Console(stderr=True)
+
+# Same web base used by `arch login --premium` for the PKCE flow.
+LOVARCH_WEB_BASE = "https://lovarch.com"
+UPGRADE_PATH = "/cli-upgrade"
+PREMIUM_DASHBOARD_PATH = "/settings/credits"
+
+
+def upgrade_command(
+    no_browser: Annotated[
+        bool,
+        typer.Option(
+            "--no-browser",
+            help="Print the URL without opening the browser (for CI/SSH).",
+        ),
+    ] = False,
+    lang_flag: Annotated[
+        str | None,
+        typer.Option("--lang", "-l", help="Override language (it/pt/en/es)."),
+    ] = None,
+) -> None:
+    """Open the Premium upgrade flow in the browser (or print URL with --no-browser)."""
+    if lang_flag is not None:
+        set_current_lang(lang_flag)
+    lang = current_lang()
+
+    creds = load_credentials()
+
+    # Prefer the language the user signed up with — falls back to runtime lang
+    # so users who didn't sign up still get something localized.
+    user_lang = creds.language if creds.mode != "none" else lang
+
+    # ─── No account → tell user to signup first ──────────────────────────
+    if creds.mode == "none":
+        err_console.print(
+            f"\n[yellow]{t('upgrade.no_account_hint', lang=user_lang)}[/yellow]\n"
+        )
+        sys.exit(1)
+
+    # ─── Already Premium → acknowledge + open billing dashboard ──────────
+    if creds.mode == "premium":
+        url = f"{LOVARCH_WEB_BASE}{PREMIUM_DASHBOARD_PATH}"
+        body = Text.from_markup(
+            f"{t('upgrade.already_premium', lang=user_lang)}\n\n"
+            f"[dim cyan]{url}[/dim cyan]"
+        )
+        console.print()
+        console.print(
+            Panel(
+                body,
+                title=f"[bold green]{t('upgrade.already_premium_title', lang=user_lang)}[/bold green]",
+                border_style="green",
+                padding=(1, 2),
+            )
+        )
+        if not no_browser:
+            webbrowser.open(url, new=1, autoraise=True)
+        console.print()
+        return
+
+    # ─── Free → show benefits + open upgrade URL ─────────────────────────
+    url = f"{LOVARCH_WEB_BASE}{UPGRADE_PATH}"
+    body = Text.from_markup(
+        f"{t('upgrade.body_free', lang=user_lang)}\n\n"
+        f"[dim]{t('login.manual_url_hint', lang=user_lang)}[/dim]\n"
+        f"[dim cyan]{url}[/dim cyan]"
+    )
+    console.print()
+    console.print(
+        Panel(
+            body,
+            title=f"[bold gold1]{t('upgrade.title', lang=user_lang)}[/bold gold1]",
+            border_style="gold1",
+            padding=(1, 2),
+        )
+    )
+    if not no_browser:
+        console.print(
+            f"\n[gold1]→[/gold1] {t('login.opening_browser', lang=user_lang)}"
+        )
+        webbrowser.open(url, new=1, autoraise=True)
+    console.print()

lovarch_cli/commands/verifica_cmd.py

@@ -0,0 +1,174 @@
+"""`lovarch verifica` — conferência de dados para profissionais.
+
+    lovarch verifica misure pianta.dxf          (determinístico, grátis)
+    lovarch verifica normativa capitolato.pdf   (adversarial 2 modelos, débito)
+"""
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+err_console = Console(stderr=True)
+
+verifica_app = typer.Typer(
+    help="Verifica dati e documenti (misure DXF gratis · normativa adversarial).",
+    no_args_is_help=True,
+)
+
+_VERDICT_STYLE = {"PASS": "green", "CONCERNS": "yellow", "REJECT": "red"}
+
+
+def _print_verdict(verdict: str) -> None:
+    style = _VERDICT_STYLE.get(verdict, "white")
+    console.print(f"\n[bold {style}]VERDETTO: {verdict}[/bold {style}]")
+
+
+@verifica_app.command("misure")
+def misure_command(
+    dxf: Path = typer.Argument(..., help="File DXF da verificare."),
+) -> None:
+    """Verifica layer ISO, etichette ambienti e cartiglio CNAPPC (gratis)."""
+    from lovarch_cli.verify import verify_misure
+
+    report = verify_misure(dxf)
+    table = Table(title=f"verifica misure — {dxf.name}", header_style="bold gold1")
+    table.add_column("Controllo", style="cyan")
+    table.add_column("Esito")
+    table.add_row("Entità DXF", str(report.stats.get("entities", "—")))
+    table.add_row("Layer ISO presenti", f"{report.stats.get('iso_layers_present', 0)}/9")
+    table.add_row("Ambienti etichettati", ", ".join(report.stats.get("room_labels_found", [])) or "—")
+    console.print(table)
+    for f in report.findings:
+        console.print(f"  [yellow]·[/yellow] {f}")
+    _print_verdict(report.verdict)
+    raise typer.Exit(0 if report.verdict == "PASS" else (2 if report.verdict == "CONCERNS" else 1))
+
+
+@verifica_app.command("normativa")
+def normativa_command(
+    documento: Path = typer.Argument(..., help="Documento da verificare (.pdf, .md, .txt)."),
+    language: str = typer.Option(None, "--language", help="Lingua del report."),
+) -> None:
+    """Verifica adversarial das citações normativas (2 modelos · debita créditos)."""
+    from lovarch_cli.ai import LovarchAiGateway
+    from lovarch_cli.auth.session import LovarchSession
+    from lovarch_cli.i18n import current_lang
+    from lovarch_cli.verify import verify_normativa
+    from lovarch_cli.verify.normativa import NormativaError
+
+    session = LovarchSession.load()
+    if session is None:
+        err_console.print("[red]✗ Non autenticato. Esegui `lovarch login --premium`.[/red]")
+        raise typer.Exit(1)
+
+    try:
+        report = asyncio.run(verify_normativa(
+            LovarchAiGateway(session), documento, language=language or current_lang(),
+        ))
+    except NormativaError as exc:
+        err_console.print(f"[red]✗ {exc}[/red]")
+        raise typer.Exit(1)
+
+    if report.canonical_found:
+        console.print(f"[dim]Riferimenti canonici rilevati: {', '.join(report.canonical_found)}[/dim]")
+    table = Table(title=f"verifica normativa — {documento.name}", header_style="bold gold1")
+    table.add_column("Riferimento", style="cyan")
+    table.add_column("Status", justify="center")
+    table.add_column("Motivo")
+    for v in report.verdicts:
+        status = str(v.get("status", "?")).lower()
+        icon = {"ok": "[green]✓[/green]", "refuted": "[red]✗[/red]", "doubt": "[yellow]?[/yellow]"}.get(status, "?")
+        table.add_row(str(v.get("reference", "—")), icon, str(v.get("reason", ""))[:100])
+    console.print(table)
+    for n in report.notes:
+        console.print(f"  [yellow]·[/yellow] {n}")
+    console.print(f"[dim]Crediti addebitati: {report.credits_charged}[/dim]")
+    _print_verdict(report.verdict)
+    raise typer.Exit(0 if report.verdict == "PASS" else (2 if report.verdict == "CONCERNS" else 1))
+
+
+@verifica_app.command("contratto")
+def contratto_command(
+    documento: Path = typer.Argument(..., help="Contratto da verificare (.pdf, .md, .txt)."),
+    language: str = typer.Option(None, "--language", help="Lingua del report."),
+) -> None:
+    """Verifica adversarial de contrato CNAPPC (estrutura + compenso · debita créditos)."""
+    from lovarch_cli.ai import LovarchAiGateway
+    from lovarch_cli.auth.session import LovarchSession
+    from lovarch_cli.i18n import current_lang
+    from lovarch_cli.verify import verify_contratto
+    from lovarch_cli.verify.normativa import NormativaError
+
+    session = LovarchSession.load()
+    if session is None:
+        err_console.print("[red]\u2717 Non autenticato. Esegui `lovarch login --premium`.[/red]")
+        raise typer.Exit(1)
+    try:
+        report = asyncio.run(verify_contratto(
+            LovarchAiGateway(session), str(documento), language=language or current_lang(),
+        ))
+    except NormativaError as exc:
+        err_console.print(f"[red]\u2717 {exc}[/red]")
+        raise typer.Exit(1)
+
+    st = report.structure or {}
+    if st.get("client_type"):
+        compenso_amount = (st.get("compenso") or {}).get("amount") or "\u2014"
+        console.print(f"[dim]Committente: {st['client_type']} \u00b7 Compenso: {compenso_amount}[/dim]")
+    missing = st.get("sections_missing") or []
+    if missing:
+        console.print(f"  [yellow]\u00b7[/yellow] Sezioni mancanti: {', '.join(str(m) for m in missing[:6])}")
+    for f in report.findings:
+        sev = str(f.get("severity", "info")).lower()
+        icon = {"critical": "[red]\u2717[/red]", "concern": "[yellow]?[/yellow]"}.get(sev, "[dim]\u00b7[/dim]")
+        console.print(f"  {icon} [{f.get('area', '?')}] {str(f.get('reason', ''))[:110]}")
+    console.print(f"[dim]Crediti addebitati: {report.credits_charged}[/dim]")
+    _print_verdict(report.verdict)
+    raise typer.Exit(0 if report.verdict == "PASS" else (2 if report.verdict == "CONCERNS" else 1))
+
+
+@verifica_app.command("dossier")
+def dossier_command(
+    cartella: Path = typer.Argument(..., help="Cartella dei deliverable da verificare."),
+    language: str = typer.Option(None, "--language", help="Lingua del report."),
+    max_llm: int = typer.Option(8, "--max-llm", help="Massimo documenti verificati con AI (i DXF sono gratis)."),
+) -> None:
+    """QA completo standalone su una cartella (DXF gratis + documenti adversarial)."""
+    from lovarch_cli.ai import LovarchAiGateway
+    from lovarch_cli.auth.session import LovarchSession
+    from lovarch_cli.i18n import current_lang
+    from lovarch_cli.verify import verify_dossier
+    from lovarch_cli.verify.normativa import NormativaError
+
+    session = LovarchSession.load()
+    if session is None:
+        err_console.print("[red]\u2717 Non autenticato. Esegui `lovarch login --premium`.[/red]")
+        raise typer.Exit(1)
+    try:
+        report = asyncio.run(verify_dossier(
+            LovarchAiGateway(session), cartella,
+            language=language or current_lang(), max_llm_files=max_llm,
+        ))
+    except NormativaError as exc:
+        err_console.print(f"[red]\u2717 {exc}[/red]")
+        raise typer.Exit(1)
+
+    table = Table(title=f"verifica dossier \u2014 {cartella.name}", header_style="bold gold1")
+    table.add_column("File", style="cyan")
+    table.add_column("Tipo")
+    table.add_column("Verdetto", justify="center")
+    table.add_column("Dettaglio")
+    for f in report.files:
+        style = _VERDICT_STYLE.get(f["verdict"], "white")
+        table.add_row(f["name"], f["kind"], f"[{style}]{f['verdict']}[/{style}]", str(f["detail"])[:70])
+    console.print(table)
+    if report.skipped:
+        console.print(f"  [yellow]\u00b7[/yellow] non verificati con AI (limite --max-llm): {', '.join(report.skipped)}")
+    console.print(f"[dim]Crediti addebitati: {report.credits_charged}[/dim]")
+    _print_verdict(report.verdict)
+    raise typer.Exit(0 if report.verdict == "PASS" else (2 if report.verdict == "CONCERNS" else 1))

lovarch_cli/config.py

@@ -0,0 +1,101 @@
+"""lovarch-cli config + credentials management.
+
+Stores user state in ~/.lovarch/:
+- credentials.json — auth tokens (free_token or premium refresh_token)
+- config.yaml      — preferences (language, default workflow, API keys)
+
+Free mode token is saved as plain text (low-sensitivity lead-tracking ID).
+Premium mode tokens go through OS keyring (keyring lib) — see auth/credentials.py.
+"""
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any
+
+DEFAULT_HOME = Path.home() / ".lovarch"
+
+# Lovarch Supabase API endpoint.
+#
+# Decision 2026-05-10 (Pablo + Orion): Opção A — URL Supabase direta.
+# Custom domain api.lovarch.com fica para fase pre-PyPI public publish
+# (ver cli/MIGRATION-PLAN.md). Quando criado, usuários instalados continuam
+# funcionando via env LOVARCH_API_URL override ou bump de versão.
+#
+# The anon key below is PUBLIC by Supabase design (role=anon, RLS-protected).
+# Same key shipped in Lovarch web frontend bundle. Safe to embed in
+# distributed CLI source.
+DEFAULT_API_URL = os.environ.get(
+    "LOVARCH_API_URL", "https://cuxbydmyahjaplzkthkr.supabase.co"
+)
+DEFAULT_API_ANON_KEY = os.environ.get(
+    "LOVARCH_ANON_KEY",
+    "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImN1eGJ5ZG15YWhqYXBsemt0aGtyIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzIzODM3OTYsImV4cCI6MjA4Nzk1OTc5Nn0.UtHrPjSP40pwsRy6vCQseC5YA4DZ6e-hO8sXcRL8w_E",
+)
+
+
+@dataclass
+class Credentials:
+    """User authentication state.
+
+    Free mode: free_token + lead_id (saved here in plain JSON).
+    Premium mode: only marker; actual tokens live in OS keyring.
+    """
+
+    mode: str  # 'free' | 'premium' | 'none'
+    lead_id: str | None = None
+    user_id: str | None = None
+    free_token: str | None = None
+    email: str | None = None
+    full_name: str | None = None
+    country: str | None = None
+    language: str = "it"
+    signed_up_at: str | None = None
+    upgrade_url: str | None = None
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def empty(cls) -> Credentials:
+        return cls(mode="none")
+
+
+def credentials_path(home: Path | None = None) -> Path:
+    return (home or DEFAULT_HOME) / "credentials.json"
+
+
+def load_credentials(home: Path | None = None) -> Credentials:
+    path = credentials_path(home)
+    if not path.exists():
+        return Credentials.empty()
+    try:
+        data = json.loads(path.read_text())
+        return Credentials(**data)
+    except (json.JSONDecodeError, TypeError, ValueError):
+        return Credentials.empty()
+
+
+def save_credentials(creds: Credentials, home: Path | None = None) -> Path:
+    path = credentials_path(home)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(asdict(creds), indent=2, ensure_ascii=False))
+    # Restrict permissions on POSIX (rw-------)
+    if os.name == "posix":
+        path.chmod(0o600)
+    return path
+
+
+def clear_credentials(home: Path | None = None) -> bool:
+    path = credentials_path(home)
+    if path.exists():
+        path.unlink()
+        return True
+    return False
+
+
+def is_authenticated(home: Path | None = None) -> bool:
+    creds = load_credentials(home)
+    return creds.mode in {"free", "premium"} and (
+        creds.free_token is not None or creds.user_id is not None
+    )