lovarch-cli 0.2.1__py3-none-any.whl

lovarch_cli/commands/init.py

@@ -0,0 +1,218 @@
+"""lovarch init — Create a new project directory.
+
+Creates ~/.lovarch/projects/<project>/ with input/ and output/ subdirs and
+a project.yaml metadata file. With --sample copies the bundled villa-chianti
+sample-input as a starter pack the user can run end-to-end with no extra work.
+
+Project layout after `lovarch init my-villa --sample`:
+
+    ~/.lovarch/projects/my-villa/
+    ├── project.yaml          # name, created_at, workflow, mode
+    ├── input/                # 18 input files (briefing, photos, DXF, etc.)
+    │   ├── architetto-info.json
+    │   ├── briefing-cliente.md
+    │   ├── foto/
+    │   ├── pinterest-references/
+    │   ├── README.md
+    │   ├── stato-attuale.dxf
+    │   ├── stato-attuale.png
+    │   └── visura-catastale.pdf
+    └── output/               # populated by `lovarch run`
+
+The sample comes from the bundled squad payload (lovarch_cli/squad/), so it
+ships with the pip package — no separate download needed.
+"""
+from __future__ import annotations
+
+import re
+import shutil
+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.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)
+
+# Valid project name pattern: lowercase letters, digits, hyphens.
+# Forbids path-traversal characters and shell-unfriendly chars.
+PROJECT_NAME_RX = re.compile(r"^[a-z0-9][a-z0-9-]{1,62}$")
+
+# Sample-input villa-chianti is NOT bundled in the wheel (49MB of photos/DXF/
+# PDF — too heavy). It ships as a GitHub Releases asset and lovarch_cli.
+# sample_downloader.resolve_sample_source() handles bundled→cache→download
+# resolution transparently.
+
+
+def _project_dir(home: Path, name: str) -> Path:
+    return home / "projects" / name
+
+
+def init_command(
+    project: Annotated[
+        str,
+        typer.Argument(
+            help="Project name (lowercase letters/digits/hyphens, 2-63 chars).",
+        ),
+    ],
+    sample: Annotated[
+        bool,
+        typer.Option(
+            "--sample",
+            help="Copy the bundled villa-chianti sample-input as a starter.",
+        ),
+    ] = False,
+    workflow: Annotated[
+        str,
+        typer.Option(
+            "--workflow",
+            help="Target workflow this project will run against.",
+        ),
+    ] = "dal-brief-al-cantiere",
+    force: Annotated[
+        bool,
+        typer.Option(
+            "--force",
+            help="Overwrite an existing project directory (dangerous).",
+        ),
+    ] = False,
+    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,
+    squad_src: Annotated[
+        Path | None,
+        typer.Option(
+            "--squad-src",
+            help=(
+                "Path to a squad-architettura-progetto source dir. Also reads "
+                "$LOVARCH_SQUAD_SRC. When set, --sample reads the villa-"
+                "chianti sample from this path instead of downloading."
+            ),
+        ),
+    ] = None,
+) -> None:
+    """Initialize a new project directory."""
+    if lang_flag is not None:
+        set_current_lang(lang_flag)
+    lang = current_lang()
+
+    # ─── Validate project name ───────────────────────────────────────────
+    if not PROJECT_NAME_RX.match(project):
+        err_console.print(
+            f"\n[red]✗ {t('init.invalid_name', lang=lang, name=project)}[/red]\n"
+        )
+        sys.exit(2)
+
+    home = home_override or DEFAULT_HOME
+    proj_dir = _project_dir(home, project)
+
+    # ─── Handle existing project ─────────────────────────────────────────
+    if proj_dir.exists():
+        if not force:
+            err_console.print(
+                f"\n[yellow]{t('init.already_exists', lang=lang, name=project, path=str(proj_dir))}[/yellow]\n"
+            )
+            sys.exit(1)
+        shutil.rmtree(proj_dir)
+
+    # ─── Create dir tree ─────────────────────────────────────────────────
+    input_dir = proj_dir / "input"
+    output_dir = proj_dir / "output"
+    input_dir.mkdir(parents=True)
+    output_dir.mkdir()
+
+    # ─── Optional: resolve + copy sample-input (lazy download if needed) ─
+    sample_copied_count = 0
+    sample_origin: str | None = None
+    if sample:
+        from lovarch_cli.sample_downloader import (
+            SampleDownloadError,
+            resolve_sample_source,
+        )
+
+        try:
+            resolved = resolve_sample_source(
+                console=console,
+                lang=lang,
+                home=home,
+                squad_src=squad_src,
+            )
+            src = resolved.path
+            sample_origin = resolved.origin
+        except SampleDownloadError as exc:
+            err_console.print(f"\n[red]✗ {exc}[/red]")
+            err_console.print(
+                f"[dim]{t('init.sample_hint', lang=lang)}[/dim]\n"
+            )
+            # Don't bail: project dir exists, user can still add own input.
+        else:
+            for item in src.iterdir():
+                if item.is_dir():
+                    shutil.copytree(item, input_dir / item.name)
+                else:
+                    shutil.copy2(item, input_dir / item.name)
+            sample_copied_count = sum(1 for _ in input_dir.rglob("*") if _.is_file())
+
+    # ─── Write project.yaml metadata ─────────────────────────────────────
+    metadata = {
+        "name": project,
+        "created_at": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+        "workflow": workflow,
+        "sample": sample,
+        "cli_version": _cli_version(),
+    }
+    (proj_dir / "project.yaml").write_text(
+        yaml.safe_dump(metadata, sort_keys=False, allow_unicode=True),
+        encoding="utf-8",
+    )
+
+    # ─── Success panel ───────────────────────────────────────────────────
+    body_lines: list[str] = [
+        t("init.created", lang=lang, path=str(proj_dir)),
+    ]
+    if sample and sample_copied_count > 0:
+        body_lines.append(
+            t("init.sample_copied", lang=lang, count=sample_copied_count)
+        )
+        if sample_origin in {"cache", "download"}:
+            body_lines.append(
+                f"[dim]{t(f'init.sample_origin_{sample_origin}', lang=lang)}[/dim]"
+            )
+    body_lines.append("")
+    body_lines.append(t("init.next_steps", lang=lang, name=project))
+
+    console.print()
+    console.print(
+        Panel(
+            Text.from_markup("\n".join(body_lines)),
+            title=f"[bold gold1]🌱 {t('init.title', lang=lang, name=project)}[/bold gold1]",
+            border_style="gold1",
+            padding=(1, 2),
+        )
+    )
+    console.print()
+
+
+def _cli_version() -> str:
+    """Read version lazily — avoids circular import at module load."""
+    from lovarch_cli.version import __version__
+
+    return __version__

lovarch_cli/commands/jobs_cmd.py

@@ -0,0 +1,95 @@
+"""`lovarch jobs` — async platform jobs (video, Shotstack export, upscale).
+
+    lovarch jobs list
+    lovarch jobs status <id>
+
+Reads content_video_jobs via the user's own session (owner RLS). Costs are
+shown only as the user's credits.
+"""
+from __future__ import annotations
+
+import asyncio
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+err_console = Console(stderr=True)
+
+jobs_app = typer.Typer(
+    help="Job asincroni della piattaforma (video, export, upscale).",
+    no_args_is_help=True,
+)
+
+_STATUS_ICON = {"done": "✅", "completed": "✅", "failed": "❌", "error": "❌",
+                "running": "⏳", "pending": "⏳", "queued": "⏳"}
+
+
+def _workflows():
+    from lovarch_cli.auth.session import LovarchSession
+    from lovarch_cli.workflows import PlatformWorkflows
+
+    session = LovarchSession.load()
+    if session is None:
+        err_console.print("[red]✗ Non autenticato. Esegui `lovarch login --premium`.[/red]")
+        raise typer.Exit(1)
+    return PlatformWorkflows(session)
+
+
+@jobs_app.command("list")
+def list_command(
+    limit: int = typer.Option(10, "--limit", "-n", help="Quanti job mostrare."),
+) -> None:
+    """Ultimi job asincroni dell'account."""
+    from lovarch_cli.workflows import WorkflowError
+
+    try:
+        jobs = asyncio.run(_workflows().jobs_list(limit=limit))
+    except WorkflowError as exc:
+        err_console.print(f"[red]✗ {exc}[/red]")
+        raise typer.Exit(1)
+    if not jobs:
+        console.print("[dim]Nessun job trovato.[/dim]")
+        return
+    table = Table(title="Job asincroni", header_style="bold gold1")
+    for col in ("Stato", "Engine", "Modello", "Crediti", "Creato", "ID"):
+        table.add_column(col)
+    for j in jobs:
+        status = str(j.get("status", "?"))
+        table.add_row(
+            f"{_STATUS_ICON.get(status, '·')} {status}",
+            str(j.get("engine", "—")), str(j.get("model", "—")),
+            str(j.get("credits_charged", "—")),
+            str(j.get("created_at", ""))[:16], str(j.get("id", ""))[:8],
+        )
+    console.print(table)
+
+
+@jobs_app.command("status")
+def status_command(
+    job_id: str = typer.Argument(..., help="ID del job."),
+) -> None:
+    """Stato dettagliato di un job."""
+    from lovarch_cli.workflows import WorkflowError
+
+    try:
+        j = asyncio.run(_workflows().job_status(job_id))
+    except WorkflowError as exc:
+        err_console.print(f"[red]✗ {exc}[/red]")
+        raise typer.Exit(1)
+    status = str(j.get("status", "?"))
+    console.print(f"{_STATUS_ICON.get(status, '·')} [bold]{status}[/bold] · {j.get('engine')} · {j.get('model')}")
+    if j.get("prompt"):
+        console.print(f"[dim]{str(j['prompt'])[:120]}[/dim]")
+    if j.get("output_url"):
+        console.print(f"[green]Output:[/green] {j['output_url']}")
+    if j.get("error_message"):
+        console.print(f"[red]Errore:[/red] {j['error_message']}")
+    charged = j.get("credits_charged")
+    refunded = j.get("credits_refunded")
+    if charged is not None:
+        line = f"Crediti: {charged}"
+        if refunded:
+            line += f" (rimborsati: {refunded})"
+        console.print(f"[dim]{line}[/dim]")

lovarch_cli/commands/login.py

@@ -0,0 +1,202 @@
+"""arch login — Authentication entry point (Free or Premium).
+
+Subcommand structure:
+  arch login              → interactive: choose Free or Premium
+  arch login --free       → redirects to arch signup (free has no separate login)
+  arch login --premium    → PKCE flow with Lovarch web
+
+Premium PKCE flow:
+  1. Generate verifier + challenge + state via PkceParams.generate()
+  2. Spin up local HTTP server on 127.0.0.1:RANDOM/callback
+  3. Open browser to https://lovarch.com/cli-auth?...
+  4. Show "Waiting for browser..." spinner with timeout 5min
+  5. On callback: validate state matches, POST cli-auth-exchange EF
+  6. Save tokens via keyring_store.save_premium_session
+  7. Show success panel with user info
+
+Localized in 4 languages — keys live in lovarch_cli/i18n/translations/*.json.
+"""
+from __future__ import annotations
+
+import asyncio
+import sys
+import webbrowser
+from typing import Annotated
+from urllib.parse import urlencode
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Prompt
+from rich.text import Text
+
+from lovarch_cli.api import ApiClient, LovarchApiError
+from lovarch_cli.auth import PkceParams, save_premium_session
+from lovarch_cli.auth.local_server import AuthServer
+from lovarch_cli.config import DEFAULT_API_URL
+from lovarch_cli.i18n import current_lang, set_current_lang, t
+
+console = Console()
+err_console = Console(stderr=True)
+
+# https://lovarch.com host — ALWAYS the web app for /cli-auth, NOT the
+# Supabase API URL (which is for EF calls). This is hardcoded because the
+# /cli-auth React page only exists on lovarch.com.
+LOVARCH_WEB_BASE = "https://lovarch.com"
+PKCE_TIMEOUT_SECONDS = 300.0  # 5 minutes — matches DB code TTL
+
+
+def login_command(
+    free: Annotated[
+        bool,
+        typer.Option("--free", help="Free mode (redirects to arch signup)."),
+    ] = False,
+    premium: Annotated[
+        bool,
+        typer.Option(
+            "--premium",
+            help="Premium mode (PKCE flow with Lovarch login).",
+        ),
+    ] = False,
+    lang_flag: Annotated[
+        str | None,
+        typer.Option("--lang", "-l", help="Override language (it/pt/en/es)."),
+    ] = None,
+) -> None:
+    """Login al CLI (Free o Premium)."""
+    if lang_flag is not None:
+        set_current_lang(lang_flag)
+    lang = current_lang()
+
+    # Mutually exclusive flags
+    if free and premium:
+        err_console.print(f"[red]{t('login.modes_mutex', lang=lang)}[/red]")
+        sys.exit(2)
+
+    if not free and not premium:
+        # Interactive choice
+        choice = Prompt.ask(
+            f"[bold]{t('login.choose_mode_prompt', lang=lang)}[/bold]",
+            choices=["free", "premium"],
+            default="free",
+        )
+        free = choice == "free"
+        premium = choice == "premium"
+
+    if free:
+        console.print()
+        console.print(t("login.free_redirect", lang=lang))
+        console.print()
+        sys.exit(0)
+
+    # ─── Premium PKCE flow ───────────────────────────────────────────────
+    pkce = PkceParams.generate()
+    server = AuthServer(port=0)
+    server.start()
+
+    auth_url = (
+        f"{LOVARCH_WEB_BASE}/cli-auth?"
+        + urlencode(
+            {
+                "state": pkce.state,
+                "code_challenge": pkce.code_challenge,
+                "code_challenge_method": pkce.code_challenge_method,
+                "redirect_uri": server.callback_url,
+                "lang": lang,
+            }
+        )
+    )
+
+    console.print()
+    console.print(f"[gold1]→[/gold1] {t('login.opening_browser', lang=lang)}")
+    console.print(f"  [dim]{t('login.manual_url_hint', lang=lang)}[/dim]")
+    console.print(f"  [dim cyan]{auth_url}[/dim cyan]")
+    console.print()
+
+    webbrowser.open(auth_url, new=1, autoraise=True)
+
+    with console.status(
+        Text.from_markup(f"[gold1]{t('login.waiting_callback', lang=lang)}[/gold1]"),
+        spinner="dots",
+    ):
+        result = server.wait_for_callback(PKCE_TIMEOUT_SECONDS)
+
+    server.shutdown()
+
+    # ─── Validate callback ───────────────────────────────────────────────
+    if result.error:
+        if result.error == "timeout":
+            err_console.print(
+                f"\n[red]✗ {t('login.callback_timeout', lang=lang)}[/red]"
+            )
+        elif result.error == "access_denied":
+            err_console.print(
+                f"\n[yellow]✗ {t('login.auth_denied', lang=lang)}[/yellow]"
+            )
+        else:
+            err_console.print(
+                f"\n[red]✗ {result.error}: {result.error_description or ''}[/red]"
+            )
+        sys.exit(1)
+
+    if not result.code or result.state != pkce.state:
+        err_console.print(f"\n[red]✗ {t('login.state_mismatch', lang=lang)}[/red]")
+        sys.exit(1)
+
+    # ─── Exchange code for tokens ────────────────────────────────────────
+    api = ApiClient(base_url=DEFAULT_API_URL)
+    try:
+        response = asyncio.run(
+            api.invoke_ef(
+                "cli-auth-exchange",
+                {
+                    "code": result.code,
+                    "code_verifier": pkce.code_verifier,
+                    "language": lang,
+                },
+            )
+        )
+    except LovarchApiError as exc:
+        err_console.print(f"\n[red]✗ {exc}[/red]")
+        if exc.error_code:
+            err_console.print(f"[dim](error_code: {exc.error_code})[/dim]")
+        sys.exit(1)
+
+    # ─── Save session ────────────────────────────────────────────────────
+    user = response.get("user", {})
+    expires_in = int(response.get("expires_in", 3600))
+    from datetime import datetime, timedelta, timezone
+
+    expires_at = (
+        datetime.now(timezone.utc) + timedelta(seconds=expires_in)
+    ).isoformat(timespec="seconds")
+
+    used_keyring, location = save_premium_session(
+        user_id=user.get("id", ""),
+        email=user.get("email", ""),
+        full_name=user.get("full_name"),
+        access_token=response["access_token"],
+        refresh_token=response["refresh_token"],
+        expires_at=expires_at,
+        language=lang,
+    )
+
+    body = Text.assemble(
+        ("Account: ", "dim"),
+        (f"{user.get('email','')}\n", "bold"),
+        ("User ID: ", "dim"),
+        (f"{user.get('id','')}\n", "bold dim"),
+        ("Expires: ", "dim"),
+        (f"{expires_at}\n", "bold"),
+        ("Storage: ", "dim"),
+        (location, "bold" if used_keyring else "italic yellow"),
+    )
+    console.print()
+    console.print(
+        Panel(
+            body,
+            title=f"[bold green]{t('login.login_success', lang=lang)}[/bold green]",
+            border_style="green",
+            padding=(1, 2),
+        )
+    )

lovarch_cli/commands/mcp_cmd.py

@@ -0,0 +1,26 @@
+"""`lovarch mcp` — run the Lovarch MCP server.
+
+The heavy ``mcp`` SDK import is lazy (inside the command) so that
+``lovarch --help`` and every other command keep working even when the optional
+``[mcp]`` extra is not installed.
+"""
+from __future__ import annotations
+
+import typer
+
+mcp_app = typer.Typer(
+    help="Server MCP di Lovarch (per Claude Code / IDE). Richiede l'extra [mcp].",
+    no_args_is_help=True,
+)
+
+
+@mcp_app.command("serve")
+def serve_command() -> None:
+    """Avvia il server MCP su stdio.
+
+    Registra in Claude Code con:
+        claude mcp add lovarch -- lovarch mcp serve
+    """
+    from lovarch_cli.mcp.server import serve
+
+    serve()