dart-tools 0.6.16__py3-none-any.whl → 0.7.1__py3-none-any.whl

dart/dart.py

@@ -1,12 +1,11 @@
-#!/usr/bin/env python3
+#!/usr/bin/env uv run python3
 # -*- coding: utf-8 -*-
 
 """A CLI to interact with the Dart web app."""
 
 # Required for type hinting compatibility when using Python 3.9
 from __future__ import annotations
-from argparse import ArgumentParser
-from functools import wraps
+
 import json
 import os
 import random
@@ -15,46 +14,45 @@ import signal
 import string
 import subprocess
 import sys
+from argparse import ArgumentParser
 from collections import defaultdict
 from datetime import timezone
+from functools import wraps
 from importlib.metadata import version
-from typing import Any, Callable, NoReturn
+from typing import Callable, NoReturn, TypeVar, Union
 from webbrowser import open_new_tab
 
 import dateparser
-from pick import pick
-import requests
+import httpx
 import platformdirs
+from pick import pick
 
 from .exception import DartException
-from .generated import Client
+from .generated import Client, api
 from .generated.models import (
-    Dartboard,
-    DartboardKind,
-    DartboardUpdate,
-    Folder,
-    FolderKind,
-    FolderUpdate,
-    Operation,
-    OperationKind,
-    OperationModelKind,
+    Comment,
+    CommentCreate,
+    ConciseTask,
+    Doc,
+    DocCreate,
+    DocUpdate,
+    PaginatedConciseDocList,
+    PaginatedConciseTaskList,
     Priority,
-    PropertyKind,
-    RequestBody,
-    SpaceKind,
-    StatusKind,
-    SprintMode,
     Task,
     TaskCreate,
-    TaskSourceType,
     TaskUpdate,
-    Transaction,
-    TransactionKind,
+    UserSpaceConfiguration,
+    WrappedComment,
+    WrappedCommentCreate,
+    WrappedDoc,
+    WrappedDocCreate,
+    WrappedDocUpdate,
+    WrappedTask,
+    WrappedTaskCreate,
+    WrappedTaskUpdate,
 )
-from .generated.api.dartboards import dartboards_list
-from .generated.api.folders import folders_list
-from .generated.api.transactions import transactions_create
-from .order_manager import get_orders_between
+from .generated.types import UNSET, Response, Unset
 
 _APP = "dart-tools"
 _PROG = "dart"
@@ -64,52 +62,74 @@ _STAG_HOST = "https://stag.itsdart.com"
 _DEV_HOST = "http://localhost:5173"
 _HOST_MAP = {"prod": _PROD_HOST, "stag": _STAG_HOST, "dev": _DEV_HOST}
 
-_VERSION_CMD = "--version"
-_SET_HOST_CMD = "sethost"
+# Service commands
 _LOGIN_CMD = "login"
-_CREATE_TASK_CMD = "createtask"
-_UPDATE_TASK_CMD = "updatetask"
-_BEGIN_TASK_CMD = "begintask"
+_SET_HOST_CMD = "host-set"
+_VERSION_CMD = "--version"
+# Task commands
+_CREATE_TASK_CMD = "task-create"
+_UPDATE_TASK_CMD = "task-update"
+_DELETE_TASK_CMD = "task-delete"
+_BEGIN_TASK_CMD = "task-begin"
+# Doc commands
+_CREATE_DOC_CMD = "doc-create"
+_UPDATE_DOC_CMD = "doc-update"
+_DELETE_DOC_CMD = "doc-delete"
+# Comment commands
+_CREATE_COMMENT_CMD = "comment-create"
 
 _PROFILE_SETTINGS_URL_FRAG = "/?settings=account"
-_ROOT_API_URL_FRAG = "/api/v0"
-_USER_STATUS_URL_FRAG = _ROOT_API_URL_FRAG + "/user-status"
-_USER_DATA_URL_FRAG = _ROOT_API_URL_FRAG + "/user-data?mode=auto"
-_COPY_BRANCH_URL_FRAG = _ROOT_API_URL_FRAG + "/vcs/copy-branch-link"
-_REPLICATE_SPACE_URL_FRAG_FMT = _ROOT_API_URL_FRAG + "/spaces/replicate/{duid}"
-_REPLICATE_DARTBOARD_URL_FRAG_FMT = _ROOT_API_URL_FRAG + "/dartboards/replicate/{duid}"
+_ROOT_PRIVATE_API_URL_FRAG = "/api/v0"
+_ROOT_PUBLIC_API_URL_FRAG = f"{_ROOT_PRIVATE_API_URL_FRAG}/public"
+_COPY_BRANCH_URL_FRAG = "/vcs/copy-branch-link"
 
 _AUTH_TOKEN_ENVVAR_KEY = "DART_TOKEN"
 _CONFIG_FPATH = platformdirs.user_config_path(_APP)
-_CLIENT_DUID_KEY = "clientDuid"
+_CLIENT_ID_KEY = "clientId"
 _HOST_KEY = "host"
 _HOSTS_KEY = "hosts"
 _AUTH_TOKEN_KEY = "authToken"
 
-_DUID_CHARS = string.ascii_lowercase + string.ascii_uppercase + string.digits
+_ID_CHARS = string.ascii_lowercase + string.ascii_uppercase + string.digits
 _NON_ALPHANUM_RE = re.compile(r"[^a-zA-Z0-9-]+")
 _REPEATED_DASH_RE = re.compile(r"-{2,}")
-_PRIORITY_MAP = {
+_PRIORITY_MAP: dict[int, str] = {
     0: Priority.CRITICAL,
     1: Priority.HIGH,
     2: Priority.MEDIUM,
     3: Priority.LOW,
 }
 _SIZES = {1, 2, 3, 5, 8}
-_COMPLETED_STATUS_KINDS = {"Finished", "Canceled"}
 
 _VERSION = version(_APP)
 _AUTH_TOKEN_ENVVAR = os.environ.get(_AUTH_TOKEN_ENVVAR_KEY)
 
+
+def _get_help_text(fn: Callable) -> str:
+    if fn.__doc__ is None:
+        raise ValueError(f"Function {fn.__name__} has no docstring.")
+    return fn.__doc__.split("\n")[0].lower()
+
+
+_HELP_TEXT_TO_COMMAND = {
+    _CREATE_TASK_CMD: _get_help_text(api.create_task.sync_detailed),
+    _UPDATE_TASK_CMD: _get_help_text(api.update_task.sync_detailed),
+    _DELETE_TASK_CMD: _get_help_text(api.delete_task.sync_detailed),
+    _CREATE_DOC_CMD: _get_help_text(api.create_doc.sync_detailed),
+    _UPDATE_DOC_CMD: _get_help_text(api.update_doc.sync_detailed),
+    _DELETE_DOC_CMD: _get_help_text(api.delete_doc.sync_detailed),
+    _CREATE_COMMENT_CMD: _get_help_text(api.create_comment.sync_detailed),
+}
+
 _is_cli = False
 
 
 # TODO dedupe these functions with other usages elsewhere
-def _make_duid() -> str:
-    return "".join(random.choices(_DUID_CHARS, k=12))
+def _make_id() -> str:
+    return "".join(random.choices(_ID_CHARS, k=12))
 
 
-def trim_slug_str(s: str, length: int, max_under: int | None = None) -> str:
+def trim_slug_str(s: str, length: int, max_under: Union[int, None] = None) -> str:
     max_under = max_under if max_under is not None else length // 6
     if len(s) <= length:
         return s
@@ -119,37 +139,17 @@ def trim_slug_str(s: str, length: int, max_under: int | None = None) -> str:
     return s[:length]
 
 
-def slugify_str(s: str, lower: bool = False, trim_kwargs: dict | None = None) -> str:
+def slugify_str(s: str, lower: bool = False, trim_kwargs: Union[dict, None] = None) -> str:
     lowered = s.lower() if lower else s
     formatted = _NON_ALPHANUM_RE.sub("-", lowered.replace("'", ""))
     formatted = _REPEATED_DASH_RE.sub("-", formatted).strip("-")
-    return (
-        trim_slug_str(formatted, **trim_kwargs)
-        if trim_kwargs is not None
-        else formatted
-    )
+    return trim_slug_str(formatted, **trim_kwargs) if trim_kwargs is not None else formatted
 
 
 def _run_cmd(cmd: str) -> str:
     return subprocess.check_output(cmd, shell=True).decode()
 
 
-def _get_space_url(host: str, duid: str) -> str:
-    return f"{host}/s/{duid}"
-
-
-def _get_dartboard_url(host: str, duid: str) -> str:
-    return f"{host}/d/{duid}"
-
-
-def _get_task_url(host: str, duid: str) -> str:
-    return f"{host}/t/{duid}"
-
-
-def _get_folder_url(host: str, duid: str) -> str:
-    return f"{host}/f/{duid}"
-
-
 def _suppress_exception(fn: Callable) -> Callable:
     @wraps(fn)
     def wrapper(*args, **kwargs):
@@ -177,6 +177,37 @@ def _log(s: str) -> None:
     print(s)
 
 
+T = TypeVar("T")
+
+
+def _get_response_parsed(response: Response[T], not_found_message="Not found.") -> T:
+    if response.parsed is not None:
+        return response.parsed
+    if response.status_code in {401, 403}:
+        _auth_failure_exit()
+    elif response.status_code == 404:
+        _dart_exit(not_found_message)
+    try:
+        response_content = json.loads(response.content)
+        error_message = response_content.get("detail") or " ".join(response_content.get("errors", []))
+        _dart_exit(error_message)
+    except (json.JSONDecodeError, AttributeError):
+        _unknown_failure_exit()
+
+
+def _handle_request_errors(fn: Callable) -> Callable:
+    @wraps(fn)
+    def wrapper(*args, **kwargs):
+        try:
+            return fn(*args, **kwargs)
+        except DartException as ex:
+            _dart_exit(ex)
+        except (httpx.TimeoutException, httpx.RequestError, httpx.ConnectError) as ex:
+            _dart_exit(f"Failed to execute API call: {ex}.")
+
+    return wrapper
+
+
 class _Config:
     def __init__(self):
         self._content = {}
@@ -187,14 +218,14 @@ class _Config:
             except OSError:
                 pass
         self._content = {
-            _CLIENT_DUID_KEY: _make_duid(),
+            _CLIENT_ID_KEY: _make_id(),
             _HOST_KEY: _PROD_HOST,
             _HOSTS_KEY: {},
         } | self._content
         self._content[_HOSTS_KEY] = defaultdict(dict, self._content[_HOSTS_KEY])
         self._write()
 
-    def _write(self):
+    def _write(self) -> None:
         try:
             with open(_CONFIG_FPATH, "w+", encoding="UTF-8") as fout:
                 json.dump(self._content, fout, indent=2)
@@ -202,176 +233,140 @@ class _Config:
             pass
 
     @property
-    def client_duid(self):
-        return self._content[_CLIENT_DUID_KEY]
+    def client_id(self) -> str:
+        return self._content[_CLIENT_ID_KEY]
 
     @property
-    def host(self):
+    def host(self) -> str:
         return self._content[_HOST_KEY]
 
     @host.setter
-    def host(self, v):
+    def host(self, v: str) -> None:
         self._content[_HOST_KEY] = v
         self._write()
 
-    def get(self, k):
+    def get(self, k: str) -> str | None:
         return self._content[_HOSTS_KEY][self.host].get(k)
 
-    def set(self, k, v):
+    def set(self, k: str, v: str) -> None:
         self._content[_HOSTS_KEY][self.host][k] = v
         self._write()
 
 
-class _Session:
+class Dart:
     def __init__(self, config=None):
         self._config = config or _Config()
-        self._session = requests.Session()
+        self._init_clients()
+
+    def _init_clients(self) -> None:
+        self._private_api = Client(
+            base_url=self.get_base_url() + _ROOT_PRIVATE_API_URL_FRAG,
+            headers=self.get_headers(),
+        )
+        self._public_api = Client(
+            base_url=self.get_base_url() + _ROOT_PUBLIC_API_URL_FRAG,
+            headers=self.get_headers(),
+        )
 
-    def get_base_url(self):
+    def get_base_url(self) -> str:
         return self._config.host
 
-    def get_client_duid(self):
-        return self._config.client_duid
+    def get_client_id(self) -> str:
+        return self._config.client_id
 
-    def get_auth_token(self):
+    def get_auth_token(self) -> Union[str, None]:
         result = self._config.get(_AUTH_TOKEN_KEY)
         if result is not None:
             return result
         return _AUTH_TOKEN_ENVVAR
 
-    def get_headers(self):
+    def get_headers(self) -> dict[str, str]:
         result = {
             "Origin": self._config.host,
-            "client-duid": self.get_client_duid(),
+            "client-duid": self.get_client_id(),
         }
         if (auth_token := self.get_auth_token()) is not None:
             result["Authorization"] = f"Bearer {auth_token}"
         return result
 
-    def get(self, url_frag, *args, **kwargs):
-        kwargs["headers"] = self.get_headers() | kwargs.get("headers", {})
-        return self._session.get(self._config.host + url_frag, *args, **kwargs)
-
-    def post(self, url_frag, *args, **kwargs):
-        kwargs["headers"] = self.get_headers() | kwargs.get("headers", {})
-        result = self._session.post(self._config.host + url_frag, *args, **kwargs)
-        if result.status_code != 403:
-            return result
-        kwargs["headers"] = self.get_headers() | kwargs.get("headers", {})
-        return self._session.post(self._config.host + url_frag, *args, **kwargs)
-
-
-class Dart(Client):
-    def __init__(self, session=None):
-        self._session = session or _Session()
-        super().__init__(
-            base_url=self._session.get_base_url(),
-            headers=self._session.get_headers(),
-        )
-
-    def transact(self, operations: list[Operation], kind: TransactionKind):
-        transaction = Transaction(
-            duid=_make_duid(),
-            kind=kind,
-            operations=operations,
-        )
-        request_body = RequestBody(
-            client_duid=self._session.get_client_duid(),
-            items=[transaction],
-        )
-        return transactions_create.sync(
-            client=self,
-            body=request_body,
-        )
-
-
-class UserBundle:
-    def __init__(self, session):
-        _log("Loading active tasks")
-        response = session.get(_USER_DATA_URL_FRAG)
-        _check_request_response_and_maybe_exit(response)
-        self._raw = response.json()
-        if not self.is_logged_in:
-            _auth_failure_exit()
-
-    @property
-    def is_logged_in(self):
-        return self._raw["isLoggedIn"]
-
-    @property
-    def user(self):
-        return self._raw["user"]
-
-    @property
-    def users(self):
-        return self._raw["users"]
-
-    @property
-    def properties(self):
-        return self._raw["properties"]
-
-    @property
-    def task_kinds(self):
-        return self._raw["taskKinds"]
-
-    @property
-    def default_dartboard(self):
-        space = next(
-            (e for e in self.spaces if e["kind"] == SpaceKind.WORKSPACE),
-            self.spaces[0],
-        )
-        space_duid = space["duid"]
-        dartboard_kind = (
-            DartboardKind.ACTIVE
-            if space["sprintMode"] == SprintMode.ANBA
-            else DartboardKind.CUSTOM
-        )
-        return next(
-            e
-            for e in self.dartboards
-            if e["spaceDuid"] == space_duid and e["kind"] == dartboard_kind
-        )
-
-    @property
-    def default_statuses(self):
-        default_status_property_duid = next(
-            e["duid"]
-            for e in self.properties
-            if e["kind"] == PropertyKind.DEFAULT_STATUS
-        )
-        return [
-            e
-            for e in self._raw["statuses"]
-            if e["propertyDuid"] == default_status_property_duid
-        ]
-
-    @property
-    def default_tags(self):
-        default_tags_property_duid = next(
-            e["duid"] for e in self.properties if e["kind"] == PropertyKind.DEFAULT_TAGS
-        )
-        return [
-            e
-            for e in self._raw["options"]
-            if e["propertyDuid"] == default_tags_property_duid
-        ]
-
-    @property
-    def spaces(self):
-        return self._raw["spaces"]
-
-    @property
-    def dartboards(self):
-        return self._raw["dartboards"]
+    def is_logged_in(self) -> bool:
+        self._init_clients()
+        try:
+            config = api.get_config.sync(client=self._public_api)
+            if config is None:
+                return False
+        except:
+            return False
+        return True
 
-    @property
-    def tasks(self):
-        return self._raw["tasks"]
+    @_handle_request_errors
+    def get_config(self) -> UserSpaceConfiguration:
+        response = api.get_config.sync_detailed(client=self._public_api)
+        return _get_response_parsed(response)
+
+    @_handle_request_errors
+    def create_task(self, body: WrappedTaskCreate) -> WrappedTask:
+        response = api.create_task.sync_detailed(client=self._public_api, body=body)
+        return _get_response_parsed(response)
+
+    @_handle_request_errors
+    def retrieve_task(self, id: str) -> WrappedTask:
+        response = api.retrieve_task.sync_detailed(id, client=self._public_api)
+        return _get_response_parsed(response, not_found_message=f"Task with ID {id} not found.")
+
+    @_handle_request_errors
+    def update_task(self, id: str, body: WrappedTaskUpdate) -> WrappedTask:
+        response = api.update_task.sync_detailed(id, client=self._public_api, body=body)
+        return _get_response_parsed(response, not_found_message=f"Task with ID {id} not found.")
+
+    @_handle_request_errors
+    def delete_task(self, id: str) -> WrappedTask:
+        response = api.delete_task.sync_detailed(id, client=self._public_api)
+        return _get_response_parsed(response, not_found_message=f"Task with ID {id} not found.")
+
+    @_handle_request_errors
+    def list_tasks(self, **kwargs) -> PaginatedConciseTaskList:
+        response = api.list_tasks.sync_detailed(client=self._public_api, **kwargs)
+        return _get_response_parsed(response)
+
+    @_handle_request_errors
+    def create_comment(self, body: WrappedCommentCreate) -> WrappedComment:
+        response = api.create_comment.sync_detailed(client=self._public_api, body=body)
+        return _get_response_parsed(response)
+
+    @_handle_request_errors
+    def create_doc(self, body: WrappedDocCreate) -> WrappedDoc:
+        response = api.create_doc.sync_detailed(client=self._public_api, body=body)
+        return _get_response_parsed(response)
+
+    @_handle_request_errors
+    def retrieve_doc(self, id: str) -> WrappedDoc:
+        response = api.retrieve_doc.sync_detailed(id, client=self._public_api)
+        return _get_response_parsed(response, not_found_message=f"Doc with ID {id} not found.")
+
+    @_handle_request_errors
+    def update_doc(self, id: str, body: WrappedDocUpdate) -> WrappedDoc:
+        response = api.update_doc.sync_detailed(id, client=self._public_api, body=body)
+        return _get_response_parsed(response, not_found_message=f"Doc with ID {id} not found.")
+
+    @_handle_request_errors
+    def delete_doc(self, id: str) -> WrappedDoc:
+        response = api.delete_doc.sync_detailed(id, client=self._public_api)
+        return _get_response_parsed(response, not_found_message=f"Doc with ID {id} not found.")
+
+    @_handle_request_errors
+    def list_docs(self, **kwargs) -> PaginatedConciseDocList:
+        response = api.list_docs.sync_detailed(client=self._public_api, **kwargs)
+        return _get_response_parsed(response)
+
+    @_handle_request_errors
+    def copy_branch_link(self, id: str) -> None:
+        self._private_api.get_httpx_client().post(_COPY_BRANCH_URL_FRAG, json={"duid": id})
 
 
 class _Git:
     @staticmethod
-    def _cmd_succeeds(cmd):
+    def _cmd_succeeds(cmd: str) -> bool:
         try:
             _run_cmd(f"{cmd} 2>&1")
         except subprocess.CalledProcessError as ex:
@@ -381,29 +376,29 @@ class _Git:
         return True
 
     @staticmethod
-    def make_task_name(email, task):
+    def make_task_name(email: str, task: ConciseTask | Task) -> str:
         username = slugify_str(email.split("@")[0], lower=True)
         title = slugify_str(task.title, lower=True)
-        return trim_slug_str(f"{username}/{task.duid}-{title}", length=60)
+        return trim_slug_str(f"{username}/{task.id}-{title}", length=60)
 
     @staticmethod
-    def get_current_branch():
+    def get_current_branch() -> str:
         return _run_cmd("git rev-parse --abbrev-ref HEAD").strip()
 
     @staticmethod
-    def ensure_in_repo():
+    def ensure_in_repo() -> None:
         if _Git._cmd_succeeds("git rev-parse --is-inside-work-tree"):
             return
         _dart_exit("You are not in a git repo.")
 
     @staticmethod
-    def ensure_no_unstaged_changes():
+    def ensure_no_unstaged_changes() -> None:
         if _run_cmd("git status --porcelain") == "":
             return
         _dart_exit("You have uncommitted changes. Please commit or stash them.")
 
     @staticmethod
-    def ensure_on_main_or_intended():
+    def ensure_on_main_or_intended() -> None:
         branch = _Git.get_current_branch()
         if branch == "main":
             return
@@ -419,11 +414,11 @@ class _Git:
         _run_cmd("git checkout main")
 
     @staticmethod
-    def branch_exists(branch):
+    def branch_exists(branch: str) -> bool:
         return _Git._cmd_succeeds(f"git rev-parse --verify {branch}")
 
     @staticmethod
-    def checkout_branch(branch):
+    def checkout_branch(branch: str) -> None:
         if _Git.branch_exists(branch):
             _run_cmd(f"git checkout {branch}")
             return
@@ -456,39 +451,17 @@ def set_host(host: str) -> bool:
 
 
 def _auth_failure_exit() -> NoReturn:
-    _dart_exit(f"Not logged in, run\n\n  {_PROG} {_LOGIN_CMD}\n\nto log in.")
+    _dart_exit(
+        f"Not logged in, run\n\n  {_PROG} {_LOGIN_CMD}\n\nto log in."
+        if _is_cli
+        else "Not logged in, either run\n\n  dart.login(token)\n\nor save the token into the DART_TOKEN environment variable."
+    )
 
 
 def _unknown_failure_exit() -> NoReturn:
     _dart_exit("Unknown failure, email\n\n  support@itsdart.com\n\nfor help.")
 
 
-def _check_request_response_and_maybe_exit(response) -> None:
-    try:
-        response.raise_for_status()
-    except requests.exceptions.HTTPError:
-        if response.status_code in {401, 403}:
-            _auth_failure_exit()
-        _unknown_failure_exit()
-
-
-def _parse_transaction_response_and_maybe_exit(
-    response, model_kind: str, duid: str
-) -> Any:
-    if (
-        response is None
-        or not hasattr(response, "results")
-        or len(response.results) == 0
-        or not response.results[0].success
-    ):
-        _unknown_failure_exit()
-    models = getattr(response.results[0].models, f"{model_kind}s")
-    model = next((e for e in models if e.duid == duid), None)
-    if model is None:
-        _unknown_failure_exit()
-    return model
-
-
 def print_version() -> str:
     result = f"dart-tools version {_VERSION}"
     _log(result)
@@ -503,9 +476,7 @@ def print_version_update_message_maybe() -> None:
         .split("\n", maxsplit=1)[0]
         .strip()
     )
-    if latest == _VERSION or [int(e) for e in latest.split(".")] <= [
-        int(e) for e in _VERSION.split(".")
-    ]:
+    if latest == _VERSION or [int(e) for e in latest.split(".")] <= [int(e) for e in _VERSION.split(".")]:
         return
 
     _log(
@@ -513,39 +484,31 @@ def print_version_update_message_maybe() -> None:
     )
 
 
-def _get_is_logged_in(session: _Session) -> bool:
-    response = session.get(_USER_STATUS_URL_FRAG)
-    return response.json().get("isLoggedIn", False)
-
-
 def is_logged_in(should_raise: bool = False) -> bool:
-    session = _Session()
-
-    result = _get_is_logged_in(session)
+    dart = Dart()
+    result = dart.is_logged_in()
 
     if not result and should_raise:
         _auth_failure_exit()
-    _log(f"You are {'' if result else 'not '}logged in")
+    _log(f"You are{'' if result else ' not'} logged in")
     return result
 
 
 def login(token: str | None = None) -> bool:
     config = _Config()
-    session = _Session(config)
+    dart = Dart(config=config)
 
     _log("Log in to Dart")
     if token is None:
         if not _is_cli:
             _dart_exit("Login failed, token is required.")
-        _log(
-            "Dart is opening in your browser, log in if needed and copy your authentication token from the page"
-        )
+        _log("Dart is opening in your browser, log in if needed and copy your authentication token from the page")
         open_new_tab(config.host + _PROFILE_SETTINGS_URL_FRAG)
         token = input("Token: ")
 
     config.set(_AUTH_TOKEN_KEY, token)
 
-    worked = _get_is_logged_in(session)
+    worked = dart.is_logged_in()
     if not worked:
         _dart_exit("Invalid token.")
 
@@ -553,507 +516,207 @@ def login(token: str | None = None) -> bool:
     return True
 
 
-def _begin_task(
-    config: _Config, session: _Session, user_email: str, get_task: Callable
-) -> bool:
+def _begin_task(dart: Dart, email: str, task: ConciseTask | Task) -> bool:
     _Git.ensure_in_repo()
     _Git.ensure_no_unstaged_changes()
     _Git.ensure_on_main_or_intended()
 
-    task = get_task()
-
-    response = session.post(_COPY_BRANCH_URL_FRAG, json={"duid": task.duid})
-    _check_request_response_and_maybe_exit(response)
+    dart = Dart()
+    dart.copy_branch_link(task.id)
 
-    branch_name = _Git.make_task_name(user_email, task)
+    branch_name = _Git.make_task_name(email, task)
     _Git.checkout_branch(branch_name)
 
-    _log(
-        f"Started work on\n\n  {task.title}\n  {_get_task_url(config.host, task.duid)}\n"
-    )
+    _log(f"Started work on\n\n  {task.title}\n  {task.html_url}\n")
     return True
 
 
 def begin_task() -> bool:
-    config = _Config()
-    session = _Session(config)
-
-    user_bundle = UserBundle(session)
-    user = user_bundle.user
-
-    def _get_task():
-        user_duid = user["duid"]
-        active_duid = user_bundle.default_dartboard["duid"]
-        incomplete_status_duids = {
-            e["duid"]
-            for e in user_bundle.default_statuses
-            if e["kind"] not in _COMPLETED_STATUS_KINDS
-        }
-        filtered_tasks = [
-            e
-            for e in user_bundle.tasks
-            if not e["inTrash"]
-            and e["dartboardDuid"] == active_duid
-            and user_duid in e["assigneeDuids"]
-            and e["statusDuid"] in incomplete_status_duids
-            and e["drafterDuid"] is None
-        ]
-        filtered_tasks.sort(key=lambda e: e["order"])
+    dart = Dart()
+    config = dart.get_config()
+    user = config.user
+    filtered_tasks = dart.list_tasks(assignee=user.email, is_completed=False).results
 
-        if len(filtered_tasks) == 0:
-            _dart_exit("No active, incomplete tasks found.")
+    if not filtered_tasks:
+        _dart_exit("No active, incomplete tasks found.")
 
-        picked_idx = pick(
-            [e["title"] for e in filtered_tasks],
-            "Which of your active, incomplete tasks are you beginning work on?",
-            "→",
-        )[1]
-        assert isinstance(picked_idx, int)
-        return TaskCreate.from_dict(filtered_tasks[picked_idx])
+    picked_idx = pick(
+        [e.title for e in filtered_tasks],
+        "Which of your active, incomplete tasks are you beginning work on?",
+        "→",
+    )[1]
+    assert isinstance(picked_idx, int)
 
-    _begin_task(config, session, user["email"], _get_task)
+    _begin_task(dart, user.email, filtered_tasks[picked_idx])
 
     _log("Done.")
     return True
 
 
+def _normalize_priority(priority_int: Union[int, None, Unset]) -> Union[str, None, Unset]:
+    if priority_int in (None, UNSET):
+        return priority_int
+
+    if priority_int not in _PRIORITY_MAP:
+        _dart_exit(f"Invalid priority {priority_int}. Valid values are {list(_PRIORITY_MAP.keys())}.")
+
+    return _PRIORITY_MAP[priority_int]
+
+
+def _get_due_at_from_str_arg(due_at_str: Union[str, None, Unset]) -> Union[str, None, Unset]:
+    if due_at_str in (None, UNSET):
+        return due_at_str
+
+    due_at = dateparser.parse(due_at_str)
+    if not due_at:
+        _dart_exit(f"Could not parse due date: {due_at_str}.")
+    due_at = due_at.replace(hour=0, minute=0, second=0, microsecond=0, tzinfo=timezone.utc).isoformat()
+
+    return due_at
+
+
 def create_task(
     title: str,
     *,
-    dartboard_duid: str | None = None,
-    dartboard_title: str | None = None,
-    kind_title: str | None = None,
-    status_title: str | None = None,
-    assignee_emails: list[str] | None = None,
-    tag_titles: list[str] | None = None,
-    priority_int: int | None = None,
-    size_int: int | None = None,
-    due_at_str: str | None = None,
+    dartboard_title: Union[str, Unset] = UNSET,
+    status_title: Union[str, Unset] = UNSET,
+    assignee_emails: Union[list[str], Unset] = UNSET,
+    tag_titles: Union[list[str], Unset] = UNSET,
+    priority_int: Union[int, None, Unset] = UNSET,
+    size_int: Union[int, None, Unset] = UNSET,
+    due_at_str: Union[str, None, Unset] = UNSET,
     should_begin: bool = False,
 ) -> Task:
-    config = _Config()
-    session = _Session(config)
-    dart = Dart(session)
-
-    user_bundle = UserBundle(session)
-
-    user = user_bundle.user
-    user_duid = user["duid"]
-
-    dartboards = user_bundle.dartboards
-    if dartboard_duid is None:
-        if dartboard_title is not None:
-            dartboard_title_norm = dartboard_title.strip().lower()
-            dartboard = next(
-                (
-                    e
-                    for e in dartboards
-                    if dartboard_title_norm in {e["title"].lower(), e["kind"].lower()}
-                ),
-                None,
-            )
-            if dartboard is None:
-                _dart_exit(f"No dartboard found with title '{dartboard_title}'.")
-        else:
-            dartboard = user_bundle.default_dartboard
-        dartboard_duid = dartboard["duid"]
-
-    orders = [
-        e["order"] for e in user_bundle.tasks if e["dartboardDuid"] == dartboard_duid
-    ]
-    first_order = min(orders) if len(orders) > 0 else None
-    order = get_orders_between(None, first_order, 1)[0]
-
-    kinds = user_bundle.task_kinds
-    if kind_title is not None:
-        kind_title_norm = kind_title.strip().lower()
-        kind = next((e for e in kinds if e["title"].lower() == kind_title_norm), None)
-        if kind is None:
-            _dart_exit(f"No status found with title '{status_title}'.")
-    else:
-        kind = next(e for e in kinds if e["locked"])
-    kind_duid = kind["duid"]
-
-    statuses = user_bundle.default_statuses
-    if status_title is not None:
-        status_title_norm = status_title.strip().lower()
-        status = next(
-            (e for e in statuses if e["title"].lower() == status_title_norm), None
-        )
-        if status is None:
-            _dart_exit(f"No status found with title '{status_title}'.")
-    else:
-        status = next(
-            e for e in statuses if e["kind"] == StatusKind.UNSTARTED and e["locked"]
-        )
-    status_duid = status["duid"]
-
-    users = user_bundle.users
-    user_emails_to_duids = {e["email"]: e["duid"] for e in users}
-    assignee_duids = []
-    subscriber_duids = []
-    if assignee_emails is not None:
-        for assignee_email in assignee_emails:
-            assignee_email_norm = assignee_email.strip().lower()
-            if assignee_email_norm not in user_emails_to_duids:
-                _dart_exit(f"No user found with email '{assignee_email}'.")
-            assignee_duids.append(user_emails_to_duids[assignee_email_norm])
-            subscriber_duids.append(user_emails_to_duids[assignee_email_norm])
-    else:
-        assignee_duids.append(user_duid)
-    assignee_duids = list(set(assignee_duids))
-    subscriber_duids.append(user_duid)
-    subscriber_duids = list(set(subscriber_duids))
-
-    tags = user_bundle.default_tags
-    tag_titles_to_duids = {e["title"]: e["duid"] for e in tags}
-    tag_duids = []
-    if tag_titles is not None:
-        for tag_title in tag_titles:
-            tag_title_norm = tag_title.strip().lower()
-            if tag_title_norm not in tag_titles_to_duids:
-                _dart_exit(f"No tag found with title '{tag_title}'.")
-            tag_duids.append(tag_titles_to_duids[tag_title_norm])
-
-    priority = None
-    if priority_int is not None:
-        priority = _PRIORITY_MAP[priority_int]
-
-    size = size_int
-
-    due_at = None
-    if due_at_str is not None:
-        due_at = dateparser.parse(due_at_str)
-        if due_at is None:
-            _dart_exit(f"Could not parse due date '{due_at_str}'.")
-        due_at = due_at.replace(
-            hour=9, minute=0, second=0, microsecond=0, tzinfo=timezone.utc
+    dart = Dart()
+    task_create = WrappedTaskCreate(
+        item=TaskCreate(
+            title,
+            dartboard=dartboard_title,
+            status=status_title,
+            assignees=assignee_emails if assignee_emails is not None else UNSET,
+            tags=tag_titles if tag_titles is not None else UNSET,
+            priority=_normalize_priority(priority_int),
+            size=size_int,
+            due_at=_get_due_at_from_str_arg(due_at_str),
         )
-
-    task_create = TaskCreate(
-        duid=_make_duid(),
-        source_type=TaskSourceType.CLI,
-        drafter_duid=None,
-        dartboard_duid=dartboard_duid,
-        order=order,
-        kind_duid=kind_duid,
-        title=title,
-        status_duid=status_duid,
-        assignee_duids=assignee_duids,
-        subscriber_duids=subscriber_duids,
-        tag_duids=tag_duids,
-        priority=priority,
-        size=size,
-        due_at=due_at,
-    )
-    task_create_op = Operation(
-        model=OperationModelKind.TASK,
-        kind=OperationKind.CREATE,
-        data=task_create,
-    )
-    response = dart.transact([task_create_op], TransactionKind.TASK_CREATE)
-    task = _parse_transaction_response_and_maybe_exit(
-        response, OperationModelKind.TASK, task_create.duid
     )
-
-    _log(f"Created task {task.title} at {_get_task_url(config.host, task.duid)}")
+    task = dart.create_task(task_create).item
+    _log(f"Created task\n\n  {task.title}\n  {task.html_url}\n  ID: {task.id}\n")
 
     if should_begin:
-        _begin_task(config, session, user["email"], lambda: task_create)
+        user = dart.get_config().user
+        _begin_task(dart, user.email, task)
 
     _log("Done.")
     return task
 
 
 def update_task(
-    duid: str,
+    id: str,
     *,
-    title: str | None = None,
-    dartboard_duid: str | None = None,
-    dartboard_title: str | None = None,
-    status_title: str | None = None,
-    assignee_emails: list[str] | None = None,
-    tag_titles: list[str] | None = None,
-    priority_int: int | None = None,
-    size_int: int | None = None,
-    due_at_str: str | None = None,
+    title: Union[Unset, str] = UNSET,
+    dartboard_title: Union[str, Unset] = UNSET,
+    status_title: Union[str, Unset] = UNSET,
+    assignee_emails: Union[list[str], Unset] = UNSET,
+    tag_titles: Union[list[str], Unset] = UNSET,
+    priority_int: Union[int, None, Unset] = UNSET,
+    size_int: Union[int, None, Unset] = UNSET,
+    due_at_str: Union[str, None, Unset] = UNSET,
 ) -> Task:
-    config = _Config()
-    session = _Session(config)
-    dart = Dart(session)
-
-    user_bundle = UserBundle(session)
-
-    user = user_bundle.user
-    user_duid = user["duid"]
-
-    tasks = user_bundle.tasks
-    old_task = next((e for e in tasks if e["duid"] == duid), None)
-    if old_task is None:
-        _dart_exit(f"No task found with DUID '{duid}'.")
-
-    task_update_kwargs = {"duid": duid}
-
-    if title is not None:
-        task_update_kwargs["title"] = title
-
-    dartboards = user_bundle.dartboards
-    if dartboard_duid is not None:
-        task_update_kwargs["dartboard_duid"] = dartboard_duid
-    elif dartboard_title is not None:
-        dartboard_title_norm = dartboard_title.strip().lower()
-        dartboard = next(
-            (
-                e
-                for e in dartboards
-                if dartboard_title_norm in {e["title"].lower(), e["kind"].lower()}
-            ),
-            None,
-        )
-        if dartboard is None:
-            _dart_exit(f"No dartboard found with title '{dartboard_title}'.")
-        dartboard_duid = dartboard["duid"]
-        if dartboard_duid != old_task["dartboardDuid"]:
-            task_update_kwargs["dartboard_duid"] = dartboard_duid
-
-    statuses = user_bundle.default_statuses
-    if status_title is not None:
-        status_title_norm = status_title.strip().lower()
-        status = next(
-            (e for e in statuses if e["title"].lower() == status_title_norm), None
-        )
-        if status is None:
-            _dart_exit(f"No status found with title '{status_title}'.")
-        status_duid = status["duid"]
-        if status_duid != old_task["statusDuid"]:
-            task_update_kwargs["status_duid"] = status_duid
-
-    users = user_bundle.users
-    user_emails_to_duids = {e["email"]: e["duid"] for e in users}
-    subscriber_duids = []
-    if assignee_emails is not None:
-        assignee_duids = []
-        for assignee_email in assignee_emails:
-            assignee_email_norm = assignee_email.strip().lower()
-            if assignee_email_norm not in user_emails_to_duids:
-                _dart_exit(f"No user found with email '{assignee_email}'.")
-            assignee_duids.append(user_emails_to_duids[assignee_email_norm])
-            subscriber_duids.append(user_emails_to_duids[assignee_email_norm])
-        assignee_duids = sorted(set(assignee_duids))
-        if assignee_duids != old_task["assigneeDuids"]:
-            task_update_kwargs["assignee_duids"] = assignee_duids
-
-    # TODO do add to list operation rather than replace
-    subscriber_duids = list(
-        set(old_task["subscriberDuids"]) | set(subscriber_duids) | {user_duid}
-    )
-    if subscriber_duids != old_task["subscriberDuids"]:
-        task_update_kwargs["subscriber_duids"] = subscriber_duids
-
-    tags = user_bundle.default_tags
-    tag_titles_to_duids = {e["title"]: e["duid"] for e in tags}
-    if tag_titles is not None:
-        tag_duids = []
-        for tag_title in tag_titles:
-            tag_title_norm = tag_title.strip().lower()
-            if tag_title_norm not in tag_titles_to_duids:
-                _dart_exit(f"No tag found with title '{tag_title}'.")
-            tag_duids.append(tag_titles_to_duids[tag_title_norm])
-        task_update_kwargs["tag_duids"] = tag_duids
-
-    # TODO add a way for optional stuff to be removed
-    if priority_int is not None:
-        priority = _PRIORITY_MAP[priority_int]
-        if priority != old_task["priority"]:
-            task_update_kwargs["priority"] = priority
-
-    if size_int is not None:
-        size = size_int
-        if size != old_task["size"]:
-            task_update_kwargs["size"] = size
-
-    if due_at_str is not None:
-        due_at = dateparser.parse(due_at_str)
-        if due_at is None:
-            _dart_exit(f"Could not parse due date '{due_at_str}'.")
-        due_at = due_at.replace(
-            hour=9, minute=0, second=0, microsecond=0, tzinfo=timezone.utc
+    dart = Dart()
+    task_update = WrappedTaskUpdate(
+        item=TaskUpdate(
+            id,
+            title=title,
+            dartboard=dartboard_title,
+            status=status_title,
+            assignees=assignee_emails if assignee_emails is not None else UNSET,
+            tags=tag_titles if tag_titles is not None else UNSET,
+            priority=_normalize_priority(priority_int),
+            size=size_int,
+            due_at=_get_due_at_from_str_arg(due_at_str),
         )
-        due_at = due_at.isoformat()[:-6] + ".000Z"
-        if due_at != old_task["dueAt"]:
-            task_update_kwargs["due_at"] = due_at
-
-    task_update = TaskUpdate(**task_update_kwargs)
-    task_update_op = Operation(
-        model=OperationModelKind.TASK,
-        kind=OperationKind.UPDATE,
-        data=task_update,
-    )
-    response = dart.transact([task_update_op], TransactionKind.TASK_UPDATE)
-    task = _parse_transaction_response_and_maybe_exit(
-        response, OperationModelKind.TASK, task_update.duid
     )
+    task = dart.update_task(id, task_update).item
 
-    _log(f"Updated task {task.title} at {_get_task_url(config.host, task.duid)}")
+    _log(f"Updated task\n\n  {task.title}\n  {task.html_url}\n  ID: {task.id}\n")
     _log("Done.")
     return task
 
 
-def replicate_space(
-    duid: str,
-    *,
-    title: str | None = None,
-    abrev: str | None = None,
-    color_hex: str | None = None,
-    accessible_by_team: bool | None = None,
-    accessor_duids: list[str] | None = None,
-) -> str:
-    config = _Config()
-    session = _Session(config)
-
-    content = {}
-    if title is not None:
-        content["title"] = title
-    if abrev is not None:
-        content["abrev"] = abrev
-    if color_hex is not None:
-        content["colorHex"] = color_hex
-    if accessible_by_team is not None:
-        content["accessibleByTeam"] = accessible_by_team
-    if accessor_duids is not None:
-        content["accessorIds"] = accessor_duids
-    response = session.post(
-        _REPLICATE_SPACE_URL_FRAG_FMT.format(duid=duid), json=content
-    )
-    _check_request_response_and_maybe_exit(response)
-
-    space_duid = response.json()["duid"]
-
-    _log(f"Replicated space at {_get_space_url(config.host, space_duid)}")
-    _log("Done.")
-    return space_duid
-
-
-def get_dartboards(space_duid: str, include_special: bool = False) -> list[Dartboard]:
+def delete_task(id: str) -> Task:
     dart = Dart()
+    task = dart.delete_task(id).item
 
-    response = dartboards_list.sync(client=dart, space_duid=space_duid)
-    dartboards = response.results if response is not None else []
-    if not include_special:
-        dartboards = [e for e in dartboards if e.kind == DartboardKind.CUSTOM]
-
-    _log(f"Got {len(dartboards)} dartboards")
+    _log(f"Deleted task\n\n  {task.title}\n  {task.html_url}\n  ID: {task.id}\n")
     _log("Done.")
-    return dartboards
-
-
-def replicate_dartboard(duid: str, *, title: str | None = None) -> str:
-    config = _Config()
-    session = _Session(config)
+    return task
 
-    content = {}
-    if title is not None:
-        content["title"] = title
-    response = session.post(
-        _REPLICATE_DARTBOARD_URL_FRAG_FMT.format(duid=duid), json=content
-    )
-    _check_request_response_and_maybe_exit(response)
 
-    dartboard_duid = response.json()["duid"]
+def create_doc(
+    title: str,
+    *,
+    folder: Union[str, Unset] = UNSET,
+    text: Union[str, Unset] = UNSET,
+) -> Doc:
+    dart = Dart()
+    doc_create = WrappedDocCreate(item=DocCreate(title=title, folder=folder, text=text))
+    doc = dart.create_doc(doc_create).item
 
-    _log(f"Replicated dartboard at {_get_dartboard_url(config.host, dartboard_duid)}")
+    _log(f"Created doc\n\n  {doc.title}\n  {doc.html_url}\n  ID: {doc.id}\n")
     _log("Done.")
-    return dartboard_duid
+    return doc
 
 
-def update_dartboard(
-    duid: str,
+def update_doc(
+    id: str,
     *,
-    title: str | None = None,
-    color_hex: str | None = None,
-) -> Dartboard:
-    config = _Config()
-    session = _Session(config)
-    dart = Dart(session)
-
-    dartboard_update_kwargs = {"duid": duid}
-
-    if title is not None:
-        dartboard_update_kwargs["title"] = title
-    if color_hex is not None:
-        dartboard_update_kwargs["color_hex"] = color_hex
-
-    dartboard_update = DartboardUpdate(**dartboard_update_kwargs)
-    dartboard_update_op = Operation(
-        model=OperationModelKind.DARTBOARD,
-        kind=OperationKind.UPDATE,
-        data=dartboard_update,
-    )
-    response = dart.transact([dartboard_update_op], TransactionKind.DARTBOARD_UPDATE)
-    dartboard = _parse_transaction_response_and_maybe_exit(
-        response, OperationModelKind.DARTBOARD, dartboard_update.duid
-    )
+    title: str,
+    folder: Union[str, Unset] = UNSET,
+    text: Union[str, Unset] = UNSET,
+) -> Doc:
+    dart = Dart()
+    doc_update = WrappedDocUpdate(item=DocUpdate(id, title=title, folder=folder, text=text))
+    doc = dart.update_doc(id, doc_update).item
 
-    _log(
-        f"Updated dartboard {dartboard.title} at {_get_dartboard_url(config.host, dartboard.duid)}"
-    )
+    _log(f"Updated doc\n\n  {doc.title}\n  {doc.html_url}\n  ID: {doc.id}\n")
     _log("Done.")
-    return dartboard
+    return doc
 
 
-def get_folders(space_duid: str, *, include_special: bool = False) -> list[Folder]:
+def delete_doc(id: str) -> Doc:
     dart = Dart()
+    doc = dart.delete_doc(id).item
 
-    response = folders_list.sync(client=dart, space_duid=space_duid)
-    folders = response.results if response is not None else []
-    if not include_special:
-        folders = [e for e in folders if e.kind == FolderKind.OTHER]
-
-    _log(f"Got {len(folders)} folders")
+    _log(f"Deleted doc\n\n  {doc.title}\n  {doc.html_url}\n  ID: {doc.id}\n")
     _log("Done.")
-    return folders
-
-
-def update_folder(
-    duid: str,
-    *,
-    title: str | None = None,
-    color_hex: str | None = None,
-) -> Folder:
-    config = _Config()
-    session = _Session(config)
-    dart = Dart(session)
-
-    folder_update_kwargs = {"duid": duid}
+    return doc
 
-    if title is not None:
-        folder_update_kwargs["title"] = title
-    if color_hex is not None:
-        folder_update_kwargs["color_hex"] = color_hex
 
-    folder_update = FolderUpdate(**folder_update_kwargs)
-    folder_update_op = Operation(
-        model=OperationModelKind.FOLDER,
-        kind=OperationKind.UPDATE,
-        data=folder_update,
-    )
-    response = dart.transact([folder_update_op], TransactionKind.FOLDER_UPDATE)
-    folder = _parse_transaction_response_and_maybe_exit(
-        response, OperationModelKind.FOLDER, folder_update.duid
-    )
-
-    _log(
-        f"Updated folder {folder.title} at {_get_folder_url(config.host, folder.duid)}"
-    )
+def create_comment(id: str, text: str) -> Comment:
+    dart = Dart()
+    comment_create = WrappedCommentCreate(item=CommentCreate(task_id=id, text=text))
+    comment = dart.create_comment(comment_create).item
+    _log(f"Created comment\n\n  {comment.html_url}\n  ID: {comment.id}\n")
     _log("Done.")
-    return folder
+    return comment
 
 
 def _add_standard_task_arguments(parser: ArgumentParser) -> None:
     parser.add_argument(
-        "-d", "--dartboard", dest="dartboard_title", help="dartboard title"
+        "-d",
+        "--dartboard",
+        dest="dartboard_title",
+        help="dartboard title",
+        default=UNSET,
+    )
+    parser.add_argument(
+        "-s",
+        "--status",
+        dest="status_title",
+        help="status title",
+        default=UNSET,
     )
-    parser.add_argument("-s", "--status", dest="status_title", help="status title")
     parser.add_argument(
         "-a",
         "--assignee",
@@ -1077,11 +740,24 @@ def _add_standard_task_arguments(parser: ArgumentParser) -> None:
         type=int,
         choices=_PRIORITY_MAP.keys(),
         help="priority",
+        default=UNSET,
+    )
+    parser.add_argument(
+        "-i",
+        "--size",
+        dest="size_int",
+        type=int,
+        choices=_SIZES,
+        help="size",
+        default=UNSET,
     )
     parser.add_argument(
-        "-i", "--size", dest="size_int", type=int, choices=_SIZES, help="size"
+        "-r",
+        "--duedate",
+        dest="due_at_str",
+        help="due date",
+        default=UNSET,
     )
-    parser.add_argument("-r", "--duedate", dest="due_at_str", help="due date")
 
 
 def cli() -> None:
@@ -1096,24 +772,35 @@ def cli() -> None:
         return
 
     parser = ArgumentParser(prog=_PROG, description="A CLI to interact with Dart")
+    metavar = ",".join(
+        [
+            _LOGIN_CMD,
+            _CREATE_TASK_CMD,
+            _UPDATE_TASK_CMD,
+            _DELETE_TASK_CMD,
+            _BEGIN_TASK_CMD,
+            _CREATE_DOC_CMD,
+            _UPDATE_DOC_CMD,
+            _DELETE_DOC_CMD,
+            _CREATE_COMMENT_CMD,
+        ]
+    )
     subparsers = parser.add_subparsers(
         title="command",
         required=True,
-        metavar=f"{{{_LOGIN_CMD},{_CREATE_TASK_CMD},{_UPDATE_TASK_CMD},{_BEGIN_TASK_CMD}}}",
+        metavar=f"{{{metavar}}}",
     )
 
-    set_host_parser = subparsers.add_parser(_SET_HOST_CMD, aliases="s")
+    set_host_parser = subparsers.add_parser(_SET_HOST_CMD, aliases=["sh"])
     set_host_parser.add_argument("host", help="the new host: {prod|stag|dev|[URL]}")
     set_host_parser.set_defaults(func=set_host)
 
-    login_parser = subparsers.add_parser(_LOGIN_CMD, aliases="l", help="login")
-    login_parser.add_argument(
-        "-t", "--token", dest="token", help="your authentication token"
-    )
+    login_parser = subparsers.add_parser(_LOGIN_CMD, aliases=["l"], help="login")
+    login_parser.add_argument("-t", "--token", dest="token", help="your authentication token")
     login_parser.set_defaults(func=login)
 
     create_task_parser = subparsers.add_parser(
-        _CREATE_TASK_CMD, aliases="c", help="create a new task"
+        _CREATE_TASK_CMD, aliases=["tc"], help=_HELP_TEXT_TO_COMMAND[_CREATE_TASK_CMD]
     )
     create_task_parser.add_argument("title", help="title of the task")
     create_task_parser.add_argument(
@@ -1127,18 +814,52 @@ def cli() -> None:
     create_task_parser.set_defaults(func=create_task)
 
     update_task_parser = subparsers.add_parser(
-        _UPDATE_TASK_CMD, aliases="u", help="update an existing task"
+        _UPDATE_TASK_CMD, aliases=["tu"], help=_HELP_TEXT_TO_COMMAND[_UPDATE_TASK_CMD]
     )
-    update_task_parser.add_argument("duid", help="Dart ID (DUID) of the task")
-    update_task_parser.add_argument("-e", "--title", dest="title", help="task title")
+    update_task_parser.add_argument("id", help="ID of the task")
+    update_task_parser.add_argument("-e", "--title", dest="title", help="task title", default=UNSET)
     _add_standard_task_arguments(update_task_parser)
     update_task_parser.set_defaults(func=update_task)
 
-    begin_task_parser = subparsers.add_parser(
-        _BEGIN_TASK_CMD, aliases="b", help="begin work on a task"
+    delete_task_parser = subparsers.add_parser(
+        _DELETE_TASK_CMD, aliases=["td"], help=_HELP_TEXT_TO_COMMAND[_DELETE_TASK_CMD]
     )
+    delete_task_parser.add_argument("id", help="ID of the task")
+    delete_task_parser.set_defaults(func=delete_task)
+
+    begin_task_parser = subparsers.add_parser(_BEGIN_TASK_CMD, aliases=["tb"], help="begin work on a task")
     begin_task_parser.set_defaults(func=begin_task)
 
+    create_doc_parser = subparsers.add_parser(
+        _CREATE_DOC_CMD, aliases=["dc"], help=_HELP_TEXT_TO_COMMAND[_CREATE_DOC_CMD]
+    )
+    create_doc_parser.add_argument("title", help="title of the doc")
+    create_doc_parser.add_argument("-f", "--folder", dest="folder", help="doc folder", default=UNSET)
+    create_doc_parser.add_argument("-t", "--text", dest="text", help="doc text", default=UNSET)
+    create_doc_parser.set_defaults(func=create_doc)
+
+    update_doc_parser = subparsers.add_parser(
+        _UPDATE_DOC_CMD, aliases=["du"], help=_HELP_TEXT_TO_COMMAND[_UPDATE_DOC_CMD]
+    )
+    update_doc_parser.add_argument("id", help="ID of the doc")
+    update_doc_parser.add_argument("-e", "--title", dest="title", help="doc title", default=UNSET)
+    update_doc_parser.add_argument("-f", "--folder", dest="folder", help="doc folder", default=UNSET)
+    update_doc_parser.add_argument("-t", "--text", dest="text", help="doc text", default=UNSET)
+    update_doc_parser.set_defaults(func=update_doc)
+
+    delete_doc_parser = subparsers.add_parser(
+        _DELETE_DOC_CMD, aliases=["dd"], help=_HELP_TEXT_TO_COMMAND[_DELETE_DOC_CMD]
+    )
+    delete_doc_parser.add_argument("id", help="ID of the doc")
+    delete_doc_parser.set_defaults(func=delete_doc)
+
+    create_comment_parser = subparsers.add_parser(
+        _CREATE_COMMENT_CMD, aliases=["cc"], help=_HELP_TEXT_TO_COMMAND[_CREATE_COMMENT_CMD]
+    )
+    create_comment_parser.add_argument("id", help="ID of the task")
+    create_comment_parser.add_argument("text", help="text of the comment")
+    create_comment_parser.set_defaults(func=create_comment)
+
     args = vars(parser.parse_args())
     func = args.pop("func")
     func(**args)