lxw-cli 0.1.0__py3-none-any.whl

lxw_cli/commands/invoices.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from lxw_cli.commands._common import ARCHIVED_HINT, load_json_arg, state
+from lxw_cli.core import services
+from lxw_cli.core.constants import DEFAULT_VOUCHER_STATUSES
+from lxw_cli.output import print_count, render, working, write_binary
+
+app = typer.Typer(no_args_is_help=True)
+
+LIST_COLUMNS = [
+    "id",
+    "voucherNumber",
+    "voucherDate",
+    "voucherStatus",
+    "contactName",
+    "totalAmount",
+    "currency",
+]
+
+
+@app.command(
+    "list",
+    epilog="""\
+[bold cyan]Beispiele[/bold cyan]
+
+Offene Rechnungen: [green]lxw invoices list --status open[/green]
+
+Alle als CSV: [green]lxw --csv invoices list --all[/green]
+
+Nach Rechnungsnummer: [green]lxw invoices list --number FB2600682[/green]
+
+Inkl. archivierte: [green]lxw invoices list --include-archived[/green]
+""",
+)
+def list_invoices(
+    ctx: typer.Context,
+    limit: int = typer.Option(
+        25, "--limit", "-n", help="Maximale Anzahl Einträge (0 = alle)."
+    ),
+    fetch_all: bool = typer.Option(
+        False, "--all", "-a", help="Alle Treffer laden (überschreibt --limit)."
+    ),
+    voucher_status: str = typer.Option(
+        DEFAULT_VOUCHER_STATUSES,
+        "--status",
+        help="Komma-separiert: draft,open,paid,paidoff,voided,overdue,accepted,rejected.",
+    ),
+    voucher_number: str | None = typer.Option(
+        None, "--number", help="Filter: exakte Rechnungsnummer."
+    ),
+    contact_id: str | None = typer.Option(
+        None, "--contact-id", help="Filter: Kontakt-UUID (Kunde)."
+    ),
+    include_archived: bool = typer.Option(
+        False,
+        "--include-archived",
+        help="Auch archivierte Rechnungen anzeigen (Standard: ausgeblendet).",
+    ),
+) -> None:
+    """Rechnungen auflisten.
+
+    Listet Rechnungen aus /v1/voucherlist (salesinvoice, invoice,
+    downpaymentinvoice). Standardmäßig werden bis zu 25 Einträge gezeigt — mit
+    --all bzw. --limit 0 werden alle Seiten geladen. Filtern lässt sich nach
+    Status, exakter Rechnungsnummer und Kunde.
+
+    Archivierte Rechnungen sind standardmäßig ausgeblendet; --include-archived
+    zeigt sie. Am Ende wird die Gesamtzahl ausgegeben. Tipp: get/pdf akzeptieren
+    UUID oder Rechnungsnummer (z.B. FB2600682).
+    """
+    s = state(ctx)
+    with working("Lade Rechnungen …"):
+        result = services.list_invoices(
+            s.client,
+            status=voucher_status,
+            number=voucher_number,
+            contact_id=contact_id,
+            include_archived=include_archived,
+            limit=limit,
+            fetch_all=fetch_all,
+        )
+    render(result.items, s.output_format, columns=LIST_COLUMNS, output_path=s.output_path)
+    note = None if include_archived else ARCHIVED_HINT
+    print_count(len(result.items), result.total, noun="Rechnungen", note=note)
+
+
+@app.command(
+    "get",
+    epilog="""\
+[bold cyan]Beispiele[/bold cyan]
+
+Nach Rechnungsnummer: [green]lxw invoices get FB2600682[/green]
+
+Betrag via jq: [green]lxw --json invoices get FB2600682 | jq .totalGrossAmount[/green]
+""",
+)
+def get_invoice(
+    ctx: typer.Context,
+    invoice: str = typer.Argument(..., help="UUID oder Rechnungsnummer (z.B. FB2600682)."),
+) -> None:
+    """Eine Rechnung im Detail abrufen.
+
+    Akzeptiert die UUID oder die Rechnungsnummer (z.B. FB2600682) — die Nummer
+    wird automatisch aufgelöst. Mit --json gibt es die vollständigen Rohdaten
+    für die Weiterverarbeitung.
+    """
+    s = state(ctx)
+    with working("Lade Rechnung …"):
+        data = services.get_invoice(s.client, invoice)
+    render(data, s.output_format, output_path=s.output_path)
+
+
+@app.command(
+    "pdf",
+    epilog="""\
+[bold cyan]Beispiele[/bold cyan]
+
+Ins aktuelle Verzeichnis: [green]lxw invoices pdf FB2600682[/green]
+
+In ein Verzeichnis (Auto-Name): [green]lxw invoices pdf FB2600682 -o ~/Rechnungen[/green]
+
+Mit festem Dateinamen: [green]lxw invoices pdf FB2600682 -o rechnung.pdf[/green]
+""",
+)
+def download_pdf(
+    ctx: typer.Context,
+    invoice: str = typer.Argument(..., help="UUID oder Rechnungsnummer."),
+    output: Path | None = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Ziel-Datei oder -Verzeichnis (Standard: aktuelles Verzeichnis).",
+    ),
+) -> None:
+    """PDF einer Rechnung herunterladen.
+
+    Akzeptiert UUID oder Rechnungsnummer. Ohne -o landet die Datei im aktuellen
+    Verzeichnis (z.B. invoice-FB2600682.pdf); zeigt -o auf ein Verzeichnis, wird
+    der Dateiname automatisch vergeben. Hinweis: Entwürfe haben noch kein PDF.
+    """
+    s = state(ctx)
+    with working("Lade PDF …"):
+        data = services.download_invoice_pdf(s.client, invoice)
+    write_binary(data, output, default_name=f"invoice-{invoice}.pdf")
+
+
+@app.command(
+    "create-draft",
+    epilog="""\
+[bold cyan]Beispiele[/bold cyan]
+
+Aus einer Datei: [green]lxw invoices create-draft --body @rechnung.json[/green]
+
+Inline: [green]lxw invoices create-draft --body '{…}'[/green]
+""",
+)
+def create_draft(
+    ctx: typer.Context,
+    body: str = typer.Option(
+        ...,
+        "--body",
+        help="JSON-Body inline oder @datei.json (siehe API-Doku).",
+    ),
+) -> None:
+    """Neue Rechnung als Draft anlegen (kein Finalize).
+
+    Erwartet den vollständigen JSON-Body der Lexware-API — inline oder als
+    @pfad.json. Die Rechnung wird als Entwurf gespeichert (nicht finalisiert).
+    Schema siehe https://developers.lexware.io/docs/.
+    """
+    s = state(ctx)
+    payload = load_json_arg(body)
+    with working("Lege Rechnung an …"):
+        result = services.create_invoice(s.client, payload)
+    render(result, s.output_format, output_path=s.output_path)

lxw_cli/commands/mcp.py

@@ -0,0 +1,167 @@
+"""Subcommand `lxw mcp …` — manages Claude Code/Desktop integration."""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+import typer
+from dotenv import dotenv_values
+
+from lxw_cli.config import ENV_KEY, global_env_path, load_config, store_key
+from lxw_cli.output import console, err_console
+
+app = typer.Typer(no_args_is_help=True)
+
+MCP_NAME = "lexware"
+
+
+def _check_claude() -> None:
+    if not shutil.which("claude"):
+        err_console.print(
+            "[red]Fehler:[/red] `claude` CLI nicht gefunden. "
+            "Installiere zuerst Claude Code (https://claude.com/claude-code)."
+        )
+        raise typer.Exit(code=2)
+
+
+def _mcp_command() -> list[str]:
+    """Build the command Claude will use to launch the MCP server.
+
+    Prefer the `lxw-mcp` console script when it's on PATH (works for
+    pipx-installed setups). Otherwise fall back to the current interpreter
+    plus `-m lxw_cli.mcp_server` so the venv path is captured even when
+    `.venv/bin` isn't on the system PATH.
+    """
+    on_path = shutil.which("lxw-mcp")
+    if on_path:
+        return [on_path]
+    # Look for the entry-point next to the running python (typical venv layout;
+    # on Windows console scripts get an .exe suffix)
+    exe_suffix = ".exe" if sys.platform == "win32" else ""
+    candidate = Path(sys.executable).parent / f"lxw-mcp{exe_suffix}"
+    if candidate.exists():
+        return [str(candidate)]
+    return [sys.executable, "-m", "lxw_cli.mcp_server"]
+
+
+def _ensure_global_key(api_key: str) -> None:
+    """Make sure the MCP server can resolve the key from the global config.
+
+    The key is deliberately NOT passed via `claude mcp add -e …` — that would
+    expose it in the process list and store a second plaintext copy in the
+    Claude config. The server resolves it itself from the global `.env`
+    (chmod 600), so we only have to guarantee it exists there.
+    """
+    path = global_env_path()
+    existing = (dotenv_values(path).get(ENV_KEY) or "").strip() if path.is_file() else ""
+    if not existing:
+        stored = store_key(api_key)
+        err_console.print(
+            f"[dim]API-Key in {stored} hinterlegt (wird vom MCP-Server gelesen).[/dim]"
+        )
+    elif existing != api_key:
+        err_console.print(
+            f"[yellow]Hinweis:[/yellow] {path} enthält einen anderen API-Key — "
+            "der MCP-Server verwendet den dort hinterlegten."
+        )
+
+
+@app.command("install-claude")
+def install_claude(
+    scope: str = typer.Option(
+        "user", "--scope", help="user (global), project (per repo), oder local."
+    ),
+    force: bool = typer.Option(
+        False, "--force", help="Vorher entfernen, falls bereits registriert."
+    ),
+) -> None:
+    """Registriert den Lexware-MCP-Server bei Claude Code."""
+    _check_claude()
+    config = load_config()  # validates LEXWARE_API_KEY
+    _ensure_global_key(config.api_key)
+
+    server_cmd = _mcp_command()
+
+    if force:
+        subprocess.run(
+            ["claude", "mcp", "remove", MCP_NAME, "--scope", scope],
+            check=False,
+            capture_output=True,
+        )
+
+    cmd = [
+        "claude",
+        "mcp",
+        "add",
+        MCP_NAME,
+        "--scope",
+        scope,
+        "--",
+        *server_cmd,
+    ]
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        err_console.print(f"[red]claude mcp add fehlgeschlagen:[/red]\n{result.stderr}")
+        if "already exists" in (result.stderr or "").lower():
+            err_console.print(
+                "[yellow]Hinweis:[/yellow] Mit `--force` kannst du die "
+                "bestehende Registrierung überschreiben."
+            )
+        raise typer.Exit(code=result.returncode)
+    console.print(
+        f"[green]✓[/green] Lexware MCP-Server bei Claude Code registriert "
+        f"(scope={scope})."
+    )
+    console.print(
+        "Test: Öffne Claude Code und frag z.B. "
+        "[bold]\"Wie viele offene Rechnungen habe ich?\"[/bold]"
+    )
+
+
+@app.command("uninstall-claude")
+def uninstall_claude(
+    scope: str = typer.Option("user", "--scope", help="Gleicher Scope wie beim Install."),
+) -> None:
+    """Entfernt den Lexware-MCP-Server aus Claude Code."""
+    _check_claude()
+    result = subprocess.run(
+        ["claude", "mcp", "remove", MCP_NAME, "--scope", scope],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        err_console.print(f"[red]Fehler:[/red] {result.stderr}")
+        raise typer.Exit(code=result.returncode)
+    console.print(f"[green]✓[/green] Lexware MCP-Server entfernt (scope={scope}).")
+
+
+@app.command("status")
+def status() -> None:
+    """Zeigt, ob der Lexware-MCP-Server aktuell bei Claude Code registriert ist."""
+    _check_claude()
+    result = subprocess.run(
+        ["claude", "mcp", "list"], capture_output=True, text=True
+    )
+    if result.returncode != 0:
+        err_console.print(f"[red]Fehler:[/red] {result.stderr}")
+        raise typer.Exit(code=result.returncode)
+    if MCP_NAME in result.stdout:
+        for line in result.stdout.splitlines():
+            if MCP_NAME in line:
+                console.print(f"[green]✓[/green] {line.strip()}")
+    else:
+        console.print(
+            "[yellow]✗[/yellow] Lexware ist nicht registriert. "
+            "Setup: [bold]lxw mcp install-claude[/bold]"
+        )
+
+
+@app.command("serve")
+def serve() -> None:
+    """Startet den MCP-Server (intern von Claude Code aufgerufen — selten manuell nötig)."""
+    from lxw_cli.mcp_server import run as run_server
+
+    run_server()

lxw_cli/commands/orders.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from lxw_cli.commands._common import ARCHIVED_HINT, load_json_arg, state
+from lxw_cli.core import services
+from lxw_cli.core.constants import DEFAULT_VOUCHER_STATUSES
+from lxw_cli.output import print_count, render, working, write_binary
+
+app = typer.Typer(no_args_is_help=True)
+
+LIST_COLUMNS = [
+    "id",
+    "voucherNumber",
+    "voucherDate",
+    "voucherStatus",
+    "contactName",
+    "totalAmount",
+    "currency",
+]
+
+
+@app.command(
+    "list",
+    epilog="""\
+[bold cyan]Beispiele[/bold cyan]
+
+Offene Aufträge: [green]lxw orders list --status open[/green]
+
+Alle als CSV: [green]lxw --csv -o auftraege.csv orders list --all[/green]
+
+Inkl. archivierte: [green]lxw orders list --include-archived[/green]
+""",
+)
+def list_orders(
+    ctx: typer.Context,
+    limit: int = typer.Option(
+        25, "--limit", "-n", help="Maximale Anzahl Einträge (0 = alle)."
+    ),
+    fetch_all: bool = typer.Option(
+        False, "--all", "-a", help="Alle Treffer laden (überschreibt --limit)."
+    ),
+    voucher_status: str = typer.Option(
+        DEFAULT_VOUCHER_STATUSES,
+        "--status",
+        help="Komma-separiert (z.B. draft,open,accepted,rejected).",
+    ),
+    include_archived: bool = typer.Option(
+        False,
+        "--include-archived",
+        help="Auch archivierte Aufträge anzeigen (Standard: ausgeblendet).",
+    ),
+) -> None:
+    """Aufträge (Auftragsbestätigungen) auflisten (über /v1/voucherlist).
+
+    Standardmäßig bis zu 25 Aufträge (--all bzw. --limit 0 lädt alle),
+    filterbar nach Status. Archivierte Aufträge sind standardmäßig
+    ausgeblendet; --include-archived zeigt sie. get/pdf akzeptieren UUID oder
+    Auftragsnummer.
+    """
+    s = state(ctx)
+    with working("Lade Aufträge …"):
+        result = services.list_order_confirmations(
+            s.client,
+            status=voucher_status,
+            include_archived=include_archived,
+            limit=limit,
+            fetch_all=fetch_all,
+        )
+    render(result.items, s.output_format, columns=LIST_COLUMNS, output_path=s.output_path)
+    note = None if include_archived else ARCHIVED_HINT
+    print_count(len(result.items), result.total, noun="Aufträge", note=note)
+
+
+@app.command("get")
+def get_order(
+    ctx: typer.Context,
+    order: str = typer.Argument(..., help="UUID oder Auftragsnummer."),
+) -> None:
+    """Einen Auftrag im Detail abrufen. Akzeptiert UUID oder Auftragsnummer."""
+    s = state(ctx)
+    with working("Lade Auftrag …"):
+        data = services.get_order_confirmation(s.client, order)
+    render(data, s.output_format, output_path=s.output_path)
+
+
+@app.command("pdf")
+def download_pdf(
+    ctx: typer.Context,
+    order: str = typer.Argument(..., help="UUID oder Auftragsnummer."),
+    output: Path | None = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Ziel-Datei oder -Verzeichnis (Standard: aktuelles Verzeichnis).",
+    ),
+) -> None:
+    """PDF eines Auftrags herunterladen. Akzeptiert UUID oder Auftragsnummer."""
+    s = state(ctx)
+    with working("Lade PDF …"):
+        data = services.download_order_confirmation_pdf(s.client, order)
+    write_binary(data, output, default_name=f"order-{order}.pdf")
+
+
+@app.command("create-draft")
+def create_draft(
+    ctx: typer.Context,
+    body: str = typer.Option(..., "--body", help="JSON-Body inline oder @datei.json."),
+) -> None:
+    """Neuen Auftrag als Draft anlegen."""
+    s = state(ctx)
+    payload = load_json_arg(body)
+    with working("Lege Auftrag an …"):
+        result = services.create_order_confirmation(s.client, payload)
+    render(result, s.output_format, output_path=s.output_path)

lxw_cli/commands/quotations.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from lxw_cli.commands._common import ARCHIVED_HINT, load_json_arg, state
+from lxw_cli.core import services
+from lxw_cli.core.constants import DEFAULT_VOUCHER_STATUSES
+from lxw_cli.output import print_count, render, working, write_binary
+
+app = typer.Typer(no_args_is_help=True)
+
+LIST_COLUMNS = [
+    "id",
+    "voucherNumber",
+    "voucherDate",
+    "voucherStatus",
+    "contactName",
+    "totalAmount",
+    "currency",
+]
+
+
+@app.command(
+    "list",
+    epilog="""\
+[bold cyan]Beispiele[/bold cyan]
+
+Offene Angebote: [green]lxw quotations list --status open[/green]
+
+Alle als CSV: [green]lxw --csv -o angebote.csv quotations list --all[/green]
+
+Inkl. archivierte: [green]lxw quotations list --include-archived[/green]
+""",
+)
+def list_quotations(
+    ctx: typer.Context,
+    limit: int = typer.Option(
+        25, "--limit", "-n", help="Maximale Anzahl Einträge (0 = alle)."
+    ),
+    fetch_all: bool = typer.Option(
+        False, "--all", "-a", help="Alle Treffer laden (überschreibt --limit)."
+    ),
+    voucher_status: str = typer.Option(
+        DEFAULT_VOUCHER_STATUSES,
+        "--status",
+        help="Komma-separiert (z.B. draft,open,accepted,rejected).",
+    ),
+    include_archived: bool = typer.Option(
+        False,
+        "--include-archived",
+        help="Auch archivierte Angebote anzeigen (Standard: ausgeblendet).",
+    ),
+) -> None:
+    """Angebote auflisten (über /v1/voucherlist).
+
+    Standardmäßig bis zu 25 Angebote (--all bzw. --limit 0 lädt alle),
+    filterbar nach Status. Archivierte Angebote sind standardmäßig
+    ausgeblendet; --include-archived zeigt sie. get/pdf akzeptieren UUID oder
+    Angebotsnummer (z.B. AG5241415).
+    """
+    s = state(ctx)
+    with working("Lade Angebote …"):
+        result = services.list_quotations(
+            s.client,
+            status=voucher_status,
+            include_archived=include_archived,
+            limit=limit,
+            fetch_all=fetch_all,
+        )
+    render(result.items, s.output_format, columns=LIST_COLUMNS, output_path=s.output_path)
+    note = None if include_archived else ARCHIVED_HINT
+    print_count(len(result.items), result.total, noun="Angebote", note=note)
+
+
+@app.command("get")
+def get_quotation(
+    ctx: typer.Context,
+    quotation: str = typer.Argument(..., help="UUID oder Angebotsnummer."),
+) -> None:
+    """Ein Angebot im Detail abrufen. Akzeptiert UUID oder Angebotsnummer."""
+    s = state(ctx)
+    with working("Lade Angebot …"):
+        data = services.get_quotation(s.client, quotation)
+    render(data, s.output_format, output_path=s.output_path)
+
+
+@app.command("pdf")
+def download_pdf(
+    ctx: typer.Context,
+    quotation: str = typer.Argument(..., help="UUID oder Angebotsnummer."),
+    output: Path | None = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Ziel-Datei oder -Verzeichnis (Standard: aktuelles Verzeichnis).",
+    ),
+) -> None:
+    """PDF eines Angebots herunterladen. Akzeptiert UUID oder Angebotsnummer."""
+    s = state(ctx)
+    with working("Lade PDF …"):
+        data = services.download_quotation_pdf(s.client, quotation)
+    write_binary(data, output, default_name=f"quotation-{quotation}.pdf")
+
+
+@app.command("create-draft")
+def create_draft(
+    ctx: typer.Context,
+    body: str = typer.Option(..., "--body", help="JSON-Body inline oder @datei.json."),
+) -> None:
+    """Neues Angebot als Draft anlegen."""
+    s = state(ctx)
+    payload = load_json_arg(body)
+    with working("Lege Angebot an …"):
+        result = services.create_quotation(s.client, payload)
+    render(result, s.output_format, output_path=s.output_path)

lxw_cli/commands/vouchers.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+import typer
+
+from lxw_cli.commands._common import ARCHIVED_HINT, load_json_arg, state
+from lxw_cli.core import services
+from lxw_cli.core.constants import DEFAULT_VOUCHER_STATUSES, DEFAULT_VOUCHER_TYPES
+from lxw_cli.output import print_count, render, working
+
+app = typer.Typer(no_args_is_help=True)
+
+LIST_COLUMNS = [
+    "id",
+    "voucherType",
+    "voucherStatus",
+    "voucherNumber",
+    "voucherDate",
+    "contactName",
+    "totalAmount",
+    "currency",
+]
+
+
+@app.command(
+    "list",
+    epilog="""\
+[bold cyan]Beispiele[/bold cyan]
+
+Nur Eingangsrechnungen: [green]lxw vouchers list --type purchaseinvoice[/green]
+
+Offene & überfällige: [green]lxw vouchers list --status open,overdue[/green]
+
+Alle eines Kontakts: [green]lxw vouchers list --contact-id <uuid> --all[/green]
+
+Inkl. archivierte: [green]lxw vouchers list --include-archived[/green]
+""",
+)
+def list_vouchers(
+    ctx: typer.Context,
+    limit: int = typer.Option(
+        25, "--limit", "-n", help="Maximale Anzahl Einträge (0 = alle)."
+    ),
+    fetch_all: bool = typer.Option(
+        False, "--all", "-a", help="Alle Treffer laden (überschreibt --limit)."
+    ),
+    voucher_type: str = typer.Option(
+        DEFAULT_VOUCHER_TYPES,
+        "--type",
+        help=(
+            "Komma-separiert: salesinvoice,salescreditnote,purchaseinvoice,"
+            "purchasecreditnote,invoice,downpaymentinvoice,creditnote,"
+            "orderconfirmation,quotation,deliverynote."
+        ),
+    ),
+    voucher_status: str = typer.Option(
+        DEFAULT_VOUCHER_STATUSES,
+        "--status",
+        help="Komma-separiert (z.B. open,paid,paidoff).",
+    ),
+    voucher_number: str | None = typer.Option(
+        None, "--number", help="Filter: exakte Belegnummer."
+    ),
+    contact_id: str | None = typer.Option(
+        None, "--contact-id", help="Filter: Kontakt-UUID."
+    ),
+    include_archived: bool = typer.Option(
+        False,
+        "--include-archived",
+        help="Auch archivierte Belege anzeigen (Standard: ausgeblendet).",
+    ),
+) -> None:
+    """Belege auflisten (alle voucher-types).
+
+    Anders als 'invoices' deckt dieser Befehl alle Beleg-Typen ab — von
+    salesinvoice über purchaseinvoice bis creditnote (siehe --type).
+    Standardmäßig bis zu 25 Einträge (--all lädt alle), filterbar nach Typ,
+    Status, exakter Belegnummer und Kontakt.
+
+    Archivierte Belege sind standardmäßig ausgeblendet; --include-archived
+    zeigt sie. Am Ende wird die Gesamtzahl ausgegeben.
+    """
+    s = state(ctx)
+    with working("Lade Belege …"):
+        result = services.list_vouchers(
+            s.client,
+            voucher_type=voucher_type,
+            status=voucher_status,
+            number=voucher_number,
+            contact_id=contact_id,
+            include_archived=include_archived,
+            limit=limit,
+            fetch_all=fetch_all,
+        )
+    render(result.items, s.output_format, columns=LIST_COLUMNS, output_path=s.output_path)
+    note = None if include_archived else ARCHIVED_HINT
+    print_count(len(result.items), result.total, noun="Belege", note=note)
+
+
+@app.command("get")
+def get_voucher(
+    ctx: typer.Context,
+    voucher: str = typer.Argument(..., help="UUID oder Belegnummer."),
+) -> None:
+    """Einen Beleg im Detail abrufen. Akzeptiert UUID oder Belegnummer."""
+    s = state(ctx)
+    with working("Lade Beleg …"):
+        data = services.get_voucher(s.client, voucher)
+    render(data, s.output_format, output_path=s.output_path)
+
+
+@app.command("create-draft")
+def create_draft(
+    ctx: typer.Context,
+    body: str = typer.Option(..., "--body", help="JSON-Body inline oder @datei.json."),
+) -> None:
+    """Neuen Beleg anlegen."""
+    s = state(ctx)
+    payload = load_json_arg(body)
+    with working("Lege Beleg an …"):
+        result = services.create_voucher(s.client, payload)
+    render(result, s.output_format, output_path=s.output_path)