wealthbox-cli 1.0.0__py3-none-any.whl

wealthbox_tools/cli/me.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+import typer
+
+from ._util import OutputFormat, handle_errors, output_result, run_client
+
+app = typer.Typer(
+    context_settings={"help_option_names": ["-h", "--help"]},
+    help="Show info about the current authenticated user.",
+)
+
+
+@app.callback(
+    invoke_without_command=True,
+    help="Show info about the current authenticated user. Use subcommands for more specific info.",
+)
+@handle_errors
+def get_me(
+    ctx: typer.Context,
+    token: str | None = typer.Option(None, envvar="WEALTHBOX_TOKEN", hidden=True),
+    fmt: OutputFormat = typer.Option(OutputFormat.JSON, "--format"),
+) -> None:
+    if ctx.invoked_subcommand is not None:
+        return
+    output_result(run_client(token, lambda c: c.get_me()), fmt)

wealthbox_tools/cli/notes.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from typing import Any
+
+import typer
+
+from wealthbox_tools.models import NoteCreateInput, NoteListQuery, NoteResourceType, NotesOrder, NoteUpdateInput
+
+from ._util import OutputFormat, build_linked_to, handle_errors, output_result, run_client, truncate_field
+
+app = typer.Typer(
+    context_settings={"help_option_names": ["-h", "--help"]},
+    help="Manage Wealthbox notes.",
+    no_args_is_help=True,
+)
+
+_DEFAULT_FIELDS = ["id", "content", "linked_to", "creator_id", "updated_at"]
+_CONTENT_PREVIEW_LEN = 500
+
+
+@app.command("list", help="List notes. Can filter by linked resource and/or updated date range.")
+@handle_errors
+def list_notes(
+    contact: int | None = typer.Option(None, "--contact", help="Filter notes linked to a Contact (by ID)"),
+    order: NotesOrder | None = typer.Option("updated", help="Sort order: updated or created"),
+    updated_since: str | None = typer.Option(None, "--updated-since"),
+    updated_before: str | None = typer.Option(None, "--updated-before"),
+    page: int | None = typer.Option(None),
+    per_page: int | None = typer.Option(None, "--per-page", help="Results per page (max 100)"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Show all fields; content is not truncated"),
+    token: str | None = typer.Option(None, envvar="WEALTHBOX_TOKEN", hidden=True),
+    fmt: OutputFormat = typer.Option(OutputFormat.JSON, "--format"),
+) -> None:
+    query = NoteListQuery(
+        resource_id=contact,
+        resource_type=NoteResourceType.CONTACT if contact is not None else None,
+        order=order,
+        updated_since=updated_since,
+        updated_before=updated_before,
+        page=page,
+        per_page=per_page,
+    )
+
+    result = run_client(token, lambda c: c.list_notes(query))
+    if not verbose:
+        result = truncate_field(result, "content", _CONTENT_PREVIEW_LEN)
+    output_result(result, fmt, fields=None if verbose else _DEFAULT_FIELDS)
+
+
+@app.command("get", help="Get a single note by ID.")
+@handle_errors
+def get_note(
+    note_id: int = typer.Argument(..., help="Note ID"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Show all fields"),
+    token: str | None = typer.Option(None, envvar="WEALTHBOX_TOKEN", hidden=True),
+    fmt: OutputFormat = typer.Option(OutputFormat.JSON, "--format"),
+) -> None:
+    output_result(run_client(token, lambda c: c.get_note(note_id)), fmt, fields=None if verbose else _DEFAULT_FIELDS)
+
+
+@app.command("add", help="Create a new note.")
+@handle_errors
+def add_note(
+    content: str = typer.Argument(..., help="Note body text"),
+    contact: int | None = typer.Option(None, "--contact", help="Link to a Contact by ID"),
+    project: int | None = typer.Option(None, "--project", help="Link to a Project by ID"),
+    opportunity: int | None = typer.Option(None, "--opportunity", help="Link to an Opportunity by ID"),
+    token: str | None = typer.Option(None, envvar="WEALTHBOX_TOKEN", hidden=True),
+    fmt: OutputFormat = typer.Option(OutputFormat.JSON, "--format"),
+) -> None:
+    input_model = NoteCreateInput(
+        content=content,
+        linked_to=build_linked_to(contact, project, opportunity),
+    )
+    output_result(run_client(token, lambda c: c.create_note(input_model)), fmt)
+
+
+@app.command("update", help="Update an existing note. Note: the API does not support deleting notes.")
+@handle_errors
+def update_note(
+    note_id: int = typer.Argument(..., help="Note ID"),
+    content: str | None = typer.Option(None, "--content", help="New note body text"),
+    contact: int | None = typer.Option(None, "--contact", help="Replace linked Contact (by ID)"),
+    project: int | None = typer.Option(None, "--project", help="Replace linked Project (by ID)"),
+    opportunity: int | None = typer.Option(None, "--opportunity", help="Replace linked Opportunity (by ID)"),
+    token: str | None = typer.Option(None, envvar="WEALTHBOX_TOKEN", hidden=True),
+    fmt: OutputFormat = typer.Option(OutputFormat.JSON, "--format"),
+) -> None:
+    payload: dict[str, Any] = {}
+    if content is not None:
+        payload["content"] = content
+    linked = build_linked_to(contact, project, opportunity)
+    if linked is not None:
+        payload["linked_to"] = linked
+    input_model = NoteUpdateInput(**payload)
+
+    output_result(run_client(token, lambda c: c.update_note(note_id, input_model)), fmt)

wealthbox_tools/cli/opportunities.py

@@ -0,0 +1,198 @@
+from __future__ import annotations
+
+from typing import Any
+
+import typer
+
+from wealthbox_tools.models import (
+    OpportunityAmountKind,
+    OpportunityCreateInput,
+    OpportunityListQuery,
+    OpportunityOrder,
+    OpportunityResourceType,
+    OpportunityUpdateInput,
+)
+
+from ._util import OutputFormat, build_linked_to, handle_errors, output_result, parse_more_fields, run_client
+
+app = typer.Typer(
+    context_settings={"help_option_names": ["-h", "--help"]},
+    help="Manage Wealthbox opportunities.",
+    no_args_is_help=True,
+)
+
+_DEFAULT_FIELDS = ["id", "name", "stage", "probability", "target_close", "manager", "linked_to"]
+
+
+def _build_amounts(
+    fee: float | None,
+    commission: float | None,
+    aum: float | None,
+    other: float | None,
+    currency: str,
+) -> list[dict[str, Any]] | None:
+    amounts = []
+    for value, kind in (
+        (fee, OpportunityAmountKind.FEE),
+        (commission, OpportunityAmountKind.COMMISSION),
+        (aum, OpportunityAmountKind.AUM),
+        (other, OpportunityAmountKind.OTHER),
+    ):
+        if value is not None:
+            amounts.append({"amount": value, "currency": currency, "kind": kind})
+    return amounts or None
+
+
+@app.command("list", help="List opportunities with optional filters.")
+@handle_errors
+def list_opportunities(
+    resource_id: int | None = typer.Option(
+        None, "--resource-id", help="Filter by linked resource ID (requires --resource-type)"
+    ),
+    resource_type: OpportunityResourceType | None = typer.Option(
+        None, "--resource-type", help="Filter by linked resource type: Contact, Project"
+    ),
+    order: OpportunityOrder | None = typer.Option(None, "--order", help="Sort order: asc, desc, recent, created"),
+    include_closed: bool | None = typer.Option(
+        None, "--include-closed/--no-include-closed", help="Include closed opportunities"
+    ),
+    updated_since: str | None = typer.Option(None, "--updated-since"),
+    updated_before: str | None = typer.Option(None, "--updated-before"),
+    page: int | None = typer.Option(None),
+    per_page: int | None = typer.Option(None, "--per-page", help="Results per page (max 100)"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Show all fields"),
+    token: str | None = typer.Option(None, envvar="WEALTHBOX_TOKEN", hidden=True),
+    fmt: OutputFormat = typer.Option(OutputFormat.JSON, "--format"),
+) -> None:
+    query = OpportunityListQuery(
+        resource_id=resource_id,
+        resource_type=resource_type,
+        order=order,
+        include_closed=include_closed,
+        updated_since=updated_since,
+        updated_before=updated_before,
+        page=page,
+        per_page=per_page,
+    )
+    output_result(
+        run_client(token, lambda c: c.list_opportunities(query)), fmt, fields=None if verbose else _DEFAULT_FIELDS
+    )
+
+
+@app.command("get", help="Get a single opportunity by ID.")
+@handle_errors
+def get_opportunity(
+    opportunity_id: int = typer.Argument(..., help="Opportunity ID"),
+    token: str | None = typer.Option(None, envvar="WEALTHBOX_TOKEN", hidden=True),
+    fmt: OutputFormat = typer.Option(OutputFormat.JSON, "--format"),
+) -> None:
+    output_result(run_client(token, lambda c: c.get_opportunity(opportunity_id)), fmt)
+
+
+@app.command("add", help="Create a new opportunity.")
+@handle_errors
+def add_opportunity(
+    name: str = typer.Argument(..., help="Opportunity name"),
+    target_close: str = typer.Option(..., "--target-close", help="Target close date (e.g. 2026-06-30)"),
+    probability: int = typer.Option(..., "--probability", help="Close probability 0–100"),
+    stage: int = typer.Option(..., "--stage", help="Stage ID — see: wbox categories"),
+    description: str | None = typer.Option(None, "--description"),
+    manager: int | None = typer.Option(None, "--manager", help="Assign a manager by user ID"),
+    visible_to: str | None = typer.Option(None, "--visible-to"),
+    contact: int | None = typer.Option(None, "--contact", help="Link to a Contact by ID"),
+    project: int | None = typer.Option(None, "--project", help="Link to a Project by ID"),
+    fee: float | None = typer.Option(None, "--fee", help="Fee amount"),
+    commission: float | None = typer.Option(None, "--commission", help="Commission amount"),
+    aum: float | None = typer.Option(None, "--aum", help="AUM amount"),
+    other_amount: float | None = typer.Option(None, "--other-amount", help="Other amount"),
+    currency: str = typer.Option("USD", "--currency", help="Currency code for all amounts (default: USD)"),
+    more_fields: str | None = typer.Option(
+        None, "--more-fields", help="JSON object for additional fields (e.g. custom_fields)"
+    ),
+    token: str | None = typer.Option(None, envvar="WEALTHBOX_TOKEN", hidden=True),
+    fmt: OutputFormat = typer.Option(OutputFormat.JSON, "--format"),
+) -> None:
+    payload: dict[str, Any] = {
+        "name": name,
+        "target_close": target_close,
+        "probability": probability,
+        "stage": stage,
+        "description": description,
+        "manager": manager,
+        "visible_to": visible_to,
+        "linked_to": build_linked_to(contact, project, None),
+        "amounts": _build_amounts(fee, commission, aum, other_amount, currency),
+    }
+
+    if more_fields:
+        _reserved = {
+            "name", "target_close", "probability", "stage", "description",
+            "manager", "visible_to", "linked_to", "amounts",
+        }
+        payload.update(parse_more_fields(more_fields, _reserved))
+
+    input_model = OpportunityCreateInput(**{k: v for k, v in payload.items() if v is not None})
+    output_result(run_client(token, lambda c: c.create_opportunity(input_model)), fmt)
+
+
+@app.command("update", help="Update an existing opportunity. Pass only the fields you want to change.")
+@handle_errors
+def update_opportunity(
+    opportunity_id: int = typer.Argument(..., help="Opportunity ID"),
+    name: str | None = typer.Option(None, "--name"),
+    target_close: str | None = typer.Option(None, "--target-close"),
+    probability: int | None = typer.Option(None, "--probability", help="Close probability 0–100"),
+    stage: int | None = typer.Option(None, "--stage", help="Stage ID — see: wbox categories"),
+    description: str | None = typer.Option(None, "--description"),
+    manager: int | None = typer.Option(None, "--manager"),
+    visible_to: str | None = typer.Option(None, "--visible-to"),
+    contact: int | None = typer.Option(None, "--contact", help="Replace linked Contact (by ID)"),
+    project: int | None = typer.Option(None, "--project", help="Replace linked Project (by ID)"),
+    fee: float | None = typer.Option(None, "--fee", help="Fee amount"),
+    commission: float | None = typer.Option(None, "--commission", help="Commission amount"),
+    aum: float | None = typer.Option(None, "--aum", help="AUM amount"),
+    other_amount: float | None = typer.Option(None, "--other-amount", help="Other amount"),
+    currency: str = typer.Option("USD", "--currency", help="Currency code for all amounts (default: USD)"),
+    more_fields: str | None = typer.Option(
+        None, "--more-fields", help="JSON object for additional fields (e.g. custom_fields)"
+    ),
+    token: str | None = typer.Option(None, envvar="WEALTHBOX_TOKEN", hidden=True),
+    fmt: OutputFormat = typer.Option(OutputFormat.JSON, "--format"),
+) -> None:
+    payload: dict[str, Any] = {k: v for k, v in {
+        "name": name,
+        "target_close": target_close,
+        "probability": probability,
+        "stage": stage,
+        "description": description,
+        "manager": manager,
+        "visible_to": visible_to,
+    }.items() if v is not None}
+
+    linked = build_linked_to(contact, project, None)
+    if linked is not None:
+        payload["linked_to"] = linked
+
+    amounts = _build_amounts(fee, commission, aum, other_amount, currency)
+    if amounts is not None:
+        payload["amounts"] = amounts
+
+    if more_fields:
+        _update_reserved = {
+            "name", "target_close", "probability", "stage", "description",
+            "manager", "visible_to", "linked_to", "amounts",
+        }
+        payload.update(parse_more_fields(more_fields, _update_reserved))
+
+    input_model = OpportunityUpdateInput(**payload)
+    output_result(run_client(token, lambda c: c.update_opportunity(opportunity_id, input_model)), fmt)
+
+
+@app.command("delete", help="Delete an opportunity by ID.")
+@handle_errors
+def delete_opportunity(
+    opportunity_id: int = typer.Argument(..., help="Opportunity ID"),
+    token: str | None = typer.Option(None, envvar="WEALTHBOX_TOKEN", hidden=True),
+) -> None:
+    run_client(token, lambda c: c.delete_opportunity(opportunity_id))
+    typer.echo(f"Opportunity {opportunity_id} deleted.")

wealthbox_tools/cli/projects.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from typing import Any
+
+import typer
+
+from wealthbox_tools.models import ProjectCreateInput, ProjectListQuery, ProjectUpdateInput
+
+from ._util import OutputFormat, handle_errors, output_result, parse_more_fields, run_client
+
+app = typer.Typer(
+    context_settings={"help_option_names": ["-h", "--help"]},
+    help="Manage Wealthbox projects.",
+    no_args_is_help=True,
+)
+
+_DEFAULT_FIELDS = ["id", "name", "description", "organizer", "updated_at"]
+
+
+@app.command("list", help="List projects with optional date range filters.")
+@handle_errors
+def list_projects(
+    updated_since: str | None = typer.Option(None, "--updated-since"),
+    updated_before: str | None = typer.Option(None, "--updated-before"),
+    page: int | None = typer.Option(None),
+    per_page: int | None = typer.Option(None, "--per-page", help="Results per page (max 100)"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Show all fields"),
+    token: str | None = typer.Option(None, envvar="WEALTHBOX_TOKEN", hidden=True),
+    fmt: OutputFormat = typer.Option(OutputFormat.JSON, "--format"),
+) -> None:
+    query = ProjectListQuery(
+        updated_since=updated_since,
+        updated_before=updated_before,
+        page=page,
+        per_page=per_page,
+    )
+    output_result(run_client(token, lambda c: c.list_projects(query)), fmt, fields=None if verbose else _DEFAULT_FIELDS)
+
+
+@app.command("get", help="Get a single project by ID.")
+@handle_errors
+def get_project(
+    project_id: int = typer.Argument(..., help="Project ID"),
+    token: str | None = typer.Option(None, envvar="WEALTHBOX_TOKEN", hidden=True),
+    fmt: OutputFormat = typer.Option(OutputFormat.JSON, "--format"),
+) -> None:
+    output_result(run_client(token, lambda c: c.get_project(project_id)), fmt)
+
+
+@app.command("add", help="Create a new project.")
+@handle_errors
+def add_project(
+    name: str = typer.Argument(..., help="Project name"),
+    description: str = typer.Option(..., "--description", help="Project description"),
+    organizer: int | None = typer.Option(None, "--organizer", help="Organizer user ID"),
+    visible_to: str | None = typer.Option(None, "--visible-to"),
+    more_fields: str | None = typer.Option(
+        None, "--more-fields", help="JSON object for additional fields (e.g. custom_fields)"
+    ),
+    token: str | None = typer.Option(None, envvar="WEALTHBOX_TOKEN", hidden=True),
+    fmt: OutputFormat = typer.Option(OutputFormat.JSON, "--format"),
+) -> None:
+    payload: dict[str, Any] = {
+        "name": name,
+        "description": description,
+        "organizer": organizer,
+        "visible_to": visible_to,
+    }
+
+    if more_fields:
+        payload.update(parse_more_fields(more_fields, {"name", "description", "organizer", "visible_to"}))
+
+    input_model = ProjectCreateInput(**{k: v for k, v in payload.items() if v is not None})
+    output_result(run_client(token, lambda c: c.create_project(input_model)), fmt)
+
+
+@app.command("update", help="Update an existing project. Pass only the fields you want to change.")
+@handle_errors
+def update_project(
+    project_id: int = typer.Argument(..., help="Project ID"),
+    name: str | None = typer.Option(None, "--name"),
+    description: str | None = typer.Option(None, "--description"),
+    organizer: int | None = typer.Option(None, "--organizer", help="Organizer user ID"),
+    visible_to: str | None = typer.Option(None, "--visible-to"),
+    more_fields: str | None = typer.Option(
+        None, "--more-fields", help="JSON object for additional fields (e.g. custom_fields)"
+    ),
+    token: str | None = typer.Option(None, envvar="WEALTHBOX_TOKEN", hidden=True),
+    fmt: OutputFormat = typer.Option(OutputFormat.JSON, "--format"),
+) -> None:
+    payload: dict[str, Any] = {k: v for k, v in {
+        "name": name,
+        "description": description,
+        "organizer": organizer,
+        "visible_to": visible_to,
+    }.items() if v is not None}
+
+    if more_fields:
+        payload.update(parse_more_fields(more_fields, {"name", "description", "organizer", "visible_to"}))
+
+    input_model = ProjectUpdateInput(**payload)
+    output_result(run_client(token, lambda c: c.update_project(project_id, input_model)), fmt)

wealthbox_tools/cli/tasks.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+from typing import Any
+
+import typer
+
+from wealthbox_tools.models import (
+    CategoryType,
+    TaskCreateInput,
+    TaskFrame,
+    TaskListQuery,
+    TaskPriority,
+    TaskType,
+    TaskUpdateInput,
+)
+
+from ._util import (
+    OutputFormat,
+    build_linked_to,
+    build_resource_filter,
+    handle_errors,
+    make_category_command,
+    output_result,
+    parse_more_fields,
+    run_client,
+)
+
+app = typer.Typer(
+    context_settings={"help_option_names": ["-h", "--help"]},
+    help="Manage Wealthbox tasks.",
+    no_args_is_help=True,
+)
+app.command("categories", help="List task category options.")(make_category_command(CategoryType.TASK_CATEGORIES))
+
+_DEFAULT_FIELDS = ["id", "name", "due_date", "frame", "complete", "category"]
+
+_TASK_CREATE_RESERVED = {"name", "due_date", "frame", "priority", "assigned_to", "linked_to"}
+
+
+@app.command(
+    "list",
+    help=(
+        "List tasks with optional filters. By default only outstanding tasks are returned; "
+        "use --include-completed to include completed tasks"
+    ),
+)
+@handle_errors
+def list_tasks(
+    contact: int | None = typer.Option(None, "--contact", help="Filter tasks linked to a Contact (by ID)"),
+    project: int | None = typer.Option(None, "--project", help="Filter tasks linked to a Project (by ID)"),
+    opportunity: int | None = typer.Option(None, "--opportunity", help="Filter tasks linked to an Opportunity (by ID)"),
+    assigned_to: int | None = typer.Option(None, "--assigned-to", help="Filter by assigned user ID"),
+    assigned_to_team: int | None = typer.Option(None, "--assigned-to-team", help="Filter by assigned team ID"),
+    created_by: int | None = typer.Option(None, "--created-by", help="Filter by creator user ID"),
+    include_completed: bool = typer.Option(
+        False, "--include-completed", help="Include completed tasks (default returns outstanding tasks only)"
+    ),
+    task_type: TaskType | None = typer.Option(None, "--type", help="all, parents, subtasks"),
+    updated_since: str | None = typer.Option(None, "--updated-since"),
+    updated_before: str | None = typer.Option(None, "--updated-before"),
+    page: int | None = typer.Option(None),
+    per_page: int | None = typer.Option(None, "--per-page", help="Results per page (max 100)"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Show all fields"),
+    token: str | None = typer.Option(None, envvar="WEALTHBOX_TOKEN", hidden=True),
+    fmt: OutputFormat = typer.Option(OutputFormat.JSON, "--format"),
+) -> None:
+    resource_id, resource_type = build_resource_filter(contact, project, opportunity)
+
+    query = TaskListQuery(
+        resource_id=resource_id,
+        resource_type=resource_type,
+        assigned_to=assigned_to,
+        assigned_to_team=assigned_to_team,
+        created_by=created_by,
+        completed=True if include_completed else None,
+        task_type=task_type,
+        updated_since=updated_since,
+        updated_before=updated_before,
+        page=page,
+        per_page=per_page,
+    )
+
+    output_result(run_client(token, lambda c: c.list_tasks(query)), fmt, fields=None if verbose else _DEFAULT_FIELDS)
+
+
+@app.command("get", help="Get a single task by ID.")
+@handle_errors
+def get_task(
+    task_id: int = typer.Argument(..., help="Task ID"),
+    token: str | None = typer.Option(None, envvar="WEALTHBOX_TOKEN", hidden=True),
+    fmt: OutputFormat = typer.Option(OutputFormat.JSON, "--format"),
+) -> None:
+    output_result(run_client(token, lambda c: c.get_task(task_id)), fmt)
+
+
+@app.command("add", help="Create a new task. Required: name, and either due_date or frame.")
+@handle_errors
+def add_task(
+    name: str = typer.Argument(..., help="Task title/name"),
+    due_date: str | None = typer.Option(
+        None, "--due-date", help="Example: '2025-05-24 10:00 AM -0700' (must match Wealthbox format)"
+    ),
+    frame: TaskFrame | None = typer.Option(None, "--frame", help="Friendly due timeframe"),
+    priority: TaskPriority | None = typer.Option(None, "--priority", help="Low, Medium, or High"),
+    assigned_to: int | None = typer.Option(None, "--assigned-to", help="Assign to a user by ID"),
+    contact: int | None = typer.Option(None, "--contact", help="Link to a Contact by ID"),
+    project: int | None = typer.Option(None, "--project", help="Link to a Project by ID"),
+    opportunity: int | None = typer.Option(None, "--opportunity", help="Link to an Opportunity by ID"),
+    more_fields: str | None = typer.Option(
+        None, "--more-fields",
+        help='JSON: {"category": 123, "complete": false, "assigned_to_team": 456, "description": "..."}',
+    ),
+    token: str | None = typer.Option(None, envvar="WEALTHBOX_TOKEN", hidden=True),
+    fmt: OutputFormat = typer.Option(OutputFormat.JSON, "--format"),
+) -> None:
+    # Friendly CLI-level guardrail (still keep model validation too)
+    if (due_date is None) == (frame is None):
+        raise typer.BadParameter("Provide exactly one --due-date or --frame.")
+
+    payload: dict[str, Any] = {
+        "name": name,
+        "due_date": due_date,
+        "frame": frame,
+        "priority": priority,
+        "assigned_to": assigned_to,
+        "linked_to": build_linked_to(contact, project, opportunity),
+    }
+
+    if more_fields:
+        payload.update(parse_more_fields(more_fields, _TASK_CREATE_RESERVED))
+
+    # Strip None before model construction (due_date XOR frame validator needs clean input)
+    input_model = TaskCreateInput(**{k: v for k, v in payload.items() if v is not None})
+
+    output_result(run_client(token, lambda c: c.create_task(input_model)), fmt)
+
+
+@app.command("update", help="Update an existing task. Pass only the fields you want to change.")
+@handle_errors
+def update_task(
+    task_id: int = typer.Argument(..., help="Task ID"),
+    name: str | None = typer.Option(None, "--name", help="Task name"),
+    due_date: str | None = typer.Option(None, "--due-date", help="ISO 8601 datetime, e.g. '2026-04-01T09:00:00-07:00'"),
+    frame: TaskFrame | None = typer.Option(None, "--frame", help="Friendly due timeframe"),
+    priority: TaskPriority | None = typer.Option(None, "--priority", help="Low, Medium, or High"),
+    assigned_to: int | None = typer.Option(None, "--assigned-to", help="Reassign to a user by ID"),
+    complete: bool | None = typer.Option(None, "--complete/--no-complete", help="Mark as complete or incomplete"),
+    description: str | None = typer.Option(None, "--description"),
+    contact: int | None = typer.Option(None, "--contact", help="Replace linked Contact (by ID)"),
+    project: int | None = typer.Option(None, "--project", help="Replace linked Project (by ID)"),
+    opportunity: int | None = typer.Option(None, "--opportunity", help="Replace linked Opportunity (by ID)"),
+    token: str | None = typer.Option(None, envvar="WEALTHBOX_TOKEN", hidden=True),
+    fmt: OutputFormat = typer.Option(OutputFormat.JSON, "--format"),
+) -> None:
+    payload: dict[str, Any] = {k: v for k, v in {
+        "name": name,
+        "due_date": due_date,
+        "frame": frame,
+        "priority": priority,
+        "assigned_to": assigned_to,
+        "description": description,
+    }.items() if v is not None}
+    if complete is not None:
+        payload["complete"] = complete
+    linked = build_linked_to(contact, project, opportunity)
+    if linked is not None:
+        payload["linked_to"] = linked
+    input_model = TaskUpdateInput(**payload)
+
+    output_result(run_client(token, lambda c: c.update_task(task_id, input_model)), fmt)
+
+
+@app.command("delete", help="Delete a task by ID.")
+@handle_errors
+def delete_task(
+    task_id: int = typer.Argument(..., help="Task ID"),
+    token: str | None = typer.Option(None, envvar="WEALTHBOX_TOKEN", hidden=True),
+) -> None:
+    run_client(token, lambda c: c.delete_task(task_id))
+    typer.echo(f"Task {task_id} deleted.")

wealthbox_tools/cli/users.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import typer
+
+from ._util import OutputFormat, handle_errors, output_result, run_client
+
+app = typer.Typer(
+    context_settings={"help_option_names": ["-h", "--help"]},
+    help="Manage Wealthbox users.",
+    no_args_is_help=True,
+)
+
+
+_DEFAULT_FIELDS = ["id", "name", "email"]
+
+
+@app.command("list", help="List users.")
+@handle_errors
+def list_users(
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Show all fields"),
+    token: str | None = typer.Option(None, envvar="WEALTHBOX_TOKEN", hidden=True),
+    fmt: OutputFormat = typer.Option(OutputFormat.JSON, "--format"),
+) -> None:
+    output_result(run_client(token, lambda c: c.list_users()), fmt, fields=None if verbose else _DEFAULT_FIELDS)