lovarch-cli 0.2.1__py3-none-any.whl

lovarch_cli/verify/normativa.py

@@ -0,0 +1,178 @@
+"""verifica normativa — adversarial two-model check of normative citations.
+
+Pipeline:
+  0. Extract document text (pypdf for .pdf; plain read for .md/.txt).
+  1. Deterministic pre-pass: regex of canonical Italian building references
+     (same table the squad's Q2 verifier uses) — free.
+  2. EXTRACT (Sonnet 5 · executor): list every normative citation with its
+     claimed subject, as strict JSON.
+  3. REFUTE (Opus 4.8 · verifier): adversarially challenge each citation —
+     does the article exist? does it regulate what the document claims?
+     Defaults to skeptical; returns per-citation verdicts as strict JSON.
+  4. Merge: any refuted citation → REJECT; doubts → CONCERNS.
+
+Credits: debited per real tokens via cli-ai-text (executor + verifier calls).
+Report language follows the user's configured language.
+"""
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+CANONICAL_REFS: dict[str, list[str]] = {
+    "DPR 380/2001": [r"dpr\s*380", r"d\.p\.r\.\s*380", r"testo unico edilizia"],
+    "UNI 11337": [r"uni\s*11337"],
+    "CAM 2025": [r"cam\s*edilizia", r"dm\s*23/06/2022", r"criteri ambientali"],
+    "NTC 2018": [r"ntc\s*2018", r"dm\s*17/01/2018"],
+    "D.Lgs 81/2008": [r"d\.?lgs\.?\s*81"],
+    "D.Lgs 42/2004": [r"d\.?lgs\.?\s*42", r"codice beni culturali"],
+    "L. 49/2023": [r"49/2023", r"equo compenso"],
+    "GDPR": [r"gdpr", r"2016/679"],
+}
+
+_EXTRACT_SYSTEM = (
+    "Sei un assistente tecnico-normativo per l'edilizia italiana. Estrai dal "
+    "documento OGNI citazione normativa (leggi, decreti, norme UNI, articoli) "
+    "insieme a ciò che il documento AFFERMA che quella norma regoli. Rispondi "
+    "SOLO con JSON valido, nessun altro testo: "
+    '{"citations": [{"reference": "...", "article": "... o null", '
+    '"claim": "cosa il documento afferma che questa norma regola"}]}'
+)
+
+_REFUTE_SYSTEM = (
+    "Sei un verificatore normativo ADVERSARIALE per l'edilizia italiana. Per "
+    "ogni citazione, cerca attivamente di CONFUTARLA: l'articolo esiste? La "
+    "norma regola davvero ciò che viene affermato? Nel dubbio, sii scettico e "
+    "segnala. Esempi noti: DPR 380/2001 art. 99 riguarda il conglomerato "
+    "cementizio armato (NON le CILA); la L.49/2023 (equo compenso) vincola solo "
+    "verso contraenti forti (PA/banche/grandi imprese), NON i clienti privati. "
+    "Rispondi SOLO con JSON valido: "
+    '{"verdicts": [{"reference": "...", "status": "ok" | "refuted" | "doubt", '
+    '"reason": "spiegazione breve"}]}'
+)
+
+
+@dataclass
+class NormativaReport:
+    verdict: str                        # PASS | CONCERNS | REJECT
+    citations: list[dict] = field(default_factory=list)
+    verdicts: list[dict] = field(default_factory=list)
+    canonical_found: list[str] = field(default_factory=list)
+    credits_charged: int = 0
+    notes: list[str] = field(default_factory=list)
+
+
+class NormativaError(Exception):
+    pass
+
+
+def extract_text(path: str | Path) -> str:
+    """Read document text — pypdf for PDFs, plain read otherwise."""
+    p = Path(path).expanduser()
+    if not p.is_file():
+        raise NormativaError(f"file non trovato: {p}")
+    if p.suffix.lower() == ".pdf":
+        try:
+            from pypdf import PdfReader
+        except ImportError as exc:
+            raise NormativaError(
+                "pypdf non installato — necessario per i PDF (pip install pypdf)."
+            ) from exc
+        try:
+            reader = PdfReader(str(p))
+            return " ".join((page.extract_text() or "") for page in reader.pages)
+        except Exception as exc:  # noqa: BLE001
+            raise NormativaError(f"PDF non leggibile: {str(exc)[:120]}") from exc
+    return p.read_text(encoding="utf-8", errors="ignore")
+
+
+def scan_canonical(text: str) -> list[str]:
+    """Deterministic pre-pass: which canonical references appear in the text."""
+    low = text.lower()
+    return [name for name, patterns in CANONICAL_REFS.items()
+            if any(re.search(pat, low) for pat in patterns)]
+
+
+def _parse_json(raw: str) -> dict:
+    """Robust JSON extraction from an LLM answer (tolerates fences/preamble)."""
+    raw = raw.strip()
+    if raw.startswith("```"):
+        raw = re.sub(r"^```(?:json)?\s*|\s*```$", "", raw, flags=re.S)
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError:
+        match = re.search(r"\{.*\}", raw, flags=re.S)
+        if match:
+            try:
+                return json.loads(match.group(0))
+            except json.JSONDecodeError:
+                pass
+    raise NormativaError("il modello non ha restituito JSON valido.")
+
+
+async def verify_normativa(
+    gateway: Any,
+    document_path: str | Path,
+    *,
+    language: str = "it",
+    max_chars: int = 60_000,
+) -> NormativaReport:
+    """Adversarial normative check of one document. Debits credits (2 calls)."""
+    text = extract_text(document_path)
+    if not text.strip():
+        raise NormativaError("documento vuoto o testo non estraibile.")
+    if len(text) > max_chars:
+        text = text[:max_chars]
+
+    canonical = scan_canonical(text)
+    credits = 0
+
+    # 1 · EXTRACT (executor → Sonnet 5)
+    extraction = await gateway.generate_text(
+        f"DOCUMENTO:\n\n{text}",
+        role="executor",
+        system=_EXTRACT_SYSTEM,
+        max_tokens=2000,
+        language=language,
+        operation_type="verify:normativa:extract",
+    )
+    credits += extraction.credits_charged
+    citations = _parse_json(extraction.text).get("citations") or []
+    if not citations:
+        return NormativaReport(
+            verdict="CONCERNS",
+            canonical_found=canonical,
+            credits_charged=credits,
+            notes=["nessuna citazione normativa trovata nel documento"],
+        )
+
+    # 2 · REFUTE (verifier → Opus 4.8) — independent adversarial pass
+    refutation = await gateway.generate_text(
+        "CITAZIONI DA CONFUTARE:\n\n" + json.dumps(citations, ensure_ascii=False),
+        role="verifier",
+        system=_REFUTE_SYSTEM,
+        max_tokens=2500,
+        language=language,
+        operation_type="verify:normativa:refute",
+    )
+    credits += refutation.credits_charged
+    verdicts = _parse_json(refutation.text).get("verdicts") or []
+
+    statuses = [str(v.get("status", "doubt")).lower() for v in verdicts]
+    if any(s == "refuted" for s in statuses):
+        overall = "REJECT"
+    elif any(s == "doubt" for s in statuses) or not verdicts:
+        overall = "CONCERNS"
+    else:
+        overall = "PASS"
+
+    return NormativaReport(
+        verdict=overall,
+        citations=citations,
+        verdicts=verdicts,
+        canonical_found=canonical,
+        credits_charged=credits,
+    )

lovarch_cli/version.py

@@ -0,0 +1,13 @@
+"""lovarch-cli version — single source of truth.
+
+Read by:
+- pyproject.toml [tool.hatch.version] for build
+- lovarch_cli/__init__.py for runtime
+- arch --version flag
+
+Bump policy (semver):
+- MAJOR: breaking CLI API (subcommand removal, flag rename)
+- MINOR: new subcommands, new agents, new languages
+- PATCH: bug fixes, dependency bumps
+"""
+__version__ = "0.2.1"

lovarch_cli/workflows/__init__.py

@@ -0,0 +1,9 @@
+"""Platform workflows — Lovarch's product features exposed to the CLI/MCP.
+
+Each workflow wraps an existing platform Edge Function (the same ones the web
+app uses), called with the user's premium session so credits are debited
+identically to the app. Cost is reported ONLY in the user's credits.
+"""
+from lovarch_cli.workflows.platform import PlatformWorkflows, WorkflowError
+
+__all__ = ["PlatformWorkflows", "WorkflowError"]

lovarch_cli/workflows/platform.py

@@ -0,0 +1,212 @@
+"""Wrappers over Lovarch platform Edge Functions (Render Studio, branding,
+contents). First batch of the TOP-12 catalog: render, colors, copy.
+
+Design rules (Pablo, 2026-07-03):
+- Cost is the USER's credits, debited server-side by each EF — never expose
+  provider amounts. Wrappers report outputs; balance can be read via
+  `lovarch credits`.
+- Output language follows the user's configured language — every call takes an
+  explicit ``language`` that callers should source from cli-user-context.
+"""
+from __future__ import annotations
+
+import base64
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from lovarch_cli.auth.session import LovarchSession
+
+# Render generation regularly takes 30-120s (image models).
+_RENDER_TIMEOUT = 300.0
+_DEFAULT_TIMEOUT = 120.0
+
+RENDER_MODES = {
+    None,             # legacy sketch/text → render (2D)
+    "room_render",    # 3D room render
+    "render_3d",
+    "plan_to_3d",     # 2D plan → 3D
+    "lighting_only",
+    "closeup_detail",
+    "closeup_angle",
+}
+COLOR_STYLES = {"modern", "vintage", "natural", "bold", "custom"}
+COPY_MODES = {"post", "story", "carousel"}
+
+
+class WorkflowError(Exception):
+    """A platform workflow call failed (message is user-safe)."""
+
+
+@dataclass
+class RenderResult:
+    image_bytes: bytes | None   # decoded when the EF returns a data URL
+    image_url: str | None       # set when the EF returns a hosted URL
+    message: str | None
+
+
+class PlatformWorkflows:
+    """Platform feature calls bound to a premium session."""
+
+    def __init__(self, session: LovarchSession) -> None:
+        self._session = session
+
+    async def _invoke(
+        self, ef: str, body: dict, *, timeout: float = _DEFAULT_TIMEOUT
+    ) -> dict:
+        response = await self._session.request(
+            "POST", f"/functions/v1/{ef}", json=body, timeout=timeout
+        )
+        try:
+            data = response.json()
+        except ValueError:
+            data = {}
+        if response.status_code == 402:
+            raise WorkflowError(
+                "Crediti insufficienti per questa operazione. "
+                f"(disponibili: {data.get('credits_available', '?')}, "
+                f"richiesti: {data.get('credits_needed', '?')})"
+            )
+        if response.status_code != 200:
+            detail = data.get("error") if isinstance(data, dict) else None
+            raise WorkflowError(f"{ef}: {detail or f'HTTP {response.status_code}'}")
+        return data if isinstance(data, dict) else {}
+
+    # ── Render Studio ──────────────────────────────────────────────────────
+
+    async def render(
+        self,
+        description: str,
+        *,
+        mode: str | None = None,
+        render_style: str = "moderno",
+        aspect_ratio: str = "16:9",
+        reference_image_path: str | Path | None = None,
+        language: str = "it",
+    ) -> RenderResult:
+        """Photorealistic render via render-ai-generate.
+
+        ``mode=None`` = sketch/text→render (2D). ``room_render``/``plan_to_3d``
+        = 3D modes (higher credit cost, debited server-side). A reference image
+        (sketch, photo, plan) is sent base64-inline when provided.
+        """
+        if mode not in RENDER_MODES:
+            raise WorkflowError(
+                f"Modo render non valido: {mode}. Validi: "
+                + ", ".join(sorted(m or "(default)" for m in RENDER_MODES))
+            )
+        body: dict[str, Any] = {
+            "description": description,
+            "renderStyle": render_style,
+            "aspectRatio": aspect_ratio,
+            "language": language,
+        }
+        if mode:
+            body["mode"] = mode
+        if reference_image_path:
+            raw = Path(reference_image_path).expanduser().read_bytes()
+            body["referenceImage"] = (
+                "data:image/png;base64," + base64.b64encode(raw).decode()
+            )
+        data = await self._invoke("render-ai-generate", body, timeout=_RENDER_TIMEOUT)
+        image = data.get("image")
+        if not image:
+            raise WorkflowError("render-ai-generate non ha restituito un'immagine.")
+        if isinstance(image, str) and image.startswith("data:"):
+            payload = image.split(",", 1)[1]
+            return RenderResult(
+                image_bytes=base64.b64decode(payload),
+                image_url=None,
+                message=data.get("message"),
+            )
+        return RenderResult(image_bytes=None, image_url=str(image), message=data.get("message"))
+
+    # ── Branding: color palette ────────────────────────────────────────────
+
+    async def colors(
+        self,
+        *,
+        style: str = "modern",
+        base_colors: list[str] | None = None,
+        image_url: str | None = None,
+        language: str = "it",
+    ) -> dict:
+        """Color palette via colors-generate. With ``image_url`` the palette is
+        extracted from the image; otherwise generated from style/base colors."""
+        if style not in COLOR_STYLES:
+            raise WorkflowError(
+                f"Stile non valido: {style}. Validi: {', '.join(sorted(COLOR_STYLES))}"
+            )
+        body: dict[str, Any] = {"style": style, "language": language}
+        if base_colors:
+            body["baseColors"] = base_colors
+        if image_url:
+            body["imageUrl"] = image_url
+            body["extractFromImage"] = True
+        return await self._invoke("colors-generate", body)
+
+    # ── Contents: copy/caption ─────────────────────────────────────────────
+
+    async def copy(
+        self,
+        brief: str,
+        *,
+        mode: str = "post",
+        slide_count: int = 5,
+        language: str = "it",
+    ) -> dict:
+        """Marketing copy (caption + hashtags + headline/slides) via
+        content-copy-generate."""
+        if mode not in COPY_MODES:
+            raise WorkflowError(
+                f"Formato non valido: {mode}. Validi: {', '.join(sorted(COPY_MODES))}"
+            )
+        data = await self._invoke("content-copy-generate", {
+            "brief": brief,
+            "mode": mode,
+            "slideCount": slide_count,
+            "language": language,
+        })
+        return data.get("copy") or data
+
+
+# ── Async jobs (video / Shotstack / upscale) ───────────────────────────────
+
+# User-facing job fields. cost_usd is deliberately EXCLUDED — user-facing cost
+# is always credits (credits_charged/credits_refunded).
+_JOB_FIELDS = (
+    "id,engine,model,status,prompt,output_url,credits_charged,credits_refunded,"
+    "error_message,duration,aspect_ratio,created_at,done_at"
+)
+
+
+class JobsMixin:
+    """PostgREST reads of content_video_jobs (owner RLS) via the user session."""
+
+    async def jobs_list(self, *, limit: int = 10) -> list[dict]:
+        response = await self._session.request(
+            "GET",
+            f"/rest/v1/content_video_jobs?select={_JOB_FIELDS}"
+            f"&order=created_at.desc&limit={limit}",
+        )
+        if response.status_code != 200:
+            raise WorkflowError(f"jobs: HTTP {response.status_code}")
+        data = response.json()
+        return data if isinstance(data, list) else []
+
+    async def job_status(self, job_id: str) -> dict:
+        response = await self._session.request(
+            "GET",
+            f"/rest/v1/content_video_jobs?id=eq.{job_id}&select={_JOB_FIELDS}",
+        )
+        if response.status_code != 200:
+            raise WorkflowError(f"job {job_id}: HTTP {response.status_code}")
+        data = response.json()
+        if not data:
+            raise WorkflowError(f"job non trovato: {job_id}")
+        return data[0]
+
+
+# Attach the mixin methods to PlatformWorkflows (single public class).
+PlatformWorkflows.jobs_list = JobsMixin.jobs_list        # type: ignore[attr-defined]
+PlatformWorkflows.job_status = JobsMixin.job_status      # type: ignore[attr-defined]

lovarch_cli-0.2.1.dist-info/METADATA

@@ -0,0 +1,232 @@
+Metadata-Version: 2.4
+Name: lovarch-cli
+Version: 0.2.1
+Summary: AI-powered architectural project execution CLI by Lovarch
+Project-URL: Homepage, https://archprime.io
+Project-URL: Documentation, https://lovarch.com/cli-docs
+Project-URL: Repository, https://github.com/ArchPrime-official/lovarch-cli
+Project-URL: Issues, https://github.com/ArchPrime-official/lovarch-cli/issues
+Project-URL: Changelog, https://github.com/ArchPrime-official/lovarch-cli/releases
+Project-URL: Course, https://lovarch.com/corso
+Author-email: Pablo Ruan Lopes <pablo@archprime.io>
+License: MIT
+License-File: LICENSE
+Keywords: ai,architecture,bim,cad,cila,ifc,italy,lovarch,uni-11337
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Natural Language :: Italian
+Classifier: Natural Language :: Portuguese
+Classifier: Natural Language :: Spanish
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Python: >=3.11
+Requires-Dist: ezdxf<2.0,>=1.3
+Requires-Dist: httpx<0.29,>=0.27
+Requires-Dist: ifcopenshell<0.9,>=0.7
+Requires-Dist: keyring<26.0,>=24.0
+Requires-Dist: pillow<12.0,>=10.0
+Requires-Dist: pydantic<3.0,>=2.6
+Requires-Dist: pypdf<6.0,>=4.0
+Requires-Dist: pyyaml<7.0,>=6.0
+Requires-Dist: reportlab<5.0,>=4.0
+Requires-Dist: rich<14.0,>=13.7
+Requires-Dist: typer<0.16,>=0.12
+Requires-Dist: xlsxwriter<4.0,>=3.2
+Provides-Extra: dev
+Requires-Dist: mcp>=1.2; extra == 'dev'
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pre-commit>=3.6; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest-cov>=4.1; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Requires-Dist: types-pyyaml>=6.0; extra == 'dev'
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.2; extra == 'mcp'
+Provides-Extra: premium
+Requires-Dist: supabase<3.0,>=2.4; extra == 'premium'
+Description-Content-Type: text/markdown
+
+# lovarch-cli
+
+[![CI](https://github.com/ArchPrime-official/lovarch-cli/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/ArchPrime-official/lovarch-cli/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11%2B-blue.svg)](https://www.python.org/downloads/)
+[![Release](https://img.shields.io/github/v/release/ArchPrime-official/lovarch-cli?include_prereleases)](https://github.com/ArchPrime-official/lovarch-cli/releases)
+
+> **AI-powered architectural project execution CLI** — squad di 17 agenti specializzati che esegue audit input, briefing, normativa IT, CAD, BIM/IFC, computo metrico, capitolato, pratiche edilizie (CILA/SCIA), contratto CNAPPC, energy/LCA preliminare, dossier consolidato — in 14 minuti vs 3 settimane di lavoro tradizionale.
+
+> ⚠️ **Status: BETA (v0.1.x)** — distribuito via Homebrew tap + pipx-from-git. Usato in produzione dagli iscritti al [Corso IA Avanzato per Architetti](https://lovarch.com/corso) (€1.497). Pubblicazione su PyPI valutata per v0.2+.
+
+🌐 **Lingue:** [🇮🇹 Italiano](README.md) (default) · [🇵🇹 Português](README.pt.md) · [🇬🇧 English](README.en.md) · [🇪🇸 Español](README.es.md)
+
+---
+
+## Cosa fa
+
+`lovarch-cli` orchestra il **Squad Architettura-Progetto** di Lovarch — 17 agenti AI con framework documentati (mind clones di Schumacher, Baldwin, Mazria, Deming, Juran, English, Dodds) — per generare 27 deliverable architettonici conformi alla normativa italiana:
+
+- **Audit input** (18 controlli) prima di iniziare
+- **CAD quotato** DXF/PDF (UNI ISO 5457, ±1mm)
+- **BIM IFC4 LOD 300**
+- **Computo metrico** (Prezzario Lombardia 2025)
+- **Capitolato Speciale d'Appalto** (UNI 11337-7 + CAM 2025)
+- **Pratiche edilizie pre-compilate** (CILA/SCIA/Paesaggistica)
+- **Contratto CNAPPC** + Equo Compenso L.49/2023
+- **APE Preliminare + LCA Embodied Carbon**
+- **Dossier finale** ZIP con 27 documenti
+
+## Due modalità
+
+### 🆓 Free Mode (registrazione richiesta)
+
+```bash
+lovarch signup
+# → Cadastro: Nome completo, email, telefono, paese, lingua
+```
+
+- Esegui il squad **localmente** con i tuoi propri API keys (OpenAI, Mapbox, fal.ai)
+- Storage in `~/.lovarch/projects/` (filesystem locale)
+- Database in `~/.lovarch/local.db` (SQLite)
+- Tutti i 17 agenti disponibili
+- Tu paghi le tue API direttamente ai provider
+
+### ⭐ Premium Mode (login Lovarch)
+
+```bash
+arch login --premium
+# → Apre il browser per autenticazione Lovarch (PKCE flow)
+```
+
+- Login con il tuo account Lovarch esistente
+- Crediti inclusi nel piano (Personal €49 / Studio €99 / Business €199)
+- Backend Lovarch (Supabase + S3 + Edge Functions ottimizzate)
+- Sincronizzazione web app `lovarch.com/admin/squad-execution/{id}/live`
+- Team member ownership automatico
+
+## Installazione
+
+### 🍺 Homebrew (raccomandato — macOS / Linux)
+
+Il modo più semplice. Funziona anche per chi non ha familiarità con Python:
+
+```bash
+brew tap archprime-official/lovarch
+brew install lovarch-cli
+lovarch --version
+```
+
+`brew upgrade lovarch-cli` aggiorna alla nuova release.
+
+### 📦 pipx — install isolato da GitHub
+
+Se preferisci un'install Python isolata senza Homebrew (utile su Linux server,
+WSL, o se hai già pipx configurato):
+
+```bash
+# Ultima release (anche pre-release):
+pipx install git+https://github.com/ArchPrime-official/lovarch-cli.git@v0.1.2
+
+# Oppure dal branch main (rolling):
+pipx install git+https://github.com/ArchPrime-official/lovarch-cli.git
+```
+
+`pipx upgrade lovarch-cli` aggiorna alla revisione successiva.
+
+### 🛠️ Da sorgente (per sviluppatori / contributori)
+
+```bash
+git clone https://github.com/ArchPrime-official/lovarch-cli.git
+cd lovarch-cli
+python3.12 -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev]"
+pytest tests/      # → 142 passing
+lovarch --version
+```
+
+Vedi [CONTRIBUTING.md](./CONTRIBUTING.md) per il workflow di sviluppo.
+
+> Backward compatibility: il comando `arch` è alias di `lovarch` per chi ha già muscle memory dalla versione interna di sviluppo.
+>
+> PyPI: la pubblicazione su `pip install lovarch-cli` è rimandata a v0.2+ (i metodi qui sopra coprono tutti i casi d'uso senza dipendere dalla burocrazia PyPI token/2FA).
+
+## Quick start
+
+```bash
+# Verifica installazione
+lovarch --version    # → lovarch-cli 0.1.2
+
+# Primo login (interattivo: Free o Premium)
+lovarch login
+
+# Inizializza un progetto (con --sample scarica villa-chianti da GitHub Releases)
+lovarch init villa-toscana --sample
+
+# Audit dei 18 input prima di girare il pipeline
+lovarch audit villa-toscana
+
+# Esegui workflow (Free=dry-run · Premium=produzione)
+lovarch run dal-brief-al-cantiere villa-toscana
+
+# Consolida deliverable in DOSSIER.zip
+lovarch consolidate villa-toscana
+
+# Stato di tutti i progetti
+lovarch status
+```
+
+## Comandi disponibili
+
+| Comando | Descrizione |
+|---------|-------------|
+| `arch login` | Login Free o Premium |
+| `arch signup` | Cadastro Free interattivo |
+| `arch config` | Configurazione (API keys, lingua, storage path) — _in arrivo (v0.2)_ |
+| `arch init <progetto>` | Crea nuovo progetto con struttura sample-input |
+| `arch audit <progetto>` | Esegue audit input (gate di ingresso) |
+| `arch run <workflow>` | Esegue workflow completo |
+| `arch consolidate <progetto>` | Genera DOSSIER.zip finale |
+| `arch status <id>` | Stato di una esecuzione |
+| `arch upgrade` | CTA per passare da Free a Premium |
+| `arch account delete` | Right-to-erasure GDPR |
+
+Vedi `arch --help` per dettagli completi.
+
+## Limiti dichiarati
+
+`lovarch-cli` **NON** sostituisce:
+
+- ❌ Firma digitale qualificata (QES) dell'architetto abilitato
+- ❌ Calcolo strutturale NTC 2018 (richiede ingegnere strutturale)
+- ❌ Rilievo metrico in loco (richiede sopralluogo)
+- ❌ Coordinamento sicurezza CSP/CSE (D.Lgs 81/2008)
+- ❌ Responsabilità professionale del tecnico
+
+L'utente assume la responsabilità di verifica e revisione professionale prima di qualsiasi presentazione ad autorità.
+
+## Licenza
+
+MIT License — vedi [LICENSE](LICENSE).
+
+## Link
+
+- 🌐 [archprime.io](https://archprime.io) · [lovarch.com](https://lovarch.com)
+- 📚 [Documentazione](https://docs.archprime.io/cli)
+- 🐛 [Issues](https://github.com/ArchPrime-official/lovarch-cli/issues)
+- 📋 [Releases](https://github.com/ArchPrime-official/lovarch-cli/releases) · [Changelog](./CHANGELOG.md)
+- 🤝 [Contributing](./CONTRIBUTING.md)
+- 🎓 [Corso IA Avanzato per Architetti](https://lovarch.com/corso) (€1.497)
+
+---
+
+🤖 Powered by [Lovarch](https://lovarch.com) — AI Growth System for Architects & Designers