PyPI - lovarch-cli - Versions diffs - 0.2.1__py3-none-any.whl - Mend

lovarch-cli 0.2.1__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (122) hide show

lovarch_cli/__init__.py +16 -0
lovarch_cli/__main__.py +10 -0
lovarch_cli/ai/__init__.py +21 -0
lovarch_cli/ai/gateway.py +240 -0
lovarch_cli/api.py +111 -0
lovarch_cli/auth/__init__.py +32 -0
lovarch_cli/auth/keyring_store.py +214 -0
lovarch_cli/auth/local_server.py +165 -0
lovarch_cli/auth/pkce.py +57 -0
lovarch_cli/auth/session.py +189 -0
lovarch_cli/cli.py +262 -0
lovarch_cli/clients/__init__.py +33 -0
lovarch_cli/clients/factory.py +54 -0
lovarch_cli/clients/local_client.py +432 -0
lovarch_cli/clients/lovarch_storage.py +174 -0
lovarch_cli/clients/lovarch_supabase.py +295 -0
lovarch_cli/clients/persistence.py +166 -0
lovarch_cli/clients/storage.py +66 -0
lovarch_cli/commands/__init__.py +10 -0
lovarch_cli/commands/account.py +172 -0
lovarch_cli/commands/audit.py +394 -0
lovarch_cli/commands/config_cmd.py +80 -0
lovarch_cli/commands/consolidate.py +217 -0
lovarch_cli/commands/context_cmd.py +73 -0
lovarch_cli/commands/dev.py +287 -0
lovarch_cli/commands/do_cmd.py +120 -0
lovarch_cli/commands/init.py +218 -0
lovarch_cli/commands/jobs_cmd.py +95 -0
lovarch_cli/commands/login.py +202 -0
lovarch_cli/commands/mcp_cmd.py +26 -0
lovarch_cli/commands/run.py +375 -0
lovarch_cli/commands/signup.py +185 -0
lovarch_cli/commands/status.py +243 -0
lovarch_cli/commands/upgrade.py +108 -0
lovarch_cli/commands/verifica_cmd.py +174 -0
lovarch_cli/config.py +101 -0
lovarch_cli/config_store.py +111 -0
lovarch_cli/credits/__init__.py +35 -0
lovarch_cli/credits/base.py +84 -0
lovarch_cli/credits/factory.py +36 -0
lovarch_cli/credits/local.py +34 -0
lovarch_cli/credits/lovarch.py +56 -0
lovarch_cli/i18n/__init__.py +27 -0
lovarch_cli/i18n/loader.py +121 -0
lovarch_cli/i18n/translations/en.json +168 -0
lovarch_cli/i18n/translations/es.json +168 -0
lovarch_cli/i18n/translations/it.json +168 -0
lovarch_cli/i18n/translations/pt.json +168 -0
lovarch_cli/mcp/__init__.py +9 -0
lovarch_cli/mcp/server.py +199 -0
lovarch_cli/mcp/tools.py +372 -0
lovarch_cli/sample_downloader.py +255 -0
lovarch_cli/squad/README.md +206 -0
lovarch_cli/squad/agents/auditor-input.md +353 -0
lovarch_cli/squad/agents/bim-engineer.md +404 -0
lovarch_cli/squad/agents/briefing-architect.md +249 -0
lovarch_cli/squad/agents/cad-engineer.md +278 -0
lovarch_cli/squad/agents/capitolato-writer.md +256 -0
lovarch_cli/squad/agents/computo-engineer.md +258 -0
lovarch_cli/squad/agents/concept-designer.md +399 -0
lovarch_cli/squad/agents/contratto-architect.md +243 -0
lovarch_cli/squad/agents/deliverable-builder.md +253 -0
lovarch_cli/squad/agents/energy-prelim.md +388 -0
lovarch_cli/squad/agents/pratiche-it.md +251 -0
lovarch_cli/squad/agents/progetto-chief.md +768 -0
lovarch_cli/squad/agents/quality-dati.md +409 -0
lovarch_cli/squad/agents/quality-misure.md +418 -0
lovarch_cli/squad/agents/quality-normativa.md +417 -0
lovarch_cli/squad/agents/quality-output.md +436 -0
lovarch_cli/squad/agents/regolatorio-it.md +278 -0
lovarch_cli/squad/checklists/handoff-quality-gate.md +232 -0
lovarch_cli/squad/checklists/quality-dati-checklist.md +134 -0
lovarch_cli/squad/checklists/quality-misure-checklist.md +139 -0
lovarch_cli/squad/checklists/quality-normativa-checklist.md +121 -0
lovarch_cli/squad/checklists/quality-output-checklist.md +116 -0
lovarch_cli/squad/config.yaml +408 -0
lovarch_cli/squad/data/CHANGELOG.md +272 -0
lovarch_cli/squad/data/agents-prd.md +428 -0
lovarch_cli/squad/data/architettura-progetto-rules.md +328 -0
lovarch_cli/squad/data/handoff-card-template.md +231 -0
lovarch_cli/squad/data/mocks/catasto-visura.json +72 -0
lovarch_cli/squad/data/mocks/firma-envelope.json +43 -0
lovarch_cli/squad/data/prezzario-lombardia-sample.json +312 -0
lovarch_cli/squad/scripts/api_clients.py +206 -0
lovarch_cli/squad/scripts/architect_profile.py +276 -0
lovarch_cli/squad/scripts/deliverable_generators.py +844 -0
lovarch_cli/squad/scripts/generate_attico_brera_dwg.py +369 -0
lovarch_cli/squad/scripts/generate_chianti_dxf.py +368 -0
lovarch_cli/squad/scripts/generate_chianti_images.py +223 -0
lovarch_cli/squad/scripts/generate_real_sample_images.py +189 -0
lovarch_cli/squad/scripts/generate_sample_assets.py +382 -0
lovarch_cli/squad/scripts/lovarch_client.py +1046 -0
lovarch_cli/squad/scripts/pipeline_runner.py +2095 -0
lovarch_cli/squad/scripts/render_dxf_to_png.py +57 -0
lovarch_cli/squad/scripts/run_palestra_demo.sh +277 -0
lovarch_cli/squad/scripts/simulate_squad_execution.py +515 -0
lovarch_cli/squad/scripts/validate-squad.py +383 -0
lovarch_cli/squad/tasks/audit-input.md +146 -0
lovarch_cli/squad/tasks/compute-metric.md +105 -0
lovarch_cli/squad/tasks/consolidate-dossier.md +187 -0
lovarch_cli/squad/tasks/generate-cad-plan.md +120 -0
lovarch_cli/squad/tasks/generate-ifc-model.md +108 -0
lovarch_cli/squad/tasks/write-capitolato.md +100 -0
lovarch_cli/squad/templates/asseverazione-tecnica.md +126 -0
lovarch_cli/squad/templates/capitolato-uni-11337.md +235 -0
lovarch_cli/squad/templates/cila-comune-milano.md +177 -0
lovarch_cli/squad/templates/contratto-cnappc.md +220 -0
lovarch_cli/squad/workflows/dal-brief-al-cantiere.yaml +218 -0
lovarch_cli/squad_loader.py +114 -0
lovarch_cli/verify/__init__.py +15 -0
lovarch_cli/verify/contratto.py +110 -0
lovarch_cli/verify/dossier.py +97 -0
lovarch_cli/verify/misure.py +83 -0
lovarch_cli/verify/normativa.py +178 -0
lovarch_cli/version.py +13 -0
lovarch_cli/workflows/__init__.py +9 -0
lovarch_cli/workflows/platform.py +212 -0
lovarch_cli-0.2.1.dist-info/METADATA +232 -0
lovarch_cli-0.2.1.dist-info/RECORD +122 -0
lovarch_cli-0.2.1.dist-info/WHEEL +4 -0
lovarch_cli-0.2.1.dist-info/entry_points.txt +3 -0
lovarch_cli-0.2.1.dist-info/licenses/LICENSE +38 -0

lovarch_cli/auth/local_server.py ADDED Viewed

@@ -0,0 +1,165 @@
+"""Ephemeral HTTP server for capturing OAuth-style PKCE redirects.
+Listens on 127.0.0.1:RANDOM_PORT. The Lovarch web /cli-auth page redirects
+the browser to http://127.0.0.1:PORT/callback?code=X&state=Y after the user
+authorizes the CLI. This module captures those query params and shuts down.
+Threading: the server runs in a background thread so the CLI's main thread
+can show a "Waiting for browser..." spinner. The result (code+state OR
+error) is delivered via a threading.Event + a result holder.
+Security notes:
+- Bound to 127.0.0.1 only (not 0.0.0.0) — only the user's machine can hit
+- One-shot: serves a single /callback request then shuts down
+- Random port (port=0 lets OS pick) — defeats simple port-based attacks
+- Ignores any path other than /callback (returns 404)
+"""
+from __future__ import annotations
+import threading
+from dataclasses import dataclass
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from typing import Optional
+from urllib.parse import parse_qs, urlparse
+CALLBACK_PATH = "/callback"
+SUCCESS_HTML = """<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>lovarch-cli login</title>
+<style>
+  body { font-family: -apple-system, system-ui, sans-serif;
+         display: flex; align-items: center; justify-content: center;
+         height: 100vh; margin: 0; background: #FAF9F7; color: #09090B; }
+  .card { text-align: center; padding: 2rem 3rem;
+          border: 1px solid rgba(0,0,0,0.08); border-radius: 12px;
+          background: #fff; box-shadow: 0 1px 4px rgba(0,0,0,0.04); }
+  h1 { color: #A16207; margin: 0 0 0.5rem; font-weight: 600; }
+  p { margin: 0.5rem 0 0; color: #71717a; }
+</style>
+</head>
+<body>
+  <div class="card">
+    <h1>✓ lovarch-cli</h1>
+    <p>Login completato. Puoi chiudere questa scheda.</p>
+    <p style="margin-top:1rem;font-size:0.85rem">Login complete — you can close this tab.</p>
+  </div>
+</body>
+</html>
+"""
+ERROR_HTML = """<!doctype html>
+<html lang="en">
+<head><meta charset="utf-8"><title>lovarch-cli login error</title></head>
+<body style="font-family:sans-serif;padding:2rem;background:#FAF9F7">
+<h1 style="color:#dc2626">lovarch-cli login failed</h1>
+<p>{error}</p>
+<p>Torna al terminale per maggiori dettagli. Return to the terminal for details.</p>
+</body>
+</html>
+"""
+@dataclass
+class CallbackResult:
+    """Result captured from the browser redirect."""
+    code: Optional[str] = None
+    state: Optional[str] = None
+    error: Optional[str] = None
+    error_description: Optional[str] = None
+class _Handler(BaseHTTPRequestHandler):
+    """Per-request handler. Stores result on the parent server."""
+    server_version = "lovarch-cli/0.1"
+    def log_message(self, format: str, *args: object) -> None:  # type: ignore[override]
+        # Suppress default stderr logging — we capture via spinner
+        return
+    def do_GET(self) -> None:  # noqa: N802 (BaseHTTPRequestHandler API)
+        parsed = urlparse(self.path)
+        if parsed.path != CALLBACK_PATH:
+            self.send_response(404)
+            self.end_headers()
+            self.wfile.write(b"Not Found")
+            return
+        params = parse_qs(parsed.query, keep_blank_values=True)
+        result: CallbackResult = self.server.callback_result  # type: ignore[attr-defined]
+        if "error" in params:
+            result.error = params["error"][0]
+            result.error_description = params.get(
+                "error_description", [""]
+            )[0]
+            html = ERROR_HTML.format(error=result.error)
+            self.send_response(400)
+            self.send_header("Content-Type", "text/html; charset=utf-8")
+            self.end_headers()
+            self.wfile.write(html.encode("utf-8"))
+        elif "code" in params and "state" in params:
+            result.code = params["code"][0]
+            result.state = params["state"][0]
+            self.send_response(200)
+            self.send_header("Content-Type", "text/html; charset=utf-8")
+            self.end_headers()
+            self.wfile.write(SUCCESS_HTML.encode("utf-8"))
+        else:
+            result.error = "missing_params"
+            result.error_description = "neither code/state nor error returned"
+            self.send_response(400)
+            self.end_headers()
+            self.wfile.write(b"Missing parameters")
+        # Signal main thread that we got the redirect
+        self.server.done_event.set()  # type: ignore[attr-defined]
+class AuthServer:
+    """Single-shot localhost HTTP server for PKCE callback capture."""
+    def __init__(self, port: int = 0) -> None:
+        self._httpd = HTTPServer(("127.0.0.1", port), _Handler)
+        # Attach result holder + event to the server instance for handler access
+        self._httpd.callback_result = CallbackResult()  # type: ignore[attr-defined]
+        self._httpd.done_event = threading.Event()  # type: ignore[attr-defined]
+        self._thread: Optional[threading.Thread] = None
+    @property
+    def port(self) -> int:
+        return self._httpd.server_address[1]
+    @property
+    def callback_url(self) -> str:
+        return f"http://127.0.0.1:{self.port}{CALLBACK_PATH}"
+    def start(self) -> None:
+        """Start serving in a background thread."""
+        self._thread = threading.Thread(
+            target=self._httpd.serve_forever,
+            daemon=True,
+            name="lovarch-cli-auth-server",
+        )
+        self._thread.start()
+    def wait_for_callback(self, timeout_seconds: float) -> CallbackResult:
+        """Block until the browser hits /callback or timeout elapses."""
+        got_it = self._httpd.done_event.wait(timeout=timeout_seconds)  # type: ignore[attr-defined]
+        if not got_it:
+            self._httpd.callback_result.error = "timeout"  # type: ignore[attr-defined]
+            self._httpd.callback_result.error_description = (  # type: ignore[attr-defined]
+                f"No callback within {timeout_seconds}s"
+            )
+        return self._httpd.callback_result  # type: ignore[attr-defined,return-value]
+    def shutdown(self) -> None:
+        """Stop the HTTP server and wait for thread to join."""
+        self._httpd.shutdown()
+        self._httpd.server_close()
+        if self._thread:
+            self._thread.join(timeout=2.0)

lovarch_cli/auth/pkce.py ADDED Viewed

@@ -0,0 +1,57 @@
+"""PKCE (RFC 7636) parameter generation for lovarch-cli premium login.
+PKCE = Proof Key for Code Exchange. Used to authenticate a CLI/native app
+without storing client secrets:
+- Generate random `code_verifier` (43-128 chars, URL-safe)
+- Compute `code_challenge` = base64url(SHA-256(code_verifier))
+- Send challenge to authorization server in initial request
+- Send verifier later when exchanging code for tokens
+- Server validates SHA-256(verifier) == challenge before issuing tokens
+Why: a CLI cannot keep a client_secret confidential (it's bundled in the
+distribution). PKCE replaces that with a per-session ephemeral secret.
+"""
+from __future__ import annotations
+import base64
+import hashlib
+import secrets
+from dataclasses import dataclass
+def _b64url(data: bytes) -> str:
+    """Encode bytes as base64url (no padding)."""
+    return base64.urlsafe_b64encode(data).rstrip(b"=").decode("ascii")
+@dataclass(frozen=True)
+class PkceParams:
+    """PKCE parameters generated by the CLI for a single login attempt."""
+    code_verifier: str
+    code_challenge: str
+    state: str
+    @classmethod
+    def generate(cls) -> PkceParams:
+        """Generate a fresh PKCE param set per RFC 7636.
+        - code_verifier: 64 random URL-safe bytes → ~86 chars (within 43-128 spec)
+        - code_challenge: base64url(SHA-256(verifier))
+        - state: 24 random URL-safe bytes for CSRF protection (~32 chars)
+        """
+        verifier = secrets.token_urlsafe(64)
+        verifier_bytes = verifier.encode("ascii")
+        challenge_digest = hashlib.sha256(verifier_bytes).digest()
+        challenge = _b64url(challenge_digest)
+        state = secrets.token_urlsafe(24)
+        return cls(
+            code_verifier=verifier,
+            code_challenge=challenge,
+            state=state,
+        )
+    @property
+    def code_challenge_method(self) -> str:
+        """RFC 7636 challenge method identifier — always SHA-256 here."""
+        return "S256"

lovarch_cli/auth/session.py ADDED Viewed

@@ -0,0 +1,189 @@
+"""LovarchSession — manages Supabase access/refresh tokens with auto-refresh.
+Wraps httpx and the Supabase /auth/v1/token endpoint to:
+- Inject Authorization: Bearer {access_token} on every call
+- Detect 401 responses and automatically refresh tokens
+- Persist refreshed tokens back to OS keyring + credentials.json
+- Surface fatal errors (refresh failed) so callers can prompt re-login
+Used by LovarchSupabaseClient (DataPersistenceClient impl) and
+LovarchStorage (StorageClient impl). NOT used by free-mode clients.
+"""
+from __future__ import annotations
+import asyncio
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+from typing import Any
+import httpx
+from lovarch_cli.auth.keyring_store import (
+    PremiumSession,
+    load_premium_session,
+    save_premium_session,
+)
+from lovarch_cli.config import DEFAULT_API_ANON_KEY, DEFAULT_API_URL
+class LovarchSessionError(Exception):
+    """Raised when token refresh fails permanently — caller should re-login."""
+@dataclass
+class _RefreshResult:
+    access_token: str
+    refresh_token: str
+    expires_in: int
+class LovarchSession:
+    """Holds + auto-refreshes a Supabase user session."""
+    def __init__(
+        self,
+        session: PremiumSession,
+        api_url: str = DEFAULT_API_URL,
+        anon_key: str = DEFAULT_API_ANON_KEY,
+    ) -> None:
+        self._session = session
+        self._api_url = api_url.rstrip("/")
+        self._anon_key = anon_key
+        self._refresh_lock = asyncio.Lock()
+    # ─── Public load/save helpers ─────────────────────────────────────────
+    @classmethod
+    def load(cls) -> "LovarchSession | None":
+        """Load from keyring + credentials.json, return None if no session."""
+        ps = load_premium_session()
+        if ps is None:
+            return None
+        return cls(ps)
+    @property
+    def user_id(self) -> str:
+        return self._session.user_id
+    @property
+    def email(self) -> str:
+        return self._session.email
+    @property
+    def access_token(self) -> str:
+        return self._session.access_token
+    # ─── HTTP request with auto-refresh ───────────────────────────────────
+    async def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: dict[str, Any] | None = None,
+        json: Any = None,
+        headers: dict[str, str] | None = None,
+        content: bytes | None = None,
+        timeout: float = 60.0,
+    ) -> httpx.Response:
+        """Perform HTTP request with Authorization injected; refresh on 401."""
+        url = f"{self._api_url}{path}" if path.startswith("/") else path
+        merged_headers: dict[str, str] = {
+            "User-Agent": "lovarch-cli/0.1.0",
+            "apikey": self._anon_key,
+            "Authorization": f"Bearer {self._session.access_token}",
+        }
+        if headers:
+            merged_headers.update(headers)
+        async with httpx.AsyncClient(timeout=timeout) as client:
+            response = await client.request(
+                method,
+                url,
+                params=params,
+                json=json,
+                headers=merged_headers,
+                content=content,
+            )
+            if response.status_code != 401:
+                return response
+            # ─── Try refresh + retry once ────────────────────────────────
+            try:
+                await self._refresh()
+            except LovarchSessionError:
+                return response  # bubble original 401 to caller
+            merged_headers["Authorization"] = f"Bearer {self._session.access_token}"
+            response = await client.request(
+                method,
+                url,
+                params=params,
+                json=json,
+                headers=merged_headers,
+                content=content,
+            )
+            return response
+    # ─── Refresh logic ────────────────────────────────────────────────────
+    async def _refresh(self) -> None:
+        """Refresh access_token using refresh_token. Persist on success."""
+        async with self._refresh_lock:
+            url = f"{self._api_url}/auth/v1/token?grant_type=refresh_token"
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                response = await client.post(
+                    url,
+                    json={"refresh_token": self._session.refresh_token},
+                    headers={
+                        "apikey": self._anon_key,
+                        "Content-Type": "application/json",
+                    },
+                )
+            if response.status_code >= 400:
+                msg = (
+                    f"Token refresh failed: HTTP {response.status_code} "
+                    f"{response.text[:200]}"
+                )
+                raise LovarchSessionError(msg)
+            try:
+                data = response.json()
+            except ValueError as exc:
+                raise LovarchSessionError(
+                    f"Invalid JSON from refresh endpoint: {exc}"
+                ) from exc
+            access = data.get("access_token")
+            refresh = data.get("refresh_token") or self._session.refresh_token
+            expires_in = int(data.get("expires_in", 3600))
+            if not access:
+                raise LovarchSessionError("Refresh response missing access_token")
+            new_expires = (
+                datetime.now(timezone.utc) + timedelta(seconds=expires_in)
+            ).isoformat(timespec="seconds")
+            # Update in-memory + persist
+            self._session = PremiumSession(
+                user_id=self._session.user_id,
+                email=self._session.email,
+                full_name=self._session.full_name,
+                access_token=access,
+                refresh_token=refresh,
+                expires_at=new_expires,
+                metadata=self._session.metadata,
+            )
+            save_premium_session(
+                user_id=self._session.user_id,
+                email=self._session.email,
+                full_name=self._session.full_name,
+                access_token=access,
+                refresh_token=refresh,
+                expires_at=new_expires,
+                language=self._session.metadata.get("language", "it"),
+            )

lovarch_cli/cli.py ADDED Viewed

@@ -0,0 +1,262 @@
+"""lovarch-cli — Typer app entry point.
+Subcommand structure (loaded lazily as commands are implemented):
+    lovarch login      → Free or Premium authentication
+    lovarch signup     → Free mode registration (name, email, phone)
+    lovarch config     → API keys, language, storage path
+    lovarch init       → Create new project with sample-input
+    lovarch audit      → Run input audit (18-point checklist)
+    lovarch run        → Execute full workflow
+    lovarch consolidate → Generate DOSSIER.zip
+    lovarch status     → Inspect execution
+    lovarch upgrade    → CTA from Free to Premium
+    lovarch account    → GDPR right-to-erasure
+Global flags:
+    --lang {it,pt,en,es}  → override detected language
+    --version             → print version and exit
+    --verbose             → verbose logging
+"""
+from __future__ import annotations
+import sys
+from typing import Annotated, Optional
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+from lovarch_cli.i18n import current_lang, set_current_lang, t
+from lovarch_cli.version import __version__
+console = Console()
+err_console = Console(stderr=True)
+app = typer.Typer(
+    name="lovarch",
+    help=(
+        "lovarch-cli — AI-powered architectural project execution.\n\n"
+        "Squad di 17 agenti specializzati che genera audit, CAD, BIM/IFC, "
+        "computo, capitolato, pratiche IT, contratto CNAPPC, energy/LCA "
+        "in 14 minuti vs 3 settimane di lavoro tradizionale."
+    ),
+    no_args_is_help=True,
+    add_completion=True,
+    rich_markup_mode="rich",
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+def _version_callback(value: bool) -> None:
+    """Print version and exit (used by --version global flag)."""
+    if value:
+        console.print(f"lovarch-cli [bold]{__version__}[/bold]")
+        raise typer.Exit()
+@app.callback()
+def main(
+    ctx: typer.Context,
+    version: Annotated[
+        Optional[bool],
+        typer.Option(
+            "--version",
+            "-V",
+            callback=_version_callback,
+            is_eager=True,
+            help="Mostra la versione e esce.",
+        ),
+    ] = None,
+    lang: Annotated[
+        Optional[str],
+        typer.Option(
+            "--lang",
+            "-l",
+            help="Lingua: it, pt, en, es (default: rilevata automaticamente).",
+        ),
+    ] = None,
+    verbose: Annotated[
+        bool,
+        typer.Option(
+            "--verbose",
+            "-v",
+            help="Output dettagliato per debug.",
+        ),
+    ] = False,
+) -> None:
+    """lovarch-cli — global flags handler."""
+    # Resolve --lang precedence: explicit flag > $LOVARCH_LANG > $LANG > 'it'.
+    # set_current_lang() validates against VALID_LANGUAGES and falls back to
+    # env detection if the override is invalid.
+    if lang is not None:
+        set_current_lang(lang)
+    ctx.ensure_object(dict)
+    ctx.obj["lang"] = lang
+    ctx.obj["verbose"] = verbose
+@app.command(name="info")
+def info_cmd() -> None:
+    """Mostra informazioni sulla installazione corrente."""
+    lang = current_lang()
+    title = Text("lovarch-cli", style="bold gold1")
+    body = Text.assemble(
+        ("Version: ", "dim"),
+        (f"{__version__}\n", "bold"),
+        ("Python:  ", "dim"),
+        (f"{sys.version.split()[0]}\n", "bold"),
+        ("Platform:", "dim"),
+        (f" {sys.platform}\n", "bold"),
+        ("Squad:   ", "dim"),
+        ("architettura-progetto (17 agents, 6 tasks, 1 workflow)\n", "bold"),
+        ("Mode:    ", "dim"),
+        (t("info.mode_not_configured", lang=lang), "italic yellow"),
+    )
+    console.print(
+        Panel(
+            Text.assemble(title, "\n\n", body),
+            title=f"[bold]{t('info.title', lang=lang)}[/bold]",
+            border_style="gold1",
+            padding=(1, 2),
+        )
+    )
+    console.print(
+        f"\n[dim]{t('info.powered_by', lang=lang)}[/dim]\n"
+        f"[dim]{t('info.course_promo', lang=lang)}[/dim]\n"
+    )
+# ════════════════════════════════════════════════════════════════════════════
+# Subcommands registration
+#
+# Each subcommand is either:
+# - a single-action command via app.command()(fn)
+# - a multi-subcommand group via app.add_typer(sub.app, name=...)
+# ════════════════════════════════════════════════════════════════════════════
+# Story 2.2 — Free mode signup with lead capture
+from lovarch_cli.commands.signup import signup_command  # noqa: E402
+app.command(name="signup", help="Cadastro Free interattivo (lead capture).")(
+    signup_command
+)
+# Story 2.3 — GDPR right-to-erasure + account info
+from lovarch_cli.commands import account as account_cmd  # noqa: E402
+app.add_typer(
+    account_cmd.app,
+    name="account",
+    help="Gestione account (info, delete GDPR).",
+)
+# Story 3.3 — premium PKCE login + free redirect
+from lovarch_cli.commands.login import login_command  # noqa: E402
+app.command(name="login", help="Login al CLI (--free o --premium).")(
+    login_command
+)
+# Story 3.4 — CTA Free → Premium upgrade flow (opens browser)
+from lovarch_cli.commands.upgrade import upgrade_command  # noqa: E402
+app.command(name="upgrade", help="Passa da Free a Premium (apre il browser).")(
+    upgrade_command
+)
+# Fase A.1 — Create a new project directory (+ optional sample-input)
+from lovarch_cli.commands.init import init_command  # noqa: E402
+app.command(name="init", help="Inizializza un nuovo progetto (con --sample copia villa-chianti).")(
+    init_command
+)
+# Fase A.2 — 18-point input validation checklist
+from lovarch_cli.commands.audit import audit_command  # noqa: E402
+app.command(name="audit", help="Audit dei 18 input prima del run (verdict PASS/CONCERNS/FAIL).")(
+    audit_command
+)
+# Fase A.3 — Execute the squad pipeline (subprocess wrapper, premium = real)
+from lovarch_cli.commands.run import run_command  # noqa: E402
+app.command(name="run", help="Esegui il pipeline (Free=dry-run, Premium=reale).")(
+    run_command
+)
+# Fase A.4 — Bundle run output into DOSSIER.zip
+from lovarch_cli.commands.consolidate import consolidate_command  # noqa: E402
+app.command(name="consolidate", help="Genera DOSSIER.zip dall'output di un run.")(
+    consolidate_command
+)
+# Fase A.5 — Inspect project state and recent runs
+from lovarch_cli.commands.status import status_command  # noqa: E402
+app.command(name="status", help="Stato dei progetti e ultime esecuzioni.")(
+    status_command
+)
+# Squad-dev-loop — developer tooling (squad path resolution, vendor refresh)
+from lovarch_cli.commands.dev import dev_app  # noqa: E402
+app.add_typer(
+    dev_app,
+    name="dev",
+    help="Developer tooling for the squad payload (contributors only).",
+)
+from lovarch_cli.commands.mcp_cmd import mcp_app  # noqa: E402
+app.add_typer(
+    mcp_app,
+    name="mcp",
+    help="Server MCP (Claude Code / IDE). Richiede l'extra [mcp].",
+)
+from lovarch_cli.commands.context_cmd import context_app  # noqa: E402
+app.add_typer(
+    context_app,
+    name="context",
+    help="Contesto di personalizzazione usato dagli agenti AI (premium).",
+)
+from lovarch_cli.commands.do_cmd import do_app  # noqa: E402
+app.add_typer(
+    do_app,
+    name="do",
+    help="Workflow della piattaforma: render, colors, copy (premium).",
+)
+from lovarch_cli.commands.verifica_cmd import verifica_app  # noqa: E402
+app.add_typer(
+    verifica_app,
+    name="verifica",
+    help="Verifica dati: misure DXF (gratis) · normativa adversarial (premium).",
+)
+from lovarch_cli.commands.jobs_cmd import jobs_app  # noqa: E402
+app.add_typer(
+    jobs_app,
+    name="jobs",
+    help="Job asincroni (video, export, upscale) — stato e output.",
+)
+from lovarch_cli.commands.config_cmd import config_app  # noqa: E402
+app.add_typer(
+    config_app,
+    name="config",
+    help="Configurazione utente (lingua, storage, API keys Free mode).",
+)
+if __name__ == "__main__":
+    app()