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

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

@@ -5,6 +5,16 @@ 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.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.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lovarch-cli
-Version: 0.3.0
+Version: 0.3.1
 Summary: AI-powered architectural project execution CLI by Lovarch
 Project-URL: Homepage, https://archprime.io
 Project-URL: Documentation, https://lovarch.com/cli-docs

{lovarch_cli-0.3.0 → lovarch_cli-0.3.1}/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.0 → lovarch_cli-0.3.1}/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)."),

{lovarch_cli-0.3.0 → lovarch_cli-0.3.1}/lovarch_cli/verify/__init__.py

@@ -7,9 +7,14 @@ Sonnet 5 (executor) extracts/structures → Opus 4.8 (verifier) tries to refute
 each claim independently. Credits are debited per real tokens via cli-ai-text;
 deterministic checks are free.
 """
+from lovarch_cli.verify.computo import verify_computo
 from lovarch_cli.verify.contratto import verify_contratto
 from lovarch_cli.verify.dossier import verify_dossier
 from lovarch_cli.verify.misure import verify_misure
 from lovarch_cli.verify.normativa import verify_normativa
+from lovarch_cli.verify.pratica import verify_pratica
 
-__all__ = ["verify_contratto", "verify_dossier", "verify_misure", "verify_normativa"]
+__all__ = [
+    "verify_computo", "verify_contratto", "verify_dossier",
+    "verify_misure", "verify_normativa", "verify_pratica",
+]

lovarch_cli-0.3.1/lovarch_cli/verify/computo.py

@@ -0,0 +1,149 @@
+"""verifica computo — deterministic check of a computo metrico against the
+regional prezzario (table `prezzari`). No LLM, no credits: it compares each
+voce's unit price and unit of measure to the official reference and flags
+codes that don't exist, prices out of tolerance, and unit mismatches.
+
+Input file: CSV (header: codice,descrizione,quantita,prezzo_unitario[,unita])
+or JSON (list of {codice, quantita, prezzo_unitario, unita?}).
+"""
+from __future__ import annotations
+
+import csv
+import io
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+# A unit price this far from the prezzario reference is flagged (±%).
+PRICE_TOLERANCE = 0.20
+
+
+class ComputoError(Exception):
+    pass
+
+
+@dataclass
+class ComputoReport:
+    verdict: str                       # PASS | CONCERNS | REJECT
+    findings: list[str] = field(default_factory=list)
+    stats: dict = field(default_factory=dict)
+
+
+def _parse_computo(path: Path) -> list[dict]:
+    text = path.read_text(encoding="utf-8")
+    if path.suffix.lower() == ".json":
+        data = json.loads(text)
+        if not isinstance(data, list):
+            raise ComputoError("il JSON del computo deve essere una lista di voci")
+        return data
+    # CSV
+    reader = csv.DictReader(io.StringIO(text))
+    return [dict(row) for row in reader]
+
+
+def _num(v: Any) -> float | None:
+    if v is None or v == "":
+        return None
+    try:
+        return float(str(v).replace(",", ".").replace("€", "").strip())
+    except ValueError:
+        return None
+
+
+async def verify_computo(
+    session: Any,
+    computo_path: str | Path,
+    *,
+    region: str = "Lombardia",
+    version: str | None = None,
+) -> ComputoReport:
+    """Compare a computo file's voci against the prezzari reference for a region."""
+    path = Path(computo_path).expanduser()
+    if not path.is_file():
+        return ComputoReport(verdict="REJECT", findings=[f"file non trovato: {path}"])
+
+    try:
+        voci = _parse_computo(path)
+    except Exception as exc:  # noqa: BLE001 — parse errors are the finding
+        return ComputoReport(verdict="REJECT", findings=[f"computo non leggibile: {str(exc)[:150]}"])
+
+    if not voci:
+        return ComputoReport(verdict="REJECT", findings=["nessuna voce nel computo"])
+
+    # Load the prezzario for the region (RLS: authenticated read).
+    params = {"region": f"eq.{region}", "select": "codice,prezzo,unita,descrizione"}
+    if version:
+        params["version"] = f"eq.{version}"
+    resp = await session.request("GET", "/rest/v1/prezzari", params=params)
+    if resp.status_code != 200:
+        raise ComputoError(f"prezzari non disponibili: HTTP {resp.status_code}")
+    ref_rows = resp.json()
+    ref = {r["codice"]: r for r in ref_rows if isinstance(r, dict) and r.get("codice")}
+    if not ref:
+        raise ComputoError(f"nessun prezzario per regione '{region}'"
+                           + (f" versione '{version}'" if version else ""))
+
+    findings: list[str] = []
+    unknown = 0
+    out_of_range = 0
+    unit_mismatch = 0
+    total_computo = 0.0
+    checked = 0
+
+    for i, voce in enumerate(voci, 1):
+        codice = str(voce.get("codice") or "").strip()
+        if not codice:
+            findings.append(f"voce {i}: codice mancante")
+            continue
+        qta = _num(voce.get("quantita") or voce.get("quantità"))
+        prezzo = _num(voce.get("prezzo_unitario") or voce.get("prezzo"))
+        unita = str(voce.get("unita") or voce.get("unità") or "").strip()
+
+        if qta is not None and prezzo is not None:
+            total_computo += qta * prezzo
+
+        r = ref.get(codice)
+        if not r:
+            unknown += 1
+            findings.append(f"voce {i} [{codice}]: codice non presente nel prezzario {region}")
+            continue
+        checked += 1
+
+        ref_price = float(r["prezzo"])
+        if prezzo is not None and ref_price > 0:
+            delta = (prezzo - ref_price) / ref_price
+            if abs(delta) > PRICE_TOLERANCE:
+                out_of_range += 1
+                findings.append(
+                    f"voce {i} [{codice}]: prezzo {prezzo:.2f} vs riferimento "
+                    f"{ref_price:.2f} ({delta:+.0%}) — fuori tolleranza ±{PRICE_TOLERANCE:.0%}"
+                )
+        if unita and r.get("unita") and unita.lower() != str(r["unita"]).lower():
+            unit_mismatch += 1
+            findings.append(
+                f"voce {i} [{codice}]: unità '{unita}' ≠ prezzario '{r['unita']}'"
+            )
+
+    stats = {
+        "voci_totali": len(voci),
+        "voci_verificate": checked,
+        "codici_sconosciuti": unknown,
+        "prezzi_fuori_tolleranza": out_of_range,
+        "unita_incoerenti": unit_mismatch,
+        "totale_computo_eur": round(total_computo, 2),
+        "prezzario": f"{region}"
+        + (f" {version}" if version else "")
+        + f" ({len(ref)} voci)",
+    }
+
+    if unknown or out_of_range:
+        verdict = "CONCERNS"
+    else:
+        verdict = "PASS"
+    # A computo where nothing could be matched is not trustworthy.
+    if checked == 0:
+        verdict = "REJECT"
+        findings.insert(0, "nessuna voce del computo trovata nel prezzario")
+
+    return ComputoReport(verdict=verdict, findings=findings, stats=stats)

lovarch_cli-0.3.1/lovarch_cli/verify/pratica.py

@@ -0,0 +1,122 @@
+"""verifica pratica — adversarial check of a building permit filing (CILA/SCIA).
+
+Same two-model pattern as contratto/normativa: Sonnet 5 (executor) extracts the
+filing's structure and declared data, Opus 4.8 (verifier) adversarially checks
+completeness and coherence against the required elements of a CILA (Comunicazione
+Inizio Lavori Asseverata) or SCIA (Segnalazione Certificata di Inizio Attività):
+identificativi catastali, titolo di legittimità, asseverazione del tecnico,
+elaborati allegati, e coerenza dell'intervento col titolo scelto (una CILA non
+copre interventi che richiedono SCIA/permesso di costruire).
+"""
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from typing import Any
+
+from lovarch_cli.verify.normativa import NormativaError, _parse_json, extract_text
+
+# Required elements per filing type (used to prompt the verifier, not as a
+# rigid checklist — the LLM judges presence/coherence adversarially).
+CILA_REQUIRED = [
+    "dati anagrafici del committente", "identificativi catastali (foglio/mappale/sub)",
+    "titolo di legittimità dell'immobile", "descrizione dell'intervento",
+    "asseverazione del tecnico abilitato", "elaborati grafici allegati",
+    "dichiarazione di conformità urbanistica",
+]
+SCIA_REQUIRED = CILA_REQUIRED + [
+    "relazione tecnica di asseverazione", "eventuali pareri/nulla osta (paesaggistico, ecc.)",
+]
+
+_EXTRACT_SYSTEM = (
+    "Sei un assistente per pratiche edilizie italiane (CILA/SCIA). Estrai dalla "
+    "pratica la struttura e i dati dichiarati. Rispondi SOLO con JSON valido: "
+    '{"tipo": "CILA|SCIA|sconosciuto", "sezioni_presenti": ["..."], '
+    '"sezioni_mancanti": ["..."], "identificativi_catastali": "... o null", '
+    '"titolo_legittimita": "... o null", "asseverazione_presente": true|false, '
+    '"intervento": "descrizione sintetica", "note": ["..."]}'
+)
+
+_REFUTE_SYSTEM = (
+    "Sei un verificatore ADVERSARIALE di pratiche edilizie (CILA/SCIA). "
+    "Controlla: (1) completezza degli elementi obbligatori per il tipo dichiarato; "
+    "(2) presenza di identificativi catastali e titolo di legittimità; "
+    "(3) presenza dell'asseverazione del tecnico abilitato; (4) COERENZA tra "
+    "l'intervento descritto e il titolo scelto — una CILA NON copre interventi "
+    "strutturali o che incidono su prospetti/volumi (quelli richiedono SCIA o "
+    "permesso di costruire); segnala il possibile sottodimensionamento del titolo. "
+    "Nel dubbio sii scettico. La firma e la responsabilità restano del tecnico "
+    "abilitato. Rispondi SOLO con JSON valido: "
+    '{"findings": [{"area": "...", "severity": "critical" | "concern" | "info", '
+    '"reason": "..."}], "overall": "PASS" | "CONCERNS" | "REJECT"}'
+)
+
+
+@dataclass
+class PraticaReport:
+    verdict: str
+    tipo: str = "sconosciuto"
+    structure: dict = field(default_factory=dict)
+    findings: list[dict] = field(default_factory=list)
+    credits_charged: int = 0
+
+
+async def verify_pratica(
+    gateway: Any,
+    document_path: str,
+    *,
+    tipo: str | None = None,
+    language: str = "it",
+    max_chars: int = 60_000,
+) -> PraticaReport:
+    """Adversarial CILA/SCIA filing check. 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]
+
+    credits = 0
+    hint = f" (tipo dichiarato dall'utente: {tipo.upper()})" if tipo else ""
+    extraction = await gateway.generate_text(
+        f"PRATICA EDILIZIA{hint}:\n\n{text}",
+        role="executor",
+        system=_EXTRACT_SYSTEM,
+        max_tokens=1500,
+        language=language,
+        operation_type="verify:pratica:extract",
+    )
+    credits += extraction.credits_charged
+    structure = _parse_json(extraction.text)
+
+    resolved_tipo = (tipo or str(structure.get("tipo") or "sconosciuto")).upper()
+    required = SCIA_REQUIRED if resolved_tipo == "SCIA" else CILA_REQUIRED
+
+    refutation = await gateway.generate_text(
+        "STRUTTURA ESTRATTA DALLA PRATICA:\n\n"
+        + json.dumps(structure, ensure_ascii=False)
+        + f"\n\nTipo: {resolved_tipo}. Elementi obbligatori attesi: "
+        + ", ".join(required),
+        role="verifier",
+        system=_REFUTE_SYSTEM,
+        max_tokens=2000,
+        language=language,
+        operation_type="verify:pratica:refute",
+    )
+    credits += refutation.credits_charged
+    judged = _parse_json(refutation.text)
+    findings = judged.get("findings") or []
+
+    overall = str(judged.get("overall", "")).upper()
+    if overall not in ("PASS", "CONCERNS", "REJECT"):
+        severities = [str(f.get("severity", "")).lower() for f in findings]
+        overall = ("REJECT" if "critical" in severities
+                   else ("CONCERNS" if "concern" in severities else "PASS"))
+
+    return PraticaReport(
+        verdict=overall,
+        tipo=resolved_tipo,
+        structure=structure,
+        findings=findings,
+        credits_charged=credits,
+    )

{lovarch_cli-0.3.0 → lovarch_cli-0.3.1}/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.0"
+__version__ = "0.3.1"

{lovarch_cli-0.3.0 → lovarch_cli-0.3.1}/lovarch_cli/workflows/platform.py

@@ -253,7 +253,38 @@ class MoreWorkflowsMixin:
             raise WorkflowError("ai-site-generate non ha restituito HTML.")
         return str(html)
 
+    async def script(
+        self,
+        topic: str,
+        *,
+        type: str = "reel",
+        goal: str = "educare",
+        tone: str = "professionale",
+        cta: str = "",
+        language: str = "it",
+    ) -> dict:
+        """Structured content script via scripts-generate. Returns the script
+        dict (title, content, outline, hashtags). `persisted` is True when it was
+        saved to the account; the platform refunds credits if it couldn't save."""
+        data = await self._invoke("scripts-generate", {
+            "type": type,
+            "topic": topic,
+            "goal": goal,
+            "tone": tone,
+            "cta": cta,
+            "editorial_line_id": "none",
+            "brainstorm_idea_id": "none",
+            "language": language,
+        }, timeout=_RENDER_TIMEOUT)
+        script = data.get("script") or {}
+        if not script:
+            raise WorkflowError(f"scripts-generate: {data.get('error', 'nessuno script')}")
+        # Normalize content field (real schema uses `content`; resilient path `full_script`).
+        script.setdefault("content", script.get("full_script"))
+        script["persisted"] = bool(data.get("persisted", True))
+        return script
 
 
 PlatformWorkflows.logo = MoreWorkflowsMixin.logo        # type: ignore[attr-defined]
 PlatformWorkflows.site = MoreWorkflowsMixin.site        # type: ignore[attr-defined]
+PlatformWorkflows.script = MoreWorkflowsMixin.script    # type: ignore[attr-defined]