diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 844fda93..48a5ee97 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -62,7 +62,7 @@ jobs:
           pipx install -e rats-devtools/
       - name: "poetry-install"
         run: |
-          rats-devtools install ${{ matrix.component }}/
+          rats-devtools ci poetry-install ${{ matrix.component }}/
       - id: package-info
         name: package-info
         run: |
@@ -155,14 +155,15 @@ jobs:
       - name: "poetry-install"
         run: |
           # I would like to optimize this soon before these steps become too slow
-          rats-devtools install rats-devtools/
-          rats-devtools install rats-pipelines/
-          rats-devtools install rats-processors/
-          rats-devtools install rats-examples-sklearn/
+          rats-devtools ci poetry-install rats-apps/
+          rats-devtools ci poetry-install rats-devtools/
+          rats-devtools ci poetry-install rats-pipelines/
+          rats-devtools ci poetry-install rats-processors/
+          rats-devtools ci poetry-install rats-examples-sklearn/
       - name: "build-docs"
         run: |
-          rats-devtools build-api-docs
-          rats-devtools mkdocs-build
+          rats-devtools docs sphinx-build
+          rats-devtools docs mkdocs-build
       - name: "upload-gh-pages"
         uses: actions/upload-pages-artifact@v3
         with:
diff --git a/.gitignore b/.gitignore
index 9c57cca8..b68b9931 100644
--- a/.gitignore
+++ b/.gitignore
@@ -37,3 +37,6 @@
 
 # rats-devtools generates these files for us
 bin/*.pipx
+
+# Aider tracks conversation history in-repo, so ignoring these files
+.aider*
diff --git a/.idea/watcherTasks.xml b/.idea/watcherTasks.xml
index a333d3f7..a0220fd8 100644
--- a/.idea/watcherTasks.xml
+++ b/.idea/watcherTasks.xml
@@ -2,7 +2,7 @@
 <project version="4">
   <component name="ProjectTasksOptions">
     <TaskOptions isEnabled="true">
-      <option name="arguments" value="pycharm-actions-on-save $FileRelativePath$" />
+      <option name="arguments" value="pycharm apply-auto-formatters $FileRelativePath$" />
       <option name="checkSyntaxErrors" value="true" />
       <option name="description" />
       <option name="exitCodeBehavior" value="ALWAYS" />
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 60174a34..70333c9f 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -5,6 +5,24 @@ ci:
   autoupdate_commit_msg: ":arrow-up: dep-bump(pre-commit): update pre-commit hooks"
 
 repos:
+  - repo: local
+    hooks:
+      - id: ruff-format
+        name: ruff-format
+        entry: "bin/ruff-format"
+        require_serial: true
+        language: script
+        pass_filenames: true
+        files: "src/python/|test/python/"
+        types: [ python ]
+      - id: ruff-check
+        name: ruff-check
+        entry: "bin/ruff-check"
+        require_serial: true
+        language: script
+        pass_filenames: true
+        files: "src/python/|test/python/"
+        types: [ python ]
   - repo: https://github.com/pre-commit/pre-commit-hooks
     rev: v4.6.0
     hooks:
@@ -28,20 +46,6 @@ repos:
       - id: name-tests-test
       - id: trailing-whitespace
 
-  - repo: https://gitlab.com/bmares/check-json5
-    rev: v1.0.0
-    hooks:
-      - id: check-json5
-
-  - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.4.2
-    hooks:
-      - id: ruff # linter
-        types_or: [python, pyi, jupyter]
-        args: [--fix]
-      - id: ruff-format # formatter
-        types_or: [python, pyi, jupyter]
-
   - repo: https://github.com/commitizen-tools/commitizen
     rev: v3.25.0
     hooks:
diff --git a/bin/rats-devtools.setup b/bin/rats-devtools.setup
index 494ac098..7509ece5 100755
--- a/bin/rats-devtools.setup
+++ b/bin/rats-devtools.setup
@@ -2,11 +2,17 @@
 
 SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
 REPO_DIR="$SCRIPT_DIR/.."
-export PIPX_BIN_DIR="$SCRIPT_DIR"
-echo "In order to make sure that the pipx installation is correct, we will remove the pipx installation and reinstall it."
-echo "Executables will be installed in $PIPX_BIN_DIR."
-echo "Using a .pipx suffix on executables. These should be .gitignored because they are system specific."
-pipx uninstall rats-devtools.pipx
-pipx install -e $REPO_DIR/rats-devtools/ --suffix .pipx || exit $?
-echo "Installation complete. Run the below command to enable shell completions:"
-echo 'eval "$(_RATS_DEVTOOLS_PIPX_COMPLETE=zsh_source rats-devtools.pipx)"'
+LOCAL_SUFFIX="pipx"
+GLOBAL_SUFFIX=$(echo -n $SCRIPT_DIR | md5sum  | awk '{print $1}')
+LOCAL_PATH="$SCRIPT_DIR/rats-devtools.$LOCAL_SUFFIX"
+GLOBAL_PATH="$(pipx environment --value PIPX_BIN_DIR)/rats-devtools.$GLOBAL_SUFFIX"
+echo "Local Executable: $LOCAL_PATH"
+echo "Global Executable: $GLOBAL_PATH"
+pipx uninstall "rats-devtools.${GLOBAL_SUFFIX}"
+pipx install -e $REPO_DIR/rats-devtools/ --suffix .$GLOBAL_SUFFIX || exit $?
+rm $LOCAL_PATH || true
+ln -s $GLOBAL_PATH $LOCAL_PATH || exit $?
+# Disabled this prompt until I find a good way to do it.
+#echo "For shell autocompletion add this to your profile:"
+#echo "eval '\$(_RATS_DEVTOOLS_${GLOBAL_SUFFIX^^}_COMPLETE=zsh_source rats-devtools.${GLOBAL_SUFFIX})'"
+echo "Installation complete!"
diff --git a/rats-apps/poetry.lock b/rats-apps/poetry.lock
index c0e4fd40..1877042b 100644
--- a/rats-apps/poetry.lock
+++ b/rats-apps/poetry.lock
@@ -154,6 +154,20 @@ files = [
     {file = "charset_normalizer-3.3.2-py3-none-any.whl", hash = "sha256:3e4d1f6587322d2788836a99c69062fbb091331ec940e02d12d179c1d53e25fc"},
 ]
 
+[[package]]
+name = "click"
+version = "8.1.7"
+description = "Composable command line interface toolkit"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "click-8.1.7-py3-none-any.whl", hash = "sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28"},
+    {file = "click-8.1.7.tar.gz", hash = "sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de"},
+]
+
+[package.dependencies]
+colorama = {version = "*", markers = "platform_system == \"Windows\""}
+
 [[package]]
 name = "colorama"
 version = "0.4.6"
@@ -433,13 +447,13 @@ windows-terminal = ["colorama (>=0.4.6)"]
 
 [[package]]
 name = "pyright"
-version = "1.1.360"
+version = "1.1.361"
 description = "Command line wrapper for pyright"
 optional = false
 python-versions = ">=3.7"
 files = [
-    {file = "pyright-1.1.360-py3-none-any.whl", hash = "sha256:7637f75451ac968b7cf1f8c51cfefb6d60ac7d086eb845364bc8ac03a026efd7"},
-    {file = "pyright-1.1.360.tar.gz", hash = "sha256:784ddcda9745e9f5610483d7b963e9aa8d4f50d7755a9dffb28ccbeb27adce32"},
+    {file = "pyright-1.1.361-py3-none-any.whl", hash = "sha256:c50fc94ce92b5c958cfccbbe34142e7411d474da43d6c14a958667e35b9df7ea"},
+    {file = "pyright-1.1.361.tar.gz", hash = "sha256:1d67933315666b05d230c85ea8fb97aaa2056e4092a13df87b7765bb9e8f1a8d"},
 ]
 
 [package.dependencies]
@@ -529,28 +543,28 @@ use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"]
 
 [[package]]
 name = "ruff"
-version = "0.4.2"
+version = "0.4.3"
 description = "An extremely fast Python linter and code formatter, written in Rust."
 optional = false
 python-versions = ">=3.7"
 files = [
-    {file = "ruff-0.4.2-py3-none-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:8d14dc8953f8af7e003a485ef560bbefa5f8cc1ad994eebb5b12136049bbccc5"},
-    {file = "ruff-0.4.2-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:24016ed18db3dc9786af103ff49c03bdf408ea253f3cb9e3638f39ac9cf2d483"},
-    {file = "ruff-0.4.2-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0e2e06459042ac841ed510196c350ba35a9b24a643e23db60d79b2db92af0c2b"},
-    {file = "ruff-0.4.2-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3afabaf7ba8e9c485a14ad8f4122feff6b2b93cc53cd4dad2fd24ae35112d5c5"},
-    {file = "ruff-0.4.2-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:799eb468ea6bc54b95527143a4ceaf970d5aa3613050c6cff54c85fda3fde480"},
-    {file = "ruff-0.4.2-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:ec4ba9436a51527fb6931a8839af4c36a5481f8c19e8f5e42c2f7ad3a49f5069"},
-    {file = "ruff-0.4.2-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6a2243f8f434e487c2a010c7252150b1fdf019035130f41b77626f5655c9ca22"},
-    {file = "ruff-0.4.2-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8772130a063f3eebdf7095da00c0b9898bd1774c43b336272c3e98667d4fb8fa"},
-    {file = "ruff-0.4.2-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6ab165ef5d72392b4ebb85a8b0fbd321f69832a632e07a74794c0e598e7a8376"},
-    {file = "ruff-0.4.2-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:1f32cadf44c2020e75e0c56c3408ed1d32c024766bd41aedef92aa3ca28eef68"},
-    {file = "ruff-0.4.2-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:22e306bf15e09af45ca812bc42fa59b628646fa7c26072555f278994890bc7ac"},
-    {file = "ruff-0.4.2-py3-none-musllinux_1_2_i686.whl", hash = "sha256:82986bb77ad83a1719c90b9528a9dd663c9206f7c0ab69282af8223566a0c34e"},
-    {file = "ruff-0.4.2-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:652e4ba553e421a6dc2a6d4868bc3b3881311702633eb3672f9f244ded8908cd"},
-    {file = "ruff-0.4.2-py3-none-win32.whl", hash = "sha256:7891ee376770ac094da3ad40c116258a381b86c7352552788377c6eb16d784fe"},
-    {file = "ruff-0.4.2-py3-none-win_amd64.whl", hash = "sha256:5ec481661fb2fd88a5d6cf1f83403d388ec90f9daaa36e40e2c003de66751798"},
-    {file = "ruff-0.4.2-py3-none-win_arm64.whl", hash = "sha256:cbd1e87c71bca14792948c4ccb51ee61c3296e164019d2d484f3eaa2d360dfaf"},
-    {file = "ruff-0.4.2.tar.gz", hash = "sha256:33bcc160aee2520664bc0859cfeaebc84bb7323becff3f303b8f1f2d81cb4edc"},
+    {file = "ruff-0.4.3-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:b70800c290f14ae6fcbb41bbe201cf62dfca024d124a1f373e76371a007454ce"},
+    {file = "ruff-0.4.3-py3-none-macosx_11_0_arm64.whl", hash = "sha256:08a0d6a22918ab2552ace96adeaca308833873a4d7d1d587bb1d37bae8728eb3"},
+    {file = "ruff-0.4.3-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eba1f14df3c758dd7de5b55fbae7e1c8af238597961e5fb628f3de446c3c40c5"},
+    {file = "ruff-0.4.3-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:819fb06d535cc76dfddbfe8d3068ff602ddeb40e3eacbc90e0d1272bb8d97113"},
+    {file = "ruff-0.4.3-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0bfc9e955e6dc6359eb6f82ea150c4f4e82b660e5b58d9a20a0e42ec3bb6342b"},
+    {file = "ruff-0.4.3-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:510a67d232d2ebe983fddea324dbf9d69b71c4d2dfeb8a862f4a127536dd4cfb"},
+    {file = "ruff-0.4.3-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc9ff11cd9a092ee7680a56d21f302bdda14327772cd870d806610a3503d001f"},
+    {file = "ruff-0.4.3-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:29efff25bf9ee685c2c8390563a5b5c006a3fee5230d28ea39f4f75f9d0b6f2f"},
+    {file = "ruff-0.4.3-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:18b00e0bcccf0fc8d7186ed21e311dffd19761cb632241a6e4fe4477cc80ef6e"},
+    {file = "ruff-0.4.3-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:262f5635e2c74d80b7507fbc2fac28fe0d4fef26373bbc62039526f7722bca1b"},
+    {file = "ruff-0.4.3-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:7363691198719c26459e08cc17c6a3dac6f592e9ea3d2fa772f4e561b5fe82a3"},
+    {file = "ruff-0.4.3-py3-none-musllinux_1_2_i686.whl", hash = "sha256:eeb039f8428fcb6725bb63cbae92ad67b0559e68b5d80f840f11914afd8ddf7f"},
+    {file = "ruff-0.4.3-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:927b11c1e4d0727ce1a729eace61cee88a334623ec424c0b1c8fe3e5f9d3c865"},
+    {file = "ruff-0.4.3-py3-none-win32.whl", hash = "sha256:25cacda2155778beb0d064e0ec5a3944dcca9c12715f7c4634fd9d93ac33fd30"},
+    {file = "ruff-0.4.3-py3-none-win_amd64.whl", hash = "sha256:7a1c3a450bc6539ef00da6c819fb1b76b6b065dec585f91456e7c0d6a0bbc725"},
+    {file = "ruff-0.4.3-py3-none-win_arm64.whl", hash = "sha256:71ca5f8ccf1121b95a59649482470c5601c60a416bf189d553955b0338e34614"},
+    {file = "ruff-0.4.3.tar.gz", hash = "sha256:ff0a3ef2e3c4b6d133fbedcf9586abfbe38d076041f2dc18ffb2c7e0485d5a07"},
 ]
 
 [[package]]
@@ -814,4 +828,4 @@ zstd = ["zstandard (>=0.18.0)"]
 [metadata]
 lock-version = "2.0"
 python-versions = "^3.10"
-content-hash = "1796d6151acff07dbb7e1896ae4f9328a0751480c3cae80bab7d73aa783a22a2"
+content-hash = "c56f5ddfa86ac124a39db790aba139df55b80041f974e29028638d60b123f6aa"
diff --git a/rats-apps/pyproject.toml b/rats-apps/pyproject.toml
index 8bc5519e..681c3a57 100644
--- a/rats-apps/pyproject.toml
+++ b/rats-apps/pyproject.toml
@@ -28,6 +28,7 @@ version-pinning-strategy = "semver"
 [tool.poetry.dependencies]
 python = "^3.10"
 typing_extensions = "*"
+click = "*"
 
 [tool.poetry.group.dev.dependencies]
 coverage = "*"
diff --git a/rats-apps/src/python/rats/annotations/__init__.py b/rats-apps/src/python/rats/annotations/__init__.py
new file mode 100644
index 00000000..bab07e54
--- /dev/null
+++ b/rats-apps/src/python/rats/annotations/__init__.py
@@ -0,0 +1,25 @@
+"""
+General purpose library to attach annotations to functions.
+
+Annotations are typically, but not exclusively, attached using decorators.
+"""
+
+from ._functions import (
+    AnnotationsContainer,
+    DecoratorType,
+    GroupAnnotations,
+    T_GroupType,
+    annotation,
+    get_annotations,
+    get_class_annotations,
+)
+
+__all__ = [
+    "annotation",
+    "DecoratorType",
+    "AnnotationsContainer",
+    "get_annotations",
+    "get_class_annotations",
+    "GroupAnnotations",
+    "T_GroupType",
+]
diff --git a/rats-apps/src/python/rats/annotations/_functions.py b/rats-apps/src/python/rats/annotations/_functions.py
new file mode 100644
index 00000000..23b0f5bf
--- /dev/null
+++ b/rats-apps/src/python/rats/annotations/_functions.py
@@ -0,0 +1,125 @@
+# type: ignore
+from __future__ import annotations
+
+from collections import defaultdict
+from collections.abc import Callable
+from functools import cache
+from typing import Any, Generic, ParamSpec, TypeVar
+from typing import NamedTuple as tNamedTuple
+
+from typing_extensions import NamedTuple
+
+T_GroupType = TypeVar("T_GroupType", bound=NamedTuple)
+
+
+class GroupAnnotations(NamedTuple, Generic[T_GroupType]):
+    """The list of T_GroupType objects identified by a given name in a namespace."""
+
+    name: str
+    """The name of the annotation, typically the name of the function in a class"""
+    namespace: str
+    """All the groups in a namespace are expected to be of the same T_GroupType."""
+    groups: tuple[T_GroupType, ...]
+
+
+class AnnotationsContainer(NamedTuple):
+    """
+    Holds metadata about the annotated service provider.
+
+    Loosely inspired by: https://peps.python.org/pep-3107/.
+    """
+
+    annotations: tuple[GroupAnnotations[...], ...]
+
+    @staticmethod
+    def empty() -> AnnotationsContainer:
+        return AnnotationsContainer(annotations=())
+
+    def with_group(
+        self,
+        namespace: str,
+        group_id: T_GroupType,
+    ) -> AnnotationsContainer:
+        return AnnotationsContainer(
+            annotations=tuple(
+                [
+                    annotation_group
+                    for x in self.with_namespace(namespace)
+                    for annotation_group in x
+                    if group_id in annotation_group.groups
+                ]
+            ),
+        )
+
+    def with_namespace(
+        self,
+        namespace: str,
+    ) -> AnnotationsContainer:
+        return AnnotationsContainer(
+            annotations=tuple([x for x in self.annotations if x.namespace == namespace]),
+        )
+
+
+class AnnotationsBuilder:
+    _group_ids: dict[str, set[Any]]
+
+    def __init__(self) -> None:
+        self._group_ids = defaultdict(set)
+
+    def add(self, namespace: str, group_id: NamedTuple | tNamedTuple) -> None:
+        self._group_ids[namespace].add(group_id)
+
+    def make(self, name: str) -> AnnotationsContainer:
+        return AnnotationsContainer(
+            annotations=tuple(
+                [
+                    GroupAnnotations[Any](name=name, namespace=namespace, groups=tuple(groups))
+                    for namespace, groups in self._group_ids.items()
+                ]
+            ),
+        )
+
+
+DecoratorType = TypeVar("DecoratorType", bound=Callable[..., Any])
+
+
+def annotation(
+    namespace: str,
+    group_id: NamedTuple | tNamedTuple,
+) -> Callable[[DecoratorType], DecoratorType]:
+    def decorator(fn: DecoratorType) -> DecoratorType:
+        if not hasattr(fn, "__rats_annotations__"):
+            fn.__rats_annotations__ = AnnotationsBuilder()  # type: ignore[reportFunctionMemberAccess]
+
+        fn.__rats_annotations__.add(namespace, group_id)  # type: ignore[reportFunctionMemberAccess]
+
+        return fn
+
+    return decorator
+
+
+@cache
+def get_class_annotations(cls: type) -> AnnotationsContainer:
+    tates = []
+
+    for method_name in dir(cls):
+        method = getattr(cls, method_name)
+        if not hasattr(method, "__rats_annotations__"):
+            continue
+
+        tates.extend(method.__rats_annotations__.make(method_name).annotations)
+
+    return AnnotationsContainer(annotations=tuple(tates))
+
+
+P = ParamSpec("P")
+
+
+def get_annotations(fn: Callable[..., Any]) -> AnnotationsContainer:
+    builder: AnnotationsBuilder = getattr(
+        fn,
+        "__rats_annotations__",
+        AnnotationsBuilder(),
+    )
+
+    return builder.make(fn.__name__)
diff --git a/rats-apps/src/python/rats/annotations/py.typed b/rats-apps/src/python/rats/annotations/py.typed
new file mode 100644
index 00000000..e69de29b
diff --git a/rats-apps/src/python/rats/apps/__init__.py b/rats-apps/src/python/rats/apps/__init__.py
index da41b448..59024f94 100644
--- a/rats-apps/src/python/rats/apps/__init__.py
+++ b/rats-apps/src/python/rats/apps/__init__.py
@@ -18,11 +18,18 @@
     service,
 )
 from ._composite_container import CompositeContainer
-from ._container import Container, DuplicateServiceError, ServiceNotFoundError
+from ._container import (
+    ConfigProvider,
+    Container,
+    DuplicateServiceError,
+    ServiceNotFoundError,
+    ServiceProvider,
+)
 from ._executables import App, AppContainer, Executable
 from ._ids import ConfigId, ServiceId
 from ._namespaces import ProviderNamespaces
 from ._plugin_container import PluginContainers
+from ._plugins import PluginRunner
 from ._scoping import autoscope
 
 __all__ = [
@@ -36,12 +43,15 @@
     "Executable",
     "PluginContainers",
     "ProviderNamespaces",
+    "ConfigProvider",
+    "ServiceProvider",
     "ServiceId",
     "ServiceNotFoundError",
     "autoid_service",
     "autoscope",
     "config",
     "container",
+    "PluginRunner",
     "fallback_config",
     "fallback_group",
     "fallback_service",
diff --git a/rats-apps/src/python/rats/apps/_annotations.py b/rats-apps/src/python/rats/apps/_annotations.py
index 3752d0aa..956b25dc 100644
--- a/rats-apps/src/python/rats/apps/_annotations.py
+++ b/rats-apps/src/python/rats/apps/_annotations.py
@@ -1,3 +1,4 @@
+import abc
 from collections import defaultdict
 from collections.abc import Callable, Iterator
 from functools import cache
@@ -70,7 +71,7 @@ def make(self, name: str) -> tuple[GroupAnnotations, ...]:
         )
 
 
-class AnnotatedContainer(Container):
+class AnnotatedContainer(Container, abc.ABC):
     def get_namespaced_group(
         self,
         namespace: str,
diff --git a/rats-apps/src/python/rats/apps/_plugins.py b/rats-apps/src/python/rats/apps/_plugins.py
new file mode 100644
index 00000000..48bb5d63
--- /dev/null
+++ b/rats-apps/src/python/rats/apps/_plugins.py
@@ -0,0 +1,17 @@
+from collections.abc import Callable, Iterator
+from typing import Generic, TypeVar
+
+T_PluginType = TypeVar("T_PluginType")
+
+
+class PluginRunner(Generic[T_PluginType]):
+    """Client to apply a function to a list of plugins."""
+
+    _plugins: Iterator[T_PluginType]
+
+    def __init__(self, plugins: Iterator[T_PluginType]) -> None:
+        self._plugins = plugins
+
+    def apply(self, handler: Callable[[T_PluginType], None]) -> None:
+        for plugin in self._plugins:
+            handler(plugin)
diff --git a/rats-apps/src/python/rats/cli/__init__.py b/rats-apps/src/python/rats/cli/__init__.py
new file mode 100644
index 00000000..e92a0cfc
--- /dev/null
+++ b/rats-apps/src/python/rats/cli/__init__.py
@@ -0,0 +1,19 @@
+"""Uses `rats.annotations` to streamline the creation of CLI commands written with Click."""
+
+from ._annotations import CommandId, command, group
+from ._click import ClickCommandGroup, ClickCommandMapper
+from ._executable import ClickExecutable
+from ._plugins import AttachClickCommands, AttachClickGroup, ClickGroupPlugin, CommandContainer
+
+__all__ = [
+    "CommandId",
+    "command",
+    "group",
+    "ClickCommandMapper",
+    "ClickExecutable",
+    "ClickGroupPlugin",
+    "ClickCommandGroup",
+    "AttachClickCommands",
+    "AttachClickGroup",
+    "CommandContainer",
+]
diff --git a/rats-apps/src/python/rats/cli/_annotations.py b/rats-apps/src/python/rats/cli/_annotations.py
new file mode 100644
index 00000000..8cb97e36
--- /dev/null
+++ b/rats-apps/src/python/rats/cli/_annotations.py
@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any, NamedTuple, TypeVar
+
+from rats import annotations as anns
+
+
+class CommandId(NamedTuple):
+    name: str
+
+    # does this api make it impossible to reference a given command that was auto generated?
+    @staticmethod
+    def auto() -> CommandId:
+        return CommandId(name=f"{__name__}:auto")
+
+
+T = TypeVar("T", bound=Callable[[Any], Any])
+
+
+def command(command_id: CommandId) -> Callable[[T], T]:
+    def decorator(fn: T) -> T:
+        if command_id == CommandId.auto():
+            return anns.annotation("commands", CommandId(fn.__name__.replace("_", "-")))(fn)
+        return anns.annotation("commands", command_id)(fn)
+
+    return decorator
+
+
+def group(command_id: CommandId) -> Callable[[T], T]:
+    def decorator(fn: T) -> T:
+        if command_id == CommandId.auto():
+            return anns.annotation("command-groups", CommandId(fn.__name__.replace("_", "-")))(fn)
+        return anns.annotation("commands", command_id)(fn)
+
+    return decorator
+
+
+def get_class_commands(cls: type) -> anns.AnnotationsContainer:
+    return anns.get_class_annotations(cls).with_namespace("commands")
diff --git a/rats-apps/src/python/rats/cli/_click.py b/rats-apps/src/python/rats/cli/_click.py
new file mode 100644
index 00000000..a99ef5d2
--- /dev/null
+++ b/rats-apps/src/python/rats/cli/_click.py
@@ -0,0 +1,38 @@
+from collections.abc import Callable, Mapping
+from typing import final
+
+import click
+
+
+class ClickCommandMapper:
+    _commands: Mapping[str, Callable[[], click.Command]]
+
+    def __init__(
+        self,
+        commands: Mapping[str, Callable[[], click.Command]],
+    ) -> None:
+        self._commands = commands
+
+    def names(self) -> frozenset[str]:
+        return frozenset(self._commands.keys())
+
+    def get(self, name: str) -> click.Command:
+        if name not in self._commands:
+            raise ValueError(f"Command {name} not found")
+
+        return self._commands[name]()
+
+
+@final
+class ClickCommandGroup(click.Group):
+    _mapper: ClickCommandMapper
+
+    def __init__(self, name: str, mapper: ClickCommandMapper) -> None:
+        super().__init__(name=name)
+        self._mapper = mapper
+
+    def get_command(self, ctx: click.Context, cmd_name: str) -> click.Command | None:
+        return self._mapper.get(cmd_name)
+
+    def list_commands(self, ctx: click.Context) -> list[str]:
+        return list(self._mapper.names())
diff --git a/rats-apps/src/python/rats/cli/_executable.py b/rats-apps/src/python/rats/cli/_executable.py
new file mode 100644
index 00000000..2a8092c9
--- /dev/null
+++ b/rats-apps/src/python/rats/cli/_executable.py
@@ -0,0 +1,23 @@
+import click
+
+from rats import apps
+
+from ._plugins import ClickGroupPlugin
+
+
+class ClickExecutable(apps.Executable):
+    _command: apps.ServiceProvider[click.Group]
+    _plugins: apps.PluginRunner[ClickGroupPlugin]
+
+    def __init__(
+        self,
+        command: apps.ServiceProvider[click.Group],
+        plugins: apps.PluginRunner[ClickGroupPlugin],
+    ) -> None:
+        self._command = command
+        self._plugins = plugins
+
+    def execute(self) -> None:
+        cmd = self._command()
+        self._plugins.apply(lambda plugin: plugin.on_group_open(cmd))
+        cmd()
diff --git a/rats-apps/src/python/rats/cli/_plugins.py b/rats-apps/src/python/rats/cli/_plugins.py
new file mode 100644
index 00000000..6c240dd8
--- /dev/null
+++ b/rats-apps/src/python/rats/cli/_plugins.py
@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from collections.abc import Callable, Iterator
+from functools import partial
+from typing import Any, Protocol
+
+import click
+
+from rats import apps
+
+from ._annotations import get_class_commands
+
+
+class ClickGroupPlugin(Protocol):
+    @abstractmethod
+    def on_group_open(self, group: click.Group) -> None:
+        pass
+
+
+class AttachClickCommands(ClickGroupPlugin):
+    """When a group is opened, attach a set of commands to it."""
+
+    _commands: Iterator[click.Command]
+
+    def __init__(self, commands: Iterator[click.Command]) -> None:
+        self._commands = commands
+
+    def on_group_open(self, group: click.Group) -> None:
+        for command in self._commands:
+            group.add_command(command)
+
+
+class AttachClickGroup(ClickGroupPlugin):
+    _group: apps.ServiceProvider[click.Group]
+    _plugins: apps.PluginRunner[ClickGroupPlugin]
+
+    def __init__(
+        self,
+        group: apps.ServiceProvider[click.Group],
+        plugins: apps.PluginRunner[ClickGroupPlugin],
+    ) -> None:
+        self._group = group
+        self._plugins = plugins
+
+    def on_group_open(self, group: click.Group) -> None:
+        cmd = self._group()
+        self._plugins.apply(lambda plugin: plugin.on_group_open(cmd))
+        group.add_command(cmd)
+
+
+class CommandContainer(ClickGroupPlugin):
+    def on_group_open(self, group: click.Group) -> None:
+        def cb(_method: Callable[[Any], Any], *args: Any, **kwargs: Any) -> None:
+            """
+            Callback handed to `click.Command`. Calls the method with matching name on this class.
+
+            When the command is decorated with `@click.params` and `@click.option`, `click` will
+            call this callback with the parameters in the order they were defined. This callback
+            then calls the method with the same name on this class, passing the parameters in
+            reverse order. This is because the method is defined with the parameters in the
+            reverse order to the decorator, so we need to reverse them again to get the correct
+            order.
+            """
+            _method(*args, **kwargs)
+
+        commands = get_class_commands(type(self))
+        tates = commands.annotations
+
+        for tate in tates:
+            method = getattr(self, tate.name)
+            params = list(reversed(getattr(method, "__click_params__", [])))
+            for command in tate.groups:
+                group.add_command(
+                    click.Command(
+                        name=command.name,
+                        callback=partial(cb, method),
+                        short_help=method.__doc__,
+                        params=params,
+                    )
+                )
diff --git a/rats-apps/src/python/rats/cli/py.typed b/rats-apps/src/python/rats/cli/py.typed
new file mode 100644
index 00000000..e69de29b
diff --git a/rats-devtools/pyproject.toml b/rats-devtools/pyproject.toml
index 3f78d187..8e099f5f 100644
--- a/rats-devtools/pyproject.toml
+++ b/rats-devtools/pyproject.toml
@@ -60,8 +60,12 @@ sphinx-markdown-builder = "*"
 rats-devtools = "rats.devtools.__main__:run"
 
 [tool.poetry.plugins."rats.devtools.plugins"]
-"rats-devtools.pycharm" = "rats.pycharm._app:RatsPycharmPlugin"
-"rats-devtools.ci" = "rats.ci._app:RatsCiPlugin"
+"rats-devtools.ci" = "rats.ci._plugin:RatsCiPlugin"
+"rats-devtools.docs" = "rats.docs._plugin:RatsDocsPlugin"
+"rats-devtools.pycharm" = "rats.pycharm._plugin:RatsPycharmPlugin"
+"rats-devtools-ct.ci" = "rats.ci._command_tree_plugin:RatsCiCommandTreePlugin"
+"rats-devtools-ct.docs" = "rats.docs._command_tree_plugin:RatsDocsCommandTreePlugin"
+"rats-devtools-ct.pycharm" = "rats.pycharm._command_tree_plugin:RatsPycharmCommandTreePlugin"
 
 [build-system]
 requires = ["poetry-core>=1.0.0", "poetry-dynamic-versioning>=1.0.0,<2.0.0"]
@@ -124,19 +128,26 @@ target-version = "py310"
 
 [tool.ruff.lint]
 # Enable Pyflakes (`F`) and a subset of the pycodestyle (`E`)  codes by default.
-select = ["B", "D", "E", "F", "I", "Q", "W", "NPY", "PD", "PTH", "RUF", "UP"]
+select = [
+    "B",    # Bugbear
+    "D",    # Docstring
+    "E",    # Pycodestyle
+    "F",    # Pyflakes
+    "I",    # Import
+    "Q",    # Quotes
+    "W",    # PEP8 warnings
+    "NPY",  # Numpy
+    "PD",   # Pydocstyle
+    "PTH",  # Path
+    "RUF",  # Ruff
+    "UP",   # Unittest
+    "D213", # D213: Multi-line docstring summary should start at the second line
+]
 ignore = [
-    "B026", # B026: Star-arg unpacking after a keyword argument is strongly discouraged
-    "D100", # D100: Missing docstring in public module
-    "D101", # D101: Missing docstring in public class
-    "D102", # D102: Missing docstring in public method
-    "D103", # D103: Missing docstring in public function
-    "D104", # D104: Missing docstring in public package
-    "D105", # D105: Missing docstring in magic method
-    "D107", # D107: Missing docstring in __init__
-    "D417", # D417: Missing argument descriptions in Docstrings
-    "E203", # E203: Whitespace before ':'
     "E501", # E501: Line too long ({width} > {limit})
+    "D212", # D212: Multi-line docstring summary should start at the second line
+    # This rule seems buggy: https://github.com/astral-sh/ruff/issues/2480
+    "PD011", # PD011: Use `.to_numpy()` instead of `.values`
 ]
 
 # Allow fix for all enabled rules (when `--fix`) is provided.
@@ -147,7 +158,14 @@ unfixable = []
 dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
 
 [tool.ruff.lint.per-file-ignores]
-"test/*" = ["F401"] # unused-import
+"test/*" = [
+    "F401", # Unused import
+    "D100", # Missing docstring in public module
+    "D101", # Missing docstring in public class
+    "D102", # Missing docstring in public method
+    "D103", # Missing docstring in public function
+    "D104", # Missing docstring in public package
+]
 
 [tool.ruff.lint.pydocstyle]
 convention = "google"
diff --git a/rats-devtools/src/python/rats/ci/__init__.py b/rats-devtools/src/python/rats/ci/__init__.py
index e69de29b..4337b36e 100644
--- a/rats-devtools/src/python/rats/ci/__init__.py
+++ b/rats-devtools/src/python/rats/ci/__init__.py
@@ -0,0 +1 @@
+"""Commands for building and validating our components."""
diff --git a/rats-devtools/src/python/rats/ci/__main__.py b/rats-devtools/src/python/rats/ci/__main__.py
deleted file mode 100644
index 345c0be0..00000000
--- a/rats-devtools/src/python/rats/ci/__main__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from ._app import run
-
-if __name__ == "__main__":
-    run()
diff --git a/rats-devtools/src/python/rats/ci/_app.py b/rats-devtools/src/python/rats/ci/_app.py
deleted file mode 100644
index 483ec3cd..00000000
--- a/rats-devtools/src/python/rats/ci/_app.py
+++ /dev/null
@@ -1,37 +0,0 @@
-from rats import apps, devtools  # type: ignore[reportAttributeAccessIssue]
-
-from ._commands import RatsCiCommands
-
-
-@apps.autoscope
-class RatsCiServices:
-    CLI = apps.ServiceId[apps.Executable]("cli")
-
-
-class RatsCiGroups:
-    COMMANDS = apps.ServiceId[devtools.ClickCommandRegistry]("pycharm-commands")
-
-
-class RatsCiPlugin(apps.AnnotatedContainer):
-    _app: apps.Container
-
-    def __init__(self, app: apps.Container) -> None:
-        self._app = app
-
-    @apps.service(RatsCiServices.CLI)
-    def cli(self) -> apps.Executable:
-        return devtools.ClickCommandGroup(
-            lambda: self._app.get_group(
-                RatsCiGroups.COMMANDS,
-            )
-        )
-
-    @apps.group(devtools.RatsDevtoolsGroups.COMMANDS)
-    @apps.group(RatsCiGroups.COMMANDS)
-    def commands(self) -> RatsCiCommands:
-        return RatsCiCommands()
-
-
-def run() -> None:
-    app = apps.AppContainer(lambda app: RatsCiPlugin(app))
-    app.get(RatsCiServices.CLI).execute()
diff --git a/rats-devtools/src/python/rats/ci/_command_tree_plugin.py b/rats-devtools/src/python/rats/ci/_command_tree_plugin.py
new file mode 100644
index 00000000..921c6d4f
--- /dev/null
+++ b/rats-devtools/src/python/rats/ci/_command_tree_plugin.py
@@ -0,0 +1,37 @@
+# pyright seems to struggle with this namespace package
+# https://github.com/microsoft/pyright/issues/2882
+from rats import apps as apps
+from rats import cli as cli
+from rats import command_tree as command_tree
+from rats import devtools as devtools
+
+from ._command_trees import ComponentArgs, RatsCiCommandTrees
+
+
+class RatsCiCommandTreePlugin(apps.AnnotatedContainer):
+    _app: apps.Container
+
+    def __init__(self, app: apps.Container) -> None:
+        self._app = app
+
+    @apps.group(command_tree.CommandTreeServices.GROUPS.subcommands("rats-devtools"))
+    def ci_command_tree(self) -> command_tree.CommandTree:
+        return command_tree.CommandTree(
+            name="ci",
+            description="Commands for performing continuous integration actions.",
+            kwargs_class=ComponentArgs,
+            children=tuple(
+                (
+                    child.to_command_tree(self)
+                    if isinstance(child, command_tree.CommandServiceTree)
+                    else child
+                )
+                for child in self._app.get_group(
+                    command_tree.CommandTreeServices.GROUPS.subcommands("rats-devtools ci")
+                )
+            ),
+        )
+
+    @apps.container()
+    def ci_subcommands(self) -> apps.Container:
+        return RatsCiCommandTrees(self._app)
diff --git a/rats-devtools/src/python/rats/ci/_command_trees.py b/rats-devtools/src/python/rats/ci/_command_trees.py
new file mode 100644
index 00000000..37f463f4
--- /dev/null
+++ b/rats-devtools/src/python/rats/ci/_command_trees.py
@@ -0,0 +1,180 @@
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Annotated
+
+import click
+
+from rats import apps
+
+# pyright seems to struggle with this namespace package
+# https://github.com/microsoft/pyright/issues/2882
+from rats import command_tree as command_tree
+
+
+@dataclass(frozen=True)
+class ComponentArgs:
+    """Arguments for selecting the component to run commands against."""
+
+    component_path: Annotated[
+        str,
+        command_tree.ClickConversion(
+            argument=True, explicit_click_type=click.Path(exists=True, file_okay=False)
+        ),
+    ]
+    """The path to the component to operate on."""
+
+
+@dataclass(frozen=True)
+class PublishWheelsArgs:
+    """Arguments for publishing wheels."""
+
+    repository_name: Annotated[str, command_tree.ClickConversion(argument=True)]
+    """The name of the repository to publish to."""
+
+
+class RatsCiCommandTrees(apps.AnnotatedContainer):
+    _app: apps.Container
+
+    def __init__(self, app: apps.Container) -> None:
+        self._app = app
+
+    @apps.group(command_tree.CommandTreeServices.GROUPS.subcommands("rats-devtools ci"))
+    def poetry_install_command_tree(self) -> command_tree.CommandTree:
+        def handler(component_args: ComponentArgs) -> None:
+            p = Path(component_args.component_path)
+            if not p.exists() and p.is_dir():
+                raise ValueError(f"component {component_args.component_path} does not exist")
+
+            pyproject_path = p / "pyproject.toml"
+
+            if not p.is_dir() or not pyproject_path.is_file():
+                raise ValueError(f"component {component_args.component_path} does not exist")
+
+            try:
+                subprocess.run(
+                    ["poetry", "install"], cwd=component_args.component_path, check=True
+                )
+            except subprocess.CalledProcessError as e:
+                sys.exit(e.returncode)
+
+        return command_tree.CommandTree(
+            name="poetry-install",
+            description="Install the dependencies for a component using poetry.",
+            handler=handler,
+        )
+
+    @apps.group(command_tree.CommandTreeServices.GROUPS.subcommands("rats-devtools ci"))
+    def test_command_tree(self) -> command_tree.CommandTree:
+        def handler(component_args: ComponentArgs) -> None:
+            p = Path(component_args.component_path)
+            pyproject_path = p / "pyproject.toml"
+
+            if not p.is_dir() or not pyproject_path.is_file():
+                raise ValueError(f"component {component_args.component_path} does not exist")
+
+            try:
+                subprocess.run(
+                    ["poetry", "run", "pytest"], cwd=component_args.component_path, check=True
+                )
+            except subprocess.CalledProcessError as e:
+                sys.exit(e.returncode)
+
+        return command_tree.CommandTree(
+            name="test",
+            description="Build the python wheel for one of the components in this project.",
+            handler=handler,
+        )
+
+    @apps.group(command_tree.CommandTreeServices.GROUPS.subcommands("rats-devtools ci"))
+    def check_all_command_tree(self) -> command_tree.CommandTree:
+        def handler(component_args: ComponentArgs) -> None:
+            pyproject_path = Path(f"{component_args.component_path}/pyproject.toml")
+
+            if not pyproject_path.is_file():
+                raise ValueError("does not seem to be running within repo root")
+
+            poetry_commands = [
+                ["ruff", "check", "--fix", "--unsafe-fixes"],
+                ["ruff", "format", "--check"],
+                ["pyright"],
+                ["pytest"],
+            ]
+
+            try:
+                for cmd in poetry_commands:
+                    subprocess.run(
+                        ["poetry", "run", *cmd],
+                        check=True,
+                        cwd=component_args.component_path,
+                    )
+            except subprocess.CalledProcessError as e:
+                sys.exit(e.returncode)
+
+        return command_tree.CommandTree(
+            name="check-all",
+            description="""
+            If this command passes, ci should pass.
+
+            I hope.
+            """,
+            handler=handler,
+        )
+
+    @apps.group(command_tree.CommandTreeServices.GROUPS.subcommands("rats-devtools ci"))
+    def build_wheel_command_tree(self) -> command_tree.CommandTree:
+        def handler(component_args: ComponentArgs) -> None:
+            p = Path(component_args.component_path)
+            pyproject_path = p / "pyproject.toml"
+
+            if not p.is_dir() or not pyproject_path.is_file():
+                raise ValueError(f"component {component_args.component_path} does not exist")
+
+            try:
+                subprocess.run(
+                    ["poetry", "build", "-f", "wheel"],
+                    cwd=component_args.component_path,
+                    check=True,
+                )
+            except subprocess.CalledProcessError as e:
+                sys.exit(e.returncode)
+
+        return command_tree.CommandTree(
+            name="build-wheel",
+            description="Build the python wheel for one of the components in this project.",
+            handler=handler,
+        )
+
+    @apps.group(command_tree.CommandTreeServices.GROUPS.subcommands("rats-devtools ci"))
+    def publish_wheels_command_tree(self) -> command_tree.CommandTree:
+        def handler(component_args: ComponentArgs, publish_wheels_args: PublishWheelsArgs) -> None:
+            p = Path(component_args.component_path)
+            pyproject_path = p / "pyproject.toml"
+
+            if not p.is_dir() or not pyproject_path.is_file():
+                raise ValueError(f"component {component_args.component_path} does not exist")
+
+            try:
+                subprocess.run(
+                    [
+                        "poetry",
+                        "publish",
+                        "--repository",
+                        publish_wheels_args.repository_name,
+                        "--no-interaction",
+                        # temporarily skip existing during testing
+                        "--skip-existing",
+                    ],
+                    cwd=component_args.component_path,
+                    check=True,
+                )
+            except subprocess.CalledProcessError as e:
+                sys.exit(e.returncode)
+
+        return command_tree.CommandTree(
+            name="publish-wheel",
+            description="Publish the python wheel for one of the components in this project.",
+            kwargs_class=PublishWheelsArgs,
+            handler=handler,
+        )
diff --git a/rats-devtools/src/python/rats/ci/_commands.py b/rats-devtools/src/python/rats/ci/_commands.py
index f54a590d..72a60cc2 100644
--- a/rats-devtools/src/python/rats/ci/_commands.py
+++ b/rats-devtools/src/python/rats/ci/_commands.py
@@ -1,17 +1,52 @@
+# type: ignore[reportUntypedFunctionDecorator]
 import subprocess
 import sys
 from pathlib import Path
 
 import click
 
-from rats import devtools
+# pyright seems to struggle with this namespace package
+# https://github.com/microsoft/pyright/issues/2882
+from rats import apps as apps
+from rats import cli
 
 
-class RatsCiCommands(devtools.ClickCommandRegistry):
-    @devtools.command
+class RatsCiCommands(cli.CommandContainer):
+    @cli.command(cli.CommandId.auto())
+    @click.argument("component_path", type=click.Path(exists=True, file_okay=False))
+    def poetry_install(self, component_path: str) -> None:
+        """Build the documentation site for one of the components in this project."""
+        p = Path(component_path)
+        pyproject_path = p / "pyproject.toml"
+
+        if not p.is_dir() or not pyproject_path.is_file():
+            raise ValueError(f"component {component_path} does not exist")
+
+        try:
+            subprocess.run(["poetry", "install"], cwd=component_path, check=True)
+        except subprocess.CalledProcessError as e:
+            sys.exit(e.returncode)
+
+    @cli.command(cli.CommandId.auto())
+    @click.argument("component_path", type=click.Path(exists=True, file_okay=False))
+    def test(self, component_path: str) -> None:
+        """Build the python wheel for one of the components in this project."""
+        p = Path(component_path)
+        pyproject_path = p / "pyproject.toml"
+
+        if not p.is_dir() or not pyproject_path.is_file():
+            raise ValueError(f"component {component_path} does not exist")
+
+        try:
+            subprocess.run(["poetry", "run", "pytest"], cwd=component_path, check=True)
+        except subprocess.CalledProcessError as e:
+            sys.exit(e.returncode)
+
+    @cli.command(cli.CommandId.auto())
     @click.argument("component_path", type=click.Path(exists=True, file_okay=False))
     def check_all(self, component_path: str) -> None:
-        """If this command passes, ci should pass.
+        """
+        If this command passes, ci should pass.
 
         I hope.
         """
@@ -22,7 +57,7 @@ def check_all(self, component_path: str) -> None:
 
         poetry_commands = [
             ["ruff", "check", "--fix", "--unsafe-fixes"],
-            ["ruff", "format", "--check"],
+            ["ruff", "format"],
             ["pyright"],
             ["pytest"],
         ]
@@ -37,7 +72,45 @@ def check_all(self, component_path: str) -> None:
         except subprocess.CalledProcessError as e:
             sys.exit(e.returncode)
 
-    @devtools.command
-    def ping(self) -> None:
-        """No-op used for testing."""
-        print("pong")
+    @cli.command(cli.CommandId.auto())
+    @click.argument("component_path", type=click.Path(exists=True, file_okay=False))
+    def build_wheel(self, component_path: str) -> None:
+        """Build the python wheel for one of the components in this project."""
+        p = Path(component_path)
+        pyproject_path = p / "pyproject.toml"
+
+        if not p.is_dir() or not pyproject_path.is_file():
+            raise ValueError(f"component {component_path} does not exist")
+
+        try:
+            subprocess.run(["poetry", "build", "-f", "wheel"], cwd=component_path, check=True)
+        except subprocess.CalledProcessError as e:
+            sys.exit(e.returncode)
+
+    @cli.command(cli.CommandId.auto())
+    @click.argument("component_path", type=click.Path(exists=True, file_okay=False))
+    @click.argument("repository_name", type=str)
+    def publish_wheel(self, component_path: str, repository_name: str) -> None:
+        """Publish the python wheel for one of the components in this project."""
+        p = Path(component_path)
+        pyproject_path = p / "pyproject.toml"
+
+        if not p.is_dir() or not pyproject_path.is_file():
+            raise ValueError(f"component {component_path} does not exist")
+
+        try:
+            subprocess.run(
+                [
+                    "poetry",
+                    "publish",
+                    "--repository",
+                    repository_name,
+                    "--no-interaction",
+                    # temporarily skip existing during testing
+                    "--skip-existing",
+                ],
+                cwd=component_path,
+                check=True,
+            )
+        except subprocess.CalledProcessError as e:
+            sys.exit(e.returncode)
diff --git a/rats-devtools/src/python/rats/ci/_ids.py b/rats-devtools/src/python/rats/ci/_ids.py
new file mode 100644
index 00000000..41094928
--- /dev/null
+++ b/rats-devtools/src/python/rats/ci/_ids.py
@@ -0,0 +1,10 @@
+import click
+
+from rats import apps
+
+
+@apps.autoscope
+class PluginServices:
+    @staticmethod
+    def command(name: str) -> apps.ServiceId[click.Command]:
+        return apps.ServiceId(f"cli-commands[{name}]")
diff --git a/rats-devtools/src/python/rats/ci/_plugin.py b/rats-devtools/src/python/rats/ci/_plugin.py
new file mode 100644
index 00000000..5ce46098
--- /dev/null
+++ b/rats-devtools/src/python/rats/ci/_plugin.py
@@ -0,0 +1,25 @@
+import click
+
+# pyright seems to struggle with this namespace package
+# https://github.com/microsoft/pyright/issues/2882
+from rats import apps as apps
+from rats import cli as cli
+from rats import devtools as devtools
+
+from ._commands import RatsCiCommands
+
+
+class RatsCiPlugin(apps.AnnotatedContainer):
+    _app: apps.Container
+
+    def __init__(self, app: apps.Container) -> None:
+        self._app = app
+
+    @apps.group(devtools.AppServices.GROUPS.CLI_ROOT_PLUGINS)
+    def ci_command(self) -> cli.AttachClickGroup:
+        return cli.AttachClickGroup(
+            group=lambda: click.Group("ci"),
+            plugins=apps.PluginRunner(
+                iter([RatsCiCommands()]),
+            ),
+        )
diff --git a/rats-devtools/src/python/rats/command_tree/__init__.py b/rats-devtools/src/python/rats/command_tree/__init__.py
new file mode 100644
index 00000000..f3f9ff40
--- /dev/null
+++ b/rats-devtools/src/python/rats/command_tree/__init__.py
@@ -0,0 +1,32 @@
+"""
+This module provides a way to define a tree of commands that can be used to generate a command-line interface using Click.
+
+The `CommandTree` class is used to define the tree of commands. Each leaf in the tree represents a
+command that can be executed. The nodes can have children, which represent subcommands that can be
+executed under the parent command.
+
+The `CommandServiceTree` class is used to define the tree of command using ServiceIds. The tree's
+subcommands and handlers are resolved from the container, allowing lazy loading.
+"""
+
+from ._click import (
+    ClickConversion,
+    CommandTreeClickExecutable,
+    dataclass_to_click_parameters,
+    to_click_commands,
+)
+from ._command_service_tree import CommandServiceTree
+from ._command_tree import CommandTree
+from ._docstring import get_attribute_docstring
+from ._ids import CommandTreeServices
+
+__all__ = [
+    "ClickConversion",
+    "CommandServiceTree",
+    "CommandTree",
+    "CommandTreeClickExecutable",
+    "CommandTreeServices",
+    "dataclass_to_click_parameters",
+    "get_attribute_docstring",
+    "to_click_commands",
+]
diff --git a/rats-devtools/src/python/rats/command_tree/_click.py b/rats-devtools/src/python/rats/command_tree/_click.py
new file mode 100644
index 00000000..ad9cff5b
--- /dev/null
+++ b/rats-devtools/src/python/rats/command_tree/_click.py
@@ -0,0 +1,213 @@
+import functools
+import itertools
+import uuid
+from collections.abc import Callable
+from dataclasses import MISSING, dataclass, fields, is_dataclass
+from typing import Annotated, Any, get_args, get_origin
+
+import click
+from click import Command, Group
+
+from rats.apps import Executable
+
+from ._command_tree import CommandTree
+from ._docstring import get_attribute_docstring
+
+
+@dataclass(frozen=True)
+class ClickConversion:
+    """Type annotations for the click conversion."""
+
+    argument: bool = False
+    """Whether the field is an argument."""
+
+    explicit_click_type: click.ParamType | None = None
+    """The explicit click type to use for the field."""
+
+
+def to_click_commands(
+    command: CommandTree,
+    parent_kwarg_classes: tuple[type[Any], ...] = tuple(),
+) -> Group | Command:
+    """
+    Recursively generate click commands and groups from the command tree.
+
+    Traverse down the CommandTree until we hit a leaf node, collecting the argument groups along the way.
+    Then, create a click command with the collected argument groups and the handler.
+    Nodes traversed along the way are wrapped in a click group, and the click command is added to the group.
+    Nested CommandTree handlers are expected to take the argument groups, in nesting order, as positional arguments.
+
+    Args:
+        command: The command tree to convert to click commands.
+        parent_kwarg_classes: The dataclasses of the parent command arguments.
+
+    Returns:
+        A click group or command.
+    """
+    if command.kwargs_class is not None:
+        parent_kwarg_classes = (*parent_kwarg_classes, command.kwargs_class)
+
+    click_options_by_dataclass = {
+        kwargs_class: dataclass_to_click_parameters(kwargs_class)
+        for kwargs_class in parent_kwarg_classes
+    }
+
+    command_wrapper: Callable[..., None] | None
+    if command.handler is not None:
+
+        @functools.wraps(command.handler)
+        def wrapper_func(**kwargs: Any):
+            handler_args = []
+            for kwargs_class, click_options in click_options_by_dataclass.items():
+                kwargs_class_init = {}
+                for option in click_options:
+                    # We shouldn't be able to get here, but just in case we do, we should raise an error
+                    if option.name is None:
+                        raise ValueError("Option name cannot be None")
+
+                    kwargs_class_init[option.name] = kwargs[option.name]
+
+                handler_args.append(kwargs_class(**kwargs_class_init))
+
+            assert command.handler is not None
+            command.handler(*handler_args)
+
+        command_wrapper = wrapper_func
+    else:
+        command_wrapper = None
+
+    # if we're on a leaf node, we need to generate a click command
+    if not command.children:
+        if command.handler is None:
+            raise ValueError(f"Command {command.name} has no handler")
+
+        return Command(
+            name=command.name,
+            help=command.description,
+            params=list(itertools.chain.from_iterable(click_options_by_dataclass.values())),
+            callback=command_wrapper,
+        )
+    else:
+        # if we're not on a leaf node, we need to generate a click group
+        group_to_add = Group(name=command.name, help=command.description, callback=command_wrapper)
+        for child in command.children:
+            group_to_add.add_command(to_click_commands(child, parent_kwarg_classes))
+
+        return group_to_add
+
+
+CLICK_TYPE_MAPPING = {
+    int: click.INT,
+    float: click.FLOAT,
+    str: click.STRING,
+    bool: click.BOOL,
+    uuid.UUID: click.UUID,
+}
+
+
+def dataclass_to_click_parameters(
+    dataclass: type[Any], parent_field_name: str | None = None, parent_nargs: int | None = None
+) -> tuple[click.Option, ...]:
+    """
+    Convert a dataclass to a list of click arguments.
+
+    The dataclass fields are converted to click options, with the field name as the option name.
+    If the field type is a tuple, the option is marked as multiple and the inner type is used.
+    If the field type is a dataclass, the dataclass is recursively converted to click arguments.
+
+    Args:
+        dataclass: The dataclass to convert to click arguments.
+        parent_field_name: The name of the parent field, if any.
+        parent_nargs: The number of arguments for the parent field, if any.
+
+    Returns:
+        A tuple of click options.
+
+    Raises:
+        AssertionError: If the dataclass is not a dataclass.
+    """
+    assert is_dataclass(dataclass)
+
+    parameters = []
+    for field in fields(dataclass):
+        option_name = field.name.replace("_", "-")
+        if parent_field_name is not None:
+            option_name = f"{parent_field_name}__{option_name}"
+
+        if get_origin(field.type) is Annotated:
+            base_field_type = get_args(field.type)[0]
+            click_conversion_options = next(
+                (
+                    annotation
+                    for annotation in get_args(field.type)
+                    if isinstance(annotation, ClickConversion)
+                ),
+                ClickConversion(),
+            )
+        else:
+            base_field_type = field.type
+            click_conversion_options = ClickConversion()
+
+        if get_origin(base_field_type) is tuple:
+            inner_type = get_args(base_field_type)[0]
+
+            if get_args(base_field_type) == (inner_type, ...):
+                multiple = True
+                nargs = -1
+            else:
+                multiple = False
+                nargs = len(get_args(base_field_type))
+
+            if is_dataclass(inner_type):
+                parameters.extend(
+                    dataclass_to_click_parameters(inner_type, option_name, parent_nargs=True)
+                )
+                continue
+
+            field_type = CLICK_TYPE_MAPPING[inner_type]
+        else:
+            if is_dataclass(base_field_type):
+                parameters.extend(dataclass_to_click_parameters(base_field_type, option_name))
+                continue
+
+            field_type = CLICK_TYPE_MAPPING[base_field_type]
+            if parent_nargs is not None:
+                nargs = parent_nargs
+                multiple = True
+            else:
+                nargs = 1
+                multiple = False
+
+        if click_conversion_options.explicit_click_type is not None:
+            field_type = click_conversion_options.explicit_click_type
+
+        required = field.default is MISSING and field.default_factory is MISSING
+        help_str = get_attribute_docstring(dataclass, field.name)
+        if click_conversion_options.argument:
+            parameter = click.Argument(
+                param_decls=[option_name],
+                type=field_type,
+                nargs=nargs,
+                required=required,
+            )
+        else:
+            parameter = click.Option(
+                param_decls=[f"--{option_name}"],
+                type=field_type,
+                multiple=multiple,
+                required=required,
+                help=help_str,
+            )
+        parameters.append(parameter)
+
+    return tuple(parameters)
+
+
+class CommandTreeClickExecutable(Executable):
+    def __init__(self, command_tree: CommandTree, standalone_mode: bool = True) -> None:
+        self._command_tree = command_tree
+        self._standalone_mode = standalone_mode
+
+    def execute(self) -> None:
+        cli = to_click_commands(self._command_tree)
+        cli(standalone_mode=self._standalone_mode)
diff --git a/rats-devtools/src/python/rats/command_tree/_command_service_tree.py b/rats-devtools/src/python/rats/command_tree/_command_service_tree.py
new file mode 100644
index 00000000..bd510d94
--- /dev/null
+++ b/rats-devtools/src/python/rats/command_tree/_command_service_tree.py
@@ -0,0 +1,56 @@
+from collections.abc import Callable
+from contextlib import AbstractContextManager
+from dataclasses import dataclass
+
+from rats.apps import Container, ServiceId
+
+from ._command_tree import CommandTree
+
+
+@dataclass(frozen=True)
+class CommandServiceTree:
+    """The tree of command services that can be executed."""
+
+    name: str
+    """The name of the command service."""
+
+    description: str
+    """The description of the command service."""
+
+    children: "ServiceId[CommandServiceTree | CommandTree] | None" = None
+    """The children of the command service."""
+
+    kwargs_class: type | None = None
+    """The class that represents the arguments of the command service. If None, the command service has no arguments. Arguments are available to the handler and children."""
+
+    handler: (
+        ServiceId[Callable[..., None] | Callable[..., AbstractContextManager[None]]] | None
+    ) = None
+    """The handler for the command service. If there are children, the ContextManager wraps their execution, otherwise, the Callable is executed before the children are executed."""
+
+    def to_command_tree(self, container: Container) -> "CommandTree":
+        """
+        Convert the CommandServiceTree to a CommandTree.
+
+        Args:
+            container: The container to get the services from.
+
+        Returns:
+            The CommandTree representation of the CommandServiceTree.
+        """
+        return CommandTree(
+            name=self.name,
+            description=self.description,
+            children=(
+                tuple(
+                    child.to_command_tree(container)
+                    if isinstance(child, CommandServiceTree)
+                    else child
+                    for child in container.get_group(self.children)
+                )
+                if self.children is not None
+                else tuple()
+            ),
+            kwargs_class=self.kwargs_class,
+            handler=container.get(self.handler) if self.handler is not None else None,
+        )
diff --git a/rats-devtools/src/python/rats/command_tree/_command_tree.py b/rats-devtools/src/python/rats/command_tree/_command_tree.py
new file mode 100644
index 00000000..5713164a
--- /dev/null
+++ b/rats-devtools/src/python/rats/command_tree/_command_tree.py
@@ -0,0 +1,23 @@
+from collections.abc import Callable
+from contextlib import AbstractContextManager
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class CommandTree:
+    """The tree of commands that can be executed."""
+
+    name: str
+    """The name of the command."""
+
+    description: str
+    """The description of the command."""
+
+    children: tuple["CommandTree", ...] = tuple()
+    """The children of the command."""
+
+    kwargs_class: type | None = None
+    """The class that represents the arguments of the command. If None, the command has no arguments. Arguments are available to the handler and children."""
+
+    handler: Callable[..., None] | Callable[..., AbstractContextManager[None]] | None = None
+    """The handler for the command. If there are children, the ContextManager wraps their execution, otherwise, the Callable is executed before the children are executed."""
diff --git a/rats-devtools/src/python/rats/command_tree/_docstring.py b/rats-devtools/src/python/rats/command_tree/_docstring.py
new file mode 100644
index 00000000..7d8fbd50
--- /dev/null
+++ b/rats-devtools/src/python/rats/command_tree/_docstring.py
@@ -0,0 +1,44 @@
+import inspect
+import re
+from dataclasses import fields, is_dataclass
+
+
+def get_attribute_docstring(dataclass_tpe: type, field_name: str) -> str:
+    """
+    Get the docstring of the attribute from the dataclass.
+
+    Args:
+        dataclass_tpe: The dataclass type.
+        field_name: The name of the field.
+
+    Returns:
+        The docstring of the attribute if present, otherwise an empty string.
+
+    Raises:
+        ValueError: If the attribute is not found in the dataclass.
+    """
+    mro = inspect.getmro(dataclass_tpe)
+    assert is_dataclass(mro[0])
+    assert mro[-1] is object
+    mro = mro[:-1]
+
+    for base_class in mro:
+        if is_dataclass(base_class):
+            for field in fields(base_class):
+                if field.name == field_name:
+                    source = inspect.getsource(base_class)
+
+                    attribute_definition = re.search(rf"{field.name}\s*:", source)
+                    assert attribute_definition is not None
+
+                    try:
+                        docstring_start = source.index('"""', attribute_definition.end())
+                        docstring_end = source.index('"""', docstring_start + 3)
+
+                        return source[docstring_start + 3 : docstring_end]
+                    except ValueError:
+                        return ""
+
+    raise ValueError(
+        f"Attribute {field_name} not found in dataclass {dataclass_tpe.__module__}.{dataclass_tpe.__qualname__}"
+    )
diff --git a/rats-devtools/src/python/rats/command_tree/_ids.py b/rats-devtools/src/python/rats/command_tree/_ids.py
new file mode 100644
index 00000000..cbfd22a5
--- /dev/null
+++ b/rats-devtools/src/python/rats/command_tree/_ids.py
@@ -0,0 +1,20 @@
+from rats import apps
+
+from ._command_service_tree import CommandServiceTree
+from ._command_tree import CommandTree
+
+
+@apps.autoscope
+class CommandTreeGroups:
+    @staticmethod
+    def subcommands(name: str) -> apps.ServiceId[CommandTree | CommandServiceTree]:
+        return apps.ServiceId(f"command-tree-subcommands[{name}]")
+
+
+@apps.autoscope
+class CommandTreeServices:
+    @staticmethod
+    def command(name: str) -> apps.ServiceId[CommandTree | CommandServiceTree]:
+        return apps.ServiceId(f"command-tree[{name}]")
+
+    GROUPS = CommandTreeGroups
diff --git a/rats-devtools/src/python/rats/command_tree/py.typed b/rats-devtools/src/python/rats/command_tree/py.typed
new file mode 100644
index 00000000..e69de29b
diff --git a/rats-devtools/src/python/rats/devtools/__init__.py b/rats-devtools/src/python/rats/devtools/__init__.py
index b7e17b13..e1277b7e 100644
--- a/rats-devtools/src/python/rats/devtools/__init__.py
+++ b/rats-devtools/src/python/rats/devtools/__init__.py
@@ -1,9 +1,5 @@
-from ._app import RatsDevtoolsGroups
-from ._click import ClickCommandGroup, ClickCommandRegistry, command
+"""Some utilities for developing the devtool cli commands."""
 
-__all__ = [
-    "ClickCommandGroup",
-    "ClickCommandRegistry",
-    "command",
-    "RatsDevtoolsGroups",
-]
+from ._ids import AppServices
+
+__all__ = ["AppServices"]
diff --git a/rats-devtools/src/python/rats/devtools/__main__.py b/rats-devtools/src/python/rats/devtools/__main__.py
index 345c0be0..f5d5637f 100644
--- a/rats-devtools/src/python/rats/devtools/__main__.py
+++ b/rats-devtools/src/python/rats/devtools/__main__.py
@@ -1,3 +1,5 @@
+"""rats-devtools provides tooling for building commands that help us develop the rats libraries."""
+
 from ._app import run
 
 if __name__ == "__main__":
diff --git a/rats-devtools/src/python/rats/devtools/_app.py b/rats-devtools/src/python/rats/devtools/_app.py
index 65a373cf..2380d7f6 100644
--- a/rats-devtools/src/python/rats/devtools/_app.py
+++ b/rats-devtools/src/python/rats/devtools/_app.py
@@ -1,43 +1,25 @@
 import logging
-from typing import Any
 
-from rats import apps
+# pyright seems to struggle with this namespace package
+# https://github.com/microsoft/pyright/issues/2882
+from rats import apps as apps
 
-from ._click import ClickCommandGroup, ClickCommandRegistry
-from ._commands import RatsDevtoolsCommands
+from ._cli import DevtoolsCliPlugin
+from ._cli_tree import DevtoolsCliTreePlugin
+from ._ids import AppServices
 
 
-@apps.autoscope
-class RatsDevtoolsServices:
-    CLI = apps.ServiceId[apps.Executable]("cli")
-
-
-class RatsDevtoolsGroups:
-    COMMANDS = apps.ServiceId[ClickCommandRegistry]("commands")
-
-
-class RatsDevtoolsAppContainer(apps.AnnotatedContainer):
-    def get_service_ids(self) -> Any:
-        raise RuntimeError("deprecated method added for backwards compatibility")
-
-    @apps.service(RatsDevtoolsServices.CLI)
-    def cli(self) -> ClickCommandGroup:
-        return ClickCommandGroup(
-            lambda: self.get_group(
-                RatsDevtoolsGroups.COMMANDS,
-            )
-        )
-
-    @apps.group(RatsDevtoolsGroups.COMMANDS)
-    def commands(self) -> RatsDevtoolsCommands:
-        return RatsDevtoolsCommands()
-
+class AppContainer(apps.AnnotatedContainer):
     @apps.container()
     def plugins(self) -> apps.Container:
-        return apps.PluginContainers(self, "rats.devtools.plugins")
+        return apps.CompositeContainer(
+            apps.PluginContainers(self, "rats.devtools.plugins"),
+            DevtoolsCliPlugin(self),
+            DevtoolsCliTreePlugin(self),
+        )
 
 
 def run() -> None:
     logging.basicConfig(level=logging.INFO)
-    container = RatsDevtoolsAppContainer()
-    container.get(RatsDevtoolsServices.CLI).execute()
+    container = AppContainer()
+    container.get(AppServices.CLI_EXE).execute()
diff --git a/rats-devtools/src/python/rats/devtools/_cli.py b/rats-devtools/src/python/rats/devtools/_cli.py
new file mode 100644
index 00000000..3787dfec
--- /dev/null
+++ b/rats-devtools/src/python/rats/devtools/_cli.py
@@ -0,0 +1,30 @@
+import click
+
+from rats import apps, cli
+
+from ._ids import AppServices
+
+
+class DevtoolsCliPlugin(apps.AnnotatedContainer):
+    """
+    Plugin that provides the root cli experience for rats-devtools.
+
+    This package doesn't include any commands on its own, but it provides a plugin for others to
+    create and attach subcommands to the `rats-devtools` command.
+    """
+
+    _app: apps.Container
+
+    def __init__(self, app: apps.Container) -> None:
+        self._app = app
+
+    @apps.service(AppServices.CLI_EXE)
+    def cli_exe(self) -> apps.Executable:
+        return cli.ClickExecutable(
+            command=lambda: click.Group(),
+            plugins=apps.PluginRunner(self._app.get_group(AppServices.GROUPS.CLI_ROOT_PLUGINS)),
+        )
+
+    @apps.group(AppServices.GROUPS.CLI_ROOT_PLUGINS)
+    def root_commands_plugin(self) -> cli.AttachClickCommands:
+        return cli.AttachClickCommands(self._app.get_group(AppServices.GROUPS.CLI_ROOT_COMMANDS))
diff --git a/rats-devtools/src/python/rats/devtools/_cli_tree.py b/rats-devtools/src/python/rats/devtools/_cli_tree.py
new file mode 100644
index 00000000..5fc580d0
--- /dev/null
+++ b/rats-devtools/src/python/rats/devtools/_cli_tree.py
@@ -0,0 +1,30 @@
+from rats import apps
+from rats import command_tree as command_tree
+
+from ._ids import AppServices
+
+
+class DevtoolsCliTreePlugin(apps.AnnotatedContainer):
+    def __init__(self, app: apps.Container) -> None:
+        self._app = app
+
+    # @apps.service(AppServices.CLI_EXE)
+    def command_tree_cli_exe(self) -> apps.Executable:
+        return command_tree.CommandTreeClickExecutable(self._app.get(AppServices.CLI_COMMAND_TREE))
+
+    @apps.service(AppServices.CLI_COMMAND_TREE)
+    def cli_command_tree(self) -> command_tree.CommandTree:
+        return command_tree.CommandTree(
+            name="rats-devtools",
+            description="",
+            children=tuple(
+                (
+                    child.to_command_tree(self)
+                    if isinstance(child, command_tree.CommandServiceTree)
+                    else child
+                )
+                for child in self._app.get_group(
+                    command_tree.CommandTreeServices.GROUPS.subcommands("rats-devtools")
+                )
+            ),
+        )
diff --git a/rats-devtools/src/python/rats/devtools/_click.py b/rats-devtools/src/python/rats/devtools/_click.py
deleted file mode 100644
index 8ac66e6a..00000000
--- a/rats-devtools/src/python/rats/devtools/_click.py
+++ /dev/null
@@ -1,75 +0,0 @@
-from collections.abc import Callable, Iterator
-from functools import partial
-from typing import Any, Protocol
-
-import click
-
-from rats import apps
-
-
-def command(f: Callable[..., None]) -> Callable[..., None]:
-    setattr(f, "__rats_is_command__", True)  # noqa: B010
-    return f
-
-
-class ClickCommandRegistry(Protocol):
-    """Interface for classes that want to add `click` commands to a `click.Group`.
-
-    The default implementation of `register` loops through all the methods in the class, looking
-    for ones with the `__rats_is_command__` property, and adds them to the `click.Group`. The
-    method name is used as the command name, and the docstring is used as the help text on the
-    terminal.
-    """
-
-    def register(self, group: click.Group) -> None:
-        """A sprinkling of introspection to allow class methods to be `click` commands.
-
-        This default implementation loops through all the methods in the class and
-        turns the ones with the `__rats_is_command__` property into `click` commands.
-        The method name is used as the command name, and the docstring is used as the
-        help text on the terminal.
-        """
-
-        def cb(_method_name: str, *args: Any, **kwargs: Any):
-            """Callback handed to `click.Command`, calls the method with matching name on this class.
-
-            When the command is decorated with `@click.params` and `@click.option`, `click` will
-            call this callback with the parameters in the order they were defined. This callback
-            then calls the method with the same name on this class, passing the parameters in
-            reverse order. This is because the method is defined with the parameters in the
-            reverse order to the decorator, so we need to reverse them again to get the correct
-            order.
-            """
-            func = getattr(self, _method_name)
-            func(*args, **kwargs)
-
-        methods = [attr for attr in dir(self) if not attr.startswith("_")]
-        for method_name in methods:
-            method = getattr(self, method_name)
-            if not getattr(method, "__rats_is_command__", False):
-                continue
-
-            params = list(reversed(getattr(method, "__click_params__", [])))
-
-            group.add_command(
-                click.Command(
-                    name=method_name.lower().replace("_", "-").strip("-"),
-                    callback=partial(cb, method_name),
-                    short_help=method.__doc__,
-                    params=params,
-                )
-            )
-
-
-class ClickCommandGroup(apps.Executable):
-    _registries: Callable[[], Iterator[ClickCommandRegistry]]
-
-    def __init__(self, registries: Callable[[], Iterator[ClickCommandRegistry]]) -> None:
-        self._registries = registries
-
-    def execute(self) -> None:
-        cli = click.Group()
-        for registry in self._registries():
-            registry.register(cli)
-
-        cli()
diff --git a/rats-devtools/src/python/rats/devtools/_ids.py b/rats-devtools/src/python/rats/devtools/_ids.py
new file mode 100644
index 00000000..237a3d31
--- /dev/null
+++ b/rats-devtools/src/python/rats/devtools/_ids.py
@@ -0,0 +1,22 @@
+import click
+
+from rats import apps as apps
+from rats import cli as cli
+from rats import command_tree as command_tree
+
+
+@apps.autoscope
+class AppGroups:
+    CLI_ROOT_PLUGINS = apps.ServiceId[cli.ClickGroupPlugin]("cli-plugins[root]")
+    CLI_ROOT_COMMANDS = apps.ServiceId[click.Command]("cli-commands[root]")
+
+    @staticmethod
+    def commands(group: click.Group) -> apps.ServiceId[cli.ClickGroupPlugin]:
+        return apps.ServiceId[cli.ClickGroupPlugin](f"cli-plugins[{group.name}]")
+
+
+@apps.autoscope
+class AppServices:
+    CLI_EXE = apps.ServiceId[apps.Executable]("cli-exe")
+    CLI_COMMAND_TREE = apps.ServiceId[command_tree.CommandTree]("cli-command-tree")
+    GROUPS = AppGroups
diff --git a/rats-devtools/src/python/rats/docs/__init__.py b/rats-devtools/src/python/rats/docs/__init__.py
new file mode 100644
index 00000000..bf646d2a
--- /dev/null
+++ b/rats-devtools/src/python/rats/docs/__init__.py
@@ -0,0 +1 @@
+"""Commands for building the documentation for our components."""
diff --git a/rats-devtools/src/python/rats/docs/_command_tree_plugin.py b/rats-devtools/src/python/rats/docs/_command_tree_plugin.py
new file mode 100644
index 00000000..5541de37
--- /dev/null
+++ b/rats-devtools/src/python/rats/docs/_command_tree_plugin.py
@@ -0,0 +1,36 @@
+# pyright seems to struggle with this namespace package
+# https://github.com/microsoft/pyright/issues/2882
+from rats import apps as apps
+from rats import cli as cli
+from rats import command_tree as command_tree
+from rats import devtools as devtools
+
+from ._command_trees import RatsCiCommandTrees
+
+
+class RatsDocsCommandTreePlugin(apps.AnnotatedContainer):
+    _app: apps.Container
+
+    def __init__(self, app: apps.Container) -> None:
+        self._app = app
+
+    @apps.group(command_tree.CommandTreeServices.GROUPS.subcommands("rats-devtools"))
+    def docs_command_tree(self) -> command_tree.CommandTree:
+        return command_tree.CommandTree(
+            name="docs",
+            description="Commands for managing documentation.",
+            children=tuple(
+                (
+                    child.to_command_tree(self)
+                    if isinstance(child, command_tree.CommandServiceTree)
+                    else child
+                )
+                for child in self._app.get_group(
+                    command_tree.CommandTreeServices.GROUPS.subcommands("rats-devtools docs")
+                )
+            ),
+        )
+
+    @apps.container()
+    def ci_subcommands(self) -> apps.Container:
+        return RatsCiCommandTrees(self._app)
diff --git a/rats-devtools/src/python/rats/docs/_command_trees.py b/rats-devtools/src/python/rats/docs/_command_trees.py
new file mode 100644
index 00000000..b5f80dd1
--- /dev/null
+++ b/rats-devtools/src/python/rats/docs/_command_trees.py
@@ -0,0 +1,230 @@
+import logging
+import subprocess
+import sys
+from os import symlink
+from pathlib import Path
+from shutil import copy, copytree, rmtree
+
+# pyright seems to struggle with this namespace package
+# https://github.com/microsoft/pyright/issues/2882
+from rats import apps as apps
+from rats import command_tree as command_tree
+
+logger = logging.getLogger(__name__)
+
+
+class RatsCiCommandTrees(apps.AnnotatedContainer):
+    _app: apps.Container
+
+    def __init__(self, app: apps.Container) -> None:
+        self._app = app
+
+    @apps.group(command_tree.CommandTreeServices.GROUPS.subcommands("rats-devtools docs"))
+    def mkdocs_serve_command_tree(self) -> command_tree.CommandTree:
+        return command_tree.CommandTree(
+            name="mkdocs-serve",
+            description="Combine our docs across components and run the mkdocs serve command.",
+            handler=lambda: self._do_mkdocs_things("serve"),
+        )
+
+    @apps.group(command_tree.CommandTreeServices.GROUPS.subcommands("rats-devtools docs"))
+    def sphinx_build_command_tree(self) -> command_tree.CommandTree:
+        def sphinx_build() -> None:
+            self._sphinx_apidoc()
+            self._sphinx_markdown()
+
+        return command_tree.CommandTree(
+            name="sphinx-build",
+            description="Build the API documentation for each of the components.",
+            handler=sphinx_build,
+        )
+
+    @apps.group(command_tree.CommandTreeServices.GROUPS.subcommands("rats-devtools docs"))
+    def mkdocs_build_command_tree(self) -> command_tree.CommandTree:
+        return command_tree.CommandTree(
+            name="mkdocs-build",
+            description="Combine our docs across components using mkdocs build.",
+            handler=lambda: self._do_mkdocs_things("build"),
+        )
+
+    @apps.group(command_tree.CommandTreeServices.GROUPS.subcommands("rats-devtools docs"))
+    def build_tutorial_notebooks_command_tree(self) -> command_tree.CommandTree:
+        return command_tree.CommandTree(
+            name="build-tutorial-notebooks",
+            description="Build the tutorial notebooks section of each component's documentation.",
+            handler=self._build_tutorial_notebooks,
+        )
+
+    def _do_mkdocs_things(self, cmd: str) -> None:
+        devtools_path = Path("rats-devtools").resolve()
+        root_docs_path = devtools_path / "src/resources/root-docs"
+        mkdocs_config = devtools_path / "mkdocs.yaml"
+        mkdocs_staging_path = devtools_path / "dist/docs"
+        site_dir_path = devtools_path / "dist/site"
+        mkdocs_staging_config = devtools_path / "dist/mkdocs.yaml"
+        # clear any stale state
+        rmtree(mkdocs_staging_path, ignore_errors=True)
+
+        # start with the contents of our root-docs
+        copytree(root_docs_path, mkdocs_staging_path)
+
+        components = [
+            "rats-apps",
+            "rats-devtools",
+            "rats-pipelines",
+            "rats-processors",
+        ]
+
+        for c in components:
+            component_docs_path = Path(c).resolve() / "docs"
+            symlink(component_docs_path, mkdocs_staging_path / c)
+
+        # replace the mkdocs config with a fresh version
+        mkdocs_staging_config.unlink(missing_ok=True)
+        copy(mkdocs_config, mkdocs_staging_config)
+
+        args = [
+            "--config-file",
+            str(mkdocs_staging_config),
+        ]
+        if cmd == "build":
+            args.extend(["--site-dir", str(site_dir_path.resolve())])
+
+        try:
+            subprocess.run(
+                [
+                    "poetry",
+                    "run",
+                    "mkdocs",
+                    cmd,
+                    *args,
+                ],
+                cwd=devtools_path,
+                check=True,
+            )
+        except subprocess.CalledProcessError as e:
+            sys.exit(e.returncode)
+
+    def _sphinx_apidoc(self) -> None:
+        components = [
+            "rats-apps",
+            "rats-devtools",
+            "rats-pipelines",
+            "rats-processors",
+        ]
+        sphinx_resources_path = Path("rats-devtools/src/resources/sphinx-docs").resolve()
+
+        for c in components:
+            apidoc_path = Path(f"{c}/dist/sphinx-apidoc").resolve()
+            rmtree(apidoc_path, ignore_errors=True)
+            copytree(sphinx_resources_path, apidoc_path)
+
+            sphinx_command = [
+                "poetry",
+                "run",
+                "sphinx-apidoc",
+                "--doc-project",
+                "rats",
+                "--tocfile",
+                "index",
+                "--implicit-namespaces",
+                "--module-first",
+                "--force",
+                "--output-dir",
+                str(apidoc_path),
+                "--templatedir",
+                str(apidoc_path / "_templates"),
+                "src/python/rats",
+            ]
+            try:
+                subprocess.run(sphinx_command, cwd=c, check=True)
+            except subprocess.CalledProcessError as e:
+                sys.exit(e.returncode)
+
+    def _sphinx_markdown(self) -> None:
+        components = [
+            "rats-apps",
+            "rats-devtools",
+            "rats-pipelines",
+            "rats-processors",
+        ]
+
+        for c in components:
+            rmtree(f"{c}/dist/sphinx-markdown", ignore_errors=True)
+            sphinx_command = [
+                "poetry",
+                "run",
+                "sphinx-build",
+                "-M",
+                "markdown",
+                "dist/sphinx-apidoc",
+                "dist/sphinx-markdown",
+            ]
+            try:
+                subprocess.run(sphinx_command, cwd=c, check=True)
+            except subprocess.CalledProcessError as e:
+                sys.exit(e.returncode)
+
+            copytree(
+                f"{c}/dist/sphinx-markdown/markdown",
+                f"{c}/docs/api",
+                dirs_exist_ok=True,
+            )
+
+    def _build_tutorial_notebooks(self) -> None:
+        """
+        Build the tutorial notebooks section of each component's documentation.
+
+        Converts each *.py jupytext file in the component's docs/_tutorial_notebook_sources
+        folder into a markdown notebook in the component's docs/_tutorial_notebooks folder.
+        """
+        components = [
+            # "rats-apps",
+            # "rats-devtools",
+            # "rats-pipelines",
+            "rats-processors",
+            "rats-examples-sklearn",
+        ]
+        nb_convert_templates_path = Path(
+            "rats-devtools/src/resources/nbconvert-templates"
+        ).resolve()
+
+        commands = [
+            "poetry run jupytext --to ipynb *.py".split(),
+            f"poetry run jupyter nbconvert *.ipynb --to markdown --execute --template=mdoutput --TemplateExporter.extra_template_basedirs={nb_convert_templates_path}".split(),
+        ]
+
+        for c in components:
+            logger.info("Building notebooks for %s", c)
+            jupytext_sources_path = Path(f"{c}/docs/_tutorial_notebook_sources").resolve()
+            notebooks_target_path = Path(f"{c}/docs/_tutorial_notebooks").resolve()
+            rmtree(notebooks_target_path, ignore_errors=True)
+            notebooks_target_path.mkdir(parents=True, exist_ok=True)
+            source_file_names = [f.stem for f in jupytext_sources_path.glob("*.py")]
+
+            # symlink the jupytext files to the target path
+            for file_name in source_file_names:
+                (jupytext_sources_path / f"{file_name}.py").link_to(
+                    notebooks_target_path / f"{file_name}.py"
+                )
+
+            for cmd in commands:
+                try:
+                    subprocess.run(cmd, cwd=notebooks_target_path, check=True)
+                except subprocess.CalledProcessError as e:
+                    sys.exit(e.returncode)
+
+            for file_name in source_file_names:
+                # delete the .py symlink
+                (notebooks_target_path / f"{file_name}.py").unlink()
+                # delete the .ipynb file
+                (notebooks_target_path / f"{file_name}.ipynb").unlink()
+                # add the notebook to the .pages file
+
+            # add a readmd.md file to the target path saying this folder is autogenerated
+            source_rel_to_target = "../_tutorial_notebook_sources"
+            with (notebooks_target_path / "readme.md").open("w") as f:
+                f.write(
+                    f"This folder is autogenerated from the files in {source_rel_to_target} "
+                    + "using\n```bash\nrats-devtools.pipx build-tutorial-notebooks\n```\n"
+                )
diff --git a/rats-devtools/src/python/rats/devtools/_commands.py b/rats-devtools/src/python/rats/docs/_commands.py
similarity index 60%
rename from rats-devtools/src/python/rats/devtools/_commands.py
rename to rats-devtools/src/python/rats/docs/_commands.py
index 673b5d00..b0026f68 100644
--- a/rats-devtools/src/python/rats/devtools/_commands.py
+++ b/rats-devtools/src/python/rats/docs/_commands.py
@@ -5,46 +5,101 @@
 from pathlib import Path
 from shutil import copy, copytree, rmtree
 
-import click
-
-from ._click import ClickCommandRegistry, command
+# pyright seems to struggle with this namespace package
+# https://github.com/microsoft/pyright/issues/2882
+from rats import cli
 
 logger = logging.getLogger(__name__)
 
 
-class RatsDevtoolsCommands(ClickCommandRegistry):
-    @command
-    @click.argument("component_path", type=click.Path(exists=True, file_okay=False))
-    def install(self, component_path: str) -> None:
-        """Build the documentation site for one of the components in this project."""
-        p = Path(component_path)
-        pyproject_path = p / "pyproject.toml"
+class RatsCiCommands(cli.CommandContainer):
+    @cli.command(cli.CommandId.auto())
+    def mkdocs_serve(self) -> None:
+        """Combine our docs across components and run the mkdocs serve command."""
+        self._do_mkdocs_things("serve")
+
+    @cli.command(cli.CommandId.auto())
+    def sphinx_build(self) -> None:
+        """Build the API documentation for each of the components."""
+        self._sphinx_apidoc()
+        self._sphinx_markdown()
+
+    @cli.command(cli.CommandId.auto())
+    def mkdocs_build(self) -> None:
+        """Combine our docs across components using mkdocs build."""
+        self._do_mkdocs_things("build")
+
+    @cli.command(cli.CommandId.auto())
+    def build_tutorial_notebooks(self) -> None:
+        """
+        Build the tutorial notebooks section of each component's documentation.
+
+        Converts each *.py jupytext file in the component's docs/_tutorial_notebook_sources
+        folder into a markdown notebook in the component's docs/_tutorial_notebooks folder.
+        """
+        self._build_tutorial_notebooks()
+
+    def _do_mkdocs_things(self, cmd: str) -> None:
+        devtools_path = Path("rats-devtools").resolve()
+        root_docs_path = devtools_path / "src/resources/root-docs"
+        mkdocs_config = devtools_path / "mkdocs.yaml"
+        mkdocs_staging_path = devtools_path / "dist/docs"
+        site_dir_path = devtools_path / "dist/site"
+        mkdocs_staging_config = devtools_path / "dist/mkdocs.yaml"
+        # clear any stale state
+        rmtree(mkdocs_staging_path, ignore_errors=True)
+
+        # start with the contents of our root-docs
+        copytree(root_docs_path, mkdocs_staging_path)
+
+        components = [
+            "rats-apps",
+            "rats-devtools",
+            "rats-pipelines",
+            "rats-processors",
+        ]
+
+        for c in components:
+            component_docs_path = Path(c).resolve() / "docs"
+            symlink(component_docs_path, mkdocs_staging_path / c)
+
+        # replace the mkdocs config with a fresh version
+        mkdocs_staging_config.unlink(missing_ok=True)
+        copy(mkdocs_config, mkdocs_staging_config)
 
-        if not p.is_dir() or not pyproject_path.is_file():
-            raise ValueError(f"component {component_path} does not exist")
+        args = [
+            "--config-file",
+            str(mkdocs_staging_config),
+        ]
+        if cmd == "build":
+            args.extend(["--site-dir", str(site_dir_path.resolve())])
 
         try:
-            subprocess.run(["poetry", "install"], cwd=component_path, check=True)
+            subprocess.run(
+                [
+                    "poetry",
+                    "run",
+                    "mkdocs",
+                    cmd,
+                    *args,
+                ],
+                cwd=devtools_path,
+                check=True,
+            )
         except subprocess.CalledProcessError as e:
             sys.exit(e.returncode)
 
-    @command
-    def build_api_docs(self) -> None:
-        """Build the API documentation for each of the components."""
-        self._sphinx_apidoc()
-        self._sphinx_markdown()
-
     def _sphinx_apidoc(self) -> None:
         components = [
-            # "rats-apps",
+            "rats-apps",
             "rats-devtools",
             "rats-pipelines",
             "rats-processors",
         ]
+        sphinx_resources_path = Path("rats-devtools/src/resources/sphinx-docs").resolve()
 
         for c in components:
             apidoc_path = Path(f"{c}/dist/sphinx-apidoc").resolve()
-            sphinx_resources_path = Path("rats-devtools/src/resources/sphinx-docs").resolve()
             rmtree(apidoc_path, ignore_errors=True)
             copytree(sphinx_resources_path, apidoc_path)
 
@@ -72,7 +127,7 @@ def _sphinx_apidoc(self) -> None:
 
     def _sphinx_markdown(self) -> None:
         components = [
-            # "rats-apps",
+            "rats-apps",
             "rats-devtools",
             "rats-pipelines",
             "rats-processors",
@@ -100,9 +155,9 @@ def _sphinx_markdown(self) -> None:
                 dirs_exist_ok=True,
             )
 
-    @command
-    def build_tutorial_notebooks(self) -> None:
-        """Build the tutorial notebooks section of each component's documentation.
+    def _build_tutorial_notebooks(self) -> None:
+        """
+        Build the tutorial notebooks section of each component's documentation.
 
         Converts each *.py jupytext file in the component's docs/_tutorial_notebook_sources
         folder into a markdown notebook in the component's docs/_tutorial_notebooks folder.
@@ -157,154 +212,3 @@ def build_tutorial_notebooks(self) -> None:
                     f"This folder is autogenerated from the files in {source_rel_to_target} "
                     + "using\n```bash\nrats-devtools.pipx build-tutorial-notebooks\n```\n"
                 )
-
-    @command
-    def mkdocs_serve(self) -> None:
-        """Combine our docs across components and run the mkdocs serve command."""
-        self._do_mkdocs_things("serve")
-
-    @command
-    def mkdocs_build(self) -> None:
-        """Combine our docs across components using mkdocs build."""
-        self._do_mkdocs_things("build")
-
-    def _do_mkdocs_things(self, cmd: str) -> None:
-        devtools_path = Path("rats-devtools").resolve()
-        root_docs_path = devtools_path / "src/resources/root-docs"
-        mkdocs_config = devtools_path / "mkdocs.yaml"
-        mkdocs_staging_path = devtools_path / "dist/docs"
-        site_dir_path = devtools_path / "dist/site"
-        mkdocs_staging_config = devtools_path / "dist/mkdocs.yaml"
-        # clear any stale state
-        rmtree(mkdocs_staging_path, ignore_errors=True)
-
-        # start with the contents of our root-docs
-        copytree(root_docs_path, mkdocs_staging_path)
-
-        components = [
-            "rats-apps",
-            "rats-devtools",
-            "rats-pipelines",
-            "rats-processors",
-            "rats-examples-sklearn",
-        ]
-
-        for c in components:
-            component_docs_path = Path(c).resolve() / "docs"
-            symlink(component_docs_path, mkdocs_staging_path / c)
-
-        # replace the mkdocs config with a fresh version
-        mkdocs_staging_config.unlink(missing_ok=True)
-        copy(mkdocs_config, mkdocs_staging_config)
-
-        args = [
-            "--config-file",
-            str(mkdocs_staging_config),
-        ]
-        if cmd == "build":
-            args.extend(["--site-dir", str(site_dir_path.resolve())])
-
-        try:
-            subprocess.run(
-                [
-                    "poetry",
-                    "run",
-                    "mkdocs",
-                    cmd,
-                    *args,
-                ],
-                cwd=devtools_path,
-                check=True,
-            )
-        except subprocess.CalledProcessError as e:
-            sys.exit(e.returncode)
-
-    @command
-    @click.argument("component_path", type=click.Path(exists=True, file_okay=False))
-    def build_docs(self, component_path: str) -> None:
-        """Build the documentation site for one of the components in this project."""
-        p = Path(component_path)
-        pyproject_path = p / "pyproject.toml"
-        site_dir_path = p / "dist/site"
-
-        if not p.is_dir() or not pyproject_path.is_file():
-            raise ValueError(f"component {component_path} does not exist")
-
-        try:
-            subprocess.run(
-                [
-                    "poetry",
-                    "run",
-                    "mkdocs",
-                    "build",
-                    "--site-dir",
-                    str(site_dir_path.resolve()),
-                ],
-                cwd=component_path,
-                check=True,
-            )
-        except subprocess.CalledProcessError as e:
-            sys.exit(e.returncode)
-
-    @command
-    @click.argument("component_path", type=click.Path(exists=True, file_okay=False))
-    def build_wheel(self, component_path: str) -> None:
-        """Build the python wheel for one of the components in this project."""
-        p = Path(component_path)
-        pyproject_path = p / "pyproject.toml"
-
-        if not p.is_dir() or not pyproject_path.is_file():
-            raise ValueError(f"component {component_path} does not exist")
-
-        try:
-            subprocess.run(["poetry", "build", "-f", "wheel"], cwd=component_path, check=True)
-        except subprocess.CalledProcessError as e:
-            sys.exit(e.returncode)
-
-    @command
-    @click.argument("component_path", type=click.Path(exists=True, file_okay=False))
-    @click.argument("repository_name", type=str)
-    def publish_wheel(self, component_path: str, repository_name: str) -> None:
-        """Publish the python wheel for one of the components in this project."""
-        p = Path(component_path)
-        pyproject_path = p / "pyproject.toml"
-
-        if not p.is_dir() or not pyproject_path.is_file():
-            raise ValueError(f"component {component_path} does not exist")
-
-        try:
-            subprocess.run(
-                [
-                    "poetry",
-                    "publish",
-                    "--repository",
-                    repository_name,
-                    "--no-interaction",
-                    # temporarily skip existing during testing
-                    "--skip-existing",
-                ],
-                cwd=component_path,
-                check=True,
-            )
-        except subprocess.CalledProcessError as e:
-            sys.exit(e.returncode)
-
-    @command
-    @click.argument("component_path", type=click.Path(exists=True, file_okay=False))
-    def test(self, component_path: str) -> None:
-        """Build the python wheel for one of the components in this project."""
-        p = Path(component_path)
-        pyproject_path = p / "pyproject.toml"
-
-        if not p.is_dir() or not pyproject_path.is_file():
-            raise ValueError(f"component {component_path} does not exist")
-
-        try:
-            subprocess.run(["poetry", "run", "pytest"], cwd=component_path, check=True)
-        except subprocess.CalledProcessError as e:
-            sys.exit(e.returncode)
-
-    @command
-    def ping(self) -> None:
-        """No-op used for testing."""
-        print("pong")
diff --git a/rats-devtools/src/python/rats/docs/_ids.py b/rats-devtools/src/python/rats/docs/_ids.py
new file mode 100644
index 00000000..41094928
--- /dev/null
+++ b/rats-devtools/src/python/rats/docs/_ids.py
@@ -0,0 +1,10 @@
+import click
+
+from rats import apps
+
+
+@apps.autoscope
+class PluginServices:
+    @staticmethod
+    def command(name: str) -> apps.ServiceId[click.Command]:
+        return apps.ServiceId(f"cli-commands[{name}]")
diff --git a/rats-devtools/src/python/rats/docs/_plugin.py b/rats-devtools/src/python/rats/docs/_plugin.py
new file mode 100644
index 00000000..8a9e8fdf
--- /dev/null
+++ b/rats-devtools/src/python/rats/docs/_plugin.py
@@ -0,0 +1,25 @@
+import click
+
+# pyright seems to struggle with this namespace package
+# https://github.com/microsoft/pyright/issues/2882
+from rats import apps as apps
+from rats import cli as cli
+from rats import devtools as devtools
+
+from ._commands import RatsCiCommands
+
+
+class RatsDocsPlugin(apps.AnnotatedContainer):
+    _app: apps.Container
+
+    def __init__(self, app: apps.Container) -> None:
+        self._app = app
+
+    @apps.group(devtools.AppServices.GROUPS.CLI_ROOT_PLUGINS)
+    def docs_command(self) -> cli.AttachClickGroup:
+        return cli.AttachClickGroup(
+            group=lambda: click.Group("docs"),
+            plugins=apps.PluginRunner(
+                iter([RatsCiCommands()]),
+            ),
+        )
diff --git a/rats-devtools/src/python/rats/docs/py.typed b/rats-devtools/src/python/rats/docs/py.typed
new file mode 100644
index 00000000..e69de29b
diff --git a/rats-devtools/src/python/rats/pycharm/__init__.py b/rats-devtools/src/python/rats/pycharm/__init__.py
index e69de29b..6acf7db5 100644
--- a/rats-devtools/src/python/rats/pycharm/__init__.py
+++ b/rats-devtools/src/python/rats/pycharm/__init__.py
@@ -0,0 +1 @@
+"""Convenience commands that can be used within Pycharm."""
diff --git a/rats-devtools/src/python/rats/pycharm/__main__.py b/rats-devtools/src/python/rats/pycharm/__main__.py
deleted file mode 100644
index 345c0be0..00000000
--- a/rats-devtools/src/python/rats/pycharm/__main__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from ._app import run
-
-if __name__ == "__main__":
-    run()
diff --git a/rats-devtools/src/python/rats/pycharm/_app.py b/rats-devtools/src/python/rats/pycharm/_app.py
deleted file mode 100644
index fd92c527..00000000
--- a/rats-devtools/src/python/rats/pycharm/_app.py
+++ /dev/null
@@ -1,37 +0,0 @@
-from rats import apps, devtools  # type: ignore[reportAttributeAccessIssue]
-
-from ._commands import RatsPycharmCommands
-
-
-@apps.autoscope
-class RatsPycharmServices:
-    CLI = apps.ServiceId[apps.Executable]("cli")
-
-
-class RatsPycharmGroups:
-    COMMANDS = apps.ServiceId[devtools.ClickCommandRegistry]("pycharm-commands")
-
-
-class RatsPycharmPlugin(apps.AnnotatedContainer):
-    _app: apps.Container
-
-    def __init__(self, app: apps.Container) -> None:
-        self._app = app
-
-    @apps.service(RatsPycharmServices.CLI)
-    def cli(self) -> apps.Executable:
-        return devtools.ClickCommandGroup(
-            lambda: self._app.get_group(
-                RatsPycharmGroups.COMMANDS,
-            )
-        )
-
-    @apps.group(devtools.RatsDevtoolsGroups.COMMANDS)
-    @apps.group(RatsPycharmGroups.COMMANDS)
-    def commands(self) -> RatsPycharmCommands:
-        return RatsPycharmCommands()
-
-
-def run() -> None:
-    app = apps.AppContainer(lambda app: RatsPycharmPlugin(app))
-    app.get(RatsPycharmServices.CLI).execute()
diff --git a/rats-devtools/src/python/rats/pycharm/_command_tree_plugin.py b/rats-devtools/src/python/rats/pycharm/_command_tree_plugin.py
new file mode 100644
index 00000000..db95adab
--- /dev/null
+++ b/rats-devtools/src/python/rats/pycharm/_command_tree_plugin.py
@@ -0,0 +1,65 @@
+from dataclasses import dataclass
+from typing import Annotated
+
+import click
+
+# pyright seems to struggle with this namespace package
+# https://github.com/microsoft/pyright/issues/2882
+from rats import apps as apps
+from rats import cli as cli
+from rats import command_tree as command_tree
+from rats import devtools as devtools
+
+from ._formatter import FileFormatter, FileFormatterRequest
+
+
+@dataclass(frozen=True)
+class AutoformatterArgs:
+    """Arguments for the autoformatter command."""
+
+    filename: Annotated[
+        str,
+        command_tree.ClickConversion(
+            argument=True,
+            explicit_click_type=click.Path(exists=True, file_okay=True, dir_okay=False),
+        ),
+    ]
+    """The filename to format."""
+
+
+class RatsPycharmCommandTreePlugin(apps.AnnotatedContainer):
+    _app: apps.Container
+
+    def __init__(self, app: apps.Container) -> None:
+        self._app = app
+
+    @apps.group(command_tree.CommandTreeServices.GROUPS.subcommands("rats-devtools"))
+    def pycharm_command_tree(self) -> command_tree.CommandTree:
+        return command_tree.CommandTree(
+            name="pycharm",
+            description="Commands for managing PyCharm configuration.",
+            children=tuple(
+                (
+                    child.to_command_tree(self)
+                    if isinstance(child, command_tree.CommandServiceTree)
+                    else child
+                )
+                for child in self._app.get_group(
+                    command_tree.CommandTreeServices.GROUPS.subcommands("rats-devtools pycharm")
+                )
+            ),
+        )
+
+    @apps.group(command_tree.CommandTreeServices.GROUPS.subcommands("rats-devtools pycharm"))
+    def apply_auto_formatters_command_tree(self) -> command_tree.CommandTree:
+        def handler(autoformatter_args: AutoformatterArgs) -> None:
+            formatter = FileFormatter(
+                request=lambda: FileFormatterRequest(autoformatter_args.filename)
+            )
+            formatter.execute()
+
+        return command_tree.CommandTree(
+            name="apply-auto-formatters",
+            description="Apply auto formatters to a file.",
+            handler=handler,
+        )
diff --git a/rats-devtools/src/python/rats/pycharm/_commands.py b/rats-devtools/src/python/rats/pycharm/_commands.py
index a6b846e7..94715cbc 100644
--- a/rats-devtools/src/python/rats/pycharm/_commands.py
+++ b/rats-devtools/src/python/rats/pycharm/_commands.py
@@ -1,40 +1,17 @@
-import subprocess
-import sys
-from pathlib import Path
-
+# type: ignore
 import click
 
-from rats import devtools
-
-
-class RatsPycharmCommands(devtools.ClickCommandRegistry):
-    @devtools.command
-    @click.argument("filename", type=click.Path(exists=True, file_okay=True, dir_okay=False))
-    def pycharm_actions_on_save(self, filename: str) -> None:
-        """Build the python wheel for one of the components in this project."""
-        component_path = Path(filename.split("/")[0])
-        relative_file = "/".join(filename.split("/")[1:])
-        pyproject_path = Path(f"{component_path}/pyproject.toml")
-
-        if not pyproject_path.is_file():
-            raise ValueError("does not seem to be running within repo root")
+from rats import cli
 
-        poetry_commands = [
-            ["ruff", "check", "--fix", "--unsafe-fixes", str(relative_file)],
-            ["ruff", "format", str(relative_file)],
-        ]
+from ._formatter import FileFormatter, FileFormatterRequest
 
-        try:
-            for cmd in poetry_commands:
-                subprocess.run(
-                    ["poetry", "run", *cmd],
-                    check=True,
-                    cwd=component_path,
-                )
-        except subprocess.CalledProcessError as e:
-            sys.exit(e.returncode)
 
-    @devtools.command
-    def ping(self) -> None:
-        """No-op used for testing."""
-        print("pong")
+class PycharmCommands(cli.CommandContainer):
+    @cli.command(cli.CommandId.auto())
+    @click.argument(
+        "filename",
+        type=click.Path(exists=True, file_okay=True, dir_okay=True),
+    )
+    def apply_auto_formatters(self, filename: str) -> None:
+        formatter = FileFormatter(request=lambda: FileFormatterRequest(filename))
+        formatter.execute()
diff --git a/rats-devtools/src/python/rats/pycharm/_formatter.py b/rats-devtools/src/python/rats/pycharm/_formatter.py
new file mode 100644
index 00000000..a048e12e
--- /dev/null
+++ b/rats-devtools/src/python/rats/pycharm/_formatter.py
@@ -0,0 +1,51 @@
+import subprocess
+import sys
+from pathlib import Path
+
+from typing_extensions import NamedTuple
+
+from rats import apps
+
+
+class FileFormatterRequest(NamedTuple):
+    filename: str
+
+
+class FileFormatter(apps.Executable):
+    _request: apps.ConfigProvider[FileFormatterRequest]
+
+    def __init__(self, request: apps.ConfigProvider[FileFormatterRequest]) -> None:
+        self._request = request
+
+    def execute(self) -> None:
+        req = self._request()
+        filename = req.filename
+
+        if filename.startswith("src/"):
+            # only other place this command is allowed is in the devtools component.
+            component_path = Path()
+            relative_file = filename
+            pyproject_path = Path("pyproject.toml")
+        else:
+            component_path = Path(filename.split("/")[0])
+            relative_file = "/".join(filename.split("/")[1:])
+            pyproject_path = Path(f"{component_path}/pyproject.toml")
+
+        if not pyproject_path.is_file():
+            raise ValueError("does not seem to be running within repo root")
+
+        poetry_commands = [
+            ["ruff", "check", "--fix", "--unsafe-fixes", str(relative_file)],
+            ["ruff", "format", str(relative_file)],
+        ]
+
+        try:
+            for cmd in poetry_commands:
+                subprocess.run(
+                    ["poetry", "run", *cmd],
+                    check=True,
+                    cwd=component_path,
+                )
+        except subprocess.CalledProcessError:
+            # We exit successfully so pycharm doesn't auto-disable our hook :(
+            sys.exit(0)
diff --git a/rats-devtools/src/python/rats/pycharm/_plugin.py b/rats-devtools/src/python/rats/pycharm/_plugin.py
new file mode 100644
index 00000000..f743548e
--- /dev/null
+++ b/rats-devtools/src/python/rats/pycharm/_plugin.py
@@ -0,0 +1,39 @@
+import click
+
+# pyright seems to struggle with this namespace package
+# https://github.com/microsoft/pyright/issues/2882
+from rats import apps as apps
+from rats import cli as cli
+from rats import devtools as devtools
+
+from ._commands import PycharmCommands
+
+
+@apps.autoscope
+class PluginGroups:
+    PYCHARM_COMMAND_PLUGINS = apps.ServiceId[cli.ClickGroupPlugin]("cli-plugins[pycharm]")
+
+
+@apps.autoscope
+class PluginServices:
+    @staticmethod
+    def command(name: str) -> apps.ServiceId[click.Command]:
+        return apps.ServiceId(f"cli-commands[{name}]")
+
+    GROUPS = PluginGroups
+
+
+class RatsPycharmPlugin(apps.AnnotatedContainer):
+    _app: apps.Container
+
+    def __init__(self, app: apps.Container) -> None:
+        self._app = app
+
+    @apps.group(devtools.AppServices.GROUPS.CLI_ROOT_PLUGINS)
+    def pycharm_command(self) -> cli.ClickGroupPlugin:
+        return cli.AttachClickGroup(
+            group=lambda: click.Group("pycharm"),
+            plugins=apps.PluginRunner(
+                iter([PycharmCommands()]),
+            ),
+        )
diff --git a/rats-devtools/test/python/rats_test/cli/__init__.py b/rats-devtools/test/python/rats_test/cli/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/rats-devtools/test/python/rats_test/cli/py.typed b/rats-devtools/test/python/rats_test/cli/py.typed
new file mode 100644
index 00000000..e69de29b
diff --git a/rats-devtools/test/python/rats_test/cli/test_groups.py b/rats-devtools/test/python/rats_test/cli/test_groups.py
new file mode 100644
index 00000000..e69de29b
diff --git a/rats-devtools/test/python/rats_test/cli/test_provider.py b/rats-devtools/test/python/rats_test/cli/test_provider.py
new file mode 100644
index 00000000..161a05ed
--- /dev/null
+++ b/rats-devtools/test/python/rats_test/cli/test_provider.py
@@ -0,0 +1,31 @@
+from unittest.mock import create_autospec
+
+import click
+import pytest
+
+from rats.cli import ClickCommandMapper
+
+
+def test_command_provider_get_command():
+    mock_command = create_autospec(spec=click.Command, instance=True)
+    command_provider = ClickCommandMapper(commands={"test": lambda: mock_command})
+    assert command_provider.get("test") == mock_command
+
+
+def test_command_provider_get_command_not_found():
+    command_provider = ClickCommandMapper(commands={})
+    with pytest.raises(ValueError):
+        command_provider.get("nonexistent")
+
+
+# def test_lazy_click_group_get_command():
+#     mock_command = create_autospec(spec=click.Command, instance=True)
+#     command_provider = ClickCommandMapper(commands={"test": lambda: mock_command})
+#     lazy_group = ClickCommandGroup(name="test_group", provider=command_provider)
+#     assert lazy_group.get_command(click.Context(lazy_group), "test") == mock_command
+#
+#
+# def test_lazy_click_group_list_commands():
+#     command_provider = ClickCommandMapper(commands={"test": lambda: click.Command(name="test")})
+#     lazy_group = ClickCommandGroup(name="test_group", provider=command_provider)
+#     assert lazy_group.list_commands(click.Context(lazy_group)) == ["test"]
diff --git a/rats-devtools/test/python/rats_test/command_tree/__init__.py b/rats-devtools/test/python/rats_test/command_tree/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/rats-devtools/test/python/rats_test/command_tree/_helpers.py b/rats-devtools/test/python/rats_test/command_tree/_helpers.py
new file mode 100644
index 00000000..d656aa6f
--- /dev/null
+++ b/rats-devtools/test/python/rats_test/command_tree/_helpers.py
@@ -0,0 +1,15 @@
+from typing import Any
+
+import click
+
+
+class ProgrammaticExecutionGroup(click.Group):
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        """Alias for :meth:`main`."""
+        return self.main(*args, standalone_mode=False, **kwargs)
+
+
+class ProgrammaticExecutionCommand(click.Command):
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        """Alias for :meth:`main`."""
+        return self.main(*args, standalone_mode=False, **kwargs)
diff --git a/rats-devtools/test/python/rats_test/command_tree/py.typed b/rats-devtools/test/python/rats_test/command_tree/py.typed
new file mode 100644
index 00000000..e69de29b
diff --git a/rats-devtools/test/python/rats_test/command_tree/test_click.py b/rats-devtools/test/python/rats_test/command_tree/test_click.py
new file mode 100644
index 00000000..162d9162
--- /dev/null
+++ b/rats-devtools/test/python/rats_test/command_tree/test_click.py
@@ -0,0 +1,178 @@
+from dataclasses import dataclass
+from unittest import mock
+
+import click
+
+from rats.command_tree import (
+    CommandTree,
+    dataclass_to_click_parameters,
+    to_click_commands,
+)
+
+
+@dataclass
+class MockArguments:
+    """MockArguments description."""
+
+    arg1: str
+    """The first argument."""
+
+    arg2: int
+    """The second argument."""
+
+
+@dataclass
+class NestedMockArguments:
+    """NestedMockArguments description."""
+
+    nested_arg: MockArguments
+    """Nested argument dataclass."""
+
+
+def test_dataclass_to_click_arguments_flat():
+    arguments = dataclass_to_click_parameters(MockArguments)
+    assert len(arguments) == 2, "There should be two click arguments."
+    assert arguments[0].name == "arg1", "The first argument name should be 'arg1'."
+    assert arguments[1].name == "arg2", "The second argument name should be 'arg2'."
+
+
+def test_dataclass_to_click_arguments_nested():
+    arguments = dataclass_to_click_parameters(NestedMockArguments)
+    assert len(arguments) == 2, "There should be two click arguments for the nested dataclass."
+    assert (
+        arguments[0].name == "nested_arg__arg1"
+    ), "The nested first argument name should be 'nested_arg__arg1'."
+    assert (
+        arguments[1].name == "nested_arg__arg2"
+    ), "The nested second argument name should be 'nested_arg__arg2'."
+
+
+@dataclass
+class MockTupleArguments:
+    """MockTupleArguments description."""
+
+    arg1: tuple[int, ...]
+    """A tuple argument."""
+
+
+def test_dataclass_to_click_arguments_tuple():
+    arguments = dataclass_to_click_parameters(MockTupleArguments)
+    assert len(arguments) == 1, "There should be one click argument for the tuple field."
+    assert arguments[0].name == "arg1", "The tuple argument name should be 'arg1'."
+    assert (
+        arguments[0].type is click.INT
+    ), "The tuple argument should be of type click.types.Tuple."
+    assert arguments[0].multiple is True, "The tuple argument should have 'multiple' set to True."
+
+
+@dataclass
+class MockNestedTupleArguments:
+    """MockNestedTupleArguments description."""
+
+    arg1: tuple[MockArguments, ...]
+    """A tuple of MockArguments."""
+
+
+def test_dataclass_to_click_arguments_nested_tuple():
+    arguments = dataclass_to_click_parameters(MockNestedTupleArguments)
+    assert len(arguments) == 2, "There should be two click arguments for the nested tuple field."
+    assert (
+        arguments[0].name == "arg1__arg1"
+    ), "The nested tuple first argument name should be 'arg1__arg1'."
+    assert (
+        arguments[1].name == "arg1__arg2"
+    ), "The nested tuple second argument name should be 'arg1__arg2'."
+    assert (
+        arguments[0].type is click.STRING
+    ), "The nested tuple first argument should be of type click.types.Tuple."
+    assert (
+        arguments[1].type is click.INT
+    ), "The nested tuple second argument should be of type click.types.Tuple."
+    assert (
+        arguments[0].multiple is True
+    ), "The nested tuple first argument should have 'multiple' set to True."
+    assert (
+        arguments[1].multiple is True
+    ), "The nested tuple second argument should have 'multiple' set to True."
+
+
+def test_to_click_commands_leaf_node():
+    def test_handler():
+        click.echo("Handler executed")
+
+    command_tree = CommandTree(name="test", description="Test command", handler=test_handler)
+    click_command = to_click_commands(command_tree)
+    assert isinstance(
+        click_command, click.Command
+    ), "The result should be a click.Command instance"
+    assert click_command.name == "test", "The command name should be 'test'"
+    assert click_command.help == "Test command", "The command help should be 'Test command'"
+    assert click_command.callback is not None, "The command should have a callback"
+    assert (
+        click_command.callback.__qualname__
+        == "test_to_click_commands_leaf_node.<locals>.test_handler"
+    ), "The callback should have the same name as the wrapped function"
+    assert (
+        click_command.callback.__wrapped__ == test_handler  # type: ignore
+    ), "The command callback should wrap the test_handler function"
+
+
+def test_to_click_commands_with_children():
+    def test_handler():
+        click.echo("Handler executed")
+
+    child_command_tree = CommandTree(
+        name="child", description="Child command", handler=test_handler
+    )
+    parent_command_tree = CommandTree(
+        name="parent", description="Parent command", children=(child_command_tree,)
+    )
+    click_group = to_click_commands(parent_command_tree)
+    assert isinstance(click_group, click.Group), "The result should be a click.Group instance"
+    assert click_group.name == "parent", "The group name should be 'parent'"
+    assert click_group.help == "Parent command", "The group help should be 'Parent command'"
+    assert "child" in click_group.commands, "The group should contain the 'child' command"
+
+    with mock.patch("sys.argv", ["parent"]):
+        click_group(standalone_mode=False)
+
+
+def test_to_click_commands_with_arguments():
+    @dataclass
+    class TestArguments:
+        arg1: str
+        arg2: int
+
+    def test_handler(test_arguments: TestArguments):
+        assert isinstance(
+            test_arguments, TestArguments
+        ), "The argument should be a TestArguments instance"
+
+    command_tree = CommandTree(
+        name="test",
+        description="Test command with arguments",
+        kwargs_class=TestArguments,
+        handler=test_handler,
+    )
+    click_command = to_click_commands(command_tree)
+    assert isinstance(
+        click_command, click.Command
+    ), "The result should be a click.Command instance"
+    assert click_command.name == "test", "The command name should be 'test'"
+    assert (
+        click_command.help == "Test command with arguments"
+    ), "The command help should be 'Test command with arguments'"
+    assert len(click_command.params) == 2, "The command should have two parameters"
+    assert click_command.params[0].name == "arg1", "The first parameter should be 'arg1'"
+    assert click_command.params[1].name == "arg2", "The second parameter should be 'arg2'"
+    assert click_command.callback is not None, "The command should have a callback"
+    assert (
+        click_command.callback.__qualname__
+        == "test_to_click_commands_with_arguments.<locals>.test_handler"
+    ), "The callback should have the same name as the wrapped function"
+    assert (
+        click_command.callback.__wrapped__ == test_handler  # type: ignore
+    ), "The command callback should wrap the test_handler function"
+
+    with mock.patch("sys.argv", ["test", "--arg1", "test-str", "--arg2", "2"]):
+        click_command(standalone_mode=False)
diff --git a/rats-devtools/test/python/rats_test/command_tree/test_command_service_tree.py b/rats-devtools/test/python/rats_test/command_tree/test_command_service_tree.py
new file mode 100644
index 00000000..55db028e
--- /dev/null
+++ b/rats-devtools/test/python/rats_test/command_tree/test_command_service_tree.py
@@ -0,0 +1,116 @@
+from collections.abc import Callable
+from unittest.mock import Mock, create_autospec
+
+from rats.apps import Container, ServiceId
+from rats.command_tree import CommandServiceTree, CommandTree
+
+
+def test_command_service_tree_to_command_tree_no_children_no_handler():
+    # Create a CommandServiceTree with no children and no handler
+    command_service_tree = CommandServiceTree(
+        name="test_command",
+        description="Test command description",
+    )
+
+    # Create a mock container
+    container = Mock(spec=Container)
+
+    # Convert to CommandTree
+    command_tree = command_service_tree.to_command_tree(container)
+
+    # Assertions
+    assert isinstance(command_tree, CommandTree)
+    assert command_tree.name == "test_command"
+    assert command_tree.description == "Test command description"
+    assert command_tree.children == ()
+    assert command_tree.kwargs_class is None
+    assert command_tree.handler is None
+
+
+def test_command_service_tree_to_command_tree_with_children_with_handler():
+    # Create a CommandServiceTree with children and a handler
+    child_service_id = ServiceId("child_command_service")
+    handler_service_id = ServiceId("handler_service")
+    command_service_tree = CommandServiceTree(
+        name="parent_command",
+        description="Parent command description",
+        children=child_service_id,
+        handler=handler_service_id,
+    )
+
+    # Create a mock container
+    container = Mock(spec=Container)
+    child_command_tree = CommandTree(name="child_command", description="Child command description")
+    container.get_group.return_value = [child_command_tree]
+    container.get.return_value = lambda: None
+
+    # Convert to CommandTree
+    command_tree = command_service_tree.to_command_tree(container)
+
+    # Assertions
+    assert isinstance(command_tree, CommandTree)
+    assert command_tree.name == "parent_command"
+    assert command_tree.description == "Parent command description"
+    assert command_tree.children == (child_command_tree,)
+    assert command_tree.kwargs_class is None
+    assert command_tree.handler is not None
+    assert callable(command_tree.handler)
+
+
+def test_command_service_tree_to_command_tree_with_kwargs_class():
+    # Create a CommandServiceTree with a kwargs_class
+    kwargs_class = Mock()
+    command_service_tree = CommandServiceTree(
+        name="command_with_args",
+        description="Command with arguments description",
+        kwargs_class=kwargs_class,
+    )
+
+    # Create a mock container
+    container = Mock(spec=Container)
+
+    # Convert to CommandTree
+    command_tree = command_service_tree.to_command_tree(container)
+
+    # Assertions
+    assert isinstance(command_tree, CommandTree)
+    assert command_tree.name == "command_with_args"
+    assert command_tree.description == "Command with arguments description"
+    assert command_tree.children == ()
+    assert command_tree.kwargs_class == kwargs_class
+    assert command_tree.handler is None
+
+
+def test_command_service_tree_to_command_tree_with_handler_executes_successfully():
+    # Create a CommandServiceTree with a non-None handler
+    handler_service_id = ServiceId("handler_service")
+    command_service_tree = CommandServiceTree(
+        name="command_with_handler",
+        description="Command with handler description",
+        handler=handler_service_id,
+    )
+
+    # Create a mock container
+    container = Mock(spec=Container)
+
+    # Create a mock handler function
+    mock_handler = create_autospec(Callable[..., None], return_value=None)
+    container.get.return_value = mock_handler
+
+    # Convert to CommandTree
+    command_tree = command_service_tree.to_command_tree(container)
+
+    # Assertions
+    assert isinstance(command_tree, CommandTree)
+    assert command_tree.name == "command_with_handler"
+    assert command_tree.description == "Command with handler description"
+    assert command_tree.children == ()
+    assert command_tree.kwargs_class is None
+    assert command_tree.handler is not None
+    assert callable(command_tree.handler)
+
+    # Execute the handler to verify it's callable and works
+    command_tree.handler()
+
+    # Ensure the provided handler was called
+    mock_handler.assert_called_once()
diff --git a/rats-devtools/test/python/rats_test/command_tree/test_docstring.py b/rats-devtools/test/python/rats_test/command_tree/test_docstring.py
new file mode 100644
index 00000000..91fdc74f
--- /dev/null
+++ b/rats-devtools/test/python/rats_test/command_tree/test_docstring.py
@@ -0,0 +1,41 @@
+from dataclasses import dataclass
+
+import pytest
+
+from rats.command_tree import (
+    get_attribute_docstring,
+)
+
+
+def test_get_attribute_docstring():
+    @dataclass
+    class MockDataclass:
+        """MockDataclass description."""
+
+        field: int
+        """The field's docstring."""
+
+    docstring = get_attribute_docstring(MockDataclass, "field")
+    assert docstring == "The field's docstring.", "The docstring did not match the expected value"
+
+
+def test_get_attribute_docstring_no_docstring():
+    @dataclass
+    class MockDataclass:
+        field: int
+
+    docstring = get_attribute_docstring(MockDataclass, "field")
+    assert docstring == "", "The docstring should be empty for a field without a docstring"
+
+
+def test_get_attribute_docstring_nonexistent_field():
+    @dataclass
+    class MockDataclass:
+        field: int
+
+    with pytest.raises(ValueError) as exc_info:
+        get_attribute_docstring(MockDataclass, "nonexistent_field")
+    assert (
+        f"Attribute nonexistent_field not found in dataclass {__name__}.test_get_attribute_docstring_nonexistent_field.<locals>.MockDataclass"
+        in str(exc_info.value)
+    ), "The error message did not match the expected value"
diff --git a/rats-devtools/test/python/rats_test/devtools/py.typed b/rats-devtools/test/python/rats_test/devtools/py.typed
new file mode 100644
index 00000000..e69de29b
diff --git a/rats-devtools/test/python/rats_test/devtools/test_annotations.py b/rats-devtools/test/python/rats_test/devtools/test_annotations.py
new file mode 100644
index 00000000..38084763
--- /dev/null
+++ b/rats-devtools/test/python/rats_test/devtools/test_annotations.py
@@ -0,0 +1,80 @@
+from typing_extensions import NamedTuple
+
+from rats.annotations import AnnotationsContainer, annotation, get_annotations
+
+
+class SimpleTuple(NamedTuple):
+    name: str
+
+
+@annotation(namespace="test_namespace", group_id=SimpleTuple("group1"))
+@annotation(namespace="test_namespace", group_id=SimpleTuple("group2"))
+def test_function():
+    pass
+
+
+def test_group_annotations():
+    group_annotations = get_annotations(test_function).annotations[0]
+
+    assert group_annotations.name == "test_function"
+    assert group_annotations.namespace == "test_namespace"
+    assert set(group_annotations.groups) == {SimpleTuple("group1"), SimpleTuple("group2")}
+
+
+@annotation(namespace="ns1", group_id=SimpleTuple("group1"))
+def test_function1():
+    pass
+
+
+@annotation(namespace="ns2", group_id=SimpleTuple("group2"))
+def test_function2():
+    pass
+
+
+def test_with_namespace():
+    annotations_container = AnnotationsContainer(
+        annotations=(
+            get_annotations(test_function1).annotations[0],
+            get_annotations(test_function2).annotations[0],
+        )
+    )
+    filtered_annotations = annotations_container.with_namespace("ns1")
+
+    assert len(filtered_annotations) == 1
+    assert filtered_annotations.annotations[0].namespace == "ns1"
+    assert filtered_annotations.annotations[0].groups == (SimpleTuple("group1"),)
+    assert filtered_annotations.annotations[0].name == "test_function1"
+
+
+@annotation(namespace="ns1", group_id=SimpleTuple("group1"))
+def test_function3():
+    pass
+
+
+def test_group_in_namespace():
+    annotations_container = AnnotationsContainer(
+        annotations=(
+            get_annotations(test_function1).annotations[0],
+            get_annotations(test_function2).annotations[0],
+            get_annotations(test_function3).annotations[0],
+        )
+    )
+    filtered_annotations = annotations_container.with_group("ns1", SimpleTuple("group1"))
+
+    assert len(filtered_annotations) == 1
+    assert filtered_annotations.annotations[0].groups == (SimpleTuple("group1"),)
+
+
+@annotation(namespace="ns1", group_id=SimpleTuple("group1"))
+@annotation(namespace="ns1", group_id=SimpleTuple("group2"))
+def test_function4():
+    pass
+
+
+def test_add_and_make():
+    annotations = get_annotations(test_function4)
+
+    assert len(annotations) == 1
+    assert annotations.annotations[0].name == "test_function4"
+    assert annotations.annotations[0].namespace == "ns1"
+    assert set(annotations.annotations[0].groups) == {SimpleTuple("group2"), SimpleTuple("group1")}
diff --git a/rats-devtools/test/python/rats_test/devtools/test_groups.py b/rats-devtools/test/python/rats_test/devtools/test_groups.py
new file mode 100644
index 00000000..ff0e60a7
--- /dev/null
+++ b/rats-devtools/test/python/rats_test/devtools/test_groups.py
@@ -0,0 +1,40 @@
+from unittest import mock
+from unittest.mock import MagicMock, create_autospec
+
+import click
+
+from rats.apps import PluginRunner
+from rats.cli import AttachClickCommands, ClickExecutable
+
+
+@mock.patch("click.Group")
+def test_command_group_execute_registers_commands(m_click_group: MagicMock):
+    registered_plugins = []
+
+    class MockPlugin:
+        def on_group_open(self, group: click.Group) -> None:
+            registered_plugins.append(self)
+
+    plugin1 = MockPlugin()
+    plugin2 = MockPlugin()
+
+    m_group_instance = m_click_group.return_value
+
+    command_group = ClickExecutable(
+        command=lambda: m_group_instance,
+        plugins=PluginRunner(iter([plugin1, plugin2])),
+    )
+    command_group.execute()
+
+    assert len(registered_plugins) == 2
+    assert plugin1 in registered_plugins
+    assert plugin2 in registered_plugins
+    m_group_instance.assert_called_once()
+
+
+def test_group_commands_on_group_registration():
+    mock_command = create_autospec(spec=click.Command, instance=True)
+    group_commands = AttachClickCommands(commands=iter([mock_command]))
+    mock_group = create_autospec(spec=click.Group, instance=True)
+    group_commands.on_group_open(mock_group)
+    mock_group.add_command.assert_called_once_with(mock_command)
diff --git a/rats-devtools/test/python/rats_test/devtools/test_plugins.py b/rats-devtools/test/python/rats_test/devtools/test_plugins.py
new file mode 100644
index 00000000..fee48963
--- /dev/null
+++ b/rats-devtools/test/python/rats_test/devtools/test_plugins.py
@@ -0,0 +1,46 @@
+from typing import Any
+
+from rats.apps import PluginRunner
+
+
+def test_plugin_runner_apply() -> None:
+    # Mock plugin and handler
+    class MockPlugin:
+        def __init__(self, name: str):
+            self.name = name
+            self.handled = False
+
+        def handle(self):
+            self.handled = True
+
+    mock_plugins = [MockPlugin("plugin1"), MockPlugin("plugin2")]
+    plugin_runner = PluginRunner(iter(mock_plugins))
+
+    # Define a handler that calls the 'handle' method of the plugin
+    def handler(plugin: MockPlugin) -> None:
+        plugin.handle()
+
+    # Apply the handler to the plugins
+    plugin_runner.apply(handler)
+
+    # Assert that each plugin was handled
+    for plugin in mock_plugins:
+        assert plugin.handled, f"{plugin.name} was not handled"
+
+
+def test_plugin_runner_no_plugins() -> None:
+    # Empty iterator of plugins
+    plugin_runner = PluginRunner(iter([]))
+
+    # Define a handler that should never be called
+    handler_called = False
+
+    def handler(plugin: Any) -> None:
+        nonlocal handler_called
+        handler_called = True
+
+    # Apply the handler to the plugins
+    plugin_runner.apply(handler)
+
+    # Assert that the handler was never called
+    assert not handler_called, "Handler was called on an empty iterator of plugins"
diff --git a/test/python/rats_test/devtools/test_command_tree.py b/test/python/rats_test/devtools/test_command_tree.py
new file mode 100644
index 00000000..e47bb831
--- /dev/null
+++ b/test/python/rats_test/devtools/test_command_tree.py
@@ -0,0 +1,25 @@
+import pytest
+from dataclasses import dataclass
+from rats.devtools._command_tree import get_attribute_docstring
+
+
+@dataclass
+class ExampleDataclass:
+    """Example dataclass for testing."""
+
+    attribute: int
+    """This is the attribute's docstring."""
+
+
+def test_get_attribute_docstring():
+    docstring = get_attribute_docstring(ExampleDataclass, 'attribute')
+    expected_docstring = "This is the attribute's docstring."
+    assert docstring == expected_docstring, "The docstring should match the attribute's docstring."
+
+def test_get_attribute_docstring_nonexistent_attribute():
+    with pytest.raises(ValueError):
+        get_attribute_docstring(ExampleDataclass, 'nonexistent_attribute')
+
+def test_get_attribute_docstring_non_dataclass():
+    with pytest.raises(AssertionError):
+        get_attribute_docstring(object, 'attribute')