lovarch-cli 0.3.0__tar.gz → 0.3.2__tar.gz

{lovarch_cli-0.3.0 → lovarch_cli-0.3.2}/CHANGELOG.md

@@ -5,6 +5,25 @@ All notable changes to `lovarch-cli` are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.3.2] — 2026-07-04
+
+### Added
+- `lovarch archchat list|read` — leggi le conversazioni ArchChat del tuo studio (sola lettura, **nessun credito**): non esegue l'IA di ArchChat, ti dà accesso a ciò che c'è già.
+- `lovarch cad genera` — genera una **pianta DXF 2D reale** (9 layer ISO + cartiglio CNAPPC) da specifiche di ambienti o da un brief (`--brief`, IA→layout). Geometria deterministica gratis; passa `lovarch verifica misure`.
+
+### Notes
+- MCP remoto: OAuth 2.1 (conettori claude.ai senza chiave manuale) + tool `archchat_list`/`archchat_read`.
+
+## [0.3.1] — 2026-07-04
+
+### Added
+- `lovarch do script <topic>` — script di contenuto strutturato via piattaforma (schema drift della EF scripts-generate corretto lato monorepo; refund resiliente).
+- `lovarch verifica computo <file> [--region --version]` — confronto deterministico (gratis) delle voci di un computo col prezzario regionale (tabella `prezzari`, seed Lombardia): codici inesistenti, prezzi fuori tolleranza (±20%), unità incoerenti, totale.
+- `lovarch verifica pratica <file> [--tipo CILA|SCIA]` — verifica adversarial (2 modelli) di una pratica edilizia: completezza (catasto, titolo, asseverazione) e coerenza titolo↔intervento.
+
+### Notes
+- Persistenza premium: il runner ora crea il progetto CRM completo nell'account dell'utente tramite la EF `cli-persist` (scrittura controllata lato server, nessuna scrittura cross-tenant).
+
 ## [Unreleased]
 
 (No unreleased changes yet — last release was v0.3.0.)

{lovarch_cli-0.3.0 → lovarch_cli-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lovarch-cli
-Version: 0.3.0
+Version: 0.3.2
 Summary: AI-powered architectural project execution CLI by Lovarch
 Project-URL: Homepage, https://archprime.io
 Project-URL: Documentation, https://lovarch.com/cli-docs
@@ -222,6 +222,14 @@ lovarch skills install     # → ~/.claude/skills
 Skill disponibili: `interior-designer`, `capitolato`, `preventivi`,
 `direzione-lavori`, `verifica-normativa`, `render`.
 
+## Guida per persona
+
+Architetto, interior designer, geometra, impresa/DL: quale superficie usare
+(Skill / CLI / MCP) e cosa costa crediti → **[docs/guida-per-persona.md](docs/guida-per-persona.md)**.
+
+Workflow composto per interni: `lovarch progetto interni "<brief>" --renders 2`
+(concept → render → preventivo → mini-dossier).
+
 ## Server MCP (Claude Code / Claude / IDE)
 
 Il CLI espone le sue capacità come server **MCP** — 15 tools (render, verifica,

{lovarch_cli-0.3.0 → lovarch_cli-0.3.2}/README.md

@@ -163,6 +163,14 @@ lovarch skills install     # → ~/.claude/skills
 Skill disponibili: `interior-designer`, `capitolato`, `preventivi`,
 `direzione-lavori`, `verifica-normativa`, `render`.
 
+## Guida per persona
+
+Architetto, interior designer, geometra, impresa/DL: quale superficie usare
+(Skill / CLI / MCP) e cosa costa crediti → **[docs/guida-per-persona.md](docs/guida-per-persona.md)**.
+
+Workflow composto per interni: `lovarch progetto interni "<brief>" --renders 2`
+(concept → render → preventivo → mini-dossier).
+
 ## Server MCP (Claude Code / Claude / IDE)
 
 Il CLI espone le sue capacità come server **MCP** — 15 tools (render, verifica,

lovarch_cli-0.3.2/lovarch_cli/cad/__init__.py

@@ -0,0 +1,4 @@
+"""CAD generation (2D DXF via ezdxf). Deterministic, no credits."""
+from lovarch_cli.cad.floorplan import generate_floorplan, FloorplanResult
+
+__all__ = ["generate_floorplan", "FloorplanResult"]

lovarch_cli-0.3.2/lovarch_cli/cad/floorplan.py

@@ -0,0 +1,134 @@
+"""Deterministic 2D CAD floor-plan generator (DXF via ezdxf).
+
+Produces a real .dxf an architect can open in AutoCAD/BricsCAD, laid out on the
+9 ISO layers the platform expects (CAD-A-WALL, -WALL-EXT, -DOOR, -WIND, -DIM,
+-TEXT, -SYMB, -FURN, -CART) with room labels and a CNAPPC cartiglio. No AI, no
+credits — the geometry is computed. It round-trips: a plan generated here passes
+`lovarch verifica misure`.
+
+Input: a list of rooms {name, width_m, height_m}. Rooms are packed left-to-right
+in a single band (simple, predictable). Names are matched to the standard Italian
+room labels for the cartiglio/verify.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+ISO_LAYERS = {
+    "CAD-A-WALL": 7, "CAD-A-WALL-EXT": 7, "CAD-A-DOOR": 3, "CAD-A-WIND": 4,
+    "CAD-A-DIM": 2, "CAD-A-TEXT": 7, "CAD-A-SYMB": 1, "CAD-A-FURN": 8,
+    "CAD-A-CART": 7,
+}
+
+STANDARD_ROOMS = [
+    ("INGRESSO", 2.0, 3.0), ("SOGGIORNO", 5.0, 4.0), ("CUCINA", 3.0, 3.0),
+    ("STUDIO", 3.0, 3.0), ("CAMERA", 4.0, 3.5), ("BAGNO", 2.0, 2.5),
+    ("LAVANDERIA", 2.0, 2.0),
+]
+
+_LABEL_ALIASES = {
+    "ingresso": "INGRESSO", "entrata": "INGRESSO", "soggiorno": "SOGGIORNO",
+    "living": "SOGGIORNO", "salotto": "SOGGIORNO", "cucina": "CUCINA",
+    "studio": "STUDIO", "ufficio": "STUDIO", "camera": "CAMERA",
+    "camera da letto": "CAMERA", "bagno": "BAGNO", "wc": "BAGNO",
+    "lavanderia": "LAVANDERIA",
+}
+
+
+@dataclass
+class FloorplanResult:
+    path: str
+    rooms: list = field(default_factory=list)
+    total_area_m2: float = 0.0
+    layers: int = 0
+
+
+def _norm_label(name: str) -> str:
+    n = (name or "").strip().lower()
+    return _LABEL_ALIASES.get(n, name.strip().upper())
+
+
+def generate_floorplan(
+    rooms: list[dict] | None,
+    *,
+    out_path: str | Path,
+    progetto: str = "Progetto",
+    cliente: str = "Cliente",
+    architetto: str = "Arch.",
+    scala: str = "1:100",
+    data: str = "",
+) -> FloorplanResult:
+    """Generate a DXF floor plan and write it to out_path."""
+    import ezdxf
+
+    specs = rooms if rooms else [{"name": n, "width_m": w, "height_m": h} for n, w, h in STANDARD_ROOMS]
+
+    doc = ezdxf.new(setup=True)
+    msp = doc.modelspace()
+    for name, color in ISO_LAYERS.items():
+        if name not in doc.layers:
+            doc.layers.add(name, color=color)
+
+    def rect(x0, y0, x1, y1, layer):
+        msp.add_lwpolyline([(x0, y0), (x1, y0), (x1, y1), (x0, y1)], close=True,
+                           dxfattribs={"layer": layer})
+
+    x = 0.0
+    gap = 0.15  # wall thickness between rooms
+    max_h = 0.0
+    placed = []
+    total_area = 0.0
+    for spec in specs:
+        label = _norm_label(str(spec.get("name", "")))
+        w = float(spec.get("width_m", 3.0))
+        h = float(spec.get("height_m", 3.0))
+        # interior walls
+        rect(x, 0, x + w, h, "CAD-A-WALL")
+        # a door opening on the bottom wall
+        dx = x + w / 2
+        msp.add_line((dx - 0.4, 0), (dx + 0.4, 0), dxfattribs={"layer": "CAD-A-DOOR"})
+        # a window on the top wall
+        msp.add_line((dx - 0.6, h), (dx + 0.6, h), dxfattribs={"layer": "CAD-A-WIND"})
+        # furniture placeholder (centered box)
+        rect(x + w * 0.35, h * 0.35, x + w * 0.65, h * 0.65, "CAD-A-FURN")
+        # room label + area
+        area = w * h
+        total_area += area
+        msp.add_text(f"{label} {area:.1f} mq",
+                     dxfattribs={"layer": "CAD-A-TEXT", "height": 0.25}
+                     ).set_placement((x + 0.2, h / 2))
+        # dimension text (simple, on DIM layer)
+        msp.add_text(f"{w:.2f}", dxfattribs={"layer": "CAD-A-DIM", "height": 0.18}
+                     ).set_placement((x + w / 2 - 0.3, -0.4))
+        placed.append((label, w, h))
+        x += w + gap
+        max_h = max(max_h, h)
+
+    total_w = x
+    # exterior boundary
+    rect(-0.1, -0.1, total_w, max_h + 0.1, "CAD-A-WALL-EXT")
+    # north arrow symbol
+    msp.add_line((total_w + 1, 0), (total_w + 1, 1.2), dxfattribs={"layer": "CAD-A-SYMB"})
+    msp.add_text("N", dxfattribs={"layer": "CAD-A-SYMB", "height": 0.3}).set_placement((total_w + 0.85, 1.3))
+
+    # Cartiglio CNAPPC (title block) — all required fields on CAD-A-CART.
+    cy = -1.2
+    rect(0, cy - 2.2, 8, cy, "CAD-A-CART")
+    lines = [
+        f"PROGETTO: {progetto}", f"CLIENTE: {cliente}", f"ARCHITETTO: {architetto}",
+        f"SCALA: {scala}", f"DATA: {data or 'in redazione'}",
+        f"SUPERFICIE: {total_area:.1f} mq",
+    ]
+    for i, line in enumerate(lines):
+        msp.add_text(line, dxfattribs={"layer": "CAD-A-CART", "height": 0.22}
+                     ).set_placement((0.2, cy - 0.4 - i * 0.34))
+
+    out = Path(out_path).expanduser()
+    doc.saveas(str(out))
+    return FloorplanResult(
+        path=str(out),
+        rooms=[{"label": l, "width_m": w, "height_m": h} for l, w, h in placed],
+        total_area_m2=round(total_area, 1),
+        layers=len(ISO_LAYERS),
+    )

{lovarch_cli-0.3.0 → lovarch_cli-0.3.2}/lovarch_cli/cli.py

@@ -257,6 +257,30 @@ app.add_typer(
     help="Agenti architetto/interior/cantiere (interior-designer, direzione-lavori...).",
 )
 
+from lovarch_cli.commands.progetto_cmd import progetto_app  # noqa: E402
+
+app.add_typer(
+    progetto_app,
+    name="progetto",
+    help="Workflow composti (progetto interni: concept → render → preventivo → dossier).",
+)
+
+from lovarch_cli.commands.archchat_cmd import archchat_app  # noqa: E402
+
+app.add_typer(
+    archchat_app,
+    name="archchat",
+    help="Leggi le tue conversazioni ArchChat dello studio (sola lettura, nessun credito).",
+)
+
+from lovarch_cli.commands.cad_cmd import cad_app  # noqa: E402
+
+app.add_typer(
+    cad_app,
+    name="cad",
+    help="Genera CAD 2D (DXF) da specifiche di ambienti (deterministico, gratis).",
+)
+
 from lovarch_cli.commands.skills_cmd import skills_app  # noqa: E402
 
 app.add_typer(

lovarch_cli-0.3.2/lovarch_cli/commands/archchat_cmd.py

@@ -0,0 +1,115 @@
+"""`lovarch archchat` — read your ArchChat (office) conversations from the terminal.
+
+    lovarch archchat list
+    lovarch archchat read <conversation_id>
+
+READ-ONLY. This does NOT run the ArchChat AI and costs NO credits — since you're
+already working in your own agent (Claude Code), the point is to pull information
+that already exists in your ArchChat history, not to spend credits per message.
+Reads go through your session with RLS (you only see your own conversations).
+"""
+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)
+
+archchat_app = typer.Typer(
+    help="Leggi le tue conversazioni ArchChat (sola lettura, nessun credito).",
+    no_args_is_help=True,
+)
+
+
+async def _get(session, path: str, params: dict) -> list:
+    resp = await session.request("GET", path, params=params)
+    if resp.status_code != 200:
+        raise RuntimeError(f"HTTP {resp.status_code}")
+    data = resp.json()
+    return data if isinstance(data, list) else []
+
+
+@archchat_app.command("list")
+def list_command(
+    limit: int = typer.Option(20, "--limit", help="Numero di conversazioni."),
+) -> None:
+    """Elenca le tue conversazioni ArchChat (titolo, agente, messaggi, data)."""
+    from lovarch_cli.auth.session import LovarchSession
+
+    session = LovarchSession.load()
+    if session is None:
+        err_console.print("[red]✗ Non autenticato. Esegui `lovarch login --premium`.[/red]")
+        raise typer.Exit(1)
+
+    try:
+        convs = asyncio.run(_get(session, "/rest/v1/archchat_conversations", {
+            "select": "id,title,current_agent,message_count,last_message_at",
+            "order": "last_message_at.desc",
+            "limit": str(max(1, min(limit, 100))),
+        }))
+    except RuntimeError as exc:
+        err_console.print(f"[red]✗ {exc}[/red]"); raise typer.Exit(1)
+
+    if not convs:
+        console.print("[dim]Nessuna conversazione ArchChat.[/dim]")
+        return
+    table = Table(title="ArchChat — conversazioni", header_style="bold gold1")
+    table.add_column("ID", style="cyan", no_wrap=True)
+    table.add_column("Titolo")
+    table.add_column("Agente")
+    table.add_column("Msg", justify="right")
+    table.add_column("Ultimo")
+    for c in convs:
+        last = str(c.get("last_message_at") or "")[:10]
+        table.add_row(str(c.get("id", ""))[:8], str(c.get("title") or "—")[:44],
+                      str(c.get("current_agent") or "—"), str(c.get("message_count") or 0), last)
+    console.print(table)
+    console.print("[dim]Leggi una conversazione: lovarch archchat read <id>[/dim]")
+
+
+@archchat_app.command("read")
+def read_command(
+    conversation_id: str = typer.Argument(..., help="ID della conversazione (vedi `archchat list`)."),
+    limit: int = typer.Option(200, "--limit", help="Numero massimo di messaggi."),
+) -> None:
+    """Leggi i messaggi di una conversazione ArchChat."""
+    from lovarch_cli.auth.session import LovarchSession
+    from rich.markdown import Markdown
+
+    session = LovarchSession.load()
+    if session is None:
+        err_console.print("[red]✗ Non autenticato. Esegui `lovarch login --premium`.[/red]")
+        raise typer.Exit(1)
+
+    async def _run():
+        convs = await _get(session, "/rest/v1/archchat_conversations", {
+            "select": "id,title", "id": f"eq.{conversation_id}", "limit": "1",
+        })
+        if not convs:
+            raise RuntimeError("conversazione non trovata (o non tua).")
+        msgs = await _get(session, "/rest/v1/archchat_messages", {
+            "select": "role,content,agent_type,created_at",
+            "conversation_id": f"eq.{conversation_id}",
+            "order": "created_at.asc",
+            "limit": str(max(1, min(limit, 500))),
+        })
+        return convs[0], msgs
+
+    try:
+        conv, msgs = asyncio.run(_run())
+    except RuntimeError as exc:
+        err_console.print(f"[red]✗ {exc}[/red]"); raise typer.Exit(1)
+
+    console.print(f"\n[bold gold1]{conv.get('title') or 'ArchChat'}[/bold gold1]\n")
+    role_style = {"user": "cyan", "assistant": "green", "system": "dim"}
+    for m in msgs:
+        role = str(m.get("role") or "?")
+        who = m.get("agent_type") or role
+        console.print(f"[{role_style.get(role, 'white')}]● {who}[/]")
+        console.print(Markdown(str(m.get("content") or "")))
+        console.print("")
+    console.print(f"[dim]{len(msgs)} messaggi · sola lettura, nessun credito.[/dim]")

lovarch_cli-0.3.2/lovarch_cli/commands/cad_cmd.py

@@ -0,0 +1,107 @@
+"""`lovarch cad` — generate real 2D CAD (DXF) from room specs.
+
+    lovarch cad genera -o pianta.dxf                       # standard 7-room flat
+    lovarch cad genera --rooms rooms.json -o pianta.dxf    # your rooms
+    lovarch cad genera --brief "attico 90mq, 2 camere" -o pianta.dxf   # AI layout (crediti)
+
+Deterministic geometry (ezdxf) laid out on the 9 ISO layers with a CNAPPC
+cartiglio — no credits for the geometry. `--brief` uses the platform AI only to
+turn a description into a room list (that step debits credits). The output passes
+`lovarch verifica misure`.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+err_console = Console(stderr=True)
+
+cad_app = typer.Typer(
+    help="Genera CAD 2D (DXF) da specifiche di ambienti (deterministico, gratis).",
+    no_args_is_help=True,
+)
+
+_LAYOUT_SYSTEM = (
+    "Sei un assistente di progettazione. Data una descrizione, restituisci SOLO "
+    "JSON valido con la lista degli ambienti e le dimensioni in metri: "
+    '{"rooms": [{"name": "soggiorno", "width_m": 5.0, "height_m": 4.0}, ...]}. '
+    "Usa nomi italiani standard (ingresso, soggiorno, cucina, studio, camera, "
+    "bagno, lavanderia). Dimensioni realistiche e coerenti con la superficie."
+)
+
+
+@cad_app.command("genera")
+def genera_command(
+    output: Path = typer.Option(Path("pianta.dxf"), "--output", "-o", help="File DXF di output."),
+    rooms_file: Path = typer.Option(None, "--rooms", help="JSON con la lista ambienti."),
+    brief: str = typer.Option(None, "--brief", help="Descrizione → layout via IA (crediti)."),
+    progetto: str = typer.Option("Progetto", "--progetto"),
+    cliente: str = typer.Option("Cliente", "--cliente"),
+    architetto: str = typer.Option("Arch.", "--architetto"),
+    scala: str = typer.Option("1:100", "--scala"),
+    data: str = typer.Option("", "--data"),
+    verifica: bool = typer.Option(True, "--verifica/--no-verifica", help="Verifica il DXF generato."),
+    language: str = typer.Option(None, "--language"),
+) -> None:
+    """Genera una pianta DXF (9 layer ISO + cartiglio CNAPPC)."""
+    from lovarch_cli.cad import generate_floorplan
+
+    rooms = None
+    credits_charged = 0
+
+    if brief:
+        # AI layout: turn the description into a room list (debits credits).
+        from lovarch_cli.ai import AiGatewayError, LovarchAiGateway
+        from lovarch_cli.auth.session import LovarchSession
+        from lovarch_cli.i18n import current_lang
+
+        session = LovarchSession.load()
+        if session is None:
+            err_console.print("[red]✗ Non autenticato (--brief richiede login). `lovarch login --premium`.[/red]")
+            raise typer.Exit(1)
+        try:
+            res = asyncio.run(LovarchAiGateway(session).generate_text(
+                brief, role="executor", system=_LAYOUT_SYSTEM, max_tokens=800,
+                language=language or current_lang(), operation_type="cad:layout",
+            ))
+            credits_charged = res.credits_charged
+            parsed = json.loads(res.text[res.text.find("{"):res.text.rfind("}") + 1])
+            rooms = parsed.get("rooms")
+        except (AiGatewayError, ValueError) as exc:
+            err_console.print(f"[red]✗ layout IA non riuscito: {exc}[/red]")
+            raise typer.Exit(1)
+    elif rooms_file:
+        try:
+            data_in = json.loads(Path(rooms_file).expanduser().read_text(encoding="utf-8"))
+            rooms = data_in.get("rooms") if isinstance(data_in, dict) else data_in
+        except (json.JSONDecodeError, OSError) as exc:
+            err_console.print(f"[red]✗ rooms non leggibile: {exc}[/red]")
+            raise typer.Exit(1)
+
+    result = generate_floorplan(
+        rooms, out_path=output, progetto=progetto, cliente=cliente,
+        architetto=architetto, scala=scala, data=data,
+    )
+
+    table = Table(title=f"CAD generato — {result.path}", header_style="bold gold1")
+    table.add_column("Ambiente", style="cyan")
+    table.add_column("L (m)", justify="right")
+    table.add_column("H (m)", justify="right")
+    for r in result.rooms:
+        table.add_row(str(r["label"]), f"{r['width_m']:.2f}", f"{r['height_m']:.2f}")
+    console.print(table)
+    console.print(f"[green]✓[/green] {result.path} · {result.total_area_m2} mq · {result.layers} layer ISO"
+                  + (f" · crediti: {credits_charged}" if credits_charged else " · gratis"))
+
+    if verifica:
+        from lovarch_cli.verify import verify_misure
+        report = verify_misure(result.path)
+        style = {"PASS": "green", "CONCERNS": "yellow", "REJECT": "red"}.get(report.verdict, "white")
+        console.print(f"[dim]verifica misure:[/dim] [bold {style}]{report.verdict}[/bold {style}]"
+                      + (f" — {report.findings[0]}" if report.findings else ""))

{lovarch_cli-0.3.0 → lovarch_cli-0.3.2}/lovarch_cli/commands/do_cmd.py

@@ -154,3 +154,37 @@ def site_command(
         err_console.print(f"[red]✗ {out.get('error')}[/red]"); raise typer.Exit(1)
     console.print(f"[green]✓[/green] Sito: [bold]{out['saved_to']}[/bold] ({out.get('bytes', 0)} bytes)")
 
+
+@do_app.command("script")
+def script_command(
+    topic: str = typer.Argument(..., help="Argomento dello script."),
+    type: str = typer.Option("reel", "--type", help="reel | post | carousel | video…"),
+    goal: str = typer.Option("educare", "--goal", help="Obiettivo del contenuto."),
+    tone: str = typer.Option("professionale", "--tone", help="Tono di voce."),
+    cta: str = typer.Option("", "--cta", help="Call-to-action."),
+    output: Path = typer.Option(None, "--output", "-o", help="Salva lo script su file."),
+    language: str = typer.Option(None, "--language"),
+) -> None:
+    """Script di contenuto strutturato via piattaforma (addebita crediti)."""
+    wf = _workflows()
+    from lovarch_cli.workflows import WorkflowError
+
+    try:
+        s = asyncio.run(wf.script(topic, type=type, goal=goal, tone=tone, cta=cta,
+                                  language=_lang(language)))
+    except WorkflowError as exc:
+        err_console.print(f"[red]✗ {exc}[/red]"); raise typer.Exit(1)
+
+    title = s.get("title") or topic
+    content = s.get("content") or ""
+    console.print(f"\n[bold gold1]{title}[/bold gold1]\n")
+    if content:
+        console.print(content)
+    if s.get("keywords"):
+        console.print("\n[dim]" + " ".join(s["keywords"]) + "[/dim]")
+    if not s.get("persisted", True):
+        console.print("\n[yellow]⚠ Non salvato nel tuo account (crediti rimborsati).[/yellow]")
+    if output:
+        Path(output).expanduser().write_text(content or title, encoding="utf-8")
+        console.print(f"\n[green]✓[/green] salvato: {output}")
+

lovarch_cli-0.3.2/lovarch_cli/commands/progetto_cmd.py

@@ -0,0 +1,79 @@
+"""`lovarch progetto` — composed, phased workflows that chain the agents.
+
+    lovarch progetto interni "attico 90mq, stile caldo minimale, cliente ama il legno"
+    lovarch progetto interni "..." --renders 2 --no-preventivo -o dossier.md
+
+The interior workflow runs: interior-designer (concept) → optional render(s) →
+optional preventivo → assembled mini-dossier. Text uses the platform models;
+renders debit image credits. Everything after the concept is opt-in.
+"""
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.markdown import Markdown
+
+console = Console()
+err_console = Console(stderr=True)
+
+progetto_app = typer.Typer(
+    help="Workflow composti (progetto interni: concept → render → preventivo → dossier).",
+    no_args_is_help=True,
+)
+
+
+@progetto_app.command("interni")
+def interni_command(
+    brief: str = typer.Argument(..., help="Brief del progetto di interni."),
+    renders: int = typer.Option(0, "--renders", help="Numero di render da generare (crediti)."),
+    preventivo: bool = typer.Option(True, "--preventivo/--no-preventivo", help="Includere il preventivo."),
+    lead: str = typer.Option(None, "--lead", help="ID cliente CRM da usare come contesto."),
+    language: str = typer.Option(None, "--language", help="Lingua dell'output."),
+    output: Path = typer.Option(None, "--output", "-o", help="Salva il dossier markdown su file."),
+) -> None:
+    """Progetto di interni composto: concept → render → preventivo → mini-dossier."""
+    from lovarch_cli.ai import AiGatewayError, InsufficientCreditsError, LovarchAiGateway
+    from lovarch_cli.auth.session import LovarchSession
+    from lovarch_cli.i18n import current_lang
+    from lovarch_cli.workflows.progetto import progetto_interni
+
+    session = LovarchSession.load()
+    if session is None:
+        err_console.print("[red]✗ Non autenticato. Esegui `lovarch login --premium`.[/red]")
+        raise typer.Exit(1)
+
+    def _on_phase(name: str) -> None:
+        console.print(f"[dim]→ {name}…[/dim]")
+
+    try:
+        result = asyncio.run(progetto_interni(
+            LovarchAiGateway(session), brief,
+            language=language or current_lang(),
+            want_render=renders > 0,
+            want_preventivo=preventivo,
+            lead_id=lead,
+            render_count=max(renders, 1),
+            on_phase=_on_phase,
+        ))
+    except InsufficientCreditsError as exc:
+        err_console.print(f"[red]✗ Crediti insufficienti: disponibili {exc.available}, richiesti {exc.needed}.[/red]")
+        raise typer.Exit(1)
+    except AiGatewayError as exc:
+        err_console.print(f"[red]✗ {exc}[/red]")
+        raise typer.Exit(1)
+
+    console.print(Markdown(result.dossier_md))
+    for w in result.warnings:
+        console.print(f"  [yellow]· {w}[/yellow]")
+    console.print(f"\n[dim]Crediti addebitati: {result.credits_charged}[/dim]")
+    if output:
+        out = Path(output).expanduser()
+        out.write_text(result.dossier_md, encoding="utf-8")
+        # Save renders next to the dossier as render-1.png, … (referenced in the md).
+        for i, img in enumerate(result.renders, 1):
+            (out.parent / f"render-{i}.png").write_bytes(img)
+        console.print(f"[green]✓[/green] dossier salvato: {output}"
+                      + (f" (+{len(result.renders)} render)" if result.renders else ""))

{lovarch_cli-0.3.0 → lovarch_cli-0.3.2}/lovarch_cli/commands/verifica_cmd.py

@@ -49,6 +49,88 @@ def misure_command(
     raise typer.Exit(0 if report.verdict == "PASS" else (2 if report.verdict == "CONCERNS" else 1))
 
 
+@verifica_app.command("computo")
+def computo_command(
+    computo: Path = typer.Argument(..., help="Computo metrico (.csv o .json: codice,quantita,prezzo_unitario)."),
+    region: str = typer.Option("Lombardia", "--region", help="Regione del prezzario di riferimento."),
+    version: str = typer.Option(None, "--version", help="Versione del prezzario (opzionale)."),
+) -> None:
+    """Confronta le voci del computo col prezzario regionale (gratis, deterministico)."""
+    from lovarch_cli.auth.session import LovarchSession
+    from lovarch_cli.verify import verify_computo
+    from lovarch_cli.verify.computo import ComputoError
+
+    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_computo(session, computo, region=region, version=version))
+    except ComputoError as exc:
+        err_console.print(f"[red]✗ {exc}[/red]")
+        raise typer.Exit(1)
+
+    table = Table(title=f"verifica computo — {computo.name}", header_style="bold gold1")
+    table.add_column("Metrica", style="cyan")
+    table.add_column("Valore", justify="right")
+    table.add_row("Prezzario", str(report.stats.get("prezzario", "—")))
+    table.add_row("Voci totali", str(report.stats.get("voci_totali", "—")))
+    table.add_row("Voci verificate", str(report.stats.get("voci_verificate", "—")))
+    table.add_row("Codici sconosciuti", str(report.stats.get("codici_sconosciuti", 0)))
+    table.add_row("Prezzi fuori tolleranza", str(report.stats.get("prezzi_fuori_tolleranza", 0)))
+    table.add_row("Unità incoerenti", str(report.stats.get("unita_incoerenti", 0)))
+    table.add_row("Totale computo (€)", f"{report.stats.get('totale_computo_eur', 0):,.2f}")
+    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("pratica")
+def pratica_command(
+    documento: Path = typer.Argument(..., help="Pratica edilizia (.pdf, .md, .txt)."),
+    tipo: str = typer.Option(None, "--tipo", help="CILA | SCIA (se noto)."),
+    language: str = typer.Option(None, "--language", help="Lingua del report."),
+) -> None:
+    """Verifica adversarial di una pratica CILA/SCIA (2 modelli · debita crediti)."""
+    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_pratica
+    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_pratica(
+            LovarchAiGateway(session), documento, tipo=tipo,
+            language=language or current_lang(),
+        ))
+    except NormativaError as exc:
+        err_console.print(f"[red]✗ {exc}[/red]")
+        raise typer.Exit(1)
+
+    console.print(f"[dim]Tipo pratica: {report.tipo}[/dim]")
+    table = Table(title=f"verifica pratica — {documento.name}", header_style="bold gold1")
+    table.add_column("Area", style="cyan")
+    table.add_column("Severità", justify="center")
+    table.add_column("Motivo")
+    for f in report.findings:
+        sev = str(f.get("severity", "")).lower()
+        icon = {"critical": "[red]✗[/red]", "concern": "[yellow]?[/yellow]", "info": "[dim]·[/dim]"}.get(sev, "?")
+        table.add_row(str(f.get("area", "—")), icon, str(f.get("reason", ""))[:100])
+    console.print(table)
+    console.print("[dim]Firma e responsabilità restano del tecnico abilitato (BOZZA).[/dim]")
+    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("normativa")
 def normativa_command(
     documento: Path = typer.Argument(..., help="Documento da verificare (.pdf, .md, .txt)."),