lovarch-cli 0.2.1__py3-none-any.whl

lovarch_cli/commands/consolidate.py

@@ -0,0 +1,217 @@
+"""lovarch consolidate — Generate DOSSIER.zip from a completed run.
+
+Walks ~/.lovarch/projects/<name>/output/ and produces a structured ZIP
+that mirrors the dossier format expected by Lovarch's downstream consumers
+(architects sharing with clients, builders importing into BIM, etc.).
+
+Folder convention inside the ZIP (matches the squad's deliverable layout):
+
+    DOSSIER-<project>-<YYYY-MM-DD>.zip
+    ├── 00-validation/    audit + input-validation JSONs
+    ├── 01-bootstrap/     project metadata, project.yaml snapshot
+    ├── 02-concept/       moodboard + render images
+    ├── 03-tier1/         CAD/IFC/PDF/XLSX from tier-1 agents
+    ├── 04-tier2/         QA reports
+    └── 05-dossier/       briefing-architect, regolatorio, energy
+
+Files in output/ that don't match a known prefix go into 99-other/ so we
+never silently drop content. The user can inspect what landed there to
+catch missing routing rules.
+
+Free mode (no real run): we still zip whatever is in output/, even if
+empty — useful for users who want to package their own deliverables and
+hand them off without going through Premium.
+"""
+from __future__ import annotations
+
+import sys
+import zipfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Annotated
+
+import typer
+import yaml
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+from lovarch_cli.config import DEFAULT_HOME
+from lovarch_cli.i18n import current_lang, set_current_lang, t
+
+console = Console()
+err_console = Console(stderr=True)
+
+
+# Routing prefixes → DOSSIER folder.
+# The squad pipeline writes filenames with these prefixes; if a new
+# convention shows up, add the mapping here rather than scattering it.
+_ROUTING: list[tuple[str, str]] = [
+    ("input-validation", "00-validation"),
+    ("audit-", "00-validation"),
+    ("project-", "01-bootstrap"),
+    ("bootstrap-", "01-bootstrap"),
+    ("moodboard-", "02-concept"),
+    ("render-", "02-concept"),
+    ("brief-", "02-concept"),
+    ("dxf-", "03-tier1"),
+    ("ifc-", "03-tier1"),
+    ("pianta-", "03-tier1"),
+    ("sezione-", "03-tier1"),
+    ("computo-", "03-tier1"),
+    ("capitolato-", "03-tier1"),
+    ("contratto-", "03-tier1"),
+    ("qa-", "04-tier2"),
+    ("verifica-", "04-tier2"),
+    ("briefing-architect", "05-dossier"),
+    ("regolatorio-", "05-dossier"),
+    ("energy-", "05-dossier"),
+    ("dossier-", "05-dossier"),
+]
+
+
+def _route_filename(name: str) -> str:
+    """Map a filename prefix to its DOSSIER folder, or '99-other/' fallback."""
+    lower = name.lower()
+    for prefix, folder in _ROUTING:
+        if lower.startswith(prefix):
+            return folder
+    return "99-other"
+
+
+def _gather_files(output_dir: Path) -> list[tuple[Path, str]]:
+    """Return (abs_path, arcname) tuples for every file under output_dir."""
+    items: list[tuple[Path, str]] = []
+    for path in sorted(output_dir.rglob("*")):
+        if not path.is_file():
+            continue
+        # Use the file's name relative to output_dir for routing,
+        # but preserve any subdir structure inside the routed folder.
+        rel = path.relative_to(output_dir)
+        first_component = rel.parts[0]
+        # If the user already organized into 0X-foo/, preserve it.
+        if "-" in first_component and first_component[:2].isdigit():
+            arcname = str(rel)
+        else:
+            folder = _route_filename(rel.name)
+            arcname = f"{folder}/{rel.name}"
+        items.append((path, arcname))
+    return items
+
+
+def consolidate_command(
+    project: Annotated[
+        str, typer.Argument(help="Project name to consolidate.")
+    ],
+    output: Annotated[
+        Path | None,
+        typer.Option(
+            "--output",
+            "-o",
+            help="Where to write the ZIP (default: project's output/ dir).",
+        ),
+    ] = None,
+    lang_flag: Annotated[
+        str | None,
+        typer.Option("--lang", "-l", help="Override language (it/pt/en/es)."),
+    ] = None,
+    home_override: Annotated[
+        Path | None,
+        typer.Option(
+            "--home",
+            help="Override $HOME/.lovarch root (mainly for tests).",
+            hidden=True,
+        ),
+    ] = None,
+) -> None:
+    """Bundle the run output into a DOSSIER.zip."""
+    if lang_flag is not None:
+        set_current_lang(lang_flag)
+    lang = current_lang()
+
+    home = home_override or DEFAULT_HOME
+    proj_dir = home / "projects" / project
+    if not proj_dir.is_dir():
+        err_console.print(
+            f"\n[red]✗ {t('consolidate.no_project', lang=lang, name=project)}[/red]\n"
+        )
+        sys.exit(2)
+
+    output_dir = proj_dir / "output"
+    if not output_dir.is_dir():
+        err_console.print(
+            f"\n[red]✗ {t('consolidate.no_output', lang=lang, path=str(output_dir))}[/red]\n"
+        )
+        sys.exit(2)
+
+    items = _gather_files(output_dir)
+    if not items:
+        err_console.print(
+            f"\n[yellow]⚠ {t('consolidate.empty_output', lang=lang, name=project)}[/yellow]\n"
+        )
+        sys.exit(1)
+
+    # ─── Choose ZIP path ─────────────────────────────────────────────────
+    today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+    zip_name = f"DOSSIER-{project}-{today}.zip"
+    zip_path = output / zip_name if output else proj_dir / zip_name
+
+    # ─── Write ZIP ───────────────────────────────────────────────────────
+    console.print(
+        f"\n[gold1]→[/gold1] {t('consolidate.zipping', lang=lang, count=len(items))}"
+    )
+    try:
+        with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
+            for src, arcname in items:
+                zf.write(src, arcname=arcname)
+            # Drop a small README inside the ZIP describing the layout.
+            zf.writestr(
+                "README.md",
+                t(
+                    "consolidate.zip_readme",
+                    lang=lang,
+                    project=project,
+                    date=today,
+                    count=len(items),
+                ),
+            )
+    except OSError as exc:
+        err_console.print(
+            f"\n[red]✗ {t('consolidate.write_failed', lang=lang, message=str(exc))}[/red]\n"
+        )
+        sys.exit(2)
+
+    # ─── Persist last_dossier in project.yaml ────────────────────────────
+    yaml_path = proj_dir / "project.yaml"
+    if yaml_path.exists():
+        try:
+            meta = yaml.safe_load(yaml_path.read_text(encoding="utf-8")) or {}
+        except yaml.YAMLError:
+            meta = {}
+        meta["last_dossier"] = {
+            "path": str(zip_path),
+            "files": len(items),
+            "size_bytes": zip_path.stat().st_size,
+            "created_at": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+        }
+        yaml_path.write_text(
+            yaml.safe_dump(meta, sort_keys=False, allow_unicode=True),
+            encoding="utf-8",
+        )
+
+    # ─── Success panel ───────────────────────────────────────────────────
+    size_kb = zip_path.stat().st_size // 1024
+    body = Text.from_markup(
+        f"{t('consolidate.created', lang=lang, path=str(zip_path), size_kb=size_kb, count=len(items))}\n\n"
+        f"{t('consolidate.next_steps', lang=lang, project=project)}"
+    )
+    console.print()
+    console.print(
+        Panel(
+            body,
+            title=f"[bold green]📦 {t('consolidate.title', lang=lang)}[/bold green]",
+            border_style="green",
+            padding=(1, 2),
+        )
+    )
+    console.print()

lovarch_cli/commands/context_cmd.py

@@ -0,0 +1,73 @@
+"""`lovarch context` — show the personalization bundle the AI agents use.
+
+Displays which profile pieces the platform will inject into every generation
+(brand, style, DISC, fiscal, professional signature, language) — the CLI
+equivalent of the web app's "IA usa il tuo: …" chips.
+"""
+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)
+
+context_app = typer.Typer(
+    help="Contesto di personalizzazione usato dagli agenti AI.",
+    no_args_is_help=True,
+)
+
+_CHIP_LABELS = {
+    "hasBrand": "Brand",
+    "hasStyle": "Stile visivo",
+    "hasDisc": "DISC",
+    "hasSwot": "SWOT",
+    "hasAvatar": "Avatar cliente",
+    "hasFiscal": "Dati fiscali",
+    "hasCredentials": "Credenziali professionali",
+    "hasClient": "Cliente CRM",
+}
+
+
+@context_app.command("show")
+def show_command(
+    lead_id: str = typer.Option(None, "--lead", help="ID di un lead CRM da includere."),
+) -> None:
+    """Mostra il bundle di personalizzazione (richiede login premium)."""
+    from lovarch_cli.ai import AiGatewayError, LovarchAiGateway
+    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:
+        bundle = asyncio.run(LovarchAiGateway(session).get_user_context(lead_id=lead_id))
+    except AiGatewayError as exc:
+        err_console.print(f"[red]✗ {exc}[/red]")
+        raise typer.Exit(1)
+
+    summary = bundle.get("context_summary", {})
+    table = Table(title="Contesto AI — cosa viene usato per personalizzare",
+                  show_header=True, header_style="bold gold1")
+    table.add_column("Elemento", style="cyan")
+    table.add_column("Attivo", justify="center")
+    for key, label in _CHIP_LABELS.items():
+        table.add_row(label, "✅" if summary.get(key) else "—")
+    console.print(table)
+
+    if bundle.get("signature_line"):
+        console.print(f"\n[bold]Firma documenti:[/bold] {bundle['signature_line']}")
+    prefs = bundle.get("preferences", {})
+    console.print(
+        f"[dim]Lingua output: {prefs.get('preferred_language', 'it')} · "
+        f"Valuta: {prefs.get('currency', 'EUR')} · "
+        f"Unità: {prefs.get('measurement_unit', 'metric')}[/dim]"
+    )
+    client = bundle.get("client")
+    if client and client.get("lead"):
+        console.print(f"[bold]Cliente CRM:[/bold] {client['lead'].get('name')}")

lovarch_cli/commands/dev.py

@@ -0,0 +1,287 @@
+"""lovarch dev — developer tooling for working on the squad payload.
+
+Subcommands:
+
+  lovarch dev show-squad-root
+      Print which squad payload would be used by `lovarch run` right now,
+      and where the resolution chain landed (override flag / env var /
+      bundled).
+
+  lovarch dev refresh-squad [--source PATH] [--target PATH] [--dry-run]
+      Copy the squad source-of-truth (default: $LOVARCH_SQUAD_SRC or
+      `~/Lovarch/squads/architettura-progetto/`) into the standalone
+      repo's vendored copy at `lovarch_cli/squad/`. Excludes the heavy
+      sample-input directories — those ship via GitHub Releases. This is
+      the "promote dev edits to staged" step before cutting a release.
+
+These commands are intended for Pablo / future contributors maintaining
+the squad. Brew-installed users never need them.
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import sys
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from lovarch_cli.squad_loader import (
+    ENV_VAR,
+    SquadNotFoundError,
+    bundled_squad_dir,
+    resolve_squad_root,
+    squad_source_label,
+)
+
+
+console = Console()
+err_console = Console(stderr=True)
+
+dev_app = typer.Typer(
+    help="Developer tooling for the squad payload (Pablo / contributors only).",
+    no_args_is_help=True,
+)
+
+
+# What the build hook + refresh script copy. Mirror of scripts/sync_squad.py.
+COPY_DIRS: tuple[str, ...] = (
+    "agents",
+    "tasks",
+    "workflows",
+    "checklists",
+    "templates",
+    "scripts",
+    "data",
+)
+COPY_FILES: tuple[str, ...] = ("README.md", "config.yaml")
+# Heavy sample-inputs that ship via GitHub Releases instead.
+EXCLUDE_RELATIVE: frozenset[str] = frozenset({
+    "data/sample-input",
+    "data/sample-input-villa-chianti",
+})
+DEFAULT_SOURCE = Path.home() / "Lovarch" / "squads" / "architettura-progetto"
+
+
+@dev_app.command("show-squad-root")
+def show_squad_root_command(
+    squad_src: Annotated[
+        Path | None,
+        typer.Option(
+            "--squad-src",
+            help="Mirror the --squad-src flag passed to `lovarch run`.",
+        ),
+    ] = None,
+) -> None:
+    """Show which squad payload `lovarch run` would currently use."""
+    try:
+        root = resolve_squad_root(override=squad_src)
+    except SquadNotFoundError as exc:
+        err_console.print(f"\n[red]✗ {exc}[/red]\n")
+        sys.exit(2)
+
+    label = squad_source_label(root)
+    env_val = os.environ.get(ENV_VAR) or "(unset)"
+
+    table = Table(show_header=False, box=None, padding=(0, 2))
+    table.add_column(style="bold")
+    table.add_column()
+    table.add_row("Resolved path:", str(root))
+    table.add_row("Source:", label)
+    table.add_row(f"${ENV_VAR}:", env_val)
+    table.add_row("Bundled vendor:", str(bundled_squad_dir()))
+
+    console.print()
+    console.print(
+        Panel(
+            table,
+            title="[bold gold1]🔍 Squad resolution[/bold gold1]",
+            border_style="gold1",
+            padding=(1, 2),
+        )
+    )
+    console.print()
+
+
+def _ignore_excluded(squad_src: Path):
+    """shutil.copytree ignore-callback that skips EXCLUDE_RELATIVE dirs."""
+
+    def _ignore(_dir: str, names: list[str]) -> list[str]:
+        base = Path(_dir).relative_to(squad_src)
+        return [
+            n for n in names
+            if str((base / n).as_posix()) in EXCLUDE_RELATIVE
+        ]
+
+    return _ignore
+
+
+def _locate_target_default() -> Path | None:
+    """Try to auto-detect the `lovarch_cli/squad/` dir in the dev install.
+
+    Works when this file is imported from an editable install (i.e. the
+    user's clone of `lovarch-cli`). Returns None when imported from a
+    site-packages install (brew / pipx) — caller must require --target.
+    """
+    bundled = bundled_squad_dir()
+    # Heuristic: if the bundled dir is writable AND lives inside a path
+    # that does NOT contain "site-packages" or "/Cellar/", treat it as
+    # the dev-install target.
+    try:
+        path_str = str(bundled)
+        if "site-packages" in path_str or "/Cellar/" in path_str:
+            return None
+        # Touch-test writability
+        if not os.access(bundled, os.W_OK):
+            return None
+        return bundled
+    except (OSError, PermissionError):
+        return None
+
+
+@dev_app.command("refresh-squad")
+def refresh_squad_command(
+    source: Annotated[
+        Path | None,
+        typer.Option(
+            "--source",
+            "-s",
+            help=(
+                "Source squad-architettura-progetto path. Defaults to "
+                f"${ENV_VAR} or ~/Lovarch/squads/architettura-progetto."
+            ),
+        ),
+    ] = None,
+    target: Annotated[
+        Path | None,
+        typer.Option(
+            "--target",
+            "-t",
+            help=(
+                "Destination lovarch_cli/squad/ path. Auto-detected if "
+                "running from a dev install (pip install -e), else required."
+            ),
+        ),
+    ] = None,
+    dry_run: Annotated[
+        bool,
+        typer.Option(
+            "--dry-run",
+            help="Show what would change, no write.",
+        ),
+    ] = False,
+) -> None:
+    """Promote the dev squad source into the vendored snapshot."""
+    # ── Resolve SOURCE ──────────────────────────────────────────────────
+    if source is None:
+        env_src = os.environ.get(ENV_VAR)
+        if env_src:
+            source = Path(env_src).expanduser().resolve()
+        else:
+            source = DEFAULT_SOURCE
+    source = source.expanduser().resolve()
+
+    if not source.is_dir():
+        err_console.print(
+            f"\n[red]✗ Source not found: {source}[/red]\n"
+            f"[dim]Set ${ENV_VAR}, pass --source, or check that the path "
+            f"exists.[/dim]\n"
+        )
+        sys.exit(2)
+    if not (source / "scripts" / "pipeline_runner.py").exists():
+        err_console.print(
+            f"\n[red]✗ Source does not look like a squad payload: "
+            f"missing scripts/pipeline_runner.py at {source}[/red]\n"
+        )
+        sys.exit(2)
+
+    # ── Resolve TARGET ──────────────────────────────────────────────────
+    if target is None:
+        target = _locate_target_default()
+    if target is None:
+        err_console.print(
+            "\n[red]✗ Cannot auto-detect target — you're not running from "
+            "a dev install (pip install -e). Pass --target explicitly to "
+            "the lovarch_cli/squad/ dir of your lovarch-cli clone.[/red]\n"
+        )
+        sys.exit(2)
+    target = target.expanduser().resolve()
+
+    # ── Plan ────────────────────────────────────────────────────────────
+    summary = Table(show_header=False, box=None, padding=(0, 2))
+    summary.add_column(style="bold")
+    summary.add_column()
+    summary.add_row("Source:", str(source))
+    summary.add_row("Target:", str(target))
+    summary.add_row("Dry-run:", "yes" if dry_run else "no")
+    summary.add_row(
+        "Excluded:",
+        ", ".join(sorted(EXCLUDE_RELATIVE)),
+    )
+    console.print()
+    console.print(
+        Panel(
+            summary,
+            title="[bold gold1]🔄 Refresh squad vendor[/bold gold1]",
+            border_style="gold1",
+            padding=(1, 2),
+        )
+    )
+
+    if dry_run:
+        console.print(
+            "[dim]Dry-run: no files modified. Re-run without --dry-run "
+            "to apply.[/dim]\n"
+        )
+        return
+
+    # ── Execute ─────────────────────────────────────────────────────────
+    # Wipe target preserving the dir itself (so file ownership / git
+    # status of the parent stays sane).
+    target.mkdir(parents=True, exist_ok=True)
+    for child in target.iterdir():
+        if child.is_dir():
+            shutil.rmtree(child)
+        else:
+            child.unlink()
+
+    ignore = _ignore_excluded(source)
+    copied_dirs = 0
+    copied_files = 0
+    for dirname in COPY_DIRS:
+        src_dir = source / dirname
+        if src_dir.exists() and src_dir.is_dir():
+            shutil.copytree(src_dir, target / dirname, ignore=ignore)
+            copied_dirs += 1
+    for filename in COPY_FILES:
+        src_file = source / filename
+        if src_file.exists() and src_file.is_file():
+            shutil.copy2(src_file, target / filename)
+            copied_files += 1
+
+    total_files = sum(1 for _ in target.rglob("*") if _.is_file())
+
+    done = Text.from_markup(
+        f"[green]✓[/green] Refreshed [bold]{copied_dirs}[/bold] dirs + "
+        f"[bold]{copied_files}[/bold] top-level files\n"
+        f"  [dim]{total_files} files total at {target}[/dim]\n\n"
+        f"Next steps:\n"
+        f"  1. [cyan]cd {target.parent.parent}[/cyan]\n"
+        f"  2. [cyan]git diff --stat lovarch_cli/squad/[/cyan] — review the diff\n"
+        f"  3. [cyan]git add lovarch_cli/squad/[/cyan] + commit\n"
+        f"  4. Cut a release with [cyan]git tag v0.1.X && git push[/cyan]"
+    )
+    console.print(
+        Panel(
+            done,
+            title="[bold green]✓ Refresh complete[/bold green]",
+            border_style="green",
+            padding=(1, 2),
+        )
+    )
+    console.print()

lovarch_cli/commands/do_cmd.py

@@ -0,0 +1,120 @@
+"""`lovarch do` — run platform workflows from the terminal (premium).
+
+    lovarch do render "soggiorno minimal, luce naturale" -o render.png
+    lovarch do render "attico" --mode plan_to_3d --ref pianta.png
+    lovarch do colors --style natural
+    lovarch do copy "consegna ristrutturazione attico Brera"
+
+Credits are debited server-side by the platform (same as the web app); costs
+are always expressed in the user's credits.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+console = Console()
+err_console = Console(stderr=True)
+
+do_app = typer.Typer(
+    help="Esegui i workflow della piattaforma Lovarch (premium).",
+    no_args_is_help=True,
+)
+
+
+def _workflows():
+    from lovarch_cli.auth.session import LovarchSession
+    from lovarch_cli.workflows import PlatformWorkflows
+
+    session = LovarchSession.load()
+    if session is None:
+        err_console.print("[red]✗ Non autenticato. Esegui `lovarch login --premium`.[/red]")
+        raise typer.Exit(1)
+    return PlatformWorkflows(session)
+
+
+def _lang(language: str | None) -> str:
+    if language:
+        return language
+    from lovarch_cli.i18n import current_lang
+
+    return current_lang()
+
+
+@do_app.command("render")
+def render_command(
+    description: str = typer.Argument(..., help="Descrizione della scena da renderizzare."),
+    output: Path = typer.Option(Path("render.png"), "--output", "-o", help="File di destinazione."),
+    mode: str = typer.Option(None, "--mode", help="room_render | render_3d | plan_to_3d | lighting_only | closeup_detail | closeup_angle (vuoto = sketch/testo→render 2D)."),
+    style: str = typer.Option("moderno", "--style", "-s", help="Stile del render."),
+    aspect: str = typer.Option("16:9", "--aspect", help="Aspect ratio (16:9, 9:16, 1:1, 4:3, 3:4)."),
+    ref: Path = typer.Option(None, "--ref", help="Immagine di riferimento (sketch/foto/pianta)."),
+    language: str = typer.Option(None, "--language", help="Lingua dell'output (default: configurata)."),
+) -> None:
+    """Render fotorealistico via Render Studio (crediti addebitati dalla piattaforma)."""
+    from lovarch_cli.mcp.tools import tool_render
+
+    out = asyncio.run(tool_render(
+        _workflows(), description=description, output_path=str(output),
+        mode=mode or None, render_style=style, aspect_ratio=aspect,
+        reference_image_path=str(ref) if ref else None, language=_lang(language),
+    ))
+    if not out.get("ok"):
+        err_console.print(f"[red]✗ {out.get('error')}[/red]")
+        raise typer.Exit(1)
+    if out.get("saved_to"):
+        console.print(f"[green]✓[/green] Render salvato: [bold]{out['saved_to']}[/bold]")
+    if out.get("image_url"):
+        console.print(f"[dim]Nel tuo account Lovarch: {out['image_url']}[/dim]")
+
+
+@do_app.command("colors")
+def colors_command(
+    style: str = typer.Option("modern", "--style", "-s", help="modern | vintage | natural | bold | custom."),
+    base: str = typer.Option(None, "--base", help="Colori base separati da virgola (es. '#A16207,#09090B')."),
+    image_url: str = typer.Option(None, "--from-image", help="URL immagine da cui estrarre la palette."),
+    language: str = typer.Option(None, "--language", help="Lingua dell'output."),
+) -> None:
+    """Palette colori brand via piattaforma."""
+    wf = _workflows()
+    from lovarch_cli.workflows import WorkflowError
+
+    try:
+        out = asyncio.run(wf.colors(
+            style=style,
+            base_colors=[c.strip() for c in base.split(",")] if base else None,
+            image_url=image_url, language=_lang(language),
+        ))
+    except WorkflowError as exc:
+        err_console.print(f"[red]✗ {exc}[/red]")
+        raise typer.Exit(1)
+    console.print_json(json.dumps(out, ensure_ascii=False))
+
+
+@do_app.command("copy")
+def copy_command(
+    brief: str = typer.Argument(..., help="Brief del contenuto (min 5 caratteri)."),
+    mode: str = typer.Option("post", "--mode", help="post | story | carousel."),
+    slides: int = typer.Option(5, "--slides", help="Numero slide (solo carousel)."),
+    language: str = typer.Option(None, "--language", help="Lingua dell'output."),
+) -> None:
+    """Copy di marketing (caption + hashtags) via piattaforma."""
+    wf = _workflows()
+    from lovarch_cli.workflows import WorkflowError
+
+    try:
+        out = asyncio.run(wf.copy(brief, mode=mode, slide_count=slides, language=_lang(language)))
+    except WorkflowError as exc:
+        err_console.print(f"[red]✗ {exc}[/red]")
+        raise typer.Exit(1)
+    if out.get("caption"):
+        console.print(f"\n[bold gold1]Caption[/bold gold1]\n{out['caption']}\n")
+    if out.get("hashtags"):
+        console.print("[bold gold1]Hashtags[/bold gold1]\n" + " ".join(out["hashtags"]) + "\n")
+    rest = {k: v for k, v in out.items() if k not in ("caption", "hashtags")}
+    if rest:
+        console.print_json(json.dumps(rest, ensure_ascii=False))