crowdtime-cli 0.9.0__tar.gz → 0.10.0__tar.gz

{crowdtime_cli-0.9.0 → crowdtime_cli-0.10.0}/.gitignore

@@ -49,6 +49,12 @@ docker-compose.override.yml
 # Claude Code
 .claude/
 
+# Ralph Loop (runtime state)
+.ralph-done
+.ralph-session
+ralph.log
+QUESTIONS.md
+
 # Frontend
 node_modules/
 .next/

{crowdtime_cli-0.9.0 → crowdtime_cli-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crowdtime-cli
-Version: 0.9.0
+Version: 0.10.0
 Summary: AI-powered time tracking CLI — a modern, developer-friendly alternative to Harvest
 Project-URL: Homepage, https://crowdtime.lat
 Project-URL: Documentation, https://crowdtime.lat/docs

{crowdtime_cli-0.9.0 → crowdtime_cli-0.10.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "crowdtime-cli"
-version = "0.9.0"
+version = "0.10.0"
 description = "AI-powered time tracking CLI — a modern, developer-friendly alternative to Harvest"
 readme = "README.md"
 license = {text = "Proprietary"}

{crowdtime_cli-0.9.0 → crowdtime_cli-0.10.0}/src/crowdtime_cli/__init__.py

@@ -1,3 +1,3 @@
 """CrowdTime CLI - AI-powered time tracking from the command line."""
 
-__version__ = "0.9.0"
+__version__ = "0.10.0"

{crowdtime_cli-0.9.0 → crowdtime_cli-0.10.0}/src/crowdtime_cli/client.py

@@ -6,6 +6,7 @@ and friendly error handling.
 
 from __future__ import annotations
 
+import os
 from typing import Any
 
 import httpx
@@ -15,6 +16,7 @@ from .auth import get_token
 from .config import get_config
 
 console = Console(stderr=True)
+_DEBUG = os.environ.get("CROWDTIME_DEBUG", "").lower() in ("1", "true", "yes")
 
 
 class APIError(Exception):
@@ -102,8 +104,12 @@ class CrowdTimeClient:
 
     def _request(self, method: str, url: str, **kwargs: Any) -> Any:
         """Execute an HTTP request with error handling."""
+        if _DEBUG:
+            console.print(f"[dim]→ {method} {url}[/dim]", highlight=False)
         try:
             response = self._client.request(method, url, **kwargs)
+            if _DEBUG:
+                console.print(f"[dim]← {response.status_code}[/dim]", highlight=False)
             return self._handle_response(response)
         except httpx.ConnectError:
             console.print(

{crowdtime_cli-0.9.0 → crowdtime_cli-0.10.0}/src/crowdtime_cli/commands/ai_cmd.py

@@ -9,10 +9,12 @@ from rich.console import Console
 
 from ..client import APIError, CrowdTimeClient
 from ..formatters import (
+    extract_results,
     format_error,
     format_parse_result,
     format_success,
     format_suggestions,
+    format_warning,
     print_json,
 )
 from ..models import ParseResult, Suggestion, TimeEntry, WeeklySummary
@@ -26,7 +28,7 @@ console = Console()
 def parse(
     text: str = typer.Argument(..., help="Natural language time entry description."),
     dry_run: bool = typer.Option(False, "--dry-run", help="Show what would be created without saving."),
-    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation."),
+    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation."),
     output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
 ) -> None:
     """Parse natural language into a time entry.
@@ -34,7 +36,7 @@ def parse(
     Examples:
         ct ai parse "2 hours on project alpha doing code review"
         ct ai parse "spent yesterday afternoon on bug fixes for client X"
-        ct ai parse "30min standup" --yes
+        ct ai parse "30min standup" --force
     """
     client = CrowdTimeClient(require_auth=True, require_org=True)
 
@@ -52,7 +54,7 @@ def parse(
             console.print("[dim]Dry run - not saving.[/dim]")
             return
 
-        if not yes:
+        if not force:
             if not typer.confirm("Create this entry?"):
                 console.print("[dim]Cancelled.[/dim]")
                 return
@@ -60,12 +62,18 @@ def parse(
         # Confirm and create the entry
         confirm_data = client.post("/ai/parse/confirm/", data={
             "parse_log_id": result.parse_log_id,
-            "parsed_result": result.parsed_result,
+            **result.parsed_fields,
         })
-        entry = TimeEntry(**confirm_data)
-        format_success("Entry created from AI parse")
-        from ..formatters import format_entry_summary
-        format_entry_summary(entry)
+
+        # Response may be a full TimeEntry or a minimal {detail, time_entry_id}
+        if "id" in confirm_data and "project_name" in confirm_data:
+            entry = TimeEntry(**confirm_data)
+            format_success("Entry created from AI parse")
+            from ..formatters import format_entry_summary
+            format_entry_summary(entry)
+        else:
+            entry_id = confirm_data.get("time_entry_id", "")
+            format_success(f"Entry created from AI parse (ID: {entry_id})")
 
     except APIError as e:
         format_error(e.message)
@@ -74,7 +82,7 @@ def parse(
 
 @app.command()
 def suggest(
-    date: Optional[str] = typer.Option(None, "--date", "-d", help="Date for suggestions."),
+    date: Optional[str] = typer.Option(None, "--date", "-d", help="Date for suggestions (YYYY-MM-DD)."),
     output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
 ) -> None:
     """Get AI-powered entry suggestions based on your patterns.
@@ -93,7 +101,7 @@ def suggest(
 
     try:
         data = client.get("/ai/suggestions/", params=params)
-        suggestions_list = data if isinstance(data, list) else data.get("results", [])
+        suggestions_list = extract_results(data)
         suggestions = [Suggestion(**item) for item in suggestions_list]
 
         if output_json:
@@ -108,15 +116,19 @@ def suggest(
                 default="",
                 show_default=False,
             )
-            if choice.strip().isdigit():
+            if not choice.strip():
+                console.print("[dim]Skipped.[/dim]")
+            elif choice.strip().isdigit():
                 idx = int(choice.strip()) - 1
                 if 0 <= idx < len(suggestions):
                     s = suggestions[idx]
-                    payload: dict = {"description": s.description}
-                    if s.project_name:
-                        payload["project"] = s.project_name
-                    if s.task_name:
-                        payload["task"] = s.task_name
+                    if not s.project_id:
+                        format_error("Suggestion has no project ID. Use 'ct timer start -p <project>' manually.")
+                        raise typer.Exit(1)
+                    payload: dict = {"notes": s.description}
+                    payload["project_id"] = s.project_id
+                    if s.task_id:
+                        payload["task_id"] = s.task_id
 
                     start_data = client.post("/time/start/", data=payload)
                     entry = TimeEntry(**start_data)
@@ -125,6 +137,8 @@ def suggest(
                     format_timer(entry)
                 else:
                     format_error("Invalid selection.")
+            else:
+                console.print("[dim]Skipped.[/dim]")
 
     except APIError as e:
         format_error(e.message)
@@ -134,7 +148,7 @@ def suggest(
 @app.command()
 def summarize(
     today_flag: bool = typer.Option(False, "--today", help="Summarize today."),
-    week: bool = typer.Option(True, "--week", "-w", help="Summarize this week (default)."),
+    week: bool = typer.Option(False, "--week", "-w", help="Summarize this week."),
     month: bool = typer.Option(False, "--month", "-m", help="Summarize this month."),
     for_format: str = typer.Option("report", "--for", help="Format for: standup, report, slack."),
     copy: bool = typer.Option(False, "--copy", "-c", help="Copy to clipboard."),
@@ -194,17 +208,23 @@ def summarize(
                     ["pbcopy"], stdin=subprocess.PIPE, text=True
                 )
                 process.communicate(text_to_copy)
-                format_success("Copied to clipboard")
-            except Exception:
+                if process.returncode == 0:
+                    format_success("Copied to clipboard")
+                else:
+                    format_warning("Clipboard copy may have failed.")
+            except OSError:
                 try:
                     process = subprocess.Popen(
                         ["xclip", "-selection", "clipboard"],
                         stdin=subprocess.PIPE, text=True
                     )
                     process.communicate(text_to_copy)
-                    format_success("Copied to clipboard")
-                except Exception:
-                    console.print("[dim]Could not copy to clipboard.[/dim]")
+                    if process.returncode == 0:
+                        format_success("Copied to clipboard")
+                    else:
+                        format_warning("Clipboard copy may have failed.")
+                except OSError:
+                    format_warning("Could not copy to clipboard (pbcopy/xclip not found).")
 
     except APIError as e:
         format_error(e.message)

{crowdtime_cli-0.9.0 → crowdtime_cli-0.10.0}/src/crowdtime_cli/commands/auth_cmd.py

@@ -1,7 +1,8 @@
-"""Authentication commands: login, logout, whoami."""
+"""Authentication commands: login, logout, whoami, data-export, delete-account."""
 
 from __future__ import annotations
 
+import json
 from typing import Optional
 
 import typer
@@ -158,3 +159,98 @@ def whoami(
     else:
         console.print("  Org:      [dim]Not set (run ct org switch <slug>)[/dim]")
     console.print()
+
+
+@app.command("data-export")
+def data_export(
+    output_file: Optional[str] = typer.Option(
+        None, "--output", "-o",
+        help="Write export to file instead of stdout.",
+    ),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON (default for this command)."),
+) -> None:
+    """Export all your personal data (GDPR data portability).
+
+    Downloads a JSON dump of all your data across all organizations:
+    time entries, timesheets, favorites, expenses, API tokens, etc.
+    """
+    client = CrowdTimeClient(require_auth=True, require_org=False)
+    data = client.get("/api/v1/auth/data-export/", org_scoped=False)
+
+    formatted = json.dumps(data, indent=2, default=str)
+
+    if output_file:
+        with open(output_file, "w") as f:
+            f.write(formatted)
+        format_success(f"Data exported to {output_file}")
+        console.print(f"  [dim]{len(data.get('time_entries', []))} time entries, "
+                      f"{len(data.get('timesheets', []))} timesheets, "
+                      f"{len(data.get('favorites', []))} favorites[/dim]")
+    else:
+        console.print(formatted)
+
+
+@app.command("delete-account")
+def delete_account(
+    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation prompt."),
+    cancel: bool = typer.Option(False, "--cancel", help="Cancel a pending account deletion."),
+    status_check: bool = typer.Option(False, "--status", help="Check deletion status."),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """Request or cancel account deletion (GDPR right to erasure).
+
+    Schedules your account for permanent deletion after a 30-day grace period.
+    During the grace period, you can cancel with --cancel.
+    """
+    client = CrowdTimeClient(require_auth=True, require_org=False)
+
+    if status_check:
+        data = client.get("/api/v1/auth/delete-account/", org_scoped=False)
+        if output_json:
+            console.print(json.dumps(data, indent=2))
+        elif data.get("scheduled"):
+            console.print(f"[yellow]Account deletion scheduled[/yellow]")
+            console.print(f"  Scheduled at: {data['scheduled_at']}")
+            console.print(f"  Deletes after: {data['delete_after']}")
+        else:
+            console.print("[dim]No pending account deletion.[/dim]")
+        return
+
+    if cancel:
+        client.delete("/api/v1/auth/delete-account/", org_scoped=False)
+        format_success("Account deletion cancelled.")
+        return
+
+    # Request deletion
+    if not force and not output_json:
+        console.print("\n[bold red]⚠ Account Deletion[/bold red]")
+        console.print("This will permanently delete your account and all associated data after 30 days.")
+        console.print("During the grace period, you can cancel with: ct auth delete-account --cancel\n")
+        if not typer.confirm("Are you sure you want to delete your account?"):
+            console.print("[dim]Cancelled.[/dim]")
+            raise typer.Exit(0)
+
+    # Build request body
+    from ..auth import get_token as _get_token
+    body = {}
+
+    # Check if user has a password (try password-based confirmation)
+    me_data = client.get("/api/v1/auth/change-password/", org_scoped=False)
+    if me_data.get("has_password"):
+        if output_json or force:
+            password = typer.prompt("Password", hide_input=True)
+        else:
+            password = typer.prompt("Enter your password to confirm", hide_input=True)
+        body["password"] = password
+    else:
+        body["confirm"] = True
+
+    data = client.post("/api/v1/auth/delete-account/", data=body, org_scoped=False)
+
+    if output_json:
+        console.print(json.dumps(data, indent=2))
+    else:
+        console.print(f"\n[yellow]{data.get('detail', 'Account deletion scheduled.')}[/yellow]")
+        if data.get("delete_after"):
+            console.print(f"  Deletes after: {data['delete_after']}")
+        console.print(f"\n  To cancel: [bold]ct auth delete-account --cancel[/bold]\n")

{crowdtime_cli-0.9.0 → crowdtime_cli-0.10.0}/src/crowdtime_cli/commands/billing_cmd.py

@@ -12,7 +12,8 @@ from rich.panel import Panel
 from rich.table import Table
 
 from ..client import APIError, CrowdTimeClient
-from ..formatters import format_error, format_success, print_json
+from ..formatters import extract_results, format_currency, format_error, format_success, print_json
+from ..utils import format_iso_date
 
 app = typer.Typer(name="billing", help="Manage subscription and billing.")
 console = Console()
@@ -55,22 +56,12 @@ def _cents_to_dollars(cents: int | str | None) -> Decimal:
         return Decimal("0")
     try:
         return Decimal(str(cents)) / Decimal("100")
-    except Exception:
+    except (ValueError, ArithmeticError):
         return Decimal("0")
 
 
-def _format_currency(amount: Decimal) -> str:
-    """Format a Decimal dollar amount for display."""
-    return f"${amount:,.2f}"
 
 
-def _format_date(date_str: str | None) -> str:
-    """Format an ISO date string for display (YYYY-MM-DD)."""
-    if not date_str:
-        return ""
-    # Handle datetime strings by taking just the date part
-    return date_str[:10]
-
 
 # ─── Commands ─────────────────────────────────────────────────────
 
@@ -131,9 +122,9 @@ def status(
     per_seat_dollars = _cents_to_dollars(data.get("per_seat_amount"))
     total_dollars = _cents_to_dollars(data.get("total_amount"))
 
-    period_end = _format_date(data.get("current_period_end"))
+    period_end = format_iso_date(data.get("current_period_end"), placeholder="")
     cancel_at_end = data.get("cancel_at_period_end", False)
-    trial_ends = _format_date(data.get("trial_ends_at"))
+    trial_ends = format_iso_date(data.get("trial_ends_at"), placeholder="")
 
     # Calculate next billing amount (total * months in period)
     # For monthly it's the same; for annual it's total * 12
@@ -154,15 +145,19 @@ def status(
     table.add_row("Status", f"[{color}]{label}[/{color}]")
     table.add_row("Plan", PLAN_LABELS.get(plan, plan.capitalize()))
     table.add_row("Seats", str(seat_count))
-    table.add_row("Base", f"{_format_currency(base_dollars)}/mo")
-    table.add_row("Per seat", f"{_format_currency(per_seat_dollars)}/mo")
-    table.add_row("Total", f"{_format_currency(total_dollars)}/mo")
+    table.add_row("Base", f"{format_currency(base_dollars)}/mo")
+    table.add_row("Per seat", f"{format_currency(per_seat_dollars)}/mo")
+    table.add_row("Total", f"{format_currency(total_dollars)}/mo")
 
     if sub_status == "trialing" and trial_ends:
-        table.add_row("Trial ends", trial_ends)
+        is_usable = data.get("is_usable", False)
+        if not is_usable:
+            table.add_row("Trial ended", f"[red]{trial_ends}[/red]")
+        else:
+            table.add_row("Trial ends", trial_ends)
     elif period_end:
         table.add_row("Next bill", period_end)
-        table.add_row("Next amount", _format_currency(next_amount))
+        table.add_row("Next amount", format_currency(next_amount))
 
     if cancel_at_end:
         table.add_row("", "[yellow]Cancels at period end[/yellow]")
@@ -338,9 +333,9 @@ def plan(
 
     total = _cents_to_dollars(data.get("total_amount"))
     if new_plan == "annual":
-        console.print(f"  [dim]Billed annually at {_format_currency(total * 12)}/yr[/dim]")
+        console.print(f"  [dim]Billed annually at {format_currency(total * 12)}/yr[/dim]")
     else:
-        console.print(f"  [dim]Billed at {_format_currency(total)}/mo[/dim]")
+        console.print(f"  [dim]Billed at {format_currency(total)}/mo[/dim]")
 
 
 @app.command("reactivate")
@@ -377,7 +372,7 @@ def reactivate(
         return
 
     format_success("Subscription reactivated.")
-    period_end = _format_date(data.get("current_period_end"))
+    period_end = format_iso_date(data.get("current_period_end"), placeholder="")
     if period_end:
         console.print(f"  [dim]Next renewal: {period_end}[/dim]")
 
@@ -412,7 +407,7 @@ def events(
         raise typer.Exit(1)
 
     # Handle both paginated and flat list responses
-    event_list = data if isinstance(data, list) else data.get("results", data.get("data", []))
+    event_list = extract_results(data) or (data.get("data", []) if isinstance(data, dict) else [])
     event_list = event_list[:limit]
 
     if output_json:
@@ -429,7 +424,7 @@ def events(
     table.add_column("Status", width=10)
 
     for event in event_list:
-        date = _format_date(event.get("created_at"))
+        date = format_iso_date(event.get("created_at"))
         event_type = event.get("event_type", "unknown")
         processed = event.get("processed", False)
         error = event.get("error", "")

{crowdtime_cli-0.9.0 → crowdtime_cli-0.10.0}/src/crowdtime_cli/commands/clients_cmd.py

@@ -9,7 +9,8 @@ from rich.console import Console
 from rich.table import Table
 
 from ..client import APIError, CrowdTimeClient
-from ..formatters import format_error, format_success, print_json
+from ..formatters import extract_results, format_error, format_success, print_json
+from ..utils import is_uuid
 
 app = typer.Typer(name="clients", help="Manage clients.")
 console = Console()
@@ -22,12 +23,12 @@ def _resolve_client(api_client: CrowdTimeClient, client_ref: str) -> str:
     Otherwise search by name and return the first exact match.
     """
     # If it looks like a UUID, use it directly
-    if len(client_ref) == 36 and client_ref.count("-") == 4:
+    if is_uuid(client_ref):
         return client_ref
 
     # Search by name
     data = api_client.get("/clients/", params={"search": client_ref})
-    clients_list = data if isinstance(data, list) else data.get("results", [])
+    clients_list = extract_results(data)
 
     # Exact match (case-insensitive)
     for c in clients_list:
@@ -63,13 +64,14 @@ def list_clients(
 
     try:
         data = client.get("/clients/", params=params)
-        clients_list = data if isinstance(data, list) else data.get("results", [])
+        clients_list = extract_results(data)
 
         if output_json:
             print_json(clients_list)
         else:
             if not clients_list:
                 console.print("[dim]No clients found.[/dim]")
+                console.print("Run [bold]ct clients create <name>[/bold] to add a client.")
                 return
 
             table = Table(show_header=True, header_style="bold")
@@ -99,7 +101,11 @@ def show(
     client_id: str = typer.Argument(..., help="Client ID."),
     output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
 ) -> None:
-    """Show details for a specific client."""
+    """Show details for a specific client.
+
+    Examples:
+        ct clients show <client-id>
+    """
     api_client = CrowdTimeClient(require_auth=True, require_org=True)
 
     try:
@@ -135,9 +141,20 @@ def create(
     currency: Optional[str] = typer.Option(None, "--currency", help="Currency code (e.g. USD)."),
     contact_name: Optional[str] = typer.Option(None, "--contact", help="Contact person name."),
     contact_email: Optional[str] = typer.Option(None, "--email", help="Contact email."),
+    address_line1: Optional[str] = typer.Option(None, "--address-line1", help="Street address."),
+    address_line2: Optional[str] = typer.Option(None, "--address-line2", help="Suite, unit, etc."),
+    city: Optional[str] = typer.Option(None, "--city", help="City."),
+    state: Optional[str] = typer.Option(None, "--state", help="State/province."),
+    postal_code: Optional[str] = typer.Option(None, "--postal-code", help="Postal/ZIP code."),
+    country: Optional[str] = typer.Option(None, "--country", help="Country."),
     output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
 ) -> None:
-    """Create a new client."""
+    """Create a new client.
+
+    Examples:
+        ct clients create "Acme Corp"
+        ct clients create "Acme Corp" --currency EUR --contact "Jane Doe" --email jane@acme.com
+    """
     api_client = CrowdTimeClient(require_auth=True, require_org=True)
 
     payload: dict = {"name": name}
@@ -147,6 +164,18 @@ def create(
         payload["contact_name"] = contact_name
     if contact_email:
         payload["contact_email"] = contact_email
+    if address_line1:
+        payload["address_line1"] = address_line1
+    if address_line2:
+        payload["address_line2"] = address_line2
+    if city:
+        payload["city"] = city
+    if state:
+        payload["state"] = state
+    if postal_code:
+        payload["postal_code"] = postal_code
+    if country:
+        payload["country"] = country
 
     try:
         data = api_client.post("/clients/", data=payload)
@@ -160,6 +189,67 @@ def create(
         raise typer.Exit(1)
 
 
+@app.command()
+def edit(
+    client_id: str = typer.Argument(..., help="Client ID to edit."),
+    name: Optional[str] = typer.Option(None, "--name", help="New client name."),
+    currency: Optional[str] = typer.Option(None, "--currency", help="Currency code (e.g. USD, EUR)."),
+    contact_name: Optional[str] = typer.Option(None, "--contact", help="Contact person name."),
+    contact_email: Optional[str] = typer.Option(None, "--email", help="Contact email."),
+    address_line1: Optional[str] = typer.Option(None, "--address-line1", help="Street address."),
+    city: Optional[str] = typer.Option(None, "--city", help="City."),
+    state: Optional[str] = typer.Option(None, "--state", help="State/province."),
+    postal_code: Optional[str] = typer.Option(None, "--postal-code", help="Postal/ZIP code."),
+    country: Optional[str] = typer.Option(None, "--country", help="Country."),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """Edit an existing client.
+
+    Examples:
+        ct clients edit <client-id> --name "New Name"
+        ct clients edit <client-id> --currency EUR --contact "Jane Doe"
+    """
+    api_client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    payload: dict = {}
+    if name is not None:
+        payload["name"] = name
+    if currency is not None:
+        payload["currency"] = currency
+    if contact_name is not None:
+        payload["contact_name"] = contact_name
+    if contact_email is not None:
+        payload["contact_email"] = contact_email
+    if address_line1 is not None:
+        payload["address_line1"] = address_line1
+    if city is not None:
+        payload["city"] = city
+    if state is not None:
+        payload["state"] = state
+    if postal_code is not None:
+        payload["postal_code"] = postal_code
+    if country is not None:
+        payload["country"] = country
+
+    if not payload:
+        format_error("No changes specified. Use --name, --currency, --contact, etc.")
+        raise typer.Exit(1)
+
+    try:
+        data = api_client.patch(f"/clients/{client_id}/", data=payload)
+
+        if output_json:
+            print_json(data)
+        else:
+            format_success(f"Client '{data.get('name')}' updated (ID: {data.get('id')})")
+    except APIError as e:
+        if e.status_code == 404:
+            format_error(f"Client '{client_id}' not found.")
+        else:
+            format_error(e.message)
+        raise typer.Exit(1)
+
+
 @app.command()
 def archive(
     client_id: str = typer.Argument(..., help="Client ID to archive."),
@@ -203,7 +293,7 @@ def list_contacts(
     try:
         client_id = _resolve_client(api_client, client_ref)
         data = api_client.get(f"/clients/{client_id}/contacts/")
-        contacts = data if isinstance(data, list) else data.get("results", [])
+        contacts = extract_results(data)
 
         if output_json:
             print_json(contacts)
@@ -250,6 +340,7 @@ def add_contact(
     phone: Optional[str] = typer.Option(None, "--phone", help="Contact phone."),
     role: Optional[str] = typer.Option(None, "--role", help="Contact role/title."),
     primary: bool = typer.Option(False, "--primary", help="Set as primary contact."),
+    receives_invoices: bool = typer.Option(False, "--receives-invoices", help="Receives invoices and payment reminders."),
     output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
 ) -> None:
     """Add a contact to a client.
@@ -257,6 +348,7 @@ def add_contact(
     Examples:
         ct clients add-contact "Acme Corp" --name "Jane Doe" --email jane@acme.com
         ct clients add-contact <client-id> --name "John Smith" --role "CTO" --primary
+        ct clients add-contact "Acme Corp" --name "Billing Dept" --email billing@acme.com --receives-invoices
     """
     api_client = CrowdTimeClient(require_auth=True, require_org=True)
 
@@ -272,6 +364,8 @@ def add_contact(
             payload["role"] = role
         if primary:
             payload["is_primary"] = True
+        if receives_invoices:
+            payload["receives_invoices"] = True
 
         data = api_client.post(f"/clients/{client_id}/contacts/", data=payload)