clockify-unofficial-cli 0.2.0__py3-none-any.whl

clockify_unofficial_cli/commands/custom_field.py

@@ -0,0 +1,130 @@
+import dataclasses
+from dataclasses import dataclass
+from typing import Annotated
+from typing import Final
+
+import typer
+from clockify import CustomFieldCreate
+from clockify import CustomFieldUpdate
+
+from clockify_unofficial_cli.output.columns import CUSTOM_FIELDS
+from clockify_unofficial_cli.output.renderer import many
+from clockify_unofficial_cli.output.renderer import single
+from clockify_unofficial_cli.runtime.context import get_app_context
+from clockify_unofficial_cli.runtime.errors import handle_errors
+from clockify_unofficial_cli.runtime.params import options_from
+from clockify_unofficial_cli.runtime.prompts import confirm
+from clockify_unofficial_cli.services.listing import list_from_options
+from clockify_unofficial_cli.services.resolve import resolve_custom_field
+
+APP: Final = typer.Typer(help="Manage workspace custom fields.", no_args_is_help=True)
+
+
+@APP.command(name="list", help="List every custom field in the active workspace.")
+@handle_errors
+def list_custom_fields(
+    ctx: typer.Context,
+    *,
+    limit: Annotated[
+        int | None,
+        typer.Option("--limit", help="Stop after N fields; incompatible with --page/--page-size."),
+    ] = None,
+    page: Annotated[
+        int | None,
+        typer.Option("--page", help="1-based page number when paging through results."),
+    ] = None,
+    page_size: Annotated[
+        int | None,
+        typer.Option("--page-size", help="Page size when paging through results."),
+    ] = None,
+) -> None:
+    app_context = get_app_context(ctx)
+    workspace = app_context.workspace()
+    fields = list_from_options(workspace.custom_fields.list, workspace.custom_fields.list_page, limit, page, page_size)
+    app_context.render(many(fields, CUSTOM_FIELDS))
+
+
+@dataclass(frozen=True, slots=True)
+class _CreateArgs:
+    name: Annotated[str, typer.Option("--name", help="Field display name.")]
+    field_type: Annotated[str, typer.Option("--type", help="Clockify field type, e.g. TXT or NUMBER.")]
+    entity_type: Annotated[
+        str | None,
+        typer.Option("--entity", help="Entity the field belongs to, e.g. TIMEENTRY."),
+    ] = None
+    allowed_values: Annotated[
+        list[str] | None,
+        typer.Option("--allowed-value", help="Allowed value for dropdown fields; pass multiple times."),
+    ] = None
+    workspace_default_value: Annotated[
+        str | None,
+        typer.Option("--default-value", help="Default value applied to new entities."),
+    ] = None
+    placeholder: Annotated[str | None, typer.Option("--placeholder", help="Placeholder shown in the input.")] = None
+    description: Annotated[str | None, typer.Option("--description", help="Free-form description.")] = None
+    status: Annotated[str | None, typer.Option("--status", help="VISIBLE, INVISIBLE or INACTIVE.")] = None
+    only_admin_can_edit: Annotated[
+        bool | None,
+        typer.Option("--admin-only/--open", help="Only admins may edit the field."),
+    ] = None
+
+
+@APP.command(help="Create a new custom field.")
+@handle_errors
+@options_from(_CreateArgs)
+def create(ctx: typer.Context, args: _CreateArgs) -> None:
+    app_context = get_app_context(ctx)
+    fields = {("type" if k == "field_type" else k): v for k, v in dataclasses.asdict(args).items() if v is not None}
+    field = app_context.workspace().custom_fields.create(CustomFieldCreate(**fields))
+    app_context.render(single(field, CUSTOM_FIELDS))
+
+
+@dataclass(frozen=True, slots=True)
+class _UpdateArgs:
+    term: Annotated[str, typer.Argument(help="Custom field ID or exact name.")]
+    name: Annotated[str | None, typer.Option("--name", help="New field display name.")] = None
+    allowed_values: Annotated[
+        list[str] | None,
+        typer.Option("--allowed-value", help="New dropdown values; pass multiple times."),
+    ] = None
+    workspace_default_value: Annotated[str | None, typer.Option("--default-value", help="New default value.")] = None
+    placeholder: Annotated[str | None, typer.Option("--placeholder", help="New placeholder.")] = None
+    description: Annotated[str | None, typer.Option("--description", help="New description.")] = None
+    status: Annotated[str | None, typer.Option("--status", help="VISIBLE, INVISIBLE or INACTIVE.")] = None
+    required: Annotated[
+        bool | None,
+        typer.Option("--required/--optional", help="Toggle whether the field is required."),
+    ] = None
+    only_admin_can_edit: Annotated[
+        bool | None,
+        typer.Option("--admin-only/--open", help="Restrict edits to admins."),
+    ] = None
+
+
+@APP.command(help="Update an existing custom field.")
+@handle_errors
+@options_from(_UpdateArgs)
+def update(ctx: typer.Context, args: _UpdateArgs) -> None:
+    app_context = get_app_context(ctx)
+    field_id = resolve_custom_field(app_context, args.term)
+    changes = {k: v for k, v in dataclasses.asdict(args).items() if v is not None and k != "term"}
+    field = app_context.workspace().custom_fields.update(field_id, CustomFieldUpdate(**changes))
+    app_context.render(single(field, CUSTOM_FIELDS))
+
+
+@APP.command(help="Delete a custom field.")
+@handle_errors
+def delete(
+    ctx: typer.Context,
+    term: Annotated[str, typer.Argument(help="Custom field ID or exact name.")],
+    *,
+    yes: Annotated[
+        bool,
+        typer.Option("--yes", "-y", help="Skip the interactive confirmation prompt."),
+    ] = False,
+) -> None:
+    app_context = get_app_context(ctx)
+    confirm(f"Delete custom field '{term}'", assume_yes=yes)
+    field_id = resolve_custom_field(app_context, term)
+    app_context.workspace().custom_fields.delete(field_id)
+    app_context.notify(f"Deleted custom field '{field_id}'.")

clockify_unofficial_cli/commands/entry.py

@@ -0,0 +1,275 @@
+import dataclasses
+import datetime
+from dataclasses import dataclass
+from typing import Annotated
+from typing import Final
+
+import typer
+from clockify import ProjectId
+from clockify import TagId
+from clockify import TaskId
+from clockify import TimeEntryCreate
+from clockify import TimeEntryFilter
+from clockify import TimeEntryUpdate
+
+from clockify_unofficial_cli.output.columns import TIME_ENTRIES
+from clockify_unofficial_cli.output.renderer import many
+from clockify_unofficial_cli.output.renderer import single
+from clockify_unofficial_cli.runtime.context import AppContext
+from clockify_unofficial_cli.runtime.context import get_app_context
+from clockify_unofficial_cli.runtime.errors import CliError
+from clockify_unofficial_cli.runtime.errors import handle_errors
+from clockify_unofficial_cli.runtime.exit_codes import ExitCode
+from clockify_unofficial_cli.runtime.params import options_from
+from clockify_unofficial_cli.runtime.prompts import confirm
+from clockify_unofficial_cli.services.listing import list_from_options
+from clockify_unofficial_cli.services.resolve import resolve_project
+from clockify_unofficial_cli.services.resolve import resolve_tag
+from clockify_unofficial_cli.services.resolve import resolve_task
+
+APP: Final = typer.Typer(help="Manage time entries.", no_args_is_help=True)
+
+
+def _optional_project_id(app_context: AppContext, term: str | None) -> ProjectId | None:
+    return ProjectId(resolve_project(app_context, term)) if term else None
+
+
+def _optional_task_id(app_context: AppContext, term: str | None, project_id: ProjectId | None) -> TaskId | None:
+    if not term or project_id is None:
+        return None
+    return TaskId(resolve_task(app_context, project_id, term))
+
+
+def _optional_tag_ids(app_context: AppContext, terms: tuple[str, ...] | None) -> list[TagId] | None:
+    if not terms:
+        return None
+    return [TagId(resolve_tag(app_context, term)) for term in terms]
+
+
+@dataclass(frozen=True, slots=True)
+class _ListArgs:
+    description: str | None
+    start: datetime.datetime | None
+    end: datetime.datetime | None
+    project_id: ProjectId | None
+    task_id: TaskId | None
+    tag_ids: list[TagId] | None
+    limit: int | None
+    page: int | None
+    page_size: int | None
+
+
+@dataclass(frozen=True, slots=True)
+class _ListOptions:
+    description: Annotated[
+        str | None,
+        typer.Option("--description", help="Substring filter on the entry description."),
+    ] = None
+    from_: Annotated[
+        datetime.datetime | None,
+        typer.Option("--from", help="Lower bound on start, e.g. 2026-09-17T09:00 or 'yesterday 09:00'."),
+    ] = None
+    to: Annotated[datetime.datetime | None, typer.Option("--to", help="Upper bound on start.")] = None
+    project: Annotated[
+        str | None,
+        typer.Option("--project", "-P", help="Filter by project ID or exact name."),
+    ] = None
+    task: Annotated[
+        str | None,
+        typer.Option("--task", "-t", help="Filter by task ID or exact name; requires --project."),
+    ] = None
+    tag: Annotated[
+        list[str] | None,
+        typer.Option("--tag", help="Filter by tag ID or exact name; pass multiple times."),
+    ] = None
+    limit: Annotated[
+        int | None,
+        typer.Option("--limit", help="Stop after N entries; incompatible with --page/--page-size."),
+    ] = None
+    page: Annotated[
+        int | None,
+        typer.Option("--page", help="1-based page number when paging through results."),
+    ] = None
+    page_size: Annotated[
+        int | None,
+        typer.Option("--page-size", help="Page size when paging through results."),
+    ] = None
+
+
+@APP.command(name="list", help="List time entries for the current user.")
+@handle_errors
+@options_from(_ListOptions)
+def list_entries(ctx: typer.Context, options: _ListOptions) -> None:
+    app_context = get_app_context(ctx)
+    if options.task and not options.project:
+        message = "--task requires --project because tasks are scoped to projects."
+        raise CliError(message, exit_code=ExitCode.USAGE)
+    workspace = app_context.workspace()
+    project_id = _optional_project_id(app_context, options.project)
+    args = _ListArgs(
+        description=options.description,
+        start=options.from_,
+        end=options.to,
+        project_id=project_id,
+        task_id=_optional_task_id(app_context, options.task, project_id),
+        tag_ids=_optional_tag_ids(app_context, tuple(options.tag) if options.tag else None),
+        limit=options.limit,
+        page=options.page,
+        page_size=options.page_size,
+    )
+    entry_filter = TimeEntryFilter(
+        description=args.description,
+        start=args.start,
+        end=args.end,
+        project=args.project_id,
+        task=args.task_id,
+        tag_ids=args.tag_ids,
+    )
+    user_id = app_context.user_id()
+    entries = list_from_options(
+        lambda: workspace.time_entries.list(user_id, entry_filter=entry_filter),
+        lambda **kwargs: workspace.time_entries.list_page(user_id, entry_filter=entry_filter, **kwargs),
+        args.limit,
+        args.page,
+        args.page_size,
+    )
+    app_context.render(many(entries, TIME_ENTRIES))
+
+
+@APP.command(help="Show a time entry by ID.")
+@handle_errors
+def get(
+    ctx: typer.Context,
+    entry_id: Annotated[str, typer.Argument(help="Time entry ID.")],
+) -> None:
+    app_context = get_app_context(ctx)
+    entry = app_context.workspace().time_entries.get(entry_id)
+    app_context.render(single(entry, TIME_ENTRIES))
+
+
+@dataclass(frozen=True, slots=True)
+class _CreateArgs:
+    description: str | None
+    project_id: ProjectId | None
+    task_id: TaskId | None
+    tag_ids: list[TagId] | None
+    billable: bool
+    start: datetime.datetime | None
+    end: datetime.datetime | None
+
+
+@dataclass(frozen=True, slots=True)
+class _CreateOptions:
+    description: Annotated[str | None, typer.Option("--description", help="Entry description.")] = None
+    project: Annotated[str | None, typer.Option("--project", "-P", help="Project ID or exact name.")] = None
+    task: Annotated[
+        str | None,
+        typer.Option("--task", "-t", help="Task ID or exact name; requires --project."),
+    ] = None
+    tag: Annotated[
+        list[str] | None,
+        typer.Option("--tag", help="Tag ID or exact name; pass multiple times."),
+    ] = None
+    billable: Annotated[
+        bool,
+        typer.Option("--billable/--no-billable", help="Mark the entry as billable."),
+    ] = False
+    from_: Annotated[
+        datetime.datetime | None,
+        typer.Option("--from", help="Start instant; e.g. 2026-09-17T09:00 or 'yesterday 09:00'."),
+    ] = None
+    to: Annotated[datetime.datetime | None, typer.Option("--to", help="End instant.")] = None
+
+
+@APP.command(help="Create a finished time entry (use `start` for a running entry).")
+@handle_errors
+@options_from(_CreateOptions)
+def create(ctx: typer.Context, options: _CreateOptions) -> None:
+    app_context = get_app_context(ctx)
+    if options.from_ is None or options.to is None:
+        message = "`entry create` requires both --from and --to; use `log` for open ranges."
+        raise CliError(message, exit_code=ExitCode.USAGE)
+    project_id = _optional_project_id(app_context, options.project)
+    args = _CreateArgs(
+        description=options.description,
+        project_id=project_id,
+        task_id=_optional_task_id(app_context, options.task, project_id),
+        tag_ids=_optional_tag_ids(app_context, tuple(options.tag) if options.tag else None),
+        billable=options.billable,
+        start=options.from_,
+        end=options.to,
+    )
+    payload = TimeEntryCreate(**{k: v for k, v in dataclasses.asdict(args).items() if v is not None})
+    entry = app_context.workspace().time_entries.create(payload)
+    app_context.render(single(entry, TIME_ENTRIES))
+
+
+@dataclass(frozen=True, slots=True)
+class _UpdateArgs:
+    description: str | None
+    project_id: ProjectId | None
+    task_id: TaskId | None
+    tag_ids: list[TagId] | None
+    billable: bool | None
+    start: datetime.datetime
+    end: datetime.datetime | None
+
+
+@dataclass(frozen=True, slots=True)
+class _UpdateOptions:
+    entry_id: Annotated[str, typer.Argument(help="Time entry ID.")]
+    description: Annotated[str | None, typer.Option("--description", help="New description.")] = None
+    project: Annotated[str | None, typer.Option("--project", "-P", help="New project ID or exact name.")] = None
+    task: Annotated[
+        str | None,
+        typer.Option("--task", "-t", help="New task ID or exact name; requires --project."),
+    ] = None
+    tag: Annotated[
+        list[str] | None,
+        typer.Option("--tag", help="New tag IDs/names; pass multiple times."),
+    ] = None
+    billable: Annotated[bool | None, typer.Option("--billable/--no-billable", help="Toggle billable.")] = None
+    from_: Annotated[
+        datetime.datetime | None,
+        typer.Option("--from", help="New start instant; required because Clockify PUT replaces the entry."),
+    ] = None
+    to: Annotated[datetime.datetime | None, typer.Option("--to", help="New end instant.")] = None
+
+
+@APP.command(help="Update an existing time entry (start is required by the SDK).")
+@handle_errors
+@options_from(_UpdateOptions)
+def update(ctx: typer.Context, options: _UpdateOptions) -> None:
+    app_context = get_app_context(ctx)
+    workspace = app_context.workspace()
+    existing = workspace.time_entries.get(options.entry_id)
+    project_id = _optional_project_id(app_context, options.project)
+    args = _UpdateArgs(
+        description=options.description,
+        project_id=project_id,
+        task_id=_optional_task_id(app_context, options.task, project_id),
+        tag_ids=_optional_tag_ids(app_context, tuple(options.tag) if options.tag else None),
+        billable=options.billable,
+        start=options.from_ or existing.time_interval.start,
+        end=options.to,
+    )
+    payload = TimeEntryUpdate(**{k: v for k, v in dataclasses.asdict(args).items() if v is not None})
+    entry = workspace.time_entries.update(options.entry_id, payload)
+    app_context.render(single(entry, TIME_ENTRIES))
+
+
+@APP.command(help="Delete a time entry.")
+@handle_errors
+def delete(
+    ctx: typer.Context,
+    entry_id: Annotated[str, typer.Argument(help="Time entry ID.")],
+    *,
+    yes: Annotated[
+        bool,
+        typer.Option("--yes", "-y", help="Skip the interactive confirmation prompt."),
+    ] = False,
+) -> None:
+    app_context = get_app_context(ctx)
+    confirm(f"Delete time entry '{entry_id}'", assume_yes=yes)
+    app_context.workspace().time_entries.delete(entry_id)
+    app_context.notify(f"Deleted time entry '{entry_id}'.")

clockify_unofficial_cli/commands/group.py

@@ -0,0 +1,89 @@
+import dataclasses
+from dataclasses import dataclass
+from typing import Annotated
+from typing import Final
+
+import typer
+from clockify import UserGroupCreate
+from clockify import UserGroupUpdate
+
+from clockify_unofficial_cli.output.columns import GROUPS
+from clockify_unofficial_cli.output.renderer import many
+from clockify_unofficial_cli.output.renderer import single
+from clockify_unofficial_cli.runtime.context import get_app_context
+from clockify_unofficial_cli.runtime.errors import handle_errors
+from clockify_unofficial_cli.runtime.prompts import confirm
+from clockify_unofficial_cli.services.listing import list_from_options
+from clockify_unofficial_cli.services.resolve import resolve_group
+
+APP: Final = typer.Typer(help="Manage workspace user groups.", no_args_is_help=True)
+
+
+@APP.command(name="list", help="List every user group in the active workspace.")
+@handle_errors
+def list_groups(
+    ctx: typer.Context,
+    *,
+    limit: Annotated[
+        int | None,
+        typer.Option("--limit", help="Stop after N groups; incompatible with --page/--page-size."),
+    ] = None,
+    page: Annotated[
+        int | None,
+        typer.Option("--page", help="1-based page number when paging through results."),
+    ] = None,
+    page_size: Annotated[
+        int | None,
+        typer.Option("--page-size", help="Page size when paging through results."),
+    ] = None,
+) -> None:
+    app_context = get_app_context(ctx)
+    workspace = app_context.workspace()
+    groups = list_from_options(workspace.user_groups.list, workspace.user_groups.list_page, limit, page, page_size)
+    app_context.render(many(groups, GROUPS))
+
+
+@APP.command(help="Create a new user group.")
+@handle_errors
+def create(ctx: typer.Context, *, name: Annotated[str, typer.Option("--name", help="Group name.")]) -> None:
+    app_context = get_app_context(ctx)
+    group = app_context.workspace().user_groups.create(UserGroupCreate(name=name))
+    app_context.render(single(group, GROUPS))
+
+
+@dataclass(frozen=True, slots=True)
+class _UpdateArgs:
+    name: str
+
+
+@APP.command(help="Update an existing user group.")
+@handle_errors
+def update(
+    ctx: typer.Context,
+    term: Annotated[str, typer.Argument(help="Group ID or exact name.")],
+    *,
+    name: Annotated[str, typer.Option("--name", help="New group name.")],
+) -> None:
+    args = _UpdateArgs(name=name)
+    app_context = get_app_context(ctx)
+    group_id = resolve_group(app_context, term)
+    group = app_context.workspace().user_groups.update(group_id, UserGroupUpdate(**dataclasses.asdict(args)))
+    app_context.render(single(group, GROUPS))
+
+
+@APP.command(help="Delete a user group.")
+@handle_errors
+def delete(
+    ctx: typer.Context,
+    term: Annotated[str, typer.Argument(help="Group ID or exact name.")],
+    *,
+    yes: Annotated[
+        bool,
+        typer.Option("--yes", "-y", help="Skip the interactive confirmation prompt."),
+    ] = False,
+) -> None:
+    app_context = get_app_context(ctx)
+    confirm(f"Delete user group '{term}'", assume_yes=yes)
+    group_id = resolve_group(app_context, term)
+    app_context.workspace().user_groups.delete(group_id)
+    app_context.notify(f"Deleted user group '{group_id}'.")

clockify_unofficial_cli/commands/project.py

@@ -0,0 +1,174 @@
+import dataclasses
+from dataclasses import dataclass
+from typing import Annotated
+from typing import Final
+
+import typer
+from clockify import ClientId
+from clockify import ProjectCreate
+from clockify import ProjectUpdate
+
+from clockify_unofficial_cli.output.columns import PROJECTS_LIST
+from clockify_unofficial_cli.output.renderer import many
+from clockify_unofficial_cli.output.renderer import single
+from clockify_unofficial_cli.runtime.context import get_app_context
+from clockify_unofficial_cli.runtime.errors import handle_errors
+from clockify_unofficial_cli.runtime.params import options_from
+from clockify_unofficial_cli.runtime.prompts import confirm
+from clockify_unofficial_cli.services.listing import list_from_options
+from clockify_unofficial_cli.services.resolve import resolve_client
+from clockify_unofficial_cli.services.resolve import resolve_project
+
+APP: Final = typer.Typer(help="Manage workspace projects.", no_args_is_help=True)
+
+
+@APP.command(name="list", help="List every project in the active workspace.")
+@handle_errors
+def list_projects(
+    ctx: typer.Context,
+    *,
+    limit: Annotated[
+        int | None,
+        typer.Option("--limit", help="Stop after N projects; incompatible with --page/--page-size."),
+    ] = None,
+    page: Annotated[
+        int | None,
+        typer.Option("--page", help="1-based page number when paging through results."),
+    ] = None,
+    page_size: Annotated[
+        int | None,
+        typer.Option("--page-size", help="Page size when paging through results."),
+    ] = None,
+) -> None:
+    app_context = get_app_context(ctx)
+    workspace = app_context.workspace()
+    projects = list_from_options(workspace.projects.list, workspace.projects.list_page, limit, page, page_size)
+    app_context.render(many(projects, PROJECTS_LIST))
+
+
+@APP.command(help="Show a project by ID or exact name.")
+@handle_errors
+def get(ctx: typer.Context, term: Annotated[str, typer.Argument(help="Project ID or exact name.")]) -> None:
+    app_context = get_app_context(ctx)
+    project_id = resolve_project(app_context, term)
+    project = app_context.workspace().projects.get(project_id)
+    app_context.render(single(project, PROJECTS_LIST))
+
+
+@dataclass(frozen=True, slots=True)
+class _CreateArgs:
+    name: str
+    client_id: ClientId | None
+    is_public: bool | None
+    billable: bool | None
+    color: str | None
+    note: str | None
+
+
+@dataclass(frozen=True, slots=True)
+class _CreateOptions:
+    name: Annotated[str, typer.Option("--name", help="Project display name.")]
+    client: Annotated[
+        str | None,
+        typer.Option("--client", help="Client ID or exact name; pass --no-client to leave it blank."),
+    ] = None
+    public: Annotated[
+        bool | None,
+        typer.Option(
+            "--public/--private",
+            help="Whether the project is visible to every workspace member; omit to leave the default.",
+        ),
+    ] = None
+    billable: Annotated[
+        bool | None,
+        typer.Option("--billable/--no-billable", help="Default billable flag for time entries."),
+    ] = None
+    color: Annotated[str | None, typer.Option("--color", help="Hex colour, e.g. #0f62fe.")] = None
+    note: Annotated[str | None, typer.Option("--note", help="Free-form note.")] = None
+
+
+@APP.command(help="Create a new project.")
+@handle_errors
+@options_from(_CreateOptions)
+def create(ctx: typer.Context, options: _CreateOptions) -> None:
+    app_context = get_app_context(ctx)
+    client_id: ClientId | None = ClientId(resolve_client(app_context, options.client)) if options.client else None
+    args = _CreateArgs(
+        name=options.name,
+        client_id=client_id,
+        is_public=options.public,
+        billable=options.billable,
+        color=options.color,
+        note=options.note,
+    )
+    payload = ProjectCreate(**{k: v for k, v in dataclasses.asdict(args).items() if v is not None})
+    project = app_context.workspace().projects.create(payload)
+    app_context.render(single(project, PROJECTS_LIST))
+
+
+@dataclass(frozen=True, slots=True)
+class _UpdateArgs:
+    name: str | None
+    client_id: ClientId | None
+    is_public: bool | None
+    billable: bool | None
+    color: str | None
+    note: str | None
+    archived: bool | None
+
+
+@dataclass(frozen=True, slots=True)
+class _UpdateOptions:
+    term: Annotated[str, typer.Argument(help="Project ID or exact name.")]
+    name: Annotated[str | None, typer.Option("--name", help="New project display name.")] = None
+    client: Annotated[str | None, typer.Option("--client", help="New client ID or exact name.")] = None
+    public: Annotated[bool | None, typer.Option("--public/--private", help="Toggle the project's visibility.")] = None
+    billable: Annotated[
+        bool | None,
+        typer.Option("--billable/--no-billable", help="Default billable flag for new entries."),
+    ] = None
+    color: Annotated[str | None, typer.Option("--color", help="Hex colour, e.g. #0f62fe.")] = None
+    note: Annotated[str | None, typer.Option("--note", help="New free-form note.")] = None
+    archived: Annotated[
+        bool | None,
+        typer.Option("--archived/--no-archived", help="Archive or restore the project."),
+    ] = None
+
+
+@APP.command(help="Update an existing project.")
+@handle_errors
+@options_from(_UpdateOptions)
+def update(ctx: typer.Context, options: _UpdateOptions) -> None:
+    app_context = get_app_context(ctx)
+    project_id = resolve_project(app_context, options.term)
+    client_id: ClientId | None = ClientId(resolve_client(app_context, options.client)) if options.client else None
+    args = _UpdateArgs(
+        name=options.name,
+        client_id=client_id,
+        is_public=options.public,
+        billable=options.billable,
+        color=options.color,
+        note=options.note,
+        archived=options.archived,
+    )
+    payload = ProjectUpdate(**{k: v for k, v in dataclasses.asdict(args).items() if v is not None})
+    project = app_context.workspace().projects.update(project_id, payload)
+    app_context.render(single(project, PROJECTS_LIST))
+
+
+@APP.command(help="Delete a project.")
+@handle_errors
+def delete(
+    ctx: typer.Context,
+    term: Annotated[str, typer.Argument(help="Project ID or exact name.")],
+    *,
+    yes: Annotated[
+        bool,
+        typer.Option("--yes", "-y", help="Skip the interactive confirmation prompt."),
+    ] = False,
+) -> None:
+    app_context = get_app_context(ctx)
+    confirm(f"Delete project '{term}'", assume_yes=yes)
+    project_id = resolve_project(app_context, term)
+    app_context.workspace().projects.delete(project_id)
+    app_context.notify(f"Deleted project '{project_id}'.")