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

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

@@ -5,6 +5,15 @@ 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_cli-0.3.1 → lovarch_cli-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lovarch-cli
-Version: 0.3.1
+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.1 → 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.1 → 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.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.1 → lovarch_cli-0.3.2}/lovarch_cli/version.py

@@ -10,4 +10,4 @@ Bump policy (semver):
 - MINOR: new subcommands, new agents, new languages
 - PATCH: bug fixes, dependency bumps
 """
-__version__ = "0.3.1"
+__version__ = "0.3.2"

lovarch_cli-0.3.2/lovarch_cli/workflows/progetto.py

@@ -0,0 +1,129 @@
+"""Composed workflow `progetto interni` — chains the standalone agents into a
+single phased run: interior-designer (concept) → optional render(s) → optional
+preventivo → assembled mini-dossier (markdown).
+
+This is what turns the F11 agents from standalone tools into a real workflow.
+Everything is opt-in (the user chooses what to generate); text runs on the
+platform text models (Sonnet/Opus by role) and renders debit image credits.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from lovarch_cli.agents import run_agent
+from lovarch_cli.ai import AiGatewayError, LovarchAiGateway
+
+
+@dataclass
+class ProgettoInterniResult:
+    dossier_md: str
+    sections: dict = field(default_factory=dict)   # concept / preventivo
+    renders: list[bytes] = field(default_factory=list)  # generated render image bytes
+    credits_charged: int = 0
+    warnings: list[str] = field(default_factory=list)
+
+
+async def progetto_interni(
+    gateway: LovarchAiGateway,
+    brief: str,
+    *,
+    language: str = "it",
+    want_render: bool = False,
+    want_preventivo: bool = True,
+    lead_id: str | None = None,
+    render_count: int = 1,
+    on_phase: Any = None,   # optional callback(phase_name) for progress UI
+) -> ProgettoInterniResult:
+    """Run the composed interior-design workflow. Each phase is opt-in."""
+    def _phase(name: str) -> None:
+        if callable(on_phase):
+            on_phase(name)
+
+    credits = 0
+    sections: dict = {}
+    renders: list[bytes] = []
+    warnings: list[str] = []
+
+    # Phase 1 — Concept (interior-designer, always).
+    _phase("interior-designer")
+    concept = await run_agent(
+        gateway, "interior-designer", brief, language=language, lead_id=lead_id,
+    )
+    credits += concept.credits_charged
+    sections["concept"] = concept.text
+
+    # Phase 2 — Render(s) (opt-in; debits image credits).
+    if want_render:
+        _phase("render")
+        # Derive a render prompt from the brief; keep it grounded in the concept.
+        render_prompt = (
+            f"Interior design render, fotorealistico. {brief}. "
+            "Illuminazione naturale, materiali coerenti col concept, "
+            "composizione elegante da presentazione."
+        )
+        for _ in range(max(1, render_count)):
+            try:
+                r = await gateway.generate_image(
+                    render_prompt, quality="medium", aspect="16:9",
+                    operation_type="progetto-interni:render",
+                )
+                credits += r.credits_charged
+                if r.image_bytes:
+                    renders.append(r.image_bytes)
+            except AiGatewayError as exc:
+                warnings.append(f"render non riuscito: {exc}")
+                break
+
+    # Phase 3 — Preventivo (opt-in; the preventivi agent uses the fiscal context).
+    if want_preventivo:
+        _phase("preventivi")
+        try:
+            prev = await run_agent(
+                gateway, "preventivi",
+                f"Progetto di interni. Brief: {brief}\n\nConcept sintetico:\n{concept.text[:2000]}",
+                language=language, lead_id=lead_id,
+            )
+            credits += prev.credits_charged
+            sections["preventivo"] = prev.text
+        except AiGatewayError as exc:
+            warnings.append(f"preventivo non generato: {exc}")
+
+    # Phase 4 — Assemble the mini-dossier. Renders are referenced by the file
+    # names the command will save them under (render-1.png, …).
+    _phase("dossier")
+    dossier = _assemble_dossier(brief, sections, len(renders), language)
+
+    return ProgettoInterniResult(
+        dossier_md=dossier,
+        sections=sections,
+        renders=renders,
+        credits_charged=credits,
+        warnings=warnings,
+    )
+
+
+def _assemble_dossier(
+    brief: str, sections: dict, render_count: int, language: str,
+) -> str:
+    banner = {
+        "it": "> **BOZZA** — elaborato generato con IA. Firma e responsabilità "
+              "restano del professionista abilitato.",
+        "en": "> **DRAFT** — AI-generated. Sign-off and liability remain with the "
+              "licensed professional.",
+        "pt": "> **RASCUNHO** — gerado por IA. Assinatura e responsabilidade "
+              "permanecem do profissional habilitado.",
+        "es": "> **BORRADOR** — generado con IA. Firma y responsabilidad del "
+              "profesional habilitado.",
+    }.get(language, "")
+
+    parts = [f"# Progetto di interni\n\n{banner}\n", f"**Brief:** {brief}\n"]
+    if sections.get("concept"):
+        parts.append("## Concept e progetto\n\n" + sections["concept"])
+    if render_count:
+        parts.append("## Render\n\n" + "\n".join(
+            f"![render {i}](render-{i}.png)" for i in range(1, render_count + 1)
+        ))
+    if sections.get("preventivo"):
+        parts.append("## Preventivo / Proposta\n\n" + sections["preventivo"])
+    return "\n\n".join(parts) + "\n"