From 2cb31aa8017744f5de8cbbb38082154531b19ee5 Mon Sep 17 00:00:00 2001
From: Nasser Alansari <dacrystal@users.noreply.github.com>
Date: Sat, 28 Mar 2026 08:50:33 +0000
Subject: [PATCH 1/9] Fix: Add new line before to open i

---
 src/devcode.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/devcode.py b/src/devcode.py
index 47fc6c5..280c1d0 100644
--- a/src/devcode.py
+++ b/src/devcode.py
@@ -748,7 +748,7 @@ def cmd_ps(args) -> None:
     if not args.interactive:
         return
 
-    choice = input(f"Open [1-{len(display)}]: ").strip()
+    choice = input(f"\nOpen [1-{len(display)}]: ").strip()
     try:
         idx = int(choice) - 1
         if not (0 <= idx < len(display)):

From 54298660ac7fe39584255f87ad58e5e97f19cf57 Mon Sep 17 00:00:00 2001
From: Nasser Alansari <dacrystal@users.noreply.github.com>
Date: Sat, 28 Mar 2026 14:04:25 +0000
Subject: [PATCH 2/9] feat: reorder open args, add settings.json config, fix
 missing projectpath error
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- devcode open now takes <projectpath> [template] (template optional)
- Auto-detects template from container history (running → stopped → default)
- Adds settings.json (~/.config/dev-code/settings.json) replacing DEVCODE_TEMPLATE_PATH
- settings.json auto-created with defaults on first run (default_template: dev-code)
- DEVCODE_CONF_DIR env var overrides config directory
- Errors on non-existent projectpath (bug fix)
- Updates shell completion: template completes at position 3 (not 2)
---
 README.md              |  89 ++++----
 src/devcode.py         | 113 ++++++++--
 tests/test_dev_code.py | 477 +++++++++++++++++++++++++++++------------
 3 files changed, 489 insertions(+), 190 deletions(-)

diff --git a/README.md b/README.md
index 549cb58..cc17195 100644
--- a/README.md
+++ b/README.md
@@ -50,11 +50,11 @@ Typical Dev Container workflows involve:
 # Install
 pip install dev-code
 
-# Create default template
-devcode init
+# Open a project (auto-detects template from container history, or uses default)
+devcode open ~/projects/my-app
 
-# Open a project
-devcode open dev-code ~/projects/my-app
+# Open with an explicit template
+devcode open ~/projects/my-app dev-code
 
 # Reopen projects later
 devcode ps -a -i
@@ -81,14 +81,7 @@ Default location:
 ~/.local/share/dev-code/templates/
 ```
 
-Override search paths:
-
-```bash
-DEVCODE_TEMPLATE_PATH=/my/templates:/team/templates
-```
-
-* The first path is used for writes
-* Additional paths are read-only
+Override search paths via `settings.json` (see [Configuration](#configuration)).
 
 ---
 
@@ -105,14 +98,16 @@ DEVCODE_TEMPLATE_PATH=/my/templates:/team/templates
 ### devcode open
 
 ```bash
-devcode open <template> <path> [options]
+devcode open <path> [template] [options]
 ```
 
-Open a project using a template.
+Open a project in VS Code using a devcontainer template.
 
 #### Arguments
 
-* `<template>`
+* `<path>` — Project directory (must exist)
+
+* `[template]` *(optional)*
 
   * Template name, or
   * Path to a `devcontainer.json`, or
@@ -120,10 +115,12 @@ Open a project using a template.
 
   Paths must start with `./`, `../`, `/`, or `~/`.
 
-  If both a template and directory match, the template takes precedence and a warning is shown.
+  If both a template name and a local directory match, the template takes precedence and a warning is shown.
 
-* `<path>`
-  Project directory
+  **If omitted**, devcode auto-detects the template in this order:
+  1. Most recently running container for this project path (uses its stored config)
+  2. Most recently stopped container for this project path
+  3. `default_template` from `settings.json` (error if not set)
 
 #### Options
 
@@ -135,16 +132,6 @@ Open a project using a template.
 
 ---
 
-### devcode init
-
-```bash
-devcode init
-```
-
-Creates the default template.
-
----
-
 ### devcode new
 
 ```bash
@@ -229,32 +216,54 @@ eval "$(devcode completion bash)"
 ## Typical Workflow
 
 ```bash
-devcode init
 devcode new python-dev
 devcode edit python-dev
-devcode open python-dev ~/projects/my-app
+devcode open ~/projects/my-app python-dev
 ```
 
 ---
 
-## Template System
+## Configuration
 
-### Default Location
+devcode reads `settings.json` from:
 
 ```
-~/.local/share/dev-code/templates/
+~/.config/dev-code/settings.json
 ```
 
-### Custom Paths
+Override the config directory:
 
 ```bash
-DEVCODE_TEMPLATE_PATH=$HOME/my/templates:/team/shared/templates
+DEVCODE_CONF_DIR=/custom/path devcode open ~/projects/my-app
+```
+
+The file is created automatically with defaults on first run.
+
+### settings.json
+
+```json
+{
+  "template_sources": ["~/.local/share/dev-code/templates"],
+  "default_template": "dev-code"
+}
 ```
 
-Resolution order:
+| Key | Description |
+| --- | --- |
+| `template_sources` | Ordered list of template directories. First is the write target; rest are read-only. |
+| `default_template` | Template used when `devcode open` is called without a template argument and no container history is found. Error if unset. |
+
+---
+
+## Template System
+
+### Default Location
+
+```
+~/.local/share/dev-code/templates/
+```
 
-1. First directory is the write target
-2. Remaining directories are used for lookup
+Configure additional paths via `template_sources` in `settings.json`.
 
 ---
 
@@ -348,8 +357,8 @@ Lists containers and allows reopening projects interactively.
 
 ## Internal Flow
 
-1. Resolve template
-2. Resolve project path
+1. Validate project path (must exist)
+2. Resolve template (explicit → container history → settings default)
 3. Launch VS Code Dev Container
 4. Apply file injection rules
 
diff --git a/src/devcode.py b/src/devcode.py
index 280c1d0..4d3bb22 100644
--- a/src/devcode.py
+++ b/src/devcode.py
@@ -25,6 +25,11 @@
 
 KNOWN_CP_FIELDS = {"source", "target", "override", "owner", "group", "permissions"}
 
+_DEFAULT_SETTINGS = {
+    "template_sources": ["~/.local/share/dev-code/templates"],
+    "default_template": "dev-code",
+}
+
 _BASH_COMPLETION = """\
 # devcode bash completion
 # Requires bash 4.0+ (macOS ships bash 3.2; install bash 5 via Homebrew if needed).
@@ -90,15 +95,49 @@ def wsl_to_windows(path: str) -> str:
         raise RuntimeError(f"Failed to convert path with wslpath: {path}") from e
 
 
+def _conf_dir() -> str:
+    """Return the devcode config directory path."""
+    override = os.environ.get("DEVCODE_CONF_DIR")
+    if override:
+        return override
+    xdg_config = os.environ.get(
+        "XDG_CONFIG_HOME", os.path.join(os.path.expanduser("~"), ".config")
+    )
+    return os.path.join(xdg_config, "dev-code")
+
+
+def _load_settings() -> dict:
+    """Read settings.json, creating it with defaults if absent. Never raises."""
+    conf_dir = _conf_dir()
+    settings_path = os.path.join(conf_dir, "settings.json")
+    if not os.path.exists(settings_path):
+        try:
+            os.makedirs(conf_dir, exist_ok=True)
+            with open(settings_path, "w") as f:
+                json.dump(_DEFAULT_SETTINGS, f, indent=2)
+                f.write("\n")
+            logger.info("created default settings at %s", settings_path)
+        except OSError as e:
+            logger.warning("could not create settings file %s: %s", settings_path, e)
+        return dict(_DEFAULT_SETTINGS)
+    try:
+        with open(settings_path) as f:
+            return json.load(f)
+    except (json.JSONDecodeError, OSError) as e:
+        logger.warning("failed to load settings from %s: %s; using defaults", settings_path, e)
+        return dict(_DEFAULT_SETTINGS)
+
+
 def resolve_template_search_path() -> list[str]:
-    """Return ordered list of template search directories from DEVCODE_TEMPLATE_PATH."""
-    new_var = os.environ.get("DEVCODE_TEMPLATE_PATH")
-    xdg = os.environ.get("XDG_DATA_HOME", os.path.join(os.path.expanduser("~"), ".local", "share"))
-    default = os.path.join(xdg, "dev-code", "templates")
-    if not new_var:
-        return [default]
-    dirs = [d for d in new_var.split(os.pathsep) if d]
-    return dirs if dirs else [default]
+    """Return ordered list of template search directories from settings.json."""
+    settings = _load_settings()
+    sources = settings.get("template_sources")
+    if not sources:
+        xdg = os.environ.get(
+            "XDG_DATA_HOME", os.path.join(os.path.expanduser("~"), ".local", "share")
+        )
+        return [os.path.join(xdg, "dev-code", "templates")]
+    return [os.path.expanduser(d) for d in sources if d]
 
 
 def _write_template_dir() -> str:
@@ -521,11 +560,47 @@ def _git_repo_root(path: str) -> str | None:
         return None
 
 
+def _find_container_config_for_project(project_path: str) -> str | None:
+    """Return config_file of most recently created container for project_path, or None.
+
+    Checks running containers first; falls back to all containers (stopped too).
+    """
+    label_value = wsl_to_windows(project_path) if is_wsl() else project_path
+    fmt = '{{.CreatedAt}}\t{{.Label "devcontainer.config_file"}}'
+
+    for extra_args in [[], ["-a"]]:
+        try:
+            result = subprocess.run(
+                ["docker", "container", "ls"] + extra_args + [
+                    "--filter", f"label=devcontainer.local_folder={label_value}",
+                    "--format", fmt,
+                ],
+                capture_output=True, text=True,
+            )
+        except OSError:
+            return None
+        if result.returncode != 0:
+            return None
+        rows = []
+        for line in result.stdout.splitlines():
+            parts = line.split("\t", 1)
+            if len(parts) == 2 and parts[1].strip():
+                rows.append((parts[0], parts[1].strip()))
+        if rows:
+            rows.sort(key=lambda r: r[0], reverse=True)
+            return rows[0][1]
+
+    return None
+
+
 def cmd_open(args) -> None:
     """open subcommand: open a project in VS Code using a devcontainer template."""
-    config_file = resolve_template(args.template)
-
     project_path = os.path.abspath(args.projectpath)
+
+    if not os.path.exists(project_path):
+        logger.error("projectpath not found: %s", args.projectpath)
+        sys.exit(1)
+
     if project_path == "/":
         logger.error("projectpath must not resolve to /")
         sys.exit(1)
@@ -541,6 +616,20 @@ def cmd_open(args) -> None:
             )
             sys.exit(1)
 
+    if args.template:
+        config_file = resolve_template(args.template)
+    else:
+        config_file = _find_container_config_for_project(project_path)
+        if config_file is None:
+            settings = _load_settings()
+            default = settings.get("default_template", "")
+            if not default:
+                logger.error(
+                    "no template specified and no default_template configured in settings"
+                )
+                sys.exit(1)
+            config_file = resolve_template(default)
+
     container_folder = args.container_folder or f"/workspaces/{os.path.basename(project_path)}"
     uri = build_devcontainer_uri(project_path, config_file, container_folder)
 
@@ -841,7 +930,7 @@ def cmd_completion(args) -> None:
                 elif current_word.startswith("-"):
                     candidates = _SUBCOMMAND_FLAGS.get(subcommand, [])
                 else:
-                    if subcommand == "open" and cword_index == 2:
+                    if subcommand == "open" and cword_index == 3:
                         candidates = _list_template_names()
                     elif subcommand == "new" and cword_index == 3:
                         candidates = _list_template_names()
@@ -885,8 +974,8 @@ def main():
     subparsers = parser.add_subparsers(dest="subcommand")
 
     p_open = subparsers.add_parser("open")
-    p_open.add_argument("template")
     p_open.add_argument("projectpath")
+    p_open.add_argument("template", nargs="?")
     p_open.add_argument("--container-folder")
     p_open.add_argument("--timeout", type=int, default=300)
     p_open.add_argument("--dry-run", action="store_true", dest="dry_run")
diff --git a/tests/test_dev_code.py b/tests/test_dev_code.py
index d2f51de..0fd0180 100644
--- a/tests/test_dev_code.py
+++ b/tests/test_dev_code.py
@@ -150,52 +150,216 @@ def fake_run(cmd, **kw):
         self.assertIn(r"C:\myproject", label_filter)
 
 
-class TestResolveTemplateSearchPath(unittest.TestCase):
-    def _clean_env(self, extra=None):
-        """Return env with DEVCODE_TEMPLATE_PATH/XDG_DATA_HOME stripped."""
-        env = {k: v for k, v in os.environ.items()
-               if k not in ("DEVCODE_TEMPLATE_PATH", "XDG_DATA_HOME")}
-        if extra:
-            env.update(extra)
-        return env
+class TestFindContainerConfigForProject(unittest.TestCase):
+    def _mock_result(self, output, returncode=0):
+        return MagicMock(returncode=returncode, stdout=output)
 
-    def test_single_path(self):
-        env = self._clean_env({"DEVCODE_TEMPLATE_PATH": "/a/b"})
-        with patch.dict(os.environ, env, clear=True):
-            self.assertEqual(devcode.resolve_template_search_path(), ["/a/b"])
+    def test_returns_config_from_running_container(self):
+        output = "2024-01-15 10:00:00 +0000 UTC\t/path/to/devcontainer.json\n"
+        with patch("subprocess.run", return_value=self._mock_result(output)):
+            result = devcode._find_container_config_for_project("/myproject")
+        self.assertEqual(result, "/path/to/devcontainer.json")
 
-    def test_multiple_paths(self):
-        env = self._clean_env({"DEVCODE_TEMPLATE_PATH": os.pathsep.join(["/a", "/b", "/c"])})
-        with patch.dict(os.environ, env, clear=True):
-            self.assertEqual(devcode.resolve_template_search_path(), ["/a", "/b", "/c"])
+    def test_returns_most_recent_when_multiple_running(self):
+        output = (
+            "2024-01-14 10:00:00 +0000 UTC\t/path/old.json\n"
+            "2024-01-15 10:00:00 +0000 UTC\t/path/new.json\n"
+        )
+        with patch("subprocess.run", return_value=self._mock_result(output)):
+            result = devcode._find_container_config_for_project("/myproject")
+        self.assertEqual(result, "/path/new.json")
+
+    def test_falls_back_to_stopped_when_no_running(self):
+        running_result = self._mock_result("")
+        stopped_result = self._mock_result(
+            "2024-01-15 10:00:00 +0000 UTC\t/stopped.json\n"
+        )
+        with patch("subprocess.run", side_effect=[running_result, stopped_result]):
+            result = devcode._find_container_config_for_project("/myproject")
+        self.assertEqual(result, "/stopped.json")
 
-    def test_empty_entries_skipped(self):
-        env = self._clean_env({"DEVCODE_TEMPLATE_PATH": f"/a{os.pathsep}{os.pathsep}/b{os.pathsep}"})
-        with patch.dict(os.environ, env, clear=True):
-            self.assertEqual(devcode.resolve_template_search_path(), ["/a", "/b"])
+    def test_returns_none_when_no_containers(self):
+        with patch("subprocess.run", return_value=self._mock_result("")):
+            result = devcode._find_container_config_for_project("/myproject")
+        self.assertIsNone(result)
+
+    def test_returns_none_on_docker_failure(self):
+        with patch("subprocess.run", return_value=self._mock_result("", returncode=1)):
+            result = devcode._find_container_config_for_project("/myproject")
+        self.assertIsNone(result)
+
+    def test_wsl_converts_path(self):
+        calls = []
+        def fake_run(cmd, **kw):
+            calls.append(cmd)
+            return self._mock_result("")
+        with patch("subprocess.run", side_effect=fake_run):
+            with patch.object(devcode, "is_wsl", return_value=True):
+                with patch.object(devcode, "wsl_to_windows", return_value=r"C:\myproject"):
+                    devcode._find_container_config_for_project("/myproject")
+        label_filter = next(a for a in calls[0] if "devcontainer.local_folder" in a)
+        self.assertIn(r"C:\myproject", label_filter)
+
+    def test_returns_none_when_docker_not_installed(self):
+        with patch("subprocess.run", side_effect=OSError("docker not found")):
+            result = devcode._find_container_config_for_project("/myproject")
+        self.assertIsNone(result)
 
-    def test_all_empty_entries_falls_back_to_xdg(self):
-        env = self._clean_env({"DEVCODE_TEMPLATE_PATH": os.pathsep * 3, "XDG_DATA_HOME": "/xdg"})
-        with patch.dict(os.environ, env, clear=True):
-            result = devcode.resolve_template_search_path()
-        self.assertEqual(result, [os.path.join("/xdg", "dev-code", "templates")])
 
-    def test_unset_uses_xdg_data_home(self):
-        env = self._clean_env({"XDG_DATA_HOME": "/xdg"})
+class TestCmdOpen(unittest.TestCase):
+    def _make_args(self, projectpath, template=None, container_folder=None,
+                   timeout=300, dry_run=False):
+        return argparse.Namespace(
+            projectpath=projectpath,
+            template=template,
+            container_folder=container_folder,
+            timeout=timeout,
+            dry_run=dry_run,
+        )
+
+    def test_errors_on_nonexistent_projectpath(self):
+        args = self._make_args("/nonexistent/path/xyz123", template="mytemplate")
+        with self.assertRaises(SystemExit):
+            devcode.cmd_open(args)
+
+    def test_errors_on_root_path(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            # patch abspath to return "/" so the root guard triggers
+            with patch("os.path.abspath", return_value="/"):
+                with patch("os.path.exists", return_value=True):
+                    args = self._make_args(tmp, template="mytemplate")
+                    with self.assertRaises(SystemExit):
+                        devcode.cmd_open(args)
+
+    def test_uses_explicit_template(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            args = self._make_args(tmp, template="mytemplate")
+            with patch.object(devcode, "resolve_template", return_value="/fake/devcontainer.json") as mock_rt:
+                with patch.object(devcode, "_git_repo_root", return_value=None):
+                    with patch("shutil.which", return_value="/usr/bin/code"):
+                        with patch("subprocess.Popen"):
+                            with patch.object(devcode, "run_post_launch"):
+                                devcode.cmd_open(args)
+            mock_rt.assert_called_once_with("mytemplate")
+
+    def test_auto_detects_from_container(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            args = self._make_args(tmp, template=None)
+            with patch.object(devcode, "_find_container_config_for_project",
+                               return_value="/found/devcontainer.json") as mock_find:
+                with patch.object(devcode, "_git_repo_root", return_value=None):
+                    with patch("shutil.which", return_value="/usr/bin/code"):
+                        with patch("subprocess.Popen"):
+                            with patch.object(devcode, "run_post_launch"):
+                                devcode.cmd_open(args)
+            mock_find.assert_called_once()
+
+    def test_auto_detects_falls_back_to_default_template(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            args = self._make_args(tmp, template=None)
+            with patch.object(devcode, "_find_container_config_for_project", return_value=None):
+                with patch.object(devcode, "_load_settings",
+                                   return_value={"default_template": "dev-code"}):
+                    with patch.object(devcode, "resolve_template",
+                                       return_value="/fake/devcontainer.json") as mock_rt:
+                        with patch.object(devcode, "_git_repo_root", return_value=None):
+                            with patch("shutil.which", return_value="/usr/bin/code"):
+                                with patch("subprocess.Popen"):
+                                    with patch.object(devcode, "run_post_launch"):
+                                        devcode.cmd_open(args)
+                mock_rt.assert_called_once_with("dev-code")
+
+    def test_errors_when_no_container_and_no_default_template(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            args = self._make_args(tmp, template=None)
+            with patch.object(devcode, "_find_container_config_for_project", return_value=None):
+                with patch.object(devcode, "_load_settings", return_value={"default_template": ""}):
+                    with patch.object(devcode, "_git_repo_root", return_value=None):
+                        with self.assertRaises(SystemExit):
+                            devcode.cmd_open(args)
+
+
+class TestConfDir(unittest.TestCase):
+    def test_uses_devcode_conf_dir_override(self):
+        with patch.dict(os.environ, {"DEVCODE_CONF_DIR": "/custom/conf"}):
+            self.assertEqual(devcode._conf_dir(), "/custom/conf")
+
+    def test_falls_back_to_xdg_config_home(self):
+        env = {k: v for k, v in os.environ.items()
+               if k not in ("DEVCODE_CONF_DIR", "XDG_CONFIG_HOME")}
+        env["XDG_CONFIG_HOME"] = "/xdg/config"
         with patch.dict(os.environ, env, clear=True):
-            result = devcode.resolve_template_search_path()
-        self.assertEqual(result, [os.path.join("/xdg", "dev-code", "templates")])
+            self.assertEqual(devcode._conf_dir(), "/xdg/config/dev-code")
 
-    def test_unset_uses_default_xdg(self):
-        env = self._clean_env()
+    def test_falls_back_to_default_config_dir(self):
+        env = {k: v for k, v in os.environ.items()
+               if k not in ("DEVCODE_CONF_DIR", "XDG_CONFIG_HOME")}
         with patch.dict(os.environ, env, clear=True):
-            result = devcode.resolve_template_search_path()
-        self.assertIn(os.path.join(".local", "share", "dev-code", "templates"), result[0])
+            result = devcode._conf_dir()
+        self.assertTrue(result.endswith(os.path.join(".config", "dev-code")))
+
+
+class TestLoadSettings(unittest.TestCase):
+    def test_creates_default_settings_when_missing(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            with patch.dict(os.environ, {"DEVCODE_CONF_DIR": tmp}):
+                settings = devcode._load_settings()
+        self.assertEqual(settings["default_template"], "dev-code")
+        self.assertIn("template_sources", settings)
+
+    def test_creates_settings_file_on_disk_when_missing(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            conf_dir = os.path.join(tmp, "conf")
+            with patch.dict(os.environ, {"DEVCODE_CONF_DIR": conf_dir}):
+                devcode._load_settings()
+            self.assertTrue(os.path.exists(os.path.join(conf_dir, "settings.json")))
+
+    def test_reads_existing_settings(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            settings_path = os.path.join(tmp, "settings.json")
+            with open(settings_path, "w") as f:
+                json.dump({"template_sources": ["/custom"], "default_template": "mytemplate"}, f)
+            with patch.dict(os.environ, {"DEVCODE_CONF_DIR": tmp}):
+                settings = devcode._load_settings()
+        self.assertEqual(settings["default_template"], "mytemplate")
+        self.assertEqual(settings["template_sources"], ["/custom"])
+
+    def test_invalid_json_returns_defaults(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            settings_path = os.path.join(tmp, "settings.json")
+            with open(settings_path, "w") as f:
+                f.write("not valid json {{{")
+            with patch.dict(os.environ, {"DEVCODE_CONF_DIR": tmp}):
+                with self.assertLogs("devcode", level="WARNING"):
+                    settings = devcode._load_settings()
+        self.assertEqual(settings["default_template"], "dev-code")
+
 
+class TestResolveTemplateSearchPath(unittest.TestCase):
+    def test_uses_template_sources_from_settings(self):
+        with patch.object(devcode, "_load_settings", return_value={"template_sources": ["/a", "/b"]}):
+            self.assertEqual(devcode.resolve_template_search_path(), ["/a", "/b"])
+
+    def test_expands_tilde_in_sources(self):
+        with patch.object(devcode, "_load_settings", return_value={"template_sources": ["~/templates"]}):
+            result = devcode.resolve_template_search_path()
+        self.assertTrue(result[0].startswith("/"))
+        self.assertNotIn("~", result[0])
+
+    def test_falls_back_to_xdg_data_home_when_no_sources(self):
+        env = {k: v for k, v in os.environ.items() if k != "XDG_DATA_HOME"}
+        env["XDG_DATA_HOME"] = "/xdg/data"
+        with patch.object(devcode, "_load_settings", return_value={}):
+            with patch.dict(os.environ, env, clear=True):
+                result = devcode.resolve_template_search_path()
+        self.assertEqual(result, ["/xdg/data/dev-code/templates"])
+
+    def test_skips_empty_entries(self):
+        with patch.object(devcode, "_load_settings", return_value={"template_sources": ["/a", "", "/b"]}):
+            self.assertEqual(devcode.resolve_template_search_path(), ["/a", "/b"])
 
     def test_write_template_dir_returns_first_entry(self):
-        env = self._clean_env({"DEVCODE_TEMPLATE_PATH": os.pathsep.join(["/first", "/second"])})
-        with patch.dict(os.environ, env, clear=True):
+        with patch.object(devcode, "_load_settings", return_value={"template_sources": ["/first", "/second"]}):
             self.assertEqual(devcode._write_template_dir(), "/first")
 
 
@@ -289,13 +453,13 @@ def test_finds_user_template(self):
             os.makedirs(tpath)
             cfg = os.path.join(tpath, "devcontainer.json")
             open(cfg, "w").close()
-            with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": d}):
+            with patch.object(devcode, "_load_settings", return_value={"template_sources": [d]}):
                 result = devcode.resolve_template("mytemplate")
         self.assertEqual(result, cfg)
 
     def test_exits_when_not_found(self):
         with tempfile.TemporaryDirectory() as d:
-            with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": d}):
+            with patch.object(devcode, "_load_settings", return_value={"template_sources": [d]}):
                 with patch.object(devcode, "__file__", os.path.join(d, "devcode.py")):
                     with self.assertRaises(SystemExit):
                         devcode.resolve_template("no-such-template")
@@ -304,7 +468,7 @@ def test_resolves_file_path_when_no_template(self):
         with tempfile.TemporaryDirectory() as d:
             cfg = os.path.join(d, "devcontainer.json")
             open(cfg, "w").close()
-            with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": d + "_templates"}):
+            with patch.object(devcode, "_load_settings", return_value={"template_sources": [d + "_templates"]}):
                 with patch.object(devcode, "__file__", os.path.join(d, "devcode.py")):
                     result = devcode.resolve_template(cfg)
         self.assertEqual(result, cfg)
@@ -315,7 +479,7 @@ def test_resolves_directory_path_when_no_template(self):
             os.makedirs(sub)
             cfg = os.path.join(sub, "devcontainer.json")
             open(cfg, "w").close()
-            with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": d + "_templates"}):
+            with patch.object(devcode, "_load_settings", return_value={"template_sources": [d + "_templates"]}):
                 with patch.object(devcode, "__file__", os.path.join(d, "devcode.py")):
                     result = devcode.resolve_template(d)
         self.assertEqual(result, cfg)
@@ -333,7 +497,7 @@ def test_dot_slash_prefix_resolves_as_path_not_template(self):
             old_cwd = os.getcwd()
             os.chdir(d)
             try:
-                with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": os.path.join(d, "templates")}):
+                with patch.object(devcode, "_load_settings", return_value={"template_sources": [os.path.join(d, "templates")]}):
                     with patch.object(devcode, "__file__", os.path.join(d, "devcode.py")):
                         result = devcode.resolve_template("./mydev")
             finally:
@@ -350,7 +514,7 @@ def test_absolute_path_resolves_as_path_not_template(self):
             os.makedirs(local)
             local_cfg = os.path.join(local, "devcontainer.json")
             open(local_cfg, "w").close()
-            with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": os.path.join(d, "templates")}):
+            with patch.object(devcode, "_load_settings", return_value={"template_sources": [os.path.join(d, "templates")]}):
                 with patch.object(devcode, "__file__", os.path.join(d, "devcode.py")):
                     result = devcode.resolve_template(os.path.join(d, "mydev"))
         self.assertEqual(result, local_cfg)
@@ -368,7 +532,7 @@ def test_ambiguity_warns_and_uses_template(self):
             old_cwd = os.getcwd()
             os.chdir(os.path.dirname(d))
             try:
-                with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": d + "_templates"}):
+                with patch.object(devcode, "_load_settings", return_value={"template_sources": [d + "_templates"]}):
                     with patch.object(devcode, "__file__", os.path.join(d, "devcode.py")):
                         with self.assertLogs("devcode", level="WARNING") as cm:
                             result = devcode.resolve_template(dirname)
@@ -382,7 +546,7 @@ def test_exits_with_wrong_filename_in_path(self):
         with tempfile.TemporaryDirectory() as d:
             cfg = os.path.join(d, "custom.json")
             open(cfg, "w").close()
-            with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": d + "_t"}):
+            with patch.object(devcode, "_load_settings", return_value={"template_sources": [d + "_t"]}):
                 with patch.object(devcode, "__file__", os.path.join(d, "devcode.py")):
                     with self.assertRaises(SystemExit):
                         devcode.resolve_template(cfg)
@@ -391,7 +555,7 @@ def test_exits_when_path_prefix_dir_has_no_devcontainer(self):
         with tempfile.TemporaryDirectory() as d:
             empty_dir = os.path.join(d, "myproject")
             os.makedirs(empty_dir)
-            with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": d + "_t"}):
+            with patch.object(devcode, "_load_settings", return_value={"template_sources": [d + "_t"]}):
                 with patch.object(devcode, "__file__", os.path.join(d, "devcode.py")):
                     with self.assertRaises(SystemExit):
                         devcode.resolve_template(empty_dir)
@@ -399,7 +563,7 @@ def test_exits_when_path_prefix_dir_has_no_devcontainer(self):
     def test_exits_when_path_prefix_but_path_not_found(self):
         with tempfile.TemporaryDirectory() as d:
             nonexistent = os.path.join(d, "nonexistent")
-            with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": d + "_t"}):
+            with patch.object(devcode, "_load_settings", return_value={"template_sources": [d + "_t"]}):
                 with patch.object(devcode, "__file__", os.path.join(d, "devcode.py")):
                     with self.assertLogs("devcode", level="ERROR") as cm:
                         with self.assertRaises(SystemExit):
@@ -412,8 +576,7 @@ def test_finds_template_via_search_path(self):
             os.makedirs(tpath)
             cfg = os.path.join(tpath, "devcontainer.json")
             open(cfg, "w").close()
-            with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": d},
-                            clear=False):
+            with patch.object(devcode, "_load_settings", return_value={"template_sources": [d]}):
                 result = devcode.resolve_template("mytemplate")
         self.assertEqual(result, cfg)
 
@@ -424,7 +587,7 @@ def test_does_not_fall_back_to_builtin(self):
                 builtin = os.path.join(pkg_dir, "dev_code_templates", "dev-code", ".devcontainer")
                 os.makedirs(builtin)
                 open(os.path.join(builtin, "devcontainer.json"), "w").close()
-                with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": user_dir}):
+                with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir]}):
                     with patch.object(devcode, "__file__", os.path.join(pkg_dir, "devcode.py")):
                         with self.assertRaises(SystemExit):
                             devcode.resolve_template("dev-code")
@@ -436,7 +599,7 @@ def test_finds_in_second_search_dir(self):
                 os.makedirs(tpath)
                 cfg = os.path.join(tpath, "devcontainer.json")
                 open(cfg, "w").close()
-                with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": os.pathsep.join([d1, d2])}):
+                with patch.object(devcode, "_load_settings", return_value={"template_sources": [d1, d2]}):
                     result = devcode.resolve_template("mytemplate")
         self.assertEqual(result, cfg)
 
@@ -532,24 +695,25 @@ def setUp(self):
         tpl = os.path.join(self.tmpdir, "claude", ".devcontainer")
         os.makedirs(tpl)
         open(os.path.join(tpl, "devcontainer.json"), "w").close()
-        self.env_patch = patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": self.tmpdir})
-        self.env_patch.start()
+        self.patch_settings = patch.object(devcode, "_load_settings", return_value={"template_sources": [self.tmpdir]})
+        self.patch_settings.start()
 
     def tearDown(self):
-        self.env_patch.stop()
+        self.patch_settings.stop()
         shutil.rmtree(self.tmpdir, ignore_errors=True)
 
     def test_projectpath_root_exits(self):
-        with patch.object(sys, "argv", ["devcode", "open", "claude", "/"]):
+        with patch.object(sys, "argv", ["devcode", "open", "/", "claude"]):
             with self.assertRaises(SystemExit):
                 devcode.main()
 
     def test_code_not_on_path_exits(self):
-        with patch.object(sys, "argv", ["devcode", "open", "claude", "/myproject"]):
-            with patch.object(devcode, "_git_repo_root", return_value=None):
-                with patch("shutil.which", return_value=None):
-                    with self.assertRaises(SystemExit):
-                        devcode.main()
+        with patch.object(sys, "argv", ["devcode", "open", "/myproject", "claude"]):
+            with patch("os.path.exists", return_value=True):
+                with patch.object(devcode, "_git_repo_root", return_value=None):
+                    with patch("shutil.which", return_value=None):
+                        with self.assertRaises(SystemExit):
+                            devcode.main()
 
     def test_launches_vscode_with_folder_uri(self):
         launched = []
@@ -557,12 +721,13 @@ def fake_popen(cmd, **kw):
             launched.append(cmd)
             return MagicMock()
 
-        with patch.object(sys, "argv", ["devcode", "open", "claude", "/myproject"]):
-            with patch("shutil.which", return_value="/usr/bin/code"):
-                with patch.object(devcode, "_git_repo_root", return_value=None):
-                    with patch("subprocess.Popen", side_effect=fake_popen):
-                        with patch.object(devcode, "run_post_launch"):
-                            devcode.main()
+        with patch.object(sys, "argv", ["devcode", "open", "/myproject", "claude"]):
+            with patch("os.path.exists", return_value=True):
+                with patch("shutil.which", return_value="/usr/bin/code"):
+                    with patch.object(devcode, "_git_repo_root", return_value=None):
+                        with patch("subprocess.Popen", side_effect=fake_popen):
+                            with patch.object(devcode, "run_post_launch"):
+                                devcode.main()
 
         self.assertEqual(len(launched), 1)
         self.assertEqual(launched[0][0], "code")
@@ -575,12 +740,13 @@ def fake_popen(cmd, **kw):
             launched.append(cmd)
             return MagicMock()
 
-        with patch.object(sys, "argv", ["devcode", "open", "claude", "/myproject"]):
-            with patch("shutil.which", return_value="/usr/bin/code"):
-                with patch.object(devcode, "_git_repo_root", return_value=None):
-                    with patch("subprocess.Popen", side_effect=fake_popen):
-                        with patch.object(devcode, "run_post_launch"):
-                            devcode.main()
+        with patch.object(sys, "argv", ["devcode", "open", "/myproject", "claude"]):
+            with patch("os.path.exists", return_value=True):
+                with patch("shutil.which", return_value="/usr/bin/code"):
+                    with patch.object(devcode, "_git_repo_root", return_value=None):
+                        with patch("subprocess.Popen", side_effect=fake_popen):
+                            with patch.object(devcode, "run_post_launch"):
+                                devcode.main()
 
         self.assertIn("/workspaces/myproject", launched[0][2])
 
@@ -590,12 +756,13 @@ def fake_popen(cmd, **kw):
             launched.append(cmd)
             return MagicMock()
 
-        with patch.object(sys, "argv", ["devcode", "open", "claude", "/myproject", "--container-folder", "/workspace/custom"]):
-            with patch("shutil.which", return_value="/usr/bin/code"):
-                with patch.object(devcode, "_git_repo_root", return_value=None):
-                    with patch("subprocess.Popen", side_effect=fake_popen):
-                        with patch.object(devcode, "run_post_launch"):
-                            devcode.main()
+        with patch.object(sys, "argv", ["devcode", "open", "/myproject", "claude", "--container-folder", "/workspace/custom"]):
+            with patch("os.path.exists", return_value=True):
+                with patch("shutil.which", return_value="/usr/bin/code"):
+                    with patch.object(devcode, "_git_repo_root", return_value=None):
+                        with patch("subprocess.Popen", side_effect=fake_popen):
+                            with patch.object(devcode, "run_post_launch"):
+                                devcode.main()
 
         self.assertIn("/workspace/custom", launched[0][2])
 
@@ -604,12 +771,13 @@ def test_timeout_passed_to_run_post_launch(self):
         def fake_rpl(config_file, project_path, timeout):
             captured["timeout"] = timeout
 
-        with patch.object(sys, "argv", ["devcode", "open", "claude", "/myproject", "--timeout", "42"]):
-            with patch("shutil.which", return_value="/usr/bin/code"):
-                with patch.object(devcode, "_git_repo_root", return_value=None):
-                    with patch("subprocess.Popen", return_value=MagicMock()):
-                        with patch.object(devcode, "run_post_launch", side_effect=fake_rpl):
-                            devcode.main()
+        with patch.object(sys, "argv", ["devcode", "open", "/myproject", "claude", "--timeout", "42"]):
+            with patch("os.path.exists", return_value=True):
+                with patch("shutil.which", return_value="/usr/bin/code"):
+                    with patch.object(devcode, "_git_repo_root", return_value=None):
+                        with patch("subprocess.Popen", return_value=MagicMock()):
+                            with patch.object(devcode, "run_post_launch", side_effect=fake_rpl):
+                                devcode.main()
 
         self.assertEqual(captured["timeout"], 42)
 
@@ -618,12 +786,13 @@ def test_default_timeout_is_300(self):
         def fake_rpl(config_file, project_path, timeout):
             captured["timeout"] = timeout
 
-        with patch.object(sys, "argv", ["devcode", "open", "claude", "/myproject"]):
-            with patch("shutil.which", return_value="/usr/bin/code"):
-                with patch.object(devcode, "_git_repo_root", return_value=None):
-                    with patch("subprocess.Popen", return_value=MagicMock()):
-                        with patch.object(devcode, "run_post_launch", side_effect=fake_rpl):
-                            devcode.main()
+        with patch.object(sys, "argv", ["devcode", "open", "/myproject", "claude"]):
+            with patch("os.path.exists", return_value=True):
+                with patch("shutil.which", return_value="/usr/bin/code"):
+                    with patch.object(devcode, "_git_repo_root", return_value=None):
+                        with patch("subprocess.Popen", return_value=MagicMock()):
+                            with patch.object(devcode, "run_post_launch", side_effect=fake_rpl):
+                                devcode.main()
 
         self.assertEqual(captured["timeout"], 300)
 
@@ -634,37 +803,40 @@ def setUp(self):
         tpl = os.path.join(self.tmpdir, "claude", ".devcontainer")
         os.makedirs(tpl)
         open(os.path.join(tpl, "devcontainer.json"), "w").close()
-        self.env_patch = patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": self.tmpdir})
-        self.env_patch.start()
+        self.patch_settings = patch.object(devcode, "_load_settings", return_value={"template_sources": [self.tmpdir]})
+        self.patch_settings.start()
 
     def tearDown(self):
-        self.env_patch.stop()
+        self.patch_settings.stop()
         shutil.rmtree(self.tmpdir, ignore_errors=True)
 
     def test_subdir_of_git_repo_exits(self):
         """Guard fires when git root differs from project_path."""
-        with patch.object(sys, "argv", ["devcode", "open", "claude", "/repo/subproject"]):
-            with patch.object(devcode, "_git_repo_root", return_value="/repo"):
-                with self.assertRaises(SystemExit):
-                    devcode.main()
+        with patch.object(sys, "argv", ["devcode", "open", "/repo/subproject", "claude"]):
+            with patch("os.path.exists", return_value=True):
+                with patch.object(devcode, "_git_repo_root", return_value="/repo"):
+                    with self.assertRaises(SystemExit):
+                        devcode.main()
 
     def test_project_is_git_root_does_not_exit(self):
         """Guard does not fire when project_path IS the git root."""
-        with patch.object(sys, "argv", ["devcode", "open", "claude", "/repo"]):
-            with patch.object(devcode, "_git_repo_root", return_value="/repo"):
-                with patch("shutil.which", return_value="/usr/bin/code"):
-                    with patch("subprocess.Popen", return_value=MagicMock()):
-                        with patch.object(devcode, "run_post_launch"):
-                            devcode.main()  # must not raise
+        with patch.object(sys, "argv", ["devcode", "open", "/repo", "claude"]):
+            with patch("os.path.exists", return_value=True):
+                with patch.object(devcode, "_git_repo_root", return_value="/repo"):
+                    with patch("shutil.which", return_value="/usr/bin/code"):
+                        with patch("subprocess.Popen", return_value=MagicMock()):
+                            with patch.object(devcode, "run_post_launch"):
+                                devcode.main()  # must not raise
 
     def test_not_in_git_repo_does_not_exit(self):
         """Guard does not fire when _git_repo_root returns None."""
-        with patch.object(sys, "argv", ["devcode", "open", "claude", "/myproject"]):
-            with patch.object(devcode, "_git_repo_root", return_value=None):
-                with patch("shutil.which", return_value="/usr/bin/code"):
-                    with patch("subprocess.Popen", return_value=MagicMock()):
-                        with patch.object(devcode, "run_post_launch"):
-                            devcode.main()  # must not raise
+        with patch.object(sys, "argv", ["devcode", "open", "/myproject", "claude"]):
+            with patch("os.path.exists", return_value=True):
+                with patch.object(devcode, "_git_repo_root", return_value=None):
+                    with patch("shutil.which", return_value="/usr/bin/code"):
+                        with patch("subprocess.Popen", return_value=MagicMock()):
+                            with patch.object(devcode, "run_post_launch"):
+                                devcode.main()  # must not raise
 
     def test_git_not_available_does_not_exit(self):
         """_git_repo_root returns None when git is unavailable (OSError)."""
@@ -1115,7 +1287,8 @@ def _make_template_with_name(self, base_dir, template_name, devcontainer_name):
 
     def _run_list(self, search_path, long=False):
         lines = []
-        with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": search_path}):
+        dirs = [d for d in search_path.split(os.pathsep) if d]
+        with patch.object(devcode, "_load_settings", return_value={"template_sources": dirs}):
             args = MagicMock(subcommand="list", verbose=False, long=long)
             with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
                 devcode.cmd_list(args)
@@ -1260,7 +1433,7 @@ def test_creates_template_from_default_base_legacy_env(self):
                 args = MagicMock(subcommand="new", verbose=False,
                                  base=None, edit=False)
                 args.name = "myapp"
-                with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": user_dir}):
+                with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir]}):
                     with patch.object(devcode, "__file__", os.path.join(pkg_dir, "devcode.py")):
                         devcode.cmd_new(args)
                 self.assertTrue(os.path.isdir(os.path.join(user_dir, "myapp")))
@@ -1275,7 +1448,7 @@ def test_creates_template_from_explicit_base(self):
             args = MagicMock(subcommand="new", verbose=False,
                              base="mybase", edit=False)
             args.name = "myapp"
-            with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": user_dir}):
+            with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir]}):
                 devcode.cmd_new(args)
             self.assertTrue(os.path.isdir(os.path.join(user_dir, "myapp")))
 
@@ -1286,7 +1459,7 @@ def test_exits_if_name_already_exists(self):
             args = MagicMock(subcommand="new", verbose=False,
                              base=None, edit=False)
             args.name = "myapp"
-            with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": user_dir}):
+            with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir]}):
                 with self.assertRaises(SystemExit):
                     devcode.cmd_new(args)
 
@@ -1296,7 +1469,7 @@ def test_exits_if_base_not_found(self):
                 args = MagicMock(subcommand="new", verbose=False,
                                  base="no-such-base", edit=False)
                 args.name = "myapp"
-                with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": user_dir}):
+                with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir]}):
                     with patch.object(devcode, "__file__", os.path.join(pkg_dir, "devcode.py")):
                         with self.assertRaises(SystemExit):
                             devcode.cmd_new(args)
@@ -1308,7 +1481,7 @@ def test_edit_flag_calls_cmd_open(self):
                 args = MagicMock(subcommand="new", verbose=False,
                                  base=None, edit=True)
                 args.name = "myapp"
-                with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": user_dir}):
+                with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir]}):
                     with patch.object(devcode, "__file__", os.path.join(pkg_dir, "devcode.py")):
                         with patch.object(devcode, "cmd_open") as mock_open:
                             devcode.cmd_new(args)
@@ -1323,7 +1496,7 @@ def test_creates_template_from_default_base(self):
             with tempfile.TemporaryDirectory() as user_dir:
                 args = MagicMock(subcommand="new", verbose=False, base=None, edit=False)
                 args.name = "myapp"
-                with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": user_dir}):
+                with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir]}):
                     with patch.object(devcode, "__file__", os.path.join(pkg_dir, "devcode.py")):
                         devcode.cmd_new(args)
                 self.assertTrue(os.path.isdir(os.path.join(user_dir, "myapp")))
@@ -1336,7 +1509,7 @@ def test_base_found_in_second_search_dir(self):
                 open(os.path.join(base, "devcontainer.json"), "w").close()
                 args = MagicMock(subcommand="new", verbose=False, base="mybase", edit=False)
                 args.name = "myapp"
-                with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": os.pathsep.join([d1, d2])}):
+                with patch.object(devcode, "_load_settings", return_value={"template_sources": [d1, d2]}):
                     devcode.cmd_new(args)
                 # writes to first dir
                 self.assertTrue(os.path.isdir(os.path.join(d1, "myapp")))
@@ -1354,7 +1527,7 @@ def test_named_template_opens_root_in_code(self):
         with tempfile.TemporaryDirectory() as d:
             root = self._make_template(d, "mytemplate")
             args = MagicMock(subcommand="edit", verbose=False, template="mytemplate")
-            with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": d}):
+            with patch.object(devcode, "_load_settings", return_value={"template_sources": [d]}):
                 with patch("subprocess.run") as mock_run:
                     devcode.cmd_edit(args)
             mock_run.assert_called_once_with(["code", root])
@@ -1364,7 +1537,7 @@ def test_named_template_found_in_second_dir(self):
             with tempfile.TemporaryDirectory() as d2:
                 root = self._make_template(d2, "mytemplate")
                 args = MagicMock(subcommand="edit", verbose=False, template="mytemplate")
-                with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": os.pathsep.join([d1, d2])}):
+                with patch.object(devcode, "_load_settings", return_value={"template_sources": [d1, d2]}):
                     with patch("subprocess.run") as mock_run:
                         devcode.cmd_edit(args)
                 mock_run.assert_called_once_with(["code", root])
@@ -1372,7 +1545,7 @@ def test_named_template_found_in_second_dir(self):
     def test_named_template_not_found_exits(self):
         with tempfile.TemporaryDirectory() as d:
             args = MagicMock(subcommand="edit", verbose=False, template="no-such")
-            with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": d}):
+            with patch.object(devcode, "_load_settings", return_value={"template_sources": [d]}):
                 with self.assertRaises(SystemExit):
                     devcode.cmd_edit(args)
 
@@ -1387,7 +1560,7 @@ def test_does_not_call_cmd_open(self):
         with tempfile.TemporaryDirectory() as d:
             self._make_template(d, "mytemplate")
             args = MagicMock(subcommand="edit", verbose=False, template="mytemplate")
-            with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": d}):
+            with patch.object(devcode, "_load_settings", return_value={"template_sources": [d]}):
                 with patch.object(devcode, "cmd_open") as mock_open:
                     with patch("subprocess.run"):
                         devcode.cmd_edit(args)
@@ -1661,9 +1834,11 @@ def _run_dry_run(self, user_dir, template, projectpath, container_folder=None):
             dry_run=True,
             verbose=False,
         )
-        with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": user_dir}):
-            with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
-                devcode.cmd_open(args)
+        with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir]}):
+            with patch("os.path.exists", return_value=True):
+                with patch.object(devcode, "_git_repo_root", return_value=None):
+                    with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
+                        devcode.cmd_open(args)
         return lines
 
     def test_prints_config_and_uri(self):
@@ -1716,13 +1891,15 @@ def test_unset_env_var_shown_as_placeholder(self):
                 {"source": "${localEnv:NONEXISTENT_VAR_XYZ}", "target": "/home/vscode/x"}
             ])
             with patch.dict(os.environ, env_clean, clear=True):
-                with patch.dict(os.environ, {"DEVCODE_TEMPLATE_PATH": user_dir}):
-                    lines = []
-                    args = argparse.Namespace(template="mytemplate", projectpath="/myproject",
-                                              container_folder=None, timeout=300, dry_run=True,
-                                              verbose=False)
-                    with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
-                        devcode.cmd_open(args)
+                with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir]}):
+                    with patch("os.path.exists", return_value=True):
+                        with patch.object(devcode, "_git_repo_root", return_value=None):
+                            lines = []
+                            args = argparse.Namespace(template="mytemplate", projectpath="/myproject",
+                                                      container_folder=None, timeout=300, dry_run=True,
+                                                      verbose=False)
+                            with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
+                                devcode.cmd_open(args)
         combined = "\n".join(lines)
         self.assertIn("<unset:", combined)
 
@@ -1823,25 +2000,28 @@ def test_prefix_filters_subcommands(self):
         result = self._run(1, ["devcode", "op"])
         self.assertEqual(result, ["open"])
 
-    def test_open_index2_returns_template_names(self):
+    def test_open_index2_returns_empty(self):
+        # Position 2 is projectpath, shell handles filesystem completion
         result = self._run(2, ["devcode", "open", ""], template_names=["alpha", "beta"])
+        self.assertEqual(result, [])
+
+    def test_open_index3_returns_template_names(self):
+        # Position 3 is optional template name
+        result = self._run(3, ["devcode", "open", "/myproject", ""], template_names=["alpha", "beta"])
         self.assertIn("alpha", result)
         self.assertIn("beta", result)
 
-    def test_open_index2_prefix_filters_templates(self):
-        result = self._run(2, ["devcode", "open", "al"], template_names=["alpha", "beta"])
+    def test_open_index3_prefix_filters_templates(self):
+        result = self._run(3, ["devcode", "open", "/myproject", "al"], template_names=["alpha", "beta"])
         self.assertEqual(result, ["alpha"])
 
-    def test_open_index3_returns_empty(self):
-        result = self._run(3, ["devcode", "open", "mytemplate", ""])
-        self.assertEqual(result, [])
-
     def test_open_index4_returns_empty(self):
-        result = self._run(4, ["devcode", "open", "mytemplate", "/path", ""])
+        result = self._run(4, ["devcode", "open", "/myproject", "mytemplate", ""])
         self.assertEqual(result, [])
 
     def test_open_flag_completion_at_index3(self):
-        result = self._run(3, ["devcode", "open", "mytemplate", "--"])
+        # Position 3 can have --flags or optional template name
+        result = self._run(3, ["devcode", "open", "/myproject", "--"])
         self.assertIn("--dry-run", result)
         self.assertIn("--container-folder", result)
         self.assertIn("--timeout", result)
@@ -1983,3 +2163,24 @@ def test_unknown_shell_exits_1(self):
         with self.assertRaises(SystemExit) as cm:
             devcode.cmd_completion(args)
         self.assertEqual(cm.exception.code, 1)
+
+
+class TestCompletionOpenArgOrder(unittest.TestCase):
+    def _run_completion(self, words):
+        """Invoke cmd_completion in --complete mode, return printed lines."""
+        args = argparse.Namespace(complete_words=words, shell=None)
+        captured = []
+        with patch("builtins.print", side_effect=lambda *a, **kw: captured.append(str(a[0]) if a else "")):
+            with self.assertRaises(SystemExit):
+                devcode.cmd_completion(args)
+        return captured
+
+    def test_position_2_returns_no_template_candidates(self):
+        with patch.object(devcode, "_list_template_names", return_value=["mytemplate"]):
+            candidates = self._run_completion(["2", "devcode", "open", ""])
+        self.assertNotIn("mytemplate", candidates)
+
+    def test_position_3_returns_template_names(self):
+        with patch.object(devcode, "_list_template_names", return_value=["mytemplate"]):
+            candidates = self._run_completion(["3", "devcode", "open", "/myproject", ""])
+        self.assertIn("mytemplate", candidates)

From c992f8f4e3059dff4e730788662be191c1161f47 Mon Sep 17 00:00:00 2001
From: Nasser Alansari <dacrystal@users.noreply.github.com>
Date: Tue, 7 Apr 2026 11:51:31 +0000
Subject: [PATCH 3/9] feat: migrate CLI from argparse to click with dynamic
 shell completion
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Replace argparse with click>=8.0 throughout src/devcode.py
- Add dynamic shell completion for template names (open, edit commands)
- Extract _do_open() helper; inline cmd_* logic into click commands
- Remove hand-rolled completion subcommand (_BASH_COMPLETION, _ZSH_COMPLETION)
- Update entry point: devcode:main → devcode:cli
- Update tests: CliRunner for CLI tests, .callback() for unit tests
- Add _complete_templates tests; 184 tests passing
---
 ...ekyll-gh-pages.yml => deploy-gh-pages.yml} |   5 +-
 .../{publish.yml => publish-pypi.yml}         |   2 +-
 .gitignore                                    |  38 ++
 Makefile                                      |  42 ++
 README.md                                     |   2 +-
 assets/demo.gif                               | Bin 0 -> 392983 bytes
 cliff.toml                                    |  45 ++
 pyproject.toml                                |  23 +-
 src/devcode.py                                | 297 +++-----
 tests/test_dev_code.py                        | 646 +++++++-----------
 uv.lock                                       | 479 -------------
 11 files changed, 473 insertions(+), 1106 deletions(-)
 rename .github/workflows/{jekyll-gh-pages.yml => deploy-gh-pages.yml} (88%)
 rename .github/workflows/{publish.yml => publish-pypi.yml} (95%)
 create mode 100644 Makefile
 create mode 100644 assets/demo.gif
 create mode 100644 cliff.toml
 delete mode 100644 uv.lock

diff --git a/.github/workflows/jekyll-gh-pages.yml b/.github/workflows/deploy-gh-pages.yml
similarity index 88%
rename from .github/workflows/jekyll-gh-pages.yml
rename to .github/workflows/deploy-gh-pages.yml
index abea45d..8ce1918 100644
--- a/.github/workflows/jekyll-gh-pages.yml
+++ b/.github/workflows/deploy-gh-pages.yml
@@ -1,9 +1,9 @@
 # Sample workflow for building and deploying a Jekyll site to GitHub Pages
-name: Deploy Jekyll with GitHub Pages dependencies preinstalled
+name: Deploy GitHub Pages
 
 on:
   workflow_run:
-    workflows: ["publish"] 
+    workflows: ["Publish to PyPI"] 
     types: [completed]
 
   # Allows you to run this workflow manually from the Actions tab
@@ -25,6 +25,7 @@ jobs:
   # Build job
   build:
     runs-on: ubuntu-latest
+    if: ${{ github.event.workflow_run.conclusion == 'success' || github.event_name == 'workflow_dispatch' }}
     steps:
       - name: Checkout
         uses: actions/checkout@v4
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish-pypi.yml
similarity index 95%
rename from .github/workflows/publish.yml
rename to .github/workflows/publish-pypi.yml
index 2ad2f8b..236c04f 100644
--- a/.github/workflows/publish.yml
+++ b/.github/workflows/publish-pypi.yml
@@ -1,4 +1,4 @@
-name: Publish
+name: Publish to PyPi
 
 on:
   push:
diff --git a/.gitignore b/.gitignore
index fe89a3a..298d749 100644
--- a/.gitignore
+++ b/.gitignore
@@ -175,3 +175,41 @@ pyrightconfig.json
 
 # End of https://www.toptal.com/developers/gitignore/api/python
 
+# Created by https://www.toptal.com/developers/gitignore/api/macos
+# Edit at https://www.toptal.com/developers/gitignore?templates=macos
+
+### macOS ###
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+### macOS Patch ###
+# iCloud generated files
+*.icloud
+
+# End of https://www.toptal.com/developers/gitignore/api/macos
+uv.lock
\ No newline at end of file
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..853dd52
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,42 @@
+.PHONY: lint typecheck test all \
+        changelog changelog-preview changelog-bump release
+
+# ── CI / quality ────────────────────────────────────────────────────────────
+
+lint:
+	ruff check .
+
+typecheck:
+	mypy src/
+
+test:
+	pytest --cov=src --cov-report=term-missing
+
+all: lint typecheck test
+
+# ── Changelog / release ──────────────────────────────────────────────────────
+
+# Preview what the next changelog entry will look like (dry-run, no files changed)
+changelog-preview:
+	git cliff --unreleased --bump
+
+# Show what the next version number will be
+changelog-bump:
+	git cliff --bumped-version
+
+# Prepend new entries to CHANGELOG.md for the next release
+changelog:
+	$(eval VERSION := $(shell git cliff --bumped-version 2>/dev/null))
+	touch CHANGELOG.md
+	git cliff --unreleased --prepend CHANGELOG.md --bump
+	@echo "CHANGELOG.md updated to $(VERSION). Review, then run: make release"
+
+# Full release: update changelog, commit, tag, push
+release:
+	$(eval VERSION := $(shell git cliff --bumped-version 2>/dev/null))
+	git add CHANGELOG.md
+	@git commit -m "chore: release $(VERSION)" || { echo "Error: CHANGELOG.md unchanged. Run 'make changelog' first."; exit 1; }
+	git tag $(VERSION)
+	git push origin main
+	git push origin $(VERSION)
+	@echo "Released $(VERSION)"
\ No newline at end of file
diff --git a/README.md b/README.md
index cc17195..299ea19 100644
--- a/README.md
+++ b/README.md
@@ -20,7 +20,7 @@ Reusable Dev Containers for any project — without modifying the repository.
 
 ---
 
-![](https://github.com/dacrystal/dev-code/raw/main/demo/demo.gif "Demo gif")
+![](assets/demo.gif "Demo gif")
 
 `devcode` is a CLI that opens any project in VS Code Dev Containers using reusable, local templates.
 
diff --git a/assets/demo.gif b/assets/demo.gif
new file mode 100644
index 0000000000000000000000000000000000000000..8bf9b174f48fb641ab363be6213c2e6dcd104707
GIT binary patch
literal 392983
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

literal 0
HcmV?d00001

diff --git a/cliff.toml b/cliff.toml
new file mode 100644
index 0000000..2ca5ad5
--- /dev/null
+++ b/cliff.toml
@@ -0,0 +1,45 @@
+# git-cliff configuration
+# https://git-cliff.org/docs/configuration
+
+[changelog]
+body = """
+{% if version %}\
+    ## [{{ version | trim_start_matches(pat="v") }}] - {{ timestamp | date(format="%Y-%m-%d") }}
+{% else %}\
+    ## [Unreleased]
+{% endif %}\
+{% for group, commits in commits | group_by(attribute="group") %}
+    ### {{ group | striptags | trim | upper_first }}
+    {% for commit in commits %}
+        - {% if commit.scope %}*({{ commit.scope }})* {% endif %}\
+            {% if commit.breaking %}[**breaking**] {% endif %}\
+            {{ commit.message | upper_first }}\
+    {% endfor %}
+{% endfor %}\n
+"""
+trim = true
+render_always = true
+postprocessors = [
+    { pattern = "<REPO>", replace = "https://github.com/dacrystal/dev-code" },
+]
+
+[git]
+conventional_commits = true
+filter_unconventional = true
+split_commits = false
+commit_preprocessors = [
+    { pattern = '\((\w+\s)?#([0-9]+)\)', replace = "([#${2}](<REPO>/issues/${2}))" },
+]
+commit_parsers = [
+    { message = "^feat", group = "Added" },
+    { message = "^fix", group = "Fixed" },
+    { message = "^refactor", group = "Changed" },
+    { message = "^perf", group = "Changed" },
+    { message = "^revert", group = "Fixed" },
+    { message = "^docs|^chore|^ci|^style|^test", skip = true },
+]
+filter_commits = true
+protect_breaking_commits = true
+sort_commits = "oldest"
+topo_order = false
+skip_tags = "v*.*.*.post"
\ No newline at end of file
diff --git a/pyproject.toml b/pyproject.toml
index f0a1c29..e3b04d8 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,14 +1,16 @@
 [build-system]
-requires = ["hatchling", "hatch-vcs"]
+requires = ["hatchling", "hatch-vcs", "hatch-fancy-pypi-readme"]
 build-backend = "hatchling.build"
 
 [project]
 name = "dev-code"
-dynamic = ["version"]
+dynamic = ["version", "readme"]
 description = "Project · editor · container — simplified"
-readme = "README.md"
 requires-python = ">=3.10"
-dependencies = []
+authors = [
+    {name = "Nasser Alansari", email = "dacrystal@users.noreply.github.com"},
+]
+dependencies = ["click>=8.0"]
 classifiers = [
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.10",
@@ -24,7 +26,7 @@ classifiers = [
 "Issues" = "https://github.com/dacrystal/dev-code/issues"
 
 [project.scripts]
-devcode = "devcode:main"
+devcode = "devcode:cli"
 
 [tool.hatch.version]
 source = "vcs"
@@ -42,4 +44,15 @@ dev = [
     "pytest-cov>=4.0",
     "tox>=4.0",
     "pyyaml>=6.0",
+    "git-cliff>=2.0",
 ]
+
+[tool.hatch.metadata.hooks.fancy-pypi-readme]
+content-type = "text/markdown"
+
+[[tool.hatch.metadata.hooks.fancy-pypi-readme.fragments]]
+path = "README.md"
+
+[[tool.hatch.metadata.hooks.fancy-pypi-readme.substitutions]]
+pattern = '\(assets/'
+replacement = "(https://raw.githubusercontent.com/dacrystal/dev-code/main/assets/"
diff --git a/src/devcode.py b/src/devcode.py
index 4d3bb22..ed953d3 100644
--- a/src/devcode.py
+++ b/src/devcode.py
@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
-import argparse
+import click
+import click.shell_completion
 import importlib.metadata
 import json
 import logging
@@ -30,38 +31,6 @@
     "default_template": "dev-code",
 }
 
-_BASH_COMPLETION = """\
-# devcode bash completion
-# Requires bash 4.0+ (macOS ships bash 3.2; install bash 5 via Homebrew if needed).
-_dev_code() {
-    local -a candidates
-    mapfile -t candidates < <(devcode completion --complete "$COMP_CWORD" "${COMP_WORDS[@]}" 2>/dev/null)
-    if [[ ${#candidates[@]} -eq 0 ]]; then
-        local cur="${COMP_WORDS[COMP_CWORD]}"
-        mapfile -t COMPREPLY < <(compgen -f -- "$cur")
-    else
-        COMPREPLY=("${candidates[@]}")
-    fi
-}
-complete -F _dev_code devcode
-"""
-
-_ZSH_COMPLETION = """\
-# devcode zsh completion
-_dev_code() {
-    local candidates
-    candidates=$(devcode completion --complete "$(( CURRENT - 1 ))" "${words[@]}" 2>/dev/null)
-    if [[ -z "$candidates" ]]; then
-        _files
-    else
-        compadd -- ${(f)candidates}
-    fi
-}
-# Note: compdef requires compinit to have been called first.
-compdef _dev_code devcode
-"""
-
-
 def _configure_logging(verbose: bool) -> None:
     """Configure the module logger. Guard prevents double-registration."""
     if logger.handlers:
@@ -593,12 +562,12 @@ def _find_container_config_for_project(project_path: str) -> str | None:
     return None
 
 
-def cmd_open(args) -> None:
-    """open subcommand: open a project in VS Code using a devcontainer template."""
-    project_path = os.path.abspath(args.projectpath)
+def _do_open(projectpath: str, template, container_folder, timeout: int, dry_run: bool) -> None:
+    """Core open logic shared by the open command and internal callers."""
+    project_path = os.path.abspath(projectpath)
 
     if not os.path.exists(project_path):
-        logger.error("projectpath not found: %s", args.projectpath)
+        logger.error("projectpath not found: %s", projectpath)
         sys.exit(1)
 
     if project_path == "/":
@@ -616,8 +585,8 @@ def cmd_open(args) -> None:
             )
             sys.exit(1)
 
-    if args.template:
-        config_file = resolve_template(args.template)
+    if template:
+        config_file = resolve_template(template)
     else:
         config_file = _find_container_config_for_project(project_path)
         if config_file is None:
@@ -630,10 +599,10 @@ def cmd_open(args) -> None:
                 sys.exit(1)
             config_file = resolve_template(default)
 
-    container_folder = args.container_folder or f"/workspaces/{os.path.basename(project_path)}"
+    container_folder = container_folder or f"/workspaces/{os.path.basename(project_path)}"
     uri = build_devcontainer_uri(project_path, config_file, container_folder)
 
-    if args.dry_run:
+    if dry_run:
         _cmd_open_dry_run(config_file, project_path, uri)
         return
 
@@ -642,7 +611,7 @@ def cmd_open(args) -> None:
         sys.exit(1)
 
     subprocess.Popen(["code", "--folder-uri", uri], start_new_session=True)
-    run_post_launch(config_file, project_path, args.timeout)
+    run_post_launch(config_file, project_path, timeout)
 
 
 def _cmd_open_dry_run(config_file: str, project_path: str, uri: str) -> None:
@@ -686,18 +655,70 @@ def _cmd_open_dry_run(config_file: str, project_path: str, uri: str) -> None:
     print("(dry run — no operations executed)")
 
 
-def cmd_new(args) -> None:
+def _template_name_from_config(config_path: str) -> str:
+    """Extract template name as the directory immediately above .devcontainer/."""
+    norm = os.path.normpath(config_path)
+    parts = norm.replace("\\", "/").split("/")
+    for i, part in enumerate(parts):
+        if part == ".devcontainer" and i > 0:
+            return parts[i - 1]
+    return os.path.basename(os.path.dirname(os.path.dirname(norm)))
+
+
+def _complete_templates(ctx, param, incomplete):
+    """Shell completion callback: return template names matching the incomplete prefix."""
+    return [
+        click.shell_completion.CompletionItem(t)
+        for t in _list_template_names()
+        if t.startswith(incomplete)
+    ]
+
+
+@click.group(invoke_without_command=True)
+@click.version_option(package_name="dev-code", prog_name="devcode")
+@click.option(
+    "-v", "--verbose",
+    is_flag=True,
+    is_eager=True,
+    expose_value=False,
+    callback=lambda ctx, param, v: _configure_logging(v),
+)
+@click.pass_context
+def cli(ctx):
+    """project · editor · container — simplified."""
+    if ctx.invoked_subcommand is None:
+        click.echo(BANNER)
+        click.echo(ctx.get_help())
+
+
+@cli.command("open")
+@click.argument("projectpath")
+@click.argument("template", required=False, shell_complete=_complete_templates)
+@click.option("--container-folder", default=None, help="Path inside the container.")
+@click.option("--timeout", type=int, default=300, show_default=True,
+              help="Seconds to wait for devcontainer to start.")
+@click.option("--dry-run", is_flag=True, help="Print plan without executing.")
+def open_command(projectpath, template, container_folder, timeout, dry_run):
+    """Open a project in VS Code using a devcontainer template."""
+    _do_open(projectpath, template, container_folder, timeout, dry_run)
+
+
+@cli.command("new")
+@click.argument("name")
+@click.argument("base", required=False)
+@click.option("--edit", is_flag=True, help="Open the new template in VS Code after creating it.")
+def new_command(name, base, edit):
     """Create a new template by copying a base template."""
     write_dir = _write_template_dir()
-    dest = os.path.join(write_dir, args.name)
+    dest = os.path.join(write_dir, name)
 
     # Step 1: fail if name already exists
     if os.path.exists(dest):
-        logger.error("template '%s' already exists: %s", args.name, dest)
+        logger.error("template '%s' already exists: %s", name, dest)
         sys.exit(1)
 
     # Step 2: resolve base — search all dirs, then builtins
-    base_name = args.base or "dev-code"
+    base_name = base or "dev-code"
     base_root = _find_template_in_search_path(base_name)
     if base_root:
         base_src = base_root
@@ -718,32 +739,35 @@ def cmd_new(args) -> None:
 
     # Step 5: copy
     shutil.copytree(base_src, dest)
-    print(f"Created template '{args.name}' at {dest}")
+    print(f"Created template '{name}' at {dest}")
 
     # Step 6: --edit
-    if args.edit:
-        open_args = argparse.Namespace(
-            template=args.name,
+    if edit:
+        _do_open(
             projectpath=dest,
+            template=name,
             container_folder=None,
             timeout=300,
             dry_run=False,
         )
-        cmd_open(open_args)
 
 
-def cmd_edit(args) -> None:
-    """Open a template directory directly in VS Code for editing."""
-    template_root = _find_template_in_search_path(args.template)
+@cli.command("edit")
+@click.argument("template", shell_complete=_complete_templates)
+def edit_command(template):
+    """Open a template directory in VS Code for editing."""
+    template_root = _find_template_in_search_path(template)
     if template_root is None:
-        logger.error("template not found: %s", args.template)
+        logger.error("template not found: %s", template)
         sys.exit(1)
     subprocess.run(["code", template_root])
 
 
-def cmd_list(args) -> None:
+@cli.command("list")
+@click.option("--long", is_flag=True, help="Show description and path for each template.")
+def list_command(long):
     """List available templates."""
-    if not args.long:
+    if not long:
         names = _list_template_names()
         for name in names:
             print(name)
@@ -780,18 +804,11 @@ def cmd_list(args) -> None:
         print(_fmt_row(row, widths))
 
 
-def _template_name_from_config(config_path: str) -> str:
-    """Extract template name as the directory immediately above .devcontainer/."""
-    norm = os.path.normpath(config_path)
-    parts = norm.replace("\\", "/").split("/")
-    for i, part in enumerate(parts):
-        if part == ".devcontainer" and i > 0:
-            return parts[i - 1]
-    return os.path.basename(os.path.dirname(os.path.dirname(norm)))
-
-
-def cmd_ps(args) -> None:
-    """List devcontainers (running by default; all with -a)."""
+@cli.command("ps")
+@click.option("-a", "--all", "show_all", is_flag=True, help="Show all containers (not just running).")
+@click.option("-i", "--interactive", is_flag=True, help="Prompt to reopen a listed container.")
+def ps_command(show_all, interactive):
+    """List dev containers."""
     fmt = "{{.CreatedAt}}\t{{.ID}}\t{{.Label \"devcontainer.local_folder\"}}\t{{.Label \"devcontainer.config_file\"}}\t{{.Status}}"
     result = subprocess.run(
         ["docker", "container", "ls", "-a",
@@ -810,14 +827,14 @@ def cmd_ps(args) -> None:
     rows = [r[1:] for r in rows]  # now: [cid, local_folder, config_file, status]
 
     # Filter: without -a keep only running containers
-    if not args.all:
+    if not show_all:
         rows = [r for r in rows if len(r) >= 4 and r[3].startswith("Up")]
 
     # Always drop malformed rows so rows and display stay parallel
     rows = [r for r in rows if len(r) >= 4]
 
     if not rows:
-        print("no devcontainers" if args.all else "no running devcontainers")
+        print("no devcontainers" if show_all else "no running devcontainers")
         return
 
     # Build display rows: (num, cid, template, path, status)
@@ -834,7 +851,7 @@ def cmd_ps(args) -> None:
     for row in display:
         print(_fmt_row(row, widths))
 
-    if not args.interactive:
+    if not interactive:
         return
 
     choice = input(f"\nOpen [1-{len(display)}]: ").strip()
@@ -877,144 +894,14 @@ def cmd_ps(args) -> None:
     if not container_folder:
         container_folder = f"/workspaces/{os.path.basename(local_folder)}"
 
-    open_args = argparse.Namespace(
-        template=config_file,
+    _do_open(
         projectpath=projectpath,
+        template=config_file,
         container_folder=container_folder,
         timeout=300,
         dry_run=False,
     )
-    cmd_open(open_args)
-
-
-_SUBCOMMANDS = ["open", "new", "edit", "list", "ps", "completion"]
-
-_SUBCOMMAND_FLAGS = {
-    "open": ["--dry-run", "--container-folder", "--timeout"],
-    "new": ["--edit"],
-    "edit": [],
-    "list": ["--long"],
-    "ps": ["-a", "-i"],
-    "completion": [],
-}
-
-
-def cmd_completion(args) -> None:
-    """completion subcommand: print shell completion script or candidates to stdout."""
-    if args.complete_words is not None:
-        # Internal path: called by the shell completion scripts.
-        # Always exits 0; prints nothing on any error.
-        try:
-            words = args.complete_words
-            if not words:
-                sys.exit(0)
-            try:
-                cword_index = int(words[0])
-            except ValueError:
-                sys.exit(0)
-            words = words[1:]
-
-            if not (0 <= cword_index < len(words)):
-                sys.exit(0)
-
-            current_word = words[cword_index]
-
-            if cword_index == 1:
-                candidates = _SUBCOMMANDS
-            else:
-                subcommand = words[1] if len(words) > 1 else ""
-                if subcommand == "list":
-                    candidates = ["--long"]
-                elif subcommand == "completion":
-                    candidates = ["bash", "zsh"] if cword_index == 2 else []
-                elif current_word.startswith("-"):
-                    candidates = _SUBCOMMAND_FLAGS.get(subcommand, [])
-                else:
-                    if subcommand == "open" and cword_index == 3:
-                        candidates = _list_template_names()
-                    elif subcommand == "new" and cword_index == 3:
-                        candidates = _list_template_names()
-                    elif subcommand == "edit" and cword_index == 2:
-                        candidates = _list_template_names()
-                    else:
-                        candidates = []
-
-            for c in candidates:
-                if c.startswith(current_word):
-                    print(c)
-        except Exception:
-            pass
-        sys.exit(0)
-
-    if args.shell == "bash":
-        print(_BASH_COMPLETION, end="")
-    elif args.shell == "zsh":
-        print(_ZSH_COMPLETION, end="")
-    else:
-        logger.error("unknown shell %r: supported shells are bash and zsh", args.shell)
-        sys.exit(1)
-
-
-class _BannerParser(argparse.ArgumentParser):
-    """ArgumentParser that shows the banner only in full --help output, not in error usage lines."""
-
-    def format_help(self):
-        return BANNER + "\n\n" + super().format_help()
-
-
-def main():
-    try:
-        _version = importlib.metadata.version("dev-code")
-    except importlib.metadata.PackageNotFoundError:
-        _version = "(dev)"
-
-    parser = _BannerParser(prog="devcode")
-    parser.add_argument("--version", action="version", version=f"%(prog)s {_version}")
-    parser.add_argument("-v", "--verbose", action="store_true")
-    subparsers = parser.add_subparsers(dest="subcommand")
-
-    p_open = subparsers.add_parser("open")
-    p_open.add_argument("projectpath")
-    p_open.add_argument("template", nargs="?")
-    p_open.add_argument("--container-folder")
-    p_open.add_argument("--timeout", type=int, default=300)
-    p_open.add_argument("--dry-run", action="store_true", dest="dry_run")
-
-    p_new = subparsers.add_parser("new")
-    p_new.add_argument("name")
-    p_new.add_argument("base", nargs="?")
-    p_new.add_argument("--edit", action="store_true")
-
-    p_edit = subparsers.add_parser("edit")
-    p_edit.add_argument("template")
-
-    p_list = subparsers.add_parser("list")
-    p_list.add_argument("--long", action="store_true")
-
-    p_ps = subparsers.add_parser("ps")
-    p_ps.add_argument("-a", "--all", action="store_true", dest="all")
-    p_ps.add_argument("-i", "--interactive", action="store_true", dest="interactive")
-
-    p_completion = subparsers.add_parser("completion")
-    p_completion.add_argument("shell", nargs="?")
-    p_completion.add_argument("--complete", nargs="*", dest="complete_words", help=argparse.SUPPRESS)
-
-    args = parser.parse_args()
-    if args.subcommand is None:
-        parser.print_help()
-        sys.exit(0)
-    _configure_logging(args.verbose)
-
-    dispatch = {
-        "open": cmd_open,
-        "new": cmd_new,
-        "edit": cmd_edit,
-        "list": cmd_list,
-        "ps": cmd_ps,
-        "completion": cmd_completion,
-    }
-    dispatch[args.subcommand](args)
 
 
 if __name__ == "__main__":
-    main()
\ No newline at end of file
+    cli()
diff --git a/tests/test_dev_code.py b/tests/test_dev_code.py
index 0fd0180..d62a7ee 100644
--- a/tests/test_dev_code.py
+++ b/tests/test_dev_code.py
@@ -1,4 +1,3 @@
-import argparse
 import importlib.util
 import io
 import json
@@ -10,6 +9,8 @@
 import unittest
 from unittest.mock import MagicMock, patch
 
+from click.testing import CliRunner
+
 # Load src/devcode.py as a module
 spec = importlib.util.spec_from_file_location(
     "dev_code",
@@ -207,56 +208,41 @@ def test_returns_none_when_docker_not_installed(self):
 
 
 class TestCmdOpen(unittest.TestCase):
-    def _make_args(self, projectpath, template=None, container_folder=None,
-                   timeout=300, dry_run=False):
-        return argparse.Namespace(
-            projectpath=projectpath,
-            template=template,
-            container_folder=container_folder,
-            timeout=timeout,
-            dry_run=dry_run,
-        )
-
     def test_errors_on_nonexistent_projectpath(self):
-        args = self._make_args("/nonexistent/path/xyz123", template="mytemplate")
         with self.assertRaises(SystemExit):
-            devcode.cmd_open(args)
+            devcode._do_open("/nonexistent/path/xyz123", "mytemplate", None, 300, False)
 
     def test_errors_on_root_path(self):
         with tempfile.TemporaryDirectory() as tmp:
             # patch abspath to return "/" so the root guard triggers
             with patch("os.path.abspath", return_value="/"):
                 with patch("os.path.exists", return_value=True):
-                    args = self._make_args(tmp, template="mytemplate")
                     with self.assertRaises(SystemExit):
-                        devcode.cmd_open(args)
+                        devcode._do_open(tmp, "mytemplate", None, 300, False)
 
     def test_uses_explicit_template(self):
         with tempfile.TemporaryDirectory() as tmp:
-            args = self._make_args(tmp, template="mytemplate")
             with patch.object(devcode, "resolve_template", return_value="/fake/devcontainer.json") as mock_rt:
                 with patch.object(devcode, "_git_repo_root", return_value=None):
                     with patch("shutil.which", return_value="/usr/bin/code"):
                         with patch("subprocess.Popen"):
                             with patch.object(devcode, "run_post_launch"):
-                                devcode.cmd_open(args)
+                                devcode._do_open(tmp, "mytemplate", None, 300, False)
             mock_rt.assert_called_once_with("mytemplate")
 
     def test_auto_detects_from_container(self):
         with tempfile.TemporaryDirectory() as tmp:
-            args = self._make_args(tmp, template=None)
             with patch.object(devcode, "_find_container_config_for_project",
                                return_value="/found/devcontainer.json") as mock_find:
                 with patch.object(devcode, "_git_repo_root", return_value=None):
                     with patch("shutil.which", return_value="/usr/bin/code"):
                         with patch("subprocess.Popen"):
                             with patch.object(devcode, "run_post_launch"):
-                                devcode.cmd_open(args)
+                                devcode._do_open(tmp, None, None, 300, False)
             mock_find.assert_called_once()
 
     def test_auto_detects_falls_back_to_default_template(self):
         with tempfile.TemporaryDirectory() as tmp:
-            args = self._make_args(tmp, template=None)
             with patch.object(devcode, "_find_container_config_for_project", return_value=None):
                 with patch.object(devcode, "_load_settings",
                                    return_value={"default_template": "dev-code"}):
@@ -266,17 +252,16 @@ def test_auto_detects_falls_back_to_default_template(self):
                             with patch("shutil.which", return_value="/usr/bin/code"):
                                 with patch("subprocess.Popen"):
                                     with patch.object(devcode, "run_post_launch"):
-                                        devcode.cmd_open(args)
+                                        devcode._do_open(tmp, None, None, 300, False)
                 mock_rt.assert_called_once_with("dev-code")
 
     def test_errors_when_no_container_and_no_default_template(self):
         with tempfile.TemporaryDirectory() as tmp:
-            args = self._make_args(tmp, template=None)
             with patch.object(devcode, "_find_container_config_for_project", return_value=None):
                 with patch.object(devcode, "_load_settings", return_value={"default_template": ""}):
                     with patch.object(devcode, "_git_repo_root", return_value=None):
                         with self.assertRaises(SystemExit):
-                            devcode.cmd_open(args)
+                            devcode._do_open(tmp, None, None, 300, False)
 
 
 class TestConfDir(unittest.TestCase):
@@ -697,23 +682,28 @@ def setUp(self):
         open(os.path.join(tpl, "devcontainer.json"), "w").close()
         self.patch_settings = patch.object(devcode, "_load_settings", return_value={"template_sources": [self.tmpdir]})
         self.patch_settings.start()
+        # Snapshot logger handlers so we can restore after CliRunner calls install one
+        self._logger_handlers = list(devcode.logger.handlers)
 
     def tearDown(self):
         self.patch_settings.stop()
         shutil.rmtree(self.tmpdir, ignore_errors=True)
+        # Remove any logger handlers added during the test (CliRunner installs a StreamHandler
+        # pointing at its fake stderr; that stream becomes invalid after CliRunner exits)
+        devcode.logger.handlers[:] = self._logger_handlers
 
     def test_projectpath_root_exits(self):
-        with patch.object(sys, "argv", ["devcode", "open", "/", "claude"]):
-            with self.assertRaises(SystemExit):
-                devcode.main()
+        runner = CliRunner()
+        result = runner.invoke(devcode.cli, ["open", "/", "claude"])
+        self.assertNotEqual(result.exit_code, 0)
 
     def test_code_not_on_path_exits(self):
-        with patch.object(sys, "argv", ["devcode", "open", "/myproject", "claude"]):
-            with patch("os.path.exists", return_value=True):
-                with patch.object(devcode, "_git_repo_root", return_value=None):
-                    with patch("shutil.which", return_value=None):
-                        with self.assertRaises(SystemExit):
-                            devcode.main()
+        runner = CliRunner()
+        with patch("os.path.exists", return_value=True):
+            with patch.object(devcode, "_git_repo_root", return_value=None):
+                with patch("shutil.which", return_value=None):
+                    result = runner.invoke(devcode.cli, ["open", "/myproject", "claude"])
+        self.assertNotEqual(result.exit_code, 0)
 
     def test_launches_vscode_with_folder_uri(self):
         launched = []
@@ -721,14 +711,15 @@ def fake_popen(cmd, **kw):
             launched.append(cmd)
             return MagicMock()
 
-        with patch.object(sys, "argv", ["devcode", "open", "/myproject", "claude"]):
-            with patch("os.path.exists", return_value=True):
-                with patch("shutil.which", return_value="/usr/bin/code"):
-                    with patch.object(devcode, "_git_repo_root", return_value=None):
-                        with patch("subprocess.Popen", side_effect=fake_popen):
-                            with patch.object(devcode, "run_post_launch"):
-                                devcode.main()
+        runner = CliRunner()
+        with patch("os.path.exists", return_value=True):
+            with patch("shutil.which", return_value="/usr/bin/code"):
+                with patch.object(devcode, "_git_repo_root", return_value=None):
+                    with patch("subprocess.Popen", side_effect=fake_popen):
+                        with patch.object(devcode, "run_post_launch"):
+                            result = runner.invoke(devcode.cli, ["open", "/myproject", "claude"])
 
+        self.assertEqual(result.exit_code, 0)
         self.assertEqual(len(launched), 1)
         self.assertEqual(launched[0][0], "code")
         self.assertEqual(launched[0][1], "--folder-uri")
@@ -740,14 +731,15 @@ def fake_popen(cmd, **kw):
             launched.append(cmd)
             return MagicMock()
 
-        with patch.object(sys, "argv", ["devcode", "open", "/myproject", "claude"]):
-            with patch("os.path.exists", return_value=True):
-                with patch("shutil.which", return_value="/usr/bin/code"):
-                    with patch.object(devcode, "_git_repo_root", return_value=None):
-                        with patch("subprocess.Popen", side_effect=fake_popen):
-                            with patch.object(devcode, "run_post_launch"):
-                                devcode.main()
+        runner = CliRunner()
+        with patch("os.path.exists", return_value=True):
+            with patch("shutil.which", return_value="/usr/bin/code"):
+                with patch.object(devcode, "_git_repo_root", return_value=None):
+                    with patch("subprocess.Popen", side_effect=fake_popen):
+                        with patch.object(devcode, "run_post_launch"):
+                            result = runner.invoke(devcode.cli, ["open", "/myproject", "claude"])
 
+        self.assertEqual(result.exit_code, 0)
         self.assertIn("/workspaces/myproject", launched[0][2])
 
     def test_custom_container_folder(self):
@@ -756,14 +748,18 @@ def fake_popen(cmd, **kw):
             launched.append(cmd)
             return MagicMock()
 
-        with patch.object(sys, "argv", ["devcode", "open", "/myproject", "claude", "--container-folder", "/workspace/custom"]):
-            with patch("os.path.exists", return_value=True):
-                with patch("shutil.which", return_value="/usr/bin/code"):
-                    with patch.object(devcode, "_git_repo_root", return_value=None):
-                        with patch("subprocess.Popen", side_effect=fake_popen):
-                            with patch.object(devcode, "run_post_launch"):
-                                devcode.main()
-
+        runner = CliRunner()
+        with patch("os.path.exists", return_value=True):
+            with patch("shutil.which", return_value="/usr/bin/code"):
+                with patch.object(devcode, "_git_repo_root", return_value=None):
+                    with patch("subprocess.Popen", side_effect=fake_popen):
+                        with patch.object(devcode, "run_post_launch"):
+                            result = runner.invoke(
+                                devcode.cli,
+                                ["open", "/myproject", "claude", "--container-folder", "/workspace/custom"]
+                            )
+
+        self.assertEqual(result.exit_code, 0)
         self.assertIn("/workspace/custom", launched[0][2])
 
     def test_timeout_passed_to_run_post_launch(self):
@@ -771,14 +767,18 @@ def test_timeout_passed_to_run_post_launch(self):
         def fake_rpl(config_file, project_path, timeout):
             captured["timeout"] = timeout
 
-        with patch.object(sys, "argv", ["devcode", "open", "/myproject", "claude", "--timeout", "42"]):
-            with patch("os.path.exists", return_value=True):
-                with patch("shutil.which", return_value="/usr/bin/code"):
-                    with patch.object(devcode, "_git_repo_root", return_value=None):
-                        with patch("subprocess.Popen", return_value=MagicMock()):
-                            with patch.object(devcode, "run_post_launch", side_effect=fake_rpl):
-                                devcode.main()
-
+        runner = CliRunner()
+        with patch("os.path.exists", return_value=True):
+            with patch("shutil.which", return_value="/usr/bin/code"):
+                with patch.object(devcode, "_git_repo_root", return_value=None):
+                    with patch("subprocess.Popen", return_value=MagicMock()):
+                        with patch.object(devcode, "run_post_launch", side_effect=fake_rpl):
+                            result = runner.invoke(
+                                devcode.cli,
+                                ["open", "/myproject", "claude", "--timeout", "42"]
+                            )
+
+        self.assertEqual(result.exit_code, 0)
         self.assertEqual(captured["timeout"], 42)
 
     def test_default_timeout_is_300(self):
@@ -786,14 +786,15 @@ def test_default_timeout_is_300(self):
         def fake_rpl(config_file, project_path, timeout):
             captured["timeout"] = timeout
 
-        with patch.object(sys, "argv", ["devcode", "open", "/myproject", "claude"]):
-            with patch("os.path.exists", return_value=True):
-                with patch("shutil.which", return_value="/usr/bin/code"):
-                    with patch.object(devcode, "_git_repo_root", return_value=None):
-                        with patch("subprocess.Popen", return_value=MagicMock()):
-                            with patch.object(devcode, "run_post_launch", side_effect=fake_rpl):
-                                devcode.main()
+        runner = CliRunner()
+        with patch("os.path.exists", return_value=True):
+            with patch("shutil.which", return_value="/usr/bin/code"):
+                with patch.object(devcode, "_git_repo_root", return_value=None):
+                    with patch("subprocess.Popen", return_value=MagicMock()):
+                        with patch.object(devcode, "run_post_launch", side_effect=fake_rpl):
+                            result = runner.invoke(devcode.cli, ["open", "/myproject", "claude"])
 
+        self.assertEqual(result.exit_code, 0)
         self.assertEqual(captured["timeout"], 300)
 
 
@@ -805,38 +806,45 @@ def setUp(self):
         open(os.path.join(tpl, "devcontainer.json"), "w").close()
         self.patch_settings = patch.object(devcode, "_load_settings", return_value={"template_sources": [self.tmpdir]})
         self.patch_settings.start()
+        # Snapshot logger handlers so we can restore after CliRunner calls install one
+        self._logger_handlers = list(devcode.logger.handlers)
 
     def tearDown(self):
         self.patch_settings.stop()
         shutil.rmtree(self.tmpdir, ignore_errors=True)
+        # Remove any logger handlers added during the test (CliRunner installs a StreamHandler
+        # pointing at its fake stderr; that stream becomes invalid after CliRunner exits)
+        devcode.logger.handlers[:] = self._logger_handlers
 
     def test_subdir_of_git_repo_exits(self):
         """Guard fires when git root differs from project_path."""
-        with patch.object(sys, "argv", ["devcode", "open", "/repo/subproject", "claude"]):
-            with patch("os.path.exists", return_value=True):
-                with patch.object(devcode, "_git_repo_root", return_value="/repo"):
-                    with self.assertRaises(SystemExit):
-                        devcode.main()
+        runner = CliRunner()
+        with patch("os.path.exists", return_value=True):
+            with patch.object(devcode, "_git_repo_root", return_value="/repo"):
+                result = runner.invoke(devcode.cli, ["open", "/repo/subproject", "claude"])
+        self.assertNotEqual(result.exit_code, 0)
 
     def test_project_is_git_root_does_not_exit(self):
         """Guard does not fire when project_path IS the git root."""
-        with patch.object(sys, "argv", ["devcode", "open", "/repo", "claude"]):
-            with patch("os.path.exists", return_value=True):
-                with patch.object(devcode, "_git_repo_root", return_value="/repo"):
-                    with patch("shutil.which", return_value="/usr/bin/code"):
-                        with patch("subprocess.Popen", return_value=MagicMock()):
-                            with patch.object(devcode, "run_post_launch"):
-                                devcode.main()  # must not raise
+        runner = CliRunner()
+        with patch("os.path.exists", return_value=True):
+            with patch.object(devcode, "_git_repo_root", return_value="/repo"):
+                with patch("shutil.which", return_value="/usr/bin/code"):
+                    with patch("subprocess.Popen", return_value=MagicMock()):
+                        with patch.object(devcode, "run_post_launch"):
+                            result = runner.invoke(devcode.cli, ["open", "/repo", "claude"])
+        self.assertEqual(result.exit_code, 0)
 
     def test_not_in_git_repo_does_not_exit(self):
         """Guard does not fire when _git_repo_root returns None."""
-        with patch.object(sys, "argv", ["devcode", "open", "/myproject", "claude"]):
-            with patch("os.path.exists", return_value=True):
-                with patch.object(devcode, "_git_repo_root", return_value=None):
-                    with patch("shutil.which", return_value="/usr/bin/code"):
-                        with patch("subprocess.Popen", return_value=MagicMock()):
-                            with patch.object(devcode, "run_post_launch"):
-                                devcode.main()  # must not raise
+        runner = CliRunner()
+        with patch("os.path.exists", return_value=True):
+            with patch.object(devcode, "_git_repo_root", return_value=None):
+                with patch("shutil.which", return_value="/usr/bin/code"):
+                    with patch("subprocess.Popen", return_value=MagicMock()):
+                        with patch.object(devcode, "run_post_launch"):
+                            result = runner.invoke(devcode.cli, ["open", "/myproject", "claude"])
+        self.assertEqual(result.exit_code, 0)
 
     def test_git_not_available_does_not_exit(self):
         """_git_repo_root returns None when git is unavailable (OSError)."""
@@ -1289,9 +1297,8 @@ def _run_list(self, search_path, long=False):
         lines = []
         dirs = [d for d in search_path.split(os.pathsep) if d]
         with patch.object(devcode, "_load_settings", return_value={"template_sources": dirs}):
-            args = MagicMock(subcommand="list", verbose=False, long=long)
             with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
-                devcode.cmd_list(args)
+                devcode.list_command.callback(long=long)
         return lines
 
     def test_short_lists_user_templates(self):
@@ -1430,12 +1437,9 @@ def test_creates_template_from_default_base_legacy_env(self):
         with tempfile.TemporaryDirectory() as pkg_dir:
             self._setup_pkg(pkg_dir)
             with tempfile.TemporaryDirectory() as user_dir:
-                args = MagicMock(subcommand="new", verbose=False,
-                                 base=None, edit=False)
-                args.name = "myapp"
                 with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir]}):
                     with patch.object(devcode, "__file__", os.path.join(pkg_dir, "devcode.py")):
-                        devcode.cmd_new(args)
+                        devcode.new_command.callback(name="myapp", base=None, edit=False)
                 self.assertTrue(os.path.isdir(os.path.join(user_dir, "myapp")))
 
     def test_creates_template_from_explicit_base(self):
@@ -1445,60 +1449,45 @@ def test_creates_template_from_explicit_base(self):
             os.makedirs(base_path)
             open(os.path.join(base_path, "devcontainer.json"), "w").close()
 
-            args = MagicMock(subcommand="new", verbose=False,
-                             base="mybase", edit=False)
-            args.name = "myapp"
             with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir]}):
-                devcode.cmd_new(args)
+                devcode.new_command.callback(name="myapp", base="mybase", edit=False)
             self.assertTrue(os.path.isdir(os.path.join(user_dir, "myapp")))
 
     def test_exits_if_name_already_exists(self):
         with tempfile.TemporaryDirectory() as user_dir:
             existing = os.path.join(user_dir, "myapp")
             os.makedirs(existing)
-            args = MagicMock(subcommand="new", verbose=False,
-                             base=None, edit=False)
-            args.name = "myapp"
             with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir]}):
                 with self.assertRaises(SystemExit):
-                    devcode.cmd_new(args)
+                    devcode.new_command.callback(name="myapp", base=None, edit=False)
 
     def test_exits_if_base_not_found(self):
         with tempfile.TemporaryDirectory() as pkg_dir:
             with tempfile.TemporaryDirectory() as user_dir:
-                args = MagicMock(subcommand="new", verbose=False,
-                                 base="no-such-base", edit=False)
-                args.name = "myapp"
                 with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir]}):
                     with patch.object(devcode, "__file__", os.path.join(pkg_dir, "devcode.py")):
                         with self.assertRaises(SystemExit):
-                            devcode.cmd_new(args)
+                            devcode.new_command.callback(name="myapp", base="no-such-base", edit=False)
 
-    def test_edit_flag_calls_cmd_open(self):
+    def test_edit_flag_calls_do_open(self):
         with tempfile.TemporaryDirectory() as pkg_dir:
             self._setup_pkg(pkg_dir)
             with tempfile.TemporaryDirectory() as user_dir:
-                args = MagicMock(subcommand="new", verbose=False,
-                                 base=None, edit=True)
-                args.name = "myapp"
                 with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir]}):
                     with patch.object(devcode, "__file__", os.path.join(pkg_dir, "devcode.py")):
-                        with patch.object(devcode, "cmd_open") as mock_open:
-                            devcode.cmd_new(args)
+                        with patch.object(devcode, "_do_open") as mock_open:
+                            devcode.new_command.callback(name="myapp", base=None, edit=True)
                 mock_open.assert_called_once()
-                call_args = mock_open.call_args[0][0]
-                self.assertEqual(call_args.template, "myapp")
-                self.assertEqual(call_args.projectpath, os.path.join(user_dir, "myapp"))
+                self.assertEqual(mock_open.call_args.kwargs["template"], "myapp")
+                self.assertEqual(mock_open.call_args.kwargs["projectpath"], os.path.join(user_dir, "myapp"))
 
     def test_creates_template_from_default_base(self):
         with tempfile.TemporaryDirectory() as pkg_dir:
             self._setup_pkg(pkg_dir)
             with tempfile.TemporaryDirectory() as user_dir:
-                args = MagicMock(subcommand="new", verbose=False, base=None, edit=False)
-                args.name = "myapp"
                 with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir]}):
                     with patch.object(devcode, "__file__", os.path.join(pkg_dir, "devcode.py")):
-                        devcode.cmd_new(args)
+                        devcode.new_command.callback(name="myapp", base=None, edit=False)
                 self.assertTrue(os.path.isdir(os.path.join(user_dir, "myapp")))
 
     def test_base_found_in_second_search_dir(self):
@@ -1507,10 +1496,8 @@ def test_base_found_in_second_search_dir(self):
                 base = os.path.join(d2, "mybase", ".devcontainer")
                 os.makedirs(base)
                 open(os.path.join(base, "devcontainer.json"), "w").close()
-                args = MagicMock(subcommand="new", verbose=False, base="mybase", edit=False)
-                args.name = "myapp"
                 with patch.object(devcode, "_load_settings", return_value={"template_sources": [d1, d2]}):
-                    devcode.cmd_new(args)
+                    devcode.new_command.callback(name="myapp", base="mybase", edit=False)
                 # writes to first dir
                 self.assertTrue(os.path.isdir(os.path.join(d1, "myapp")))
 
@@ -1526,44 +1513,39 @@ def _make_template(self, base_dir, name):
     def test_named_template_opens_root_in_code(self):
         with tempfile.TemporaryDirectory() as d:
             root = self._make_template(d, "mytemplate")
-            args = MagicMock(subcommand="edit", verbose=False, template="mytemplate")
             with patch.object(devcode, "_load_settings", return_value={"template_sources": [d]}):
                 with patch("subprocess.run") as mock_run:
-                    devcode.cmd_edit(args)
+                    devcode.edit_command.callback(template="mytemplate")
             mock_run.assert_called_once_with(["code", root])
 
     def test_named_template_found_in_second_dir(self):
         with tempfile.TemporaryDirectory() as d1:
             with tempfile.TemporaryDirectory() as d2:
                 root = self._make_template(d2, "mytemplate")
-                args = MagicMock(subcommand="edit", verbose=False, template="mytemplate")
                 with patch.object(devcode, "_load_settings", return_value={"template_sources": [d1, d2]}):
                     with patch("subprocess.run") as mock_run:
-                        devcode.cmd_edit(args)
+                        devcode.edit_command.callback(template="mytemplate")
                 mock_run.assert_called_once_with(["code", root])
 
     def test_named_template_not_found_exits(self):
         with tempfile.TemporaryDirectory() as d:
-            args = MagicMock(subcommand="edit", verbose=False, template="no-such")
             with patch.object(devcode, "_load_settings", return_value={"template_sources": [d]}):
                 with self.assertRaises(SystemExit):
-                    devcode.cmd_edit(args)
+                    devcode.edit_command.callback(template="no-such")
 
-    def test_no_arg_is_argparse_error(self):
-        """edit requires a template argument; omitting it should exit with code 2."""
-        with self.assertRaises(SystemExit) as ctx:
-            with patch("sys.argv", ["devcode", "edit"]):
-                devcode.main()
-        self.assertEqual(ctx.exception.code, 2)
+    def test_no_arg_is_missing_argument_error(self):
+        """edit requires a template argument; omitting it should exit non-zero."""
+        runner = CliRunner()
+        result = runner.invoke(devcode.cli, ["edit"])
+        self.assertNotEqual(result.exit_code, 0)
 
-    def test_does_not_call_cmd_open(self):
+    def test_does_not_call_do_open(self):
         with tempfile.TemporaryDirectory() as d:
             self._make_template(d, "mytemplate")
-            args = MagicMock(subcommand="edit", verbose=False, template="mytemplate")
             with patch.object(devcode, "_load_settings", return_value={"template_sources": [d]}):
-                with patch.object(devcode, "cmd_open") as mock_open:
+                with patch.object(devcode, "_do_open") as mock_open:
                     with patch("subprocess.run"):
-                        devcode.cmd_edit(args)
+                        devcode.edit_command.callback(template="mytemplate")
             mock_open.assert_not_called()
 
 
@@ -1591,9 +1573,8 @@ def test_lists_containers(self):
         mock_result = MagicMock(returncode=0, stdout=self._docker_output(rows))
         lines = []
         with patch("subprocess.run", return_value=mock_result):
-            args = MagicMock(subcommand="ps", verbose=False, all=False, interactive=False)
             with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
-                devcode.cmd_ps(args)
+                devcode.ps_command.callback(show_all=False, interactive=False)
         combined = "\n".join(lines)
         self.assertIn("claude", combined)
         self.assertIn("abc123def456", combined)
@@ -1604,17 +1585,15 @@ def test_no_containers_message(self):
         mock_result = MagicMock(returncode=0, stdout="")
         lines = []
         with patch("subprocess.run", return_value=mock_result):
-            args = MagicMock(subcommand="ps", verbose=False, all=False, interactive=False)
             with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
-                devcode.cmd_ps(args)
+                devcode.ps_command.callback(show_all=False, interactive=False)
         self.assertTrue(any("no running devcontainers" in str(l) for l in lines))
 
     def test_docker_unavailable_exits(self):
         mock_result = MagicMock(returncode=1, stdout="")
         with patch("subprocess.run", return_value=mock_result):
-            args = MagicMock(subcommand="ps", verbose=False, all=False, interactive=False)
             with self.assertRaises(SystemExit):
-                devcode.cmd_ps(args)
+                devcode.ps_command.callback(show_all=False, interactive=False)
 
     def test_malformed_row_skipped(self):
         # A row with fewer than 4 fields after dropping CreatedAt should be skipped silently
@@ -1624,9 +1603,8 @@ def test_malformed_row_skipped(self):
         mock_result = MagicMock(returncode=0, stdout=stdout)
         lines = []
         with patch("subprocess.run", return_value=mock_result):
-            args = MagicMock(subcommand="ps", verbose=False, all=False, interactive=False)
             with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
-                devcode.cmd_ps(args)  # must not raise
+                devcode.ps_command.callback(show_all=False, interactive=False)  # must not raise
         combined = "\n".join(lines)
         self.assertIn("bbb222", combined)  # good row shown
         self.assertNotIn("abc123", combined)  # malformed row skipped
@@ -1643,9 +1621,8 @@ def test_all_flag_includes_stopped(self):
         mock_result = MagicMock(returncode=0, stdout=self._docker_output(rows))
         lines = []
         with patch("subprocess.run", return_value=mock_result):
-            args = MagicMock(subcommand="ps", verbose=False, all=True, interactive=False)
             with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
-                devcode.cmd_ps(args)
+                devcode.ps_command.callback(show_all=True, interactive=False)
         combined = "\n".join(lines)
         self.assertIn("aaa111", combined)   # stopped container included
         self.assertIn("bbb222", combined)   # running container included
@@ -1662,9 +1639,8 @@ def test_no_all_flag_excludes_stopped(self):
         mock_result = MagicMock(returncode=0, stdout=self._docker_output(rows))
         lines = []
         with patch("subprocess.run", return_value=mock_result):
-            args = MagicMock(subcommand="ps", verbose=False, all=False, interactive=False)
             with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
-                devcode.cmd_ps(args)
+                devcode.ps_command.callback(show_all=False, interactive=False)
         combined = "\n".join(lines)
         self.assertNotIn("aaa111", combined)   # stopped excluded
         self.assertIn("bbb222", combined)      # running shown
@@ -1673,12 +1649,11 @@ def test_all_flag_empty_message(self):
         mock_result = MagicMock(returncode=0, stdout="")
         lines = []
         with patch("subprocess.run", return_value=mock_result):
-            args = MagicMock(subcommand="ps", verbose=False, all=True, interactive=False)
             with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
-                devcode.cmd_ps(args)
+                devcode.ps_command.callback(show_all=True, interactive=False)
         self.assertTrue(any("no devcontainers" in str(l) and "running" not in str(l) for l in lines))
 
-    def test_interactive_valid_selection_calls_cmd_open(self):
+    def test_interactive_valid_selection_opens_container(self):
         rows = [
             ("2026-03-24 10:00:00 +0000 UTC", "abc123def456", "/home/user/myapp",
              "/home/user/.local/share/dev-code/templates/python/.devcontainer/devcontainer.json",
@@ -1691,16 +1666,15 @@ def test_interactive_valid_selection_calls_cmd_open(self):
         )
         with patch("subprocess.run", side_effect=[ls_result, inspect_result]):
             with patch("builtins.input", return_value="1"):
-                with patch("devcode.cmd_open") as mock_open:
-                    args = MagicMock(subcommand="ps", verbose=False, all=False, interactive=True)
-                    devcode.cmd_ps(args)
-        mock_open.assert_called_once()
-        call_args = mock_open.call_args[0][0]
-        self.assertEqual(call_args.template, "/home/user/.local/share/dev-code/templates/python/.devcontainer/devcontainer.json")
-        self.assertEqual(call_args.projectpath, "/home/user/myapp")
-        self.assertEqual(call_args.container_folder, "/workspaces/myapp")
-        self.assertEqual(call_args.timeout, 300)
-        self.assertFalse(call_args.dry_run)
+                with patch("devcode._do_open") as mock_open:
+                    devcode.ps_command.callback(show_all=False, interactive=True)
+        mock_open.assert_called_once_with(
+            projectpath="/home/user/myapp",
+            template="/home/user/.local/share/dev-code/templates/python/.devcontainer/devcontainer.json",
+            container_folder="/workspaces/myapp",
+            timeout=300,
+            dry_run=False,
+        )
 
     def test_interactive_mount_fallback(self):
         rows = [
@@ -1716,11 +1690,9 @@ def test_interactive_mount_fallback(self):
         )
         with patch("subprocess.run", side_effect=[ls_result, inspect_result]):
             with patch("builtins.input", return_value="1"):
-                with patch("devcode.cmd_open") as mock_open:
-                    args = MagicMock(subcommand="ps", verbose=False, all=False, interactive=True)
-                    devcode.cmd_ps(args)
-        call_args = mock_open.call_args[0][0]
-        self.assertEqual(call_args.container_folder, "/workspaces/myapp")  # fallback
+                with patch("devcode._do_open") as mock_open:
+                    devcode.ps_command.callback(show_all=False, interactive=True)
+        self.assertEqual(mock_open.call_args.kwargs["container_folder"], "/workspaces/myapp")
 
     def test_interactive_invalid_selection_exits(self):
         rows = [
@@ -1731,9 +1703,8 @@ def test_interactive_invalid_selection_exits(self):
         ls_result = MagicMock(returncode=0, stdout=self._docker_output(rows))
         with patch("subprocess.run", return_value=ls_result):
             with patch("builtins.input", return_value="99"):
-                args = MagicMock(subcommand="ps", verbose=False, all=False, interactive=True)
                 with self.assertRaises(SystemExit):
-                    devcode.cmd_ps(args)
+                    devcode.ps_command.callback(show_all=False, interactive=True)
 
     def test_interactive_non_integer_exits(self):
         rows = [
@@ -1744,9 +1715,8 @@ def test_interactive_non_integer_exits(self):
         ls_result = MagicMock(returncode=0, stdout=self._docker_output(rows))
         with patch("subprocess.run", return_value=ls_result):
             with patch("builtins.input", return_value="abc"):
-                args = MagicMock(subcommand="ps", verbose=False, all=False, interactive=True)
                 with self.assertRaises(SystemExit):
-                    devcode.cmd_ps(args)
+                    devcode.ps_command.callback(show_all=False, interactive=True)
 
     def test_interactive_missing_config_label_exits(self):
         rows = [
@@ -1757,17 +1727,15 @@ def test_interactive_missing_config_label_exits(self):
         ls_result = MagicMock(returncode=0, stdout=self._docker_output(rows))
         with patch("subprocess.run", return_value=ls_result):
             with patch("builtins.input", return_value="1"):
-                args = MagicMock(subcommand="ps", verbose=False, all=False, interactive=True)
                 with self.assertRaises(SystemExit):
-                    devcode.cmd_ps(args)
+                    devcode.ps_command.callback(show_all=False, interactive=True)
 
     def test_interactive_empty_table_no_prompt(self):
         ls_result = MagicMock(returncode=0, stdout="")
         prompted = []
         with patch("subprocess.run", return_value=ls_result):
             with patch("builtins.input", side_effect=lambda _: prompted.append(True) or "1"):
-                args = MagicMock(subcommand="ps", verbose=False, all=False, interactive=True)
-                devcode.cmd_ps(args)
+                devcode.ps_command.callback(show_all=False, interactive=True)
         self.assertEqual(prompted, [])   # input() was never called
 
     def test_interactive_all_with_malformed_row_correct_selection(self):
@@ -1779,12 +1747,10 @@ def test_interactive_all_with_malformed_row_correct_selection(self):
         inspect_result = MagicMock(returncode=0, stdout='[]')
         with patch("subprocess.run", side_effect=[ls_result, inspect_result]):
             with patch("builtins.input", return_value="1"):
-                with patch("devcode.cmd_open") as mock_open:
-                    args = MagicMock(subcommand="ps", verbose=False, all=True, interactive=True)
-                    devcode.cmd_ps(args)
+                with patch("devcode._do_open") as mock_open:
+                    devcode.ps_command.callback(show_all=True, interactive=True)
         mock_open.assert_called_once()
-        call_args = mock_open.call_args[0][0]
-        self.assertEqual(call_args.projectpath, "/home/user/myapp")  # good row, not malformed
+        self.assertEqual(mock_open.call_args.kwargs["projectpath"], "/home/user/myapp")
 
     def test_sort_ascending_by_created_at(self):
         # Docker returns rows newest-first; cmd_ps must reorder oldest-first
@@ -1799,9 +1765,8 @@ def test_sort_ascending_by_created_at(self):
         mock_result = MagicMock(returncode=0, stdout=self._docker_output(rows))
         lines = []
         with patch("subprocess.run", return_value=mock_result):
-            args = MagicMock(subcommand="ps", verbose=False, all=False, interactive=False)
             with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
-                devcode.cmd_ps(args)
+                devcode.ps_command.callback(show_all=False, interactive=False)
         # Find data rows (skip header)
         data_rows = [l for l in lines if "older222" in l or "newer111" in l]
         self.assertEqual(len(data_rows), 2)
@@ -1813,6 +1778,18 @@ def test_sort_ascending_by_created_at(self):
         self.assertIn("1", lines[idx_older])
 
 
+class TestDoOpen(unittest.TestCase):
+    def test_errors_on_nonexistent_projectpath(self):
+        with self.assertRaises(SystemExit):
+            devcode._do_open(
+                projectpath="/nonexistent/path/xyz123",
+                template="mytemplate",
+                container_folder=None,
+                timeout=300,
+                dry_run=False,
+            )
+
+
 class TestCmdOpenDryRun(unittest.TestCase):
     def _make_template(self, base_dir, name, cp_entries=None):
         """Create template with optional cp entries in devcontainer.json."""
@@ -1826,19 +1803,11 @@ def _make_template(self, base_dir, name, cp_entries=None):
 
     def _run_dry_run(self, user_dir, template, projectpath, container_folder=None):
         lines = []
-        args = argparse.Namespace(
-            template=template,
-            projectpath=projectpath,
-            container_folder=container_folder,
-            timeout=300,
-            dry_run=True,
-            verbose=False,
-        )
         with patch.object(devcode, "_load_settings", return_value={"template_sources": [user_dir]}):
             with patch("os.path.exists", return_value=True):
                 with patch.object(devcode, "_git_repo_root", return_value=None):
                     with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
-                        devcode.cmd_open(args)
+                        devcode._do_open(projectpath, template, container_folder, 300, True)
         return lines
 
     def test_prints_config_and_uri(self):
@@ -1895,27 +1864,19 @@ def test_unset_env_var_shown_as_placeholder(self):
                     with patch("os.path.exists", return_value=True):
                         with patch.object(devcode, "_git_repo_root", return_value=None):
                             lines = []
-                            args = argparse.Namespace(template="mytemplate", projectpath="/myproject",
-                                                      container_folder=None, timeout=300, dry_run=True,
-                                                      verbose=False)
                             with patch("builtins.print", side_effect=lambda *a, **kw: lines.append(a[0] if a else "")):
-                                devcode.cmd_open(args)
+                                devcode._do_open("/myproject", "mytemplate", None, 300, True)
         combined = "\n".join(lines)
         self.assertIn("<unset:", combined)
 
 
 class TestBanner(unittest.TestCase):
     def test_help_contains_tagline(self):
-        """Banner tagline appears in --help output.
-        Uses subprocess to avoid argparse SystemExit contaminating the test runner.
-        """
-        result = subprocess.run(
-            ["uv", "run", "python", "src/devcode.py", "--help"],
-            capture_output=True, text=True, encoding="utf-8",
-            cwd=os.path.join(os.path.dirname(__file__), ".."),
-        )
-        self.assertEqual(result.returncode, 0, result.stderr)
-        self.assertIn("project · editor · container — simplified", result.stdout)
+        """Banner tagline appears in --help output."""
+        runner = CliRunner()
+        result = runner.invoke(devcode.cli, ["--help"])
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("project · editor · container", result.output)
 
 
 class TestListTemplateNames(unittest.TestCase):
@@ -1975,212 +1936,71 @@ def test_does_not_include_builtins(self):
                         names = devcode._list_template_names()
         self.assertEqual(names, [])
 
-class TestCmdComplete(unittest.TestCase):
-    def _run(self, cword_index, words, template_names=None):
-        """Run cmd_completion --complete path, capture printed lines, assert exit code 0."""
-        if template_names is None:
-            template_names = []
-        # --complete receives [cword_index_str, *words] as complete_words
-        args = argparse.Namespace(complete_words=[str(cword_index)] + words, shell=None)
-        captured = []
-        with patch.object(devcode, "_list_template_names", return_value=template_names):
-            with patch("builtins.print", side_effect=lambda x: captured.append(x)):
-                with self.assertRaises(SystemExit) as cm:
-                    devcode.cmd_completion(args)
-        self.assertEqual(cm.exception.code, 0)
-        return captured
-
-    def test_completing_subcommand_returns_all_subcommands(self):
-        result = self._run(1, ["devcode", ""])
-        for sub in ("open", "new", "edit", "list", "ps", "completion"):
-            self.assertIn(sub, result)
-        self.assertNotIn("init", result)
-
-    def test_prefix_filters_subcommands(self):
-        result = self._run(1, ["devcode", "op"])
-        self.assertEqual(result, ["open"])
-
-    def test_open_index2_returns_empty(self):
-        # Position 2 is projectpath, shell handles filesystem completion
-        result = self._run(2, ["devcode", "open", ""], template_names=["alpha", "beta"])
-        self.assertEqual(result, [])
-
-    def test_open_index3_returns_template_names(self):
-        # Position 3 is optional template name
-        result = self._run(3, ["devcode", "open", "/myproject", ""], template_names=["alpha", "beta"])
-        self.assertIn("alpha", result)
-        self.assertIn("beta", result)
-
-    def test_open_index3_prefix_filters_templates(self):
-        result = self._run(3, ["devcode", "open", "/myproject", "al"], template_names=["alpha", "beta"])
-        self.assertEqual(result, ["alpha"])
-
-    def test_open_index4_returns_empty(self):
-        result = self._run(4, ["devcode", "open", "/myproject", "mytemplate", ""])
-        self.assertEqual(result, [])
-
-    def test_open_flag_completion_at_index3(self):
-        # Position 3 can have --flags or optional template name
-        result = self._run(3, ["devcode", "open", "/myproject", "--"])
-        self.assertIn("--dry-run", result)
-        self.assertIn("--container-folder", result)
-        self.assertIn("--timeout", result)
-
-    def test_open_flag_completion_at_index2(self):
-        result = self._run(2, ["devcode", "open", "--"])
-        self.assertIn("--dry-run", result)
-
-    def test_new_index2_returns_empty(self):
-        result = self._run(2, ["devcode", "new", ""])
-        self.assertEqual(result, [])
-
-    def test_new_index3_returns_template_names(self):
-        result = self._run(3, ["devcode", "new", "myname", ""], template_names=["base1"])
-        self.assertIn("base1", result)
-
-    def test_new_flag_completion(self):
-        result = self._run(2, ["devcode", "new", "--"])
-        self.assertEqual(result, ["--edit"])
-
-    def test_edit_index2_returns_template_names(self):
-        result = self._run(2, ["devcode", "edit", ""], template_names=["mytemplate"])
-        self.assertIn("mytemplate", result)
-
-    def test_edit_index3_returns_empty(self):
-        result = self._run(3, ["devcode", "edit", "mytemplate", ""])
-        self.assertEqual(result, [])
-
-    def test_edit_flag_returns_empty(self):
-        result = self._run(2, ["devcode", "edit", "--"])
-        self.assertEqual(result, [])
-
-    def test_list_index2_returns_long(self):
-        result = self._run(2, ["devcode", "list", ""])
-        self.assertEqual(result, ["--long"])
-
-    def test_list_higher_index_returns_long(self):
-        result = self._run(3, ["devcode", "list", "--long", ""])
-        self.assertEqual(result, ["--long"])
-
-    def test_list_prefix_filter_long(self):
-        result = self._run(2, ["devcode", "list", "--l"])
-        self.assertEqual(result, ["--long"])
-
-    def test_list_partial_word_no_match_returns_empty(self):
-        # list branch fires unconditionally; prefix filter removes --long when current_word="x"
-        result = self._run(2, ["devcode", "list", "x"])
-        self.assertEqual(result, [])
-
-    def test_ps_returns_empty(self):
-        result = self._run(2, ["devcode", "ps", ""])
-        self.assertEqual(result, [])
-
-    def test_ps_flags_completion(self):
-        result = self._run(2, ["devcode", "ps", "-"])
-        self.assertIn("-a", result)
-        self.assertIn("-i", result)
-
-    def test_completion_index2_returns_shells(self):
-        result = self._run(2, ["devcode", "completion", ""])
-        self.assertIn("bash", result)
-        self.assertIn("zsh", result)
-
-    def test_completion_index2_prefix_filter(self):
-        result = self._run(2, ["devcode", "completion", "b"])
-        self.assertEqual(result, ["bash"])
-
-    def test_completion_index3_returns_empty(self):
-        result = self._run(3, ["devcode", "completion", "bash", ""])
-        self.assertEqual(result, [])
-
-    def test_empty_complete_words_exits_zero_no_output(self):
-        args = argparse.Namespace(complete_words=[], shell=None)
-        captured = []
-        with patch("builtins.print", side_effect=lambda x: captured.append(x)):
-            with self.assertRaises(SystemExit) as cm:
-                devcode.cmd_completion(args)
-        self.assertEqual(cm.exception.code, 0)
-        self.assertEqual(captured, [])
-
-    def test_non_integer_cword_exits_zero_no_output(self):
-        args = argparse.Namespace(complete_words=["notanint", "dev-code", "open"], shell=None)
-        captured = []
-        with patch("builtins.print", side_effect=lambda x: captured.append(x)):
-            with self.assertRaises(SystemExit) as cm:
-                devcode.cmd_completion(args)
-        self.assertEqual(cm.exception.code, 0)
-        self.assertEqual(captured, [])
-
-    def test_out_of_range_cword_exits_zero_no_output(self):
-        args = argparse.Namespace(complete_words=["5", "dev-code", "open"], shell=None)
-        captured = []
-        with patch("builtins.print", side_effect=lambda x: captured.append(x)):
-            with self.assertRaises(SystemExit) as cm:
-                devcode.cmd_completion(args)
-        self.assertEqual(cm.exception.code, 0)
-        self.assertEqual(captured, [])
-
-    def test_cword_index0_returns_empty(self):
-        # index 0 is the command name slot — nothing to complete
-        result = self._run(0, ["devcode"])
+class TestClickCLI(unittest.TestCase):
+    def test_no_args_shows_banner(self):
+        runner = CliRunner()
+        result = runner.invoke(devcode.cli, [])
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("project · editor · container", result.output)
+
+    def test_version_flag(self):
+        runner = CliRunner()
+        result = runner.invoke(devcode.cli, ["--version"])
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("devcode", result.output)
+
+    def test_open_dry_run(self):
+        runner = CliRunner()
+        with runner.isolated_filesystem():
+            os.makedirs("mytemplate/.devcontainer")
+            with open("mytemplate/.devcontainer/devcontainer.json", "w") as f:
+                f.write('{"name": "test"}')
+            project = os.path.abspath(".")
+            with patch.object(devcode, "_load_settings",
+                               return_value={"template_sources": [os.path.abspath(".")]}):
+                with patch.object(devcode, "_git_repo_root", return_value=None):
+                    result = runner.invoke(
+                        devcode.cli, ["open", project, "mytemplate", "--dry-run"]
+                    )
+        self.assertEqual(result.exit_code, 0)
+
+    def test_list_command(self):
+        runner = CliRunner()
+        with patch.object(devcode, "_list_template_names", return_value=["tmpl-a", "tmpl-b"]):
+            result = runner.invoke(devcode.cli, ["list"])
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("tmpl-a", result.output)
+        self.assertIn("tmpl-b", result.output)
+
+    def test_new_command_unknown_base_exits(self):
+        runner = CliRunner()
+        with runner.isolated_filesystem():
+            with patch.object(devcode, "_load_settings",
+                               return_value={"template_sources": [os.path.abspath(".")]}):
+                result = runner.invoke(devcode.cli, ["new", "myapp", "no-such-base"])
+        self.assertNotEqual(result.exit_code, 0)
+
+    def test_ps_no_docker_exits(self):
+        runner = CliRunner()
+        with patch("subprocess.run", return_value=MagicMock(returncode=1, stdout="")):
+            result = runner.invoke(devcode.cli, ["ps"])
+        self.assertNotEqual(result.exit_code, 0)
+
+
+class TestCompleteTemplates(unittest.TestCase):
+    def test_returns_all_when_incomplete_is_empty(self):
+        with patch.object(devcode, "_list_template_names", return_value=["alpha", "beta", "gamma"]):
+            result = devcode._complete_templates(None, None, "")
+        names = [item.value for item in result]
+        self.assertEqual(sorted(names), ["alpha", "beta", "gamma"])
+
+    def test_filters_by_prefix(self):
+        with patch.object(devcode, "_list_template_names", return_value=["alpha", "beta", "gamma"]):
+            result = devcode._complete_templates(None, None, "al")
+        names = [item.value for item in result]
+        self.assertEqual(names, ["alpha"])
+
+    def test_returns_empty_when_no_match(self):
+        with patch.object(devcode, "_list_template_names", return_value=["alpha", "beta"]):
+            result = devcode._complete_templates(None, None, "z")
         self.assertEqual(result, [])
-
-
-class TestCmdCompletion(unittest.TestCase):
-    def _capture(self, shell):
-        args = argparse.Namespace(shell=shell, complete_words=None)
-        buf = io.StringIO()
-        with patch("builtins.print", side_effect=lambda *a, **kw: buf.write(a[0] if a else "")):
-            devcode.cmd_completion(args)
-        return buf.getvalue()
-
-    def test_bash_contains_function_name(self):
-        output = self._capture("bash")
-        self.assertIn("_dev_code", output)
-
-    def test_bash_contains_complete_registration(self):
-        output = self._capture("bash")
-        self.assertIn("complete -F", output)
-
-    def test_bash_contains_mapfile(self):
-        output = self._capture("bash")
-        self.assertIn("mapfile", output)
-
-    def test_zsh_contains_function_name(self):
-        output = self._capture("zsh")
-        self.assertIn("_dev_code", output)
-
-    def test_zsh_contains_compdef(self):
-        output = self._capture("zsh")
-        self.assertIn("compdef", output)
-
-    def test_zsh_contains_compinit_warning(self):
-        output = self._capture("zsh")
-        self.assertIn("compinit", output)
-
-    def test_unknown_shell_exits_1(self):
-        args = argparse.Namespace(shell="fish", complete_words=None)
-        with self.assertRaises(SystemExit) as cm:
-            devcode.cmd_completion(args)
-        self.assertEqual(cm.exception.code, 1)
-
-
-class TestCompletionOpenArgOrder(unittest.TestCase):
-    def _run_completion(self, words):
-        """Invoke cmd_completion in --complete mode, return printed lines."""
-        args = argparse.Namespace(complete_words=words, shell=None)
-        captured = []
-        with patch("builtins.print", side_effect=lambda *a, **kw: captured.append(str(a[0]) if a else "")):
-            with self.assertRaises(SystemExit):
-                devcode.cmd_completion(args)
-        return captured
-
-    def test_position_2_returns_no_template_candidates(self):
-        with patch.object(devcode, "_list_template_names", return_value=["mytemplate"]):
-            candidates = self._run_completion(["2", "devcode", "open", ""])
-        self.assertNotIn("mytemplate", candidates)
-
-    def test_position_3_returns_template_names(self):
-        with patch.object(devcode, "_list_template_names", return_value=["mytemplate"]):
-            candidates = self._run_completion(["3", "devcode", "open", "/myproject", ""])
-        self.assertIn("mytemplate", candidates)
diff --git a/uv.lock b/uv.lock
deleted file mode 100644
index b822310..0000000
--- a/uv.lock
+++ /dev/null
@@ -1,479 +0,0 @@
-version = 1
-revision = 3
-requires-python = ">=3.10"
-
-[[package]]
-name = "cachetools"
-version = "7.0.5"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/dd/57fe3fdb6e65b25a5987fd2cdc7e22db0aef508b91634d2e57d22928d41b/cachetools-7.0.5.tar.gz", hash = "sha256:0cd042c24377200c1dcd225f8b7b12b0ca53cc2c961b43757e774ebe190fd990", size = 37367, upload-time = "2026-03-09T20:51:29.451Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/06/f3/39cf3367b8107baa44f861dc802cbf16263c945b62d8265d36034fc07bea/cachetools-7.0.5-py3-none-any.whl", hash = "sha256:46bc8ebefbe485407621d0a4264b23c080cedd913921bad7ac3ed2f26c183114", size = 13918, upload-time = "2026-03-09T20:51:27.33Z" },
-]
-
-[[package]]
-name = "colorama"
-version = "0.4.6"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
-]
-
-[[package]]
-name = "coverage"
-version = "7.13.5"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/9d/e0/70553e3000e345daff267cec284ce4cbf3fc141b6da229ac52775b5428f1/coverage-7.13.5.tar.gz", hash = "sha256:c81f6515c4c40141f83f502b07bbfa5c240ba25bbe73da7b33f1e5b6120ff179", size = 915967, upload-time = "2026-03-17T10:33:18.341Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/69/33/e8c48488c29a73fd089f9d71f9653c1be7478f2ad6b5bc870db11a55d23d/coverage-7.13.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e0723d2c96324561b9aa76fb982406e11d93cdb388a7a7da2b16e04719cf7ca5", size = 219255, upload-time = "2026-03-17T10:29:51.081Z" },
-    { url = "https://files.pythonhosted.org/packages/da/bd/b0ebe9f677d7f4b74a3e115eec7ddd4bcf892074963a00d91e8b164a6386/coverage-7.13.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:52f444e86475992506b32d4e5ca55c24fc88d73bcbda0e9745095b28ef4dc0cf", size = 219772, upload-time = "2026-03-17T10:29:52.867Z" },
-    { url = "https://files.pythonhosted.org/packages/48/cc/5cb9502f4e01972f54eedd48218bb203fe81e294be606a2bc93970208013/coverage-7.13.5-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:704de6328e3d612a8f6c07000a878ff38181ec3263d5a11da1db294fa6a9bdf8", size = 246532, upload-time = "2026-03-17T10:29:54.688Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/d8/3217636d86c7e7b12e126e4f30ef1581047da73140614523af7495ed5f2d/coverage-7.13.5-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a1a6d79a14e1ec1832cabc833898636ad5f3754a678ef8bb4908515208bf84f4", size = 248333, upload-time = "2026-03-17T10:29:56.221Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/30/2002ac6729ba2d4357438e2ed3c447ad8562866c8c63fc16f6dfc33afe56/coverage-7.13.5-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:79060214983769c7ba3f0cee10b54c97609dca4d478fa1aa32b914480fd5738d", size = 250211, upload-time = "2026-03-17T10:29:57.938Z" },
-    { url = "https://files.pythonhosted.org/packages/6c/85/552496626d6b9359eb0e2f86f920037c9cbfba09b24d914c6e1528155f7d/coverage-7.13.5-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:356e76b46783a98c2a2fe81ec79df4883a1e62895ea952968fb253c114e7f930", size = 252125, upload-time = "2026-03-17T10:29:59.388Z" },
-    { url = "https://files.pythonhosted.org/packages/44/21/40256eabdcbccdb6acf6b381b3016a154399a75fe39d406f790ae84d1f3c/coverage-7.13.5-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0cef0cdec915d11254a7f549c1170afecce708d30610c6abdded1f74e581666d", size = 247219, upload-time = "2026-03-17T10:30:01.199Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/e8/96e2a6c3f21a0ea77d7830b254a1542d0328acc8d7bdf6a284ba7e529f77/coverage-7.13.5-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:dc022073d063b25a402454e5712ef9e007113e3a676b96c5f29b2bda29352f40", size = 248248, upload-time = "2026-03-17T10:30:03.317Z" },
-    { url = "https://files.pythonhosted.org/packages/da/ba/8477f549e554827da390ec659f3c38e4b6d95470f4daafc2d8ff94eaa9c2/coverage-7.13.5-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:9b74db26dfea4f4e50d48a4602207cd1e78be33182bc9cbf22da94f332f99878", size = 246254, upload-time = "2026-03-17T10:30:04.832Z" },
-    { url = "https://files.pythonhosted.org/packages/55/59/bc22aef0e6aa179d5b1b001e8b3654785e9adf27ef24c93dc4228ebd5d68/coverage-7.13.5-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:ad146744ca4fd09b50c482650e3c1b1f4dfa1d4792e0a04a369c7f23336f0400", size = 250067, upload-time = "2026-03-17T10:30:06.535Z" },
-    { url = "https://files.pythonhosted.org/packages/de/1b/c6a023a160806a5137dca53468fd97530d6acad24a22003b1578a9c2e429/coverage-7.13.5-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:c555b48be1853fe3997c11c4bd521cdd9a9612352de01fa4508f16ec341e6fe0", size = 246521, upload-time = "2026-03-17T10:30:08.486Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/3f/3532c85a55aa2f899fa17c186f831cfa1aa434d88ff792a709636f64130e/coverage-7.13.5-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:7034b5c56a58ae5e85f23949d52c14aca2cfc6848a31764995b7de88f13a1ea0", size = 247126, upload-time = "2026-03-17T10:30:09.966Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/2e/b9d56af4a24ef45dfbcda88e06870cb7d57b2b0bfa3a888d79b4c8debd76/coverage-7.13.5-cp310-cp310-win32.whl", hash = "sha256:eb7fdf1ef130660e7415e0253a01a7d5a88c9c4d158bcf75cbbd922fd65a5b58", size = 221860, upload-time = "2026-03-17T10:30:11.393Z" },
-    { url = "https://files.pythonhosted.org/packages/9f/cc/d938417e7a4d7f0433ad4edee8bb2acdc60dc7ac5af19e2a07a048ecbee3/coverage-7.13.5-cp310-cp310-win_amd64.whl", hash = "sha256:3e1bb5f6c78feeb1be3475789b14a0f0a5b47d505bfc7267126ccbd50289999e", size = 222788, upload-time = "2026-03-17T10:30:12.886Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/37/d24c8f8220ff07b839b2c043ea4903a33b0f455abe673ae3c03bbdb7f212/coverage-7.13.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:66a80c616f80181f4d643b0f9e709d97bcea413ecd9631e1dedc7401c8e6695d", size = 219381, upload-time = "2026-03-17T10:30:14.68Z" },
-    { url = "https://files.pythonhosted.org/packages/35/8b/cd129b0ca4afe886a6ce9d183c44d8301acbd4ef248622e7c49a23145605/coverage-7.13.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:145ede53ccbafb297c1c9287f788d1bc3efd6c900da23bf6931b09eafc931587", size = 219880, upload-time = "2026-03-17T10:30:16.231Z" },
-    { url = "https://files.pythonhosted.org/packages/55/2f/e0e5b237bffdb5d6c530ce87cc1d413a5b7d7dfd60fb067ad6d254c35c76/coverage-7.13.5-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:0672854dc733c342fa3e957e0605256d2bf5934feeac328da9e0b5449634a642", size = 250303, upload-time = "2026-03-17T10:30:17.748Z" },
-    { url = "https://files.pythonhosted.org/packages/92/be/b1afb692be85b947f3401375851484496134c5554e67e822c35f28bf2fbc/coverage-7.13.5-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:ec10e2a42b41c923c2209b846126c6582db5e43a33157e9870ba9fb70dc7854b", size = 252218, upload-time = "2026-03-17T10:30:19.804Z" },
-    { url = "https://files.pythonhosted.org/packages/da/69/2f47bb6fa1b8d1e3e5d0c4be8ccb4313c63d742476a619418f85740d597b/coverage-7.13.5-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:be3d4bbad9d4b037791794ddeedd7d64a56f5933a2c1373e18e9e568b9141686", size = 254326, upload-time = "2026-03-17T10:30:21.321Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/d0/79db81da58965bd29dabc8f4ad2a2af70611a57cba9d1ec006f072f30a54/coverage-7.13.5-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4d2afbc5cc54d286bfb54541aa50b64cdb07a718227168c87b9e2fb8f25e1743", size = 256267, upload-time = "2026-03-17T10:30:23.094Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/32/d0d7cc8168f91ddab44c0ce4806b969df5f5fdfdbb568eaca2dbc2a04936/coverage-7.13.5-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3ad050321264c49c2fa67bb599100456fc51d004b82534f379d16445da40fb75", size = 250430, upload-time = "2026-03-17T10:30:25.311Z" },
-    { url = "https://files.pythonhosted.org/packages/4d/06/a055311d891ddbe231cd69fdd20ea4be6e3603ffebddf8704b8ca8e10a3c/coverage-7.13.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7300c8a6d13335b29bb76d7651c66af6bd8658517c43499f110ddc6717bfc209", size = 252017, upload-time = "2026-03-17T10:30:27.284Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/f6/d0fd2d21e29a657b5f77a2fe7082e1568158340dceb941954f776dce1b7b/coverage-7.13.5-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:eb07647a5738b89baab047f14edd18ded523de60f3b30e75c2acc826f79c839a", size = 250080, upload-time = "2026-03-17T10:30:29.481Z" },
-    { url = "https://files.pythonhosted.org/packages/4e/ab/0d7fb2efc2e9a5eb7ddcc6e722f834a69b454b7e6e5888c3a8567ecffb31/coverage-7.13.5-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:9adb6688e3b53adffefd4a52d72cbd8b02602bfb8f74dcd862337182fd4d1a4e", size = 253843, upload-time = "2026-03-17T10:30:31.301Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/6f/7467b917bbf5408610178f62a49c0ed4377bb16c1657f689cc61470da8ce/coverage-7.13.5-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7c8d4bc913dd70b93488d6c496c77f3aff5ea99a07e36a18f865bca55adef8bd", size = 249802, upload-time = "2026-03-17T10:30:33.358Z" },
-    { url = "https://files.pythonhosted.org/packages/75/2c/1172fb689df92135f5bfbbd69fc83017a76d24ea2e2f3a1154007e2fb9f8/coverage-7.13.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0e3c426ffc4cd952f54ee9ffbdd10345709ecc78a3ecfd796a57236bfad0b9b8", size = 250707, upload-time = "2026-03-17T10:30:35.2Z" },
-    { url = "https://files.pythonhosted.org/packages/67/21/9ac389377380a07884e3b48ba7a620fcd9dbfaf1d40565facdc6b36ec9ef/coverage-7.13.5-cp311-cp311-win32.whl", hash = "sha256:259b69bb83ad9894c4b25be2528139eecba9a82646ebdda2d9db1ba28424a6bf", size = 221880, upload-time = "2026-03-17T10:30:36.775Z" },
-    { url = "https://files.pythonhosted.org/packages/af/7f/4cd8a92531253f9d7c1bbecd9fa1b472907fb54446ca768c59b531248dc5/coverage-7.13.5-cp311-cp311-win_amd64.whl", hash = "sha256:258354455f4e86e3e9d0d17571d522e13b4e1e19bf0f8596bcf9476d61e7d8a9", size = 222816, upload-time = "2026-03-17T10:30:38.891Z" },
-    { url = "https://files.pythonhosted.org/packages/12/a6/1d3f6155fb0010ca68eba7fe48ca6c9da7385058b77a95848710ecf189b1/coverage-7.13.5-cp311-cp311-win_arm64.whl", hash = "sha256:bff95879c33ec8da99fc9b6fe345ddb5be6414b41d6d1ad1c8f188d26f36e028", size = 221483, upload-time = "2026-03-17T10:30:40.463Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/c3/a396306ba7db865bf96fc1fb3b7fd29bcbf3d829df642e77b13555163cd6/coverage-7.13.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:460cf0114c5016fa841214ff5564aa4864f11948da9440bc97e21ad1f4ba1e01", size = 219554, upload-time = "2026-03-17T10:30:42.208Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/16/a68a19e5384e93f811dccc51034b1fd0b865841c390e3c931dcc4699e035/coverage-7.13.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0e223ce4b4ed47f065bfb123687686512e37629be25cc63728557ae7db261422", size = 219908, upload-time = "2026-03-17T10:30:43.906Z" },
-    { url = "https://files.pythonhosted.org/packages/29/72/20b917c6793af3a5ceb7fb9c50033f3ec7865f2911a1416b34a7cfa0813b/coverage-7.13.5-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:6e3370441f4513c6252bf042b9c36d22491142385049243253c7e48398a15a9f", size = 251419, upload-time = "2026-03-17T10:30:45.545Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/49/cd14b789536ac6a4778c453c6a2338bc0a2fb60c5a5a41b4008328b9acc1/coverage-7.13.5-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:03ccc709a17a1de074fb1d11f217342fb0d2b1582ed544f554fc9fc3f07e95f5", size = 254159, upload-time = "2026-03-17T10:30:47.204Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/00/7b0edcfe64e2ed4c0340dac14a52ad0f4c9bd0b8b5e531af7d55b703db7c/coverage-7.13.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3f4818d065964db3c1c66dc0fbdac5ac692ecbc875555e13374fdbe7eedb4376", size = 255270, upload-time = "2026-03-17T10:30:48.812Z" },
-    { url = "https://files.pythonhosted.org/packages/93/89/7ffc4ba0f5d0a55c1e84ea7cee39c9fc06af7b170513d83fbf3bbefce280/coverage-7.13.5-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:012d5319e66e9d5a218834642d6c35d265515a62f01157a45bcc036ecf947256", size = 257538, upload-time = "2026-03-17T10:30:50.77Z" },
-    { url = "https://files.pythonhosted.org/packages/81/bd/73ddf85f93f7e6fa83e77ccecb6162d9415c79007b4bc124008a4995e4a7/coverage-7.13.5-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8dd02af98971bdb956363e4827d34425cb3df19ee550ef92855b0acb9c7ce51c", size = 251821, upload-time = "2026-03-17T10:30:52.5Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/81/278aff4e8dec4926a0bcb9486320752811f543a3ce5b602cc7a29978d073/coverage-7.13.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f08fd75c50a760c7eb068ae823777268daaf16a80b918fa58eea888f8e3919f5", size = 253191, upload-time = "2026-03-17T10:30:54.543Z" },
-    { url = "https://files.pythonhosted.org/packages/70/ee/fe1621488e2e0a58d7e94c4800f0d96f79671553488d401a612bebae324b/coverage-7.13.5-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:843ea8643cf967d1ac7e8ecd4bb00c99135adf4816c0c0593fdcc47b597fcf09", size = 251337, upload-time = "2026-03-17T10:30:56.663Z" },
-    { url = "https://files.pythonhosted.org/packages/37/a6/f79fb37aa104b562207cc23cb5711ab6793608e246cae1e93f26b2236ed9/coverage-7.13.5-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:9d44d7aa963820b1b971dbecd90bfe5fe8f81cff79787eb6cca15750bd2f79b9", size = 255404, upload-time = "2026-03-17T10:30:58.427Z" },
-    { url = "https://files.pythonhosted.org/packages/75/f0/ed15262a58ec81ce457ceb717b7f78752a1713556b19081b76e90896e8d4/coverage-7.13.5-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:7132bed4bd7b836200c591410ae7d97bf7ae8be6fc87d160b2bd881df929e7bf", size = 250903, upload-time = "2026-03-17T10:31:00.093Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/e9/9129958f20e7e9d4d56d51d42ccf708d15cac355ff4ac6e736e97a9393d2/coverage-7.13.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a698e363641b98843c517817db75373c83254781426e94ada3197cabbc2c919c", size = 252780, upload-time = "2026-03-17T10:31:01.916Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/d7/0ad9b15812d81272db94379fe4c6df8fd17781cc7671fdfa30c76ba5ff7b/coverage-7.13.5-cp312-cp312-win32.whl", hash = "sha256:bdba0a6b8812e8c7df002d908a9a2ea3c36e92611b5708633c50869e6d922fdf", size = 222093, upload-time = "2026-03-17T10:31:03.642Z" },
-    { url = "https://files.pythonhosted.org/packages/29/3d/821a9a5799fac2556bcf0bd37a70d1d11fa9e49784b6d22e92e8b2f85f18/coverage-7.13.5-cp312-cp312-win_amd64.whl", hash = "sha256:d2c87e0c473a10bffe991502eac389220533024c8082ec1ce849f4218dded810", size = 222900, upload-time = "2026-03-17T10:31:05.651Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/fa/2238c2ad08e35cf4f020ea721f717e09ec3152aea75d191a7faf3ef009a8/coverage-7.13.5-cp312-cp312-win_arm64.whl", hash = "sha256:bf69236a9a81bdca3bff53796237aab096cdbf8d78a66ad61e992d9dac7eb2de", size = 221515, upload-time = "2026-03-17T10:31:07.293Z" },
-    { url = "https://files.pythonhosted.org/packages/74/8c/74fedc9663dcf168b0a059d4ea756ecae4da77a489048f94b5f512a8d0b3/coverage-7.13.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5ec4af212df513e399cf11610cc27063f1586419e814755ab362e50a85ea69c1", size = 219576, upload-time = "2026-03-17T10:31:09.045Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/c9/44fb661c55062f0818a6ffd2685c67aa30816200d5f2817543717d4b92eb/coverage-7.13.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:941617e518602e2d64942c88ec8499f7fbd49d3f6c4327d3a71d43a1973032f3", size = 219942, upload-time = "2026-03-17T10:31:10.708Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/13/93419671cee82b780bab7ea96b67c8ef448f5f295f36bf5031154ec9a790/coverage-7.13.5-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:da305e9937617ee95c2e39d8ff9f040e0487cbf1ac174f777ed5eddd7a7c1f26", size = 250935, upload-time = "2026-03-17T10:31:12.392Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/68/1666e3a4462f8202d836920114fa7a5ee9275d1fa45366d336c551a162dd/coverage-7.13.5-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:78e696e1cc714e57e8b25760b33a8b1026b7048d270140d25dafe1b0a1ee05a3", size = 253541, upload-time = "2026-03-17T10:31:14.247Z" },
-    { url = "https://files.pythonhosted.org/packages/4e/5e/3ee3b835647be646dcf3c65a7c6c18f87c27326a858f72ab22c12730773d/coverage-7.13.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:02ca0eed225b2ff301c474aeeeae27d26e2537942aa0f87491d3e147e784a82b", size = 254780, upload-time = "2026-03-17T10:31:16.193Z" },
-    { url = "https://files.pythonhosted.org/packages/44/b3/cb5bd1a04cfcc49ede6cd8409d80bee17661167686741e041abc7ee1b9a9/coverage-7.13.5-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:04690832cbea4e4663d9149e05dba142546ca05cb1848816760e7f58285c970a", size = 256912, upload-time = "2026-03-17T10:31:17.89Z" },
-    { url = "https://files.pythonhosted.org/packages/1b/66/c1dceb7b9714473800b075f5c8a84f4588f887a90eb8645282031676e242/coverage-7.13.5-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0590e44dd2745c696a778f7bab6aa95256de2cbc8b8cff4f7db8ff09813d6969", size = 251165, upload-time = "2026-03-17T10:31:19.605Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/62/5502b73b97aa2e53ea22a39cf8649ff44827bef76d90bf638777daa27a9d/coverage-7.13.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d7cfad2d6d81dd298ab6b89fe72c3b7b05ec7544bdda3b707ddaecff8d25c161", size = 252908, upload-time = "2026-03-17T10:31:21.312Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/37/7792c2d69854397ca77a55c4646e5897c467928b0e27f2d235d83b5d08c6/coverage-7.13.5-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:e092b9499de38ae0fbfbc603a74660eb6ff3e869e507b50d85a13b6db9863e15", size = 250873, upload-time = "2026-03-17T10:31:23.565Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/23/bc866fb6163be52a8a9e5d708ba0d3b1283c12158cefca0a8bbb6e247a43/coverage-7.13.5-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:48c39bc4a04d983a54a705a6389512883d4a3b9862991b3617d547940e9f52b1", size = 255030, upload-time = "2026-03-17T10:31:25.58Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/8b/ef67e1c222ef49860701d346b8bbb70881bef283bd5f6cbba68a39a086c7/coverage-7.13.5-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2d3807015f138ffea1ed9afeeb8624fd781703f2858b62a8dd8da5a0994c57b6", size = 250694, upload-time = "2026-03-17T10:31:27.316Z" },
-    { url = "https://files.pythonhosted.org/packages/46/0d/866d1f74f0acddbb906db212e096dee77a8e2158ca5e6bb44729f9d93298/coverage-7.13.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ee2aa19e03161671ec964004fb74b2257805d9710bf14a5c704558b9d8dbaf17", size = 252469, upload-time = "2026-03-17T10:31:29.472Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/f5/be742fec31118f02ce42b21c6af187ad6a344fed546b56ca60caacc6a9a0/coverage-7.13.5-cp313-cp313-win32.whl", hash = "sha256:ce1998c0483007608c8382f4ff50164bfc5bd07a2246dd272aa4043b75e61e85", size = 222112, upload-time = "2026-03-17T10:31:31.526Z" },
-    { url = "https://files.pythonhosted.org/packages/66/40/7732d648ab9d069a46e686043241f01206348e2bbf128daea85be4d6414b/coverage-7.13.5-cp313-cp313-win_amd64.whl", hash = "sha256:631efb83f01569670a5e866ceb80fe483e7c159fac6f167e6571522636104a0b", size = 222923, upload-time = "2026-03-17T10:31:33.633Z" },
-    { url = "https://files.pythonhosted.org/packages/48/af/fea819c12a095781f6ccd504890aaddaf88b8fab263c4940e82c7b770124/coverage-7.13.5-cp313-cp313-win_arm64.whl", hash = "sha256:f4cd16206ad171cbc2470dbea9103cf9a7607d5fe8c242fdf1edf36174020664", size = 221540, upload-time = "2026-03-17T10:31:35.445Z" },
-    { url = "https://files.pythonhosted.org/packages/23/d2/17879af479df7fbbd44bd528a31692a48f6b25055d16482fdf5cdb633805/coverage-7.13.5-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0428cbef5783ad91fe240f673cc1f76b25e74bbfe1a13115e4aa30d3f538162d", size = 220262, upload-time = "2026-03-17T10:31:37.184Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/4c/d20e554f988c8f91d6a02c5118f9abbbf73a8768a3048cb4962230d5743f/coverage-7.13.5-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e0b216a19534b2427cc201a26c25da4a48633f29a487c61258643e89d28200c0", size = 220617, upload-time = "2026-03-17T10:31:39.245Z" },
-    { url = "https://files.pythonhosted.org/packages/29/9c/f9f5277b95184f764b24e7231e166dfdb5780a46d408a2ac665969416d61/coverage-7.13.5-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:972a9cd27894afe4bc2b1480107054e062df08e671df7c2f18c205e805ccd806", size = 261912, upload-time = "2026-03-17T10:31:41.324Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/f6/7f1ab39393eeb50cfe4747ae8ef0e4fc564b989225aa1152e13a180d74f8/coverage-7.13.5-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4b59148601efcd2bac8c4dbf1f0ad6391693ccf7a74b8205781751637076aee3", size = 263987, upload-time = "2026-03-17T10:31:43.724Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/d7/62c084fb489ed9c6fbdf57e006752e7c516ea46fd690e5ed8b8617c7d52e/coverage-7.13.5-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:505d7083c8b0c87a8fa8c07370c285847c1f77739b22e299ad75a6af6c32c5c9", size = 266416, upload-time = "2026-03-17T10:31:45.769Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/f6/df63d8660e1a0bff6125947afda112a0502736f470d62ca68b288ea762d8/coverage-7.13.5-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:60365289c3741e4db327e7baff2a4aaacf22f788e80fa4683393891b70a89fbd", size = 267558, upload-time = "2026-03-17T10:31:48.293Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/02/353ca81d36779bd108f6d384425f7139ac3c58c750dcfaafe5d0bee6436b/coverage-7.13.5-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1b88c69c8ef5d4b6fe7dea66d6636056a0f6a7527c440e890cf9259011f5e606", size = 261163, upload-time = "2026-03-17T10:31:50.125Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/16/2e79106d5749bcaf3aee6d309123548e3276517cd7851faa8da213bc61bf/coverage-7.13.5-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5b13955d31d1633cf9376908089b7cebe7d15ddad7aeaabcbe969a595a97e95e", size = 263981, upload-time = "2026-03-17T10:31:51.961Z" },
-    { url = "https://files.pythonhosted.org/packages/29/c7/c29e0c59ffa6942030ae6f50b88ae49988e7e8da06de7ecdbf49c6d4feae/coverage-7.13.5-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:f70c9ab2595c56f81a89620e22899eea8b212a4041bd728ac6f4a28bf5d3ddd0", size = 261604, upload-time = "2026-03-17T10:31:53.872Z" },
-    { url = "https://files.pythonhosted.org/packages/40/48/097cdc3db342f34006a308ab41c3a7c11c3f0d84750d340f45d88a782e00/coverage-7.13.5-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:084b84a8c63e8d6fc7e3931b316a9bcafca1458d753c539db82d31ed20091a87", size = 265321, upload-time = "2026-03-17T10:31:55.997Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/1f/4994af354689e14fd03a75f8ec85a9a68d94e0188bbdab3fc1516b55e512/coverage-7.13.5-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:ad14385487393e386e2ea988b09d62dd42c397662ac2dabc3832d71253eee479", size = 260502, upload-time = "2026-03-17T10:31:58.308Z" },
-    { url = "https://files.pythonhosted.org/packages/22/c6/9bb9ef55903e628033560885f5c31aa227e46878118b63ab15dc7ba87797/coverage-7.13.5-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:7f2c47b36fe7709a6e83bfadf4eefb90bd25fbe4014d715224c4316f808e59a2", size = 262688, upload-time = "2026-03-17T10:32:00.141Z" },
-    { url = "https://files.pythonhosted.org/packages/14/4f/f5df9007e50b15e53e01edea486814783a7f019893733d9e4d6caad75557/coverage-7.13.5-cp313-cp313t-win32.whl", hash = "sha256:67e9bc5449801fad0e5dff329499fb090ba4c5800b86805c80617b4e29809b2a", size = 222788, upload-time = "2026-03-17T10:32:02.246Z" },
-    { url = "https://files.pythonhosted.org/packages/e1/98/aa7fccaa97d0f3192bec013c4e6fd6d294a6ed44b640e6bb61f479e00ed5/coverage-7.13.5-cp313-cp313t-win_amd64.whl", hash = "sha256:da86cdcf10d2519e10cabb8ac2de03da1bcb6e4853790b7fbd48523332e3a819", size = 223851, upload-time = "2026-03-17T10:32:04.416Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/8b/e5c469f7352651e5f013198e9e21f97510b23de957dd06a84071683b4b60/coverage-7.13.5-cp313-cp313t-win_arm64.whl", hash = "sha256:0ecf12ecb326fe2c339d93fc131816f3a7367d223db37817208905c89bded911", size = 222104, upload-time = "2026-03-17T10:32:06.65Z" },
-    { url = "https://files.pythonhosted.org/packages/8e/77/39703f0d1d4b478bfd30191d3c14f53caf596fac00efb3f8f6ee23646439/coverage-7.13.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fbabfaceaeb587e16f7008f7795cd80d20ec548dc7f94fbb0d4ec2e038ce563f", size = 219621, upload-time = "2026-03-17T10:32:08.589Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/3e/51dff36d99ae14639a133d9b164d63e628532e2974d8b1edb99dd1ebc733/coverage-7.13.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9bb2a28101a443669a423b665939381084412b81c3f8c0fcfbac57f4e30b5b8e", size = 219953, upload-time = "2026-03-17T10:32:10.507Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/6c/1f1917b01eb647c2f2adc9962bd66c79eb978951cab61bdc1acab3290c07/coverage-7.13.5-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bd3a2fbc1c6cccb3c5106140d87cc6a8715110373ef42b63cf5aea29df8c217a", size = 250992, upload-time = "2026-03-17T10:32:12.41Z" },
-    { url = "https://files.pythonhosted.org/packages/22/e5/06b1f88f42a5a99df42ce61208bdec3bddb3d261412874280a19796fc09c/coverage-7.13.5-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6c36ddb64ed9d7e496028d1d00dfec3e428e0aabf4006583bb1839958d280510", size = 253503, upload-time = "2026-03-17T10:32:14.449Z" },
-    { url = "https://files.pythonhosted.org/packages/80/28/2a148a51e5907e504fa7b85490277734e6771d8844ebcc48764a15e28155/coverage-7.13.5-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:380e8e9084d8eb38db3a9176a1a4f3c0082c3806fa0dc882d1d87abc3c789247", size = 254852, upload-time = "2026-03-17T10:32:16.56Z" },
-    { url = "https://files.pythonhosted.org/packages/61/77/50e8d3d85cc0b7ebe09f30f151d670e302c7ff4a1bf6243f71dd8b0981fa/coverage-7.13.5-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e808af52a0513762df4d945ea164a24b37f2f518cbe97e03deaa0ee66139b4d6", size = 257161, upload-time = "2026-03-17T10:32:19.004Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/c4/b5fd1d4b7bf8d0e75d997afd3925c59ba629fc8616f1b3aae7605132e256/coverage-7.13.5-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e301d30dd7e95ae068671d746ba8c34e945a82682e62918e41b2679acd2051a0", size = 251021, upload-time = "2026-03-17T10:32:21.344Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/66/6ea21f910e92d69ef0b1c3346ea5922a51bad4446c9126db2ae96ee24c4c/coverage-7.13.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:800bc829053c80d240a687ceeb927a94fd108bbdc68dfbe505d0d75ab578a882", size = 252858, upload-time = "2026-03-17T10:32:23.506Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/ea/879c83cb5d61aa2a35fb80e72715e92672daef8191b84911a643f533840c/coverage-7.13.5-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:0b67af5492adb31940ee418a5a655c28e48165da5afab8c7fa6fd72a142f8740", size = 250823, upload-time = "2026-03-17T10:32:25.516Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/fb/616d95d3adb88b9803b275580bdeee8bd1b69a886d057652521f83d7322f/coverage-7.13.5-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:c9136ff29c3a91e25b1d1552b5308e53a1e0653a23e53b6366d7c2dcbbaf8a16", size = 255099, upload-time = "2026-03-17T10:32:27.944Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/93/25e6917c90ec1c9a56b0b26f6cad6408e5f13bb6b35d484a0d75c9cf000d/coverage-7.13.5-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:cff784eef7f0b8f6cb28804fbddcfa99f89efe4cc35fb5627e3ac58f91ed3ac0", size = 250638, upload-time = "2026-03-17T10:32:29.914Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/7b/dc1776b0464145a929deed214aef9fb1493f159b59ff3c7eeeedf91eddd0/coverage-7.13.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:68a4953be99b17ac3c23b6efbc8a38330d99680c9458927491d18700ef23ded0", size = 252295, upload-time = "2026-03-17T10:32:31.981Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/fb/99cbbc56a26e07762a2740713f3c8f9f3f3106e3a3dd8cc4474954bccd34/coverage-7.13.5-cp314-cp314-win32.whl", hash = "sha256:35a31f2b1578185fbe6aa2e74cea1b1d0bbf4c552774247d9160d29b80ed56cc", size = 222360, upload-time = "2026-03-17T10:32:34.233Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/b7/4758d4f73fb536347cc5e4ad63662f9d60ba9118cb6785e9616b2ce5d7fa/coverage-7.13.5-cp314-cp314-win_amd64.whl", hash = "sha256:2aa055ae1857258f9e0045be26a6d62bdb47a72448b62d7b55f4820f361a2633", size = 223174, upload-time = "2026-03-17T10:32:36.369Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/f2/24d84e1dfe70f8ac9fdf30d338239860d0d1d5da0bda528959d0ebc9da28/coverage-7.13.5-cp314-cp314-win_arm64.whl", hash = "sha256:1b11eef33edeae9d142f9b4358edb76273b3bfd30bc3df9a4f95d0e49caf94e8", size = 221739, upload-time = "2026-03-17T10:32:38.736Z" },
-    { url = "https://files.pythonhosted.org/packages/60/5b/4a168591057b3668c2428bff25dd3ebc21b629d666d90bcdfa0217940e84/coverage-7.13.5-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:10a0c37f0b646eaff7cce1874c31d1f1ccb297688d4c747291f4f4c70741cc8b", size = 220351, upload-time = "2026-03-17T10:32:41.196Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/21/1fd5c4dbfe4a58b6b99649125635df46decdfd4a784c3cd6d410d303e370/coverage-7.13.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b5db73ba3c41c7008037fa731ad5459fc3944cb7452fc0aa9f822ad3533c583c", size = 220612, upload-time = "2026-03-17T10:32:43.204Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/fe/2a924b3055a5e7e4512655a9d4609781b0d62334fa0140c3e742926834e2/coverage-7.13.5-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:750db93a81e3e5a9831b534be7b1229df848b2e125a604fe6651e48aa070e5f9", size = 261985, upload-time = "2026-03-17T10:32:45.514Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/0d/c8928f2bd518c45990fe1a2ab8db42e914ef9b726c975facc4282578c3eb/coverage-7.13.5-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9ddb4f4a5479f2539644be484da179b653273bca1a323947d48ab107b3ed1f29", size = 264107, upload-time = "2026-03-17T10:32:47.971Z" },
-    { url = "https://files.pythonhosted.org/packages/ef/ae/4ae35bbd9a0af9d820362751f0766582833c211224b38665c0f8de3d487f/coverage-7.13.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d8a7a2049c14f413163e2bdabd37e41179b1d1ccb10ffc6ccc4b7a718429c607", size = 266513, upload-time = "2026-03-17T10:32:50.1Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/20/d326174c55af36f74eac6ae781612d9492f060ce8244b570bb9d50d9d609/coverage-7.13.5-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e1c85e0b6c05c592ea6d8768a66a254bfb3874b53774b12d4c89c481eb78cb90", size = 267650, upload-time = "2026-03-17T10:32:52.391Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/5e/31484d62cbd0eabd3412e30d74386ece4a0837d4f6c3040a653878bfc019/coverage-7.13.5-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:777c4d1eff1b67876139d24288aaf1817f6c03d6bae9c5cc8d27b83bcfe38fe3", size = 261089, upload-time = "2026-03-17T10:32:54.544Z" },
-    { url = "https://files.pythonhosted.org/packages/e9/d8/49a72d6de146eebb0b7e48cc0f4bc2c0dd858e3d4790ab2b39a2872b62bd/coverage-7.13.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:6697e29b93707167687543480a40f0db8f356e86d9f67ddf2e37e2dfd91a9dab", size = 263982, upload-time = "2026-03-17T10:32:56.803Z" },
-    { url = "https://files.pythonhosted.org/packages/06/3b/0351f1bd566e6e4dd39e978efe7958bde1d32f879e85589de147654f57bb/coverage-7.13.5-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:8fdf453a942c3e4d99bd80088141c4c6960bb232c409d9c3558e2dbaa3998562", size = 261579, upload-time = "2026-03-17T10:32:59.466Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/ce/796a2a2f4017f554d7810f5c573449b35b1e46788424a548d4d19201b222/coverage-7.13.5-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:32ca0c0114c9834a43f045a87dcebd69d108d8ffb666957ea65aa132f50332e2", size = 265316, upload-time = "2026-03-17T10:33:01.847Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/16/d5ae91455541d1a78bc90abf495be600588aff8f6db5c8b0dae739fa39c9/coverage-7.13.5-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:8769751c10f339021e2638cd354e13adeac54004d1941119b2c96fe5276d45ea", size = 260427, upload-time = "2026-03-17T10:33:03.945Z" },
-    { url = "https://files.pythonhosted.org/packages/48/11/07f413dba62db21fb3fad5d0de013a50e073cc4e2dc4306e770360f6dfc8/coverage-7.13.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cec2d83125531bd153175354055cdb7a09987af08a9430bd173c937c6d0fba2a", size = 262745, upload-time = "2026-03-17T10:33:06.285Z" },
-    { url = "https://files.pythonhosted.org/packages/91/15/d792371332eb4663115becf4bad47e047d16234b1aff687b1b18c58d60ae/coverage-7.13.5-cp314-cp314t-win32.whl", hash = "sha256:0cd9ed7a8b181775459296e402ca4fb27db1279740a24e93b3b41942ebe4b215", size = 223146, upload-time = "2026-03-17T10:33:08.756Z" },
-    { url = "https://files.pythonhosted.org/packages/db/51/37221f59a111dca5e85be7dbf09696323b5b9f13ff65e0641d535ed06ea8/coverage-7.13.5-cp314-cp314t-win_amd64.whl", hash = "sha256:301e3b7dfefecaca37c9f1aa6f0049b7d4ab8dd933742b607765d757aca77d43", size = 224254, upload-time = "2026-03-17T10:33:11.174Z" },
-    { url = "https://files.pythonhosted.org/packages/54/83/6acacc889de8987441aa7d5adfbdbf33d288dad28704a67e574f1df9bcbb/coverage-7.13.5-cp314-cp314t-win_arm64.whl", hash = "sha256:9dacc2ad679b292709e0f5fc1ac74a6d4d5562e424058962c7bb0c658ad25e45", size = 222276, upload-time = "2026-03-17T10:33:13.466Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/ee/a4cf96b8ce1e566ed238f0659ac2d3f007ed1d14b181bcb684e19561a69a/coverage-7.13.5-py3-none-any.whl", hash = "sha256:34b02417cf070e173989b3db962f7ed56d2f644307b2cf9d5a0f258e13084a61", size = 211346, upload-time = "2026-03-17T10:33:15.691Z" },
-]
-
-[package.optional-dependencies]
-toml = [
-    { name = "tomli", marker = "python_full_version <= '3.11'" },
-]
-
-[[package]]
-name = "dev-code"
-source = { editable = "." }
-
-[package.dev-dependencies]
-dev = [
-    { name = "pyfiglet" },
-    { name = "pytest" },
-    { name = "pytest-cov" },
-    { name = "pyyaml" },
-    { name = "tox" },
-]
-
-[package.metadata]
-
-[package.metadata.requires-dev]
-dev = [
-    { name = "pyfiglet", specifier = ">=1.0.4" },
-    { name = "pytest", specifier = ">=7.0.1" },
-    { name = "pytest-cov", specifier = ">=4.0" },
-    { name = "pyyaml", specifier = ">=6.0" },
-    { name = "tox", specifier = ">=4.0" },
-]
-
-[[package]]
-name = "distlib"
-version = "0.4.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/96/8e/709914eb2b5749865801041647dc7f4e6d00b549cfe88b65ca192995f07c/distlib-0.4.0.tar.gz", hash = "sha256:feec40075be03a04501a973d81f633735b4b69f98b05450592310c0f401a4e0d", size = 614605, upload-time = "2025-07-17T16:52:00.465Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/33/6b/e0547afaf41bf2c42e52430072fa5658766e3d65bd4b03a563d1b6336f57/distlib-0.4.0-py2.py3-none-any.whl", hash = "sha256:9659f7d87e46584a30b5780e43ac7a2143098441670ff0a49d5f9034c54a6c16", size = 469047, upload-time = "2025-07-17T16:51:58.613Z" },
-]
-
-[[package]]
-name = "exceptiongroup"
-version = "1.3.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" },
-]
-
-[[package]]
-name = "filelock"
-version = "3.25.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/94/b8/00651a0f559862f3bb7d6f7477b192afe3f583cc5e26403b44e59a55ab34/filelock-3.25.2.tar.gz", hash = "sha256:b64ece2b38f4ca29dd3e810287aa8c48182bbecd1ae6e9ae126c9b35f1382694", size = 40480, upload-time = "2026-03-11T20:45:38.487Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a4/a5/842ae8f0c08b61d6484b52f99a03510a3a72d23141942d216ebe81fefbce/filelock-3.25.2-py3-none-any.whl", hash = "sha256:ca8afb0da15f229774c9ad1b455ed96e85a81373065fb10446672f64444ddf70", size = 26759, upload-time = "2026-03-11T20:45:37.437Z" },
-]
-
-[[package]]
-name = "iniconfig"
-version = "2.3.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
-]
-
-[[package]]
-name = "packaging"
-version = "26.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },
-]
-
-[[package]]
-name = "platformdirs"
-version = "4.9.4"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/19/56/8d4c30c8a1d07013911a8fdbd8f89440ef9f08d07a1b50ab8ca8be5a20f9/platformdirs-4.9.4.tar.gz", hash = "sha256:1ec356301b7dc906d83f371c8f487070e99d3ccf9e501686456394622a01a934", size = 28737, upload-time = "2026-03-05T18:34:13.271Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/63/d7/97f7e3a6abb67d8080dd406fd4df842c2be0efaf712d1c899c32a075027c/platformdirs-4.9.4-py3-none-any.whl", hash = "sha256:68a9a4619a666ea6439f2ff250c12a853cd1cbd5158d258bd824a7df6be2f868", size = 21216, upload-time = "2026-03-05T18:34:12.172Z" },
-]
-
-[[package]]
-name = "pluggy"
-version = "1.6.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
-]
-
-[[package]]
-name = "pyfiglet"
-version = "1.0.4"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/c8/e3/0a86276ad2c383ce08d76110a8eec2fe22e7051c4b8ba3fa163a0b08c428/pyfiglet-1.0.4.tar.gz", hash = "sha256:db9c9940ed1bf3048deff534ed52ff2dafbbc2cd7610b17bb5eca1df6d4278ef", size = 1560615, upload-time = "2025-08-15T18:32:47.302Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/9f/5c/fe9f95abd5eaedfa69f31e450f7e2768bef121dbdf25bcddee2cd3087a16/pyfiglet-1.0.4-py3-none-any.whl", hash = "sha256:65b57b7a8e1dff8a67dc8e940a117238661d5e14c3e49121032bd404d9b2b39f", size = 1806118, upload-time = "2025-08-15T18:32:45.556Z" },
-]
-
-[[package]]
-name = "pygments"
-version = "2.19.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
-]
-
-[[package]]
-name = "pyproject-api"
-version = "1.10.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "packaging" },
-    { name = "tomli", marker = "python_full_version < '3.11'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/45/7b/c0e1333b61d41c69e59e5366e727b18c4992688caf0de1be10b3e5265f6b/pyproject_api-1.10.0.tar.gz", hash = "sha256:40c6f2d82eebdc4afee61c773ed208c04c19db4c4a60d97f8d7be3ebc0bbb330", size = 22785, upload-time = "2025-10-09T19:12:27.21Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/54/cc/cecf97be298bee2b2a37dd360618c819a2a7fd95251d8e480c1f0eb88f3b/pyproject_api-1.10.0-py3-none-any.whl", hash = "sha256:8757c41a79c0f4ab71b99abed52b97ecf66bd20b04fa59da43b5840bac105a09", size = 13218, upload-time = "2025-10-09T19:12:24.428Z" },
-]
-
-[[package]]
-name = "pytest"
-version = "9.0.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "colorama", marker = "sys_platform == 'win32'" },
-    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
-    { name = "iniconfig" },
-    { name = "packaging" },
-    { name = "pluggy" },
-    { name = "pygments" },
-    { name = "tomli", marker = "python_full_version < '3.11'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" },
-]
-
-[[package]]
-name = "pytest-cov"
-version = "7.1.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "coverage", extra = ["toml"] },
-    { name = "pluggy" },
-    { name = "pytest" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/b1/51/a849f96e117386044471c8ec2bd6cfebacda285da9525c9106aeb28da671/pytest_cov-7.1.0.tar.gz", hash = "sha256:30674f2b5f6351aa09702a9c8c364f6a01c27aae0c1366ae8016160d1efc56b2", size = 55592, upload-time = "2026-03-21T20:11:16.284Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/9d/7a/d968e294073affff457b041c2be9868a40c1c71f4a35fcc1e45e5493067b/pytest_cov-7.1.0-py3-none-any.whl", hash = "sha256:a0461110b7865f9a271aa1b51e516c9a95de9d696734a2f71e3e78f46e1d4678", size = 22876, upload-time = "2026-03-21T20:11:14.438Z" },
-]
-
-[[package]]
-name = "python-discovery"
-version = "1.2.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "filelock" },
-    { name = "platformdirs" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/9c/90/bcce6b46823c9bec1757c964dc37ed332579be512e17a30e9698095dcae4/python_discovery-1.2.0.tar.gz", hash = "sha256:7d33e350704818b09e3da2bd419d37e21e7c30db6e0977bb438916e06b41b5b1", size = 58055, upload-time = "2026-03-19T01:43:08.248Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c2/3c/2005227cb951df502412de2fa781f800663cccbef8d90ec6f1b371ac2c0d/python_discovery-1.2.0-py3-none-any.whl", hash = "sha256:1e108f1bbe2ed0ef089823d28805d5ad32be8e734b86a5f212bf89b71c266e4a", size = 31524, upload-time = "2026-03-19T01:43:07.045Z" },
-]
-
-[[package]]
-name = "pyyaml"
-version = "6.0.3"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/f4/a0/39350dd17dd6d6c6507025c0e53aef67a9293a6d37d3511f23ea510d5800/pyyaml-6.0.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b", size = 184227, upload-time = "2025-09-25T21:31:46.04Z" },
-    { url = "https://files.pythonhosted.org/packages/05/14/52d505b5c59ce73244f59c7a50ecf47093ce4765f116cdb98286a71eeca2/pyyaml-6.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956", size = 174019, upload-time = "2025-09-25T21:31:47.706Z" },
-    { url = "https://files.pythonhosted.org/packages/43/f7/0e6a5ae5599c838c696adb4e6330a59f463265bfa1e116cfd1fbb0abaaae/pyyaml-6.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8", size = 740646, upload-time = "2025-09-25T21:31:49.21Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/3a/61b9db1d28f00f8fd0ae760459a5c4bf1b941baf714e207b6eb0657d2578/pyyaml-6.0.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198", size = 840793, upload-time = "2025-09-25T21:31:50.735Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/1e/7acc4f0e74c4b3d9531e24739e0ab832a5edf40e64fbae1a9c01941cabd7/pyyaml-6.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b", size = 770293, upload-time = "2025-09-25T21:31:51.828Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/ef/abd085f06853af0cd59fa5f913d61a8eab65d7639ff2a658d18a25d6a89d/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0", size = 732872, upload-time = "2025-09-25T21:31:53.282Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/15/2bc9c8faf6450a8b3c9fc5448ed869c599c0a74ba2669772b1f3a0040180/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69", size = 758828, upload-time = "2025-09-25T21:31:54.807Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/00/531e92e88c00f4333ce359e50c19b8d1de9fe8d581b1534e35ccfbc5f393/pyyaml-6.0.3-cp310-cp310-win32.whl", hash = "sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e", size = 142415, upload-time = "2025-09-25T21:31:55.885Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/fa/926c003379b19fca39dd4634818b00dec6c62d87faf628d1394e137354d4/pyyaml-6.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c", size = 158561, upload-time = "2025-09-25T21:31:57.406Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" },
-    { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" },
-    { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" },
-    { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" },
-    { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" },
-    { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" },
-    { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" },
-    { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },
-    { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },
-    { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },
-    { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },
-    { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" },
-    { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
-    { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
-    { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },
-    { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },
-    { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },
-    { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },
-    { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" },
-    { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" },
-    { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" },
-    { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" },
-    { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" },
-    { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" },
-    { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" },
-    { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" },
-    { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
-]
-
-[[package]]
-name = "tomli"
-version = "2.4.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/82/30/31573e9457673ab10aa432461bee537ce6cef177667deca369efb79df071/tomli-2.4.0.tar.gz", hash = "sha256:aa89c3f6c277dd275d8e243ad24f3b5e701491a860d5121f2cdd399fbb31fc9c", size = 17477, upload-time = "2026-01-11T11:22:38.165Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/3c/d9/3dc2289e1f3b32eb19b9785b6a006b28ee99acb37d1d47f78d4c10e28bf8/tomli-2.4.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b5ef256a3fd497d4973c11bf142e9ed78b150d36f5773f1ca6088c230ffc5867", size = 153663, upload-time = "2026-01-11T11:21:45.27Z" },
-    { url = "https://files.pythonhosted.org/packages/51/32/ef9f6845e6b9ca392cd3f64f9ec185cc6f09f0a2df3db08cbe8809d1d435/tomli-2.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5572e41282d5268eb09a697c89a7bee84fae66511f87533a6f88bd2f7b652da9", size = 148469, upload-time = "2026-01-11T11:21:46.873Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/c2/506e44cce89a8b1b1e047d64bd495c22c9f71f21e05f380f1a950dd9c217/tomli-2.4.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:551e321c6ba03b55676970b47cb1b73f14a0a4dce6a3e1a9458fd6d921d72e95", size = 236039, upload-time = "2026-01-11T11:21:48.503Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/40/e1b65986dbc861b7e986e8ec394598187fa8aee85b1650b01dd925ca0be8/tomli-2.4.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5e3f639a7a8f10069d0e15408c0b96a2a828cfdec6fca05296ebcdcc28ca7c76", size = 243007, upload-time = "2026-01-11T11:21:49.456Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/6f/6e39ce66b58a5b7ae572a0f4352ff40c71e8573633deda43f6a379d56b3e/tomli-2.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1b168f2731796b045128c45982d3a4874057626da0e2ef1fdd722848b741361d", size = 240875, upload-time = "2026-01-11T11:21:50.755Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/ad/cb089cb190487caa80204d503c7fd0f4d443f90b95cf4ef5cf5aa0f439b0/tomli-2.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:133e93646ec4300d651839d382d63edff11d8978be23da4cc106f5a18b7d0576", size = 246271, upload-time = "2026-01-11T11:21:51.81Z" },
-    { url = "https://files.pythonhosted.org/packages/0b/63/69125220e47fd7a3a27fd0de0c6398c89432fec41bc739823bcc66506af6/tomli-2.4.0-cp311-cp311-win32.whl", hash = "sha256:b6c78bdf37764092d369722d9946cb65b8767bfa4110f902a1b2542d8d173c8a", size = 96770, upload-time = "2026-01-11T11:21:52.647Z" },
-    { url = "https://files.pythonhosted.org/packages/1e/0d/a22bb6c83f83386b0008425a6cd1fa1c14b5f3dd4bad05e98cf3dbbf4a64/tomli-2.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:d3d1654e11d724760cdb37a3d7691f0be9db5fbdaef59c9f532aabf87006dbaa", size = 107626, upload-time = "2026-01-11T11:21:53.459Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/6d/77be674a3485e75cacbf2ddba2b146911477bd887dda9d8c9dfb2f15e871/tomli-2.4.0-cp311-cp311-win_arm64.whl", hash = "sha256:cae9c19ed12d4e8f3ebf46d1a75090e4c0dc16271c5bce1c833ac168f08fb614", size = 94842, upload-time = "2026-01-11T11:21:54.831Z" },
-    { url = "https://files.pythonhosted.org/packages/3c/43/7389a1869f2f26dba52404e1ef13b4784b6b37dac93bac53457e3ff24ca3/tomli-2.4.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:920b1de295e72887bafa3ad9f7a792f811847d57ea6b1215154030cf131f16b1", size = 154894, upload-time = "2026-01-11T11:21:56.07Z" },
-    { url = "https://files.pythonhosted.org/packages/e9/05/2f9bf110b5294132b2edf13fe6ca6ae456204f3d749f623307cbb7a946f2/tomli-2.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7d6d9a4aee98fac3eab4952ad1d73aee87359452d1c086b5ceb43ed02ddb16b8", size = 149053, upload-time = "2026-01-11T11:21:57.467Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/41/1eda3ca1abc6f6154a8db4d714a4d35c4ad90adc0bcf700657291593fbf3/tomli-2.4.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:36b9d05b51e65b254ea6c2585b59d2c4cb91c8a3d91d0ed0f17591a29aaea54a", size = 243481, upload-time = "2026-01-11T11:21:58.661Z" },
-    { url = "https://files.pythonhosted.org/packages/d2/6d/02ff5ab6c8868b41e7d4b987ce2b5f6a51d3335a70aa144edd999e055a01/tomli-2.4.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c8a885b370751837c029ef9bc014f27d80840e48bac415f3412e6593bbc18c1", size = 251720, upload-time = "2026-01-11T11:22:00.178Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/57/0405c59a909c45d5b6f146107c6d997825aa87568b042042f7a9c0afed34/tomli-2.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8768715ffc41f0008abe25d808c20c3d990f42b6e2e58305d5da280ae7d1fa3b", size = 247014, upload-time = "2026-01-11T11:22:01.238Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/0e/2e37568edd944b4165735687cbaf2fe3648129e440c26d02223672ee0630/tomli-2.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7b438885858efd5be02a9a133caf5812b8776ee0c969fea02c45e8e3f296ba51", size = 251820, upload-time = "2026-01-11T11:22:02.727Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/1c/ee3b707fdac82aeeb92d1a113f803cf6d0f37bdca0849cb489553e1f417a/tomli-2.4.0-cp312-cp312-win32.whl", hash = "sha256:0408e3de5ec77cc7f81960c362543cbbd91ef883e3138e81b729fc3eea5b9729", size = 97712, upload-time = "2026-01-11T11:22:03.777Z" },
-    { url = "https://files.pythonhosted.org/packages/69/13/c07a9177d0b3bab7913299b9278845fc6eaaca14a02667c6be0b0a2270c8/tomli-2.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:685306e2cc7da35be4ee914fd34ab801a6acacb061b6a7abca922aaf9ad368da", size = 108296, upload-time = "2026-01-11T11:22:04.86Z" },
-    { url = "https://files.pythonhosted.org/packages/18/27/e267a60bbeeee343bcc279bb9e8fbed0cbe224bc7b2a3dc2975f22809a09/tomli-2.4.0-cp312-cp312-win_arm64.whl", hash = "sha256:5aa48d7c2356055feef06a43611fc401a07337d5b006be13a30f6c58f869e3c3", size = 94553, upload-time = "2026-01-11T11:22:05.854Z" },
-    { url = "https://files.pythonhosted.org/packages/34/91/7f65f9809f2936e1f4ce6268ae1903074563603b2a2bd969ebbda802744f/tomli-2.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:84d081fbc252d1b6a982e1870660e7330fb8f90f676f6e78b052ad4e64714bf0", size = 154915, upload-time = "2026-01-11T11:22:06.703Z" },
-    { url = "https://files.pythonhosted.org/packages/20/aa/64dd73a5a849c2e8f216b755599c511badde80e91e9bc2271baa7b2cdbb1/tomli-2.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9a08144fa4cba33db5255f9b74f0b89888622109bd2776148f2597447f92a94e", size = 149038, upload-time = "2026-01-11T11:22:07.56Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/8a/6d38870bd3d52c8d1505ce054469a73f73a0fe62c0eaf5dddf61447e32fa/tomli-2.4.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c73add4bb52a206fd0c0723432db123c0c75c280cbd67174dd9d2db228ebb1b4", size = 242245, upload-time = "2026-01-11T11:22:08.344Z" },
-    { url = "https://files.pythonhosted.org/packages/59/bb/8002fadefb64ab2669e5b977df3f5e444febea60e717e755b38bb7c41029/tomli-2.4.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fb2945cbe303b1419e2706e711b7113da57b7db31ee378d08712d678a34e51e", size = 250335, upload-time = "2026-01-11T11:22:09.951Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/3d/4cdb6f791682b2ea916af2de96121b3cb1284d7c203d97d92d6003e91c8d/tomli-2.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bbb1b10aa643d973366dc2cb1ad94f99c1726a02343d43cbc011edbfac579e7c", size = 245962, upload-time = "2026-01-11T11:22:11.27Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/4a/5f25789f9a460bd858ba9756ff52d0830d825b458e13f754952dd15fb7bb/tomli-2.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4cbcb367d44a1f0c2be408758b43e1ffb5308abe0ea222897d6bfc8e8281ef2f", size = 250396, upload-time = "2026-01-11T11:22:12.325Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/2f/b73a36fea58dfa08e8b3a268750e6853a6aac2a349241a905ebd86f3047a/tomli-2.4.0-cp313-cp313-win32.whl", hash = "sha256:7d49c66a7d5e56ac959cb6fc583aff0651094ec071ba9ad43df785abc2320d86", size = 97530, upload-time = "2026-01-11T11:22:13.865Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/af/ca18c134b5d75de7e8dc551c5234eaba2e8e951f6b30139599b53de9c187/tomli-2.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:3cf226acb51d8f1c394c1b310e0e0e61fecdd7adcb78d01e294ac297dd2e7f87", size = 108227, upload-time = "2026-01-11T11:22:15.224Z" },
-    { url = "https://files.pythonhosted.org/packages/22/c3/b386b832f209fee8073c8138ec50f27b4460db2fdae9ffe022df89a57f9b/tomli-2.4.0-cp313-cp313-win_arm64.whl", hash = "sha256:d20b797a5c1ad80c516e41bc1fb0443ddb5006e9aaa7bda2d71978346aeb9132", size = 94748, upload-time = "2026-01-11T11:22:16.009Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/c4/84047a97eb1004418bc10bdbcfebda209fca6338002eba2dc27cc6d13563/tomli-2.4.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:26ab906a1eb794cd4e103691daa23d95c6919cc2fa9160000ac02370cc9dd3f6", size = 154725, upload-time = "2026-01-11T11:22:17.269Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/5d/d39038e646060b9d76274078cddf146ced86dc2b9e8bbf737ad5983609a0/tomli-2.4.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:20cedb4ee43278bc4f2fee6cb50daec836959aadaf948db5172e776dd3d993fc", size = 148901, upload-time = "2026-01-11T11:22:18.287Z" },
-    { url = "https://files.pythonhosted.org/packages/73/e5/383be1724cb30f4ce44983d249645684a48c435e1cd4f8b5cded8a816d3c/tomli-2.4.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:39b0b5d1b6dd03684b3fb276407ebed7090bbec989fa55838c98560c01113b66", size = 243375, upload-time = "2026-01-11T11:22:19.154Z" },
-    { url = "https://files.pythonhosted.org/packages/31/f0/bea80c17971c8d16d3cc109dc3585b0f2ce1036b5f4a8a183789023574f2/tomli-2.4.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a26d7ff68dfdb9f87a016ecfd1e1c2bacbe3108f4e0f8bcd2228ef9a766c787d", size = 250639, upload-time = "2026-01-11T11:22:20.168Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/8f/2853c36abbb7608e3f945d8a74e32ed3a74ee3a1f468f1ffc7d1cb3abba6/tomli-2.4.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:20ffd184fb1df76a66e34bd1b36b4a4641bd2b82954befa32fe8163e79f1a702", size = 246897, upload-time = "2026-01-11T11:22:21.544Z" },
-    { url = "https://files.pythonhosted.org/packages/49/f0/6c05e3196ed5337b9fe7ea003e95fd3819a840b7a0f2bf5a408ef1dad8ed/tomli-2.4.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:75c2f8bbddf170e8effc98f5e9084a8751f8174ea6ccf4fca5398436e0320bc8", size = 254697, upload-time = "2026-01-11T11:22:23.058Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/f5/2922ef29c9f2951883525def7429967fc4d8208494e5ab524234f06b688b/tomli-2.4.0-cp314-cp314-win32.whl", hash = "sha256:31d556d079d72db7c584c0627ff3a24c5d3fb4f730221d3444f3efb1b2514776", size = 98567, upload-time = "2026-01-11T11:22:24.033Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/31/22b52e2e06dd2a5fdbc3ee73226d763b184ff21fc24e20316a44ccc4d96b/tomli-2.4.0-cp314-cp314-win_amd64.whl", hash = "sha256:43e685b9b2341681907759cf3a04e14d7104b3580f808cfde1dfdb60ada85475", size = 108556, upload-time = "2026-01-11T11:22:25.378Z" },
-    { url = "https://files.pythonhosted.org/packages/48/3d/5058dff3255a3d01b705413f64f4306a141a8fd7a251e5a495e3f192a998/tomli-2.4.0-cp314-cp314-win_arm64.whl", hash = "sha256:3d895d56bd3f82ddd6faaff993c275efc2ff38e52322ea264122d72729dca2b2", size = 96014, upload-time = "2026-01-11T11:22:26.138Z" },
-    { url = "https://files.pythonhosted.org/packages/b8/4e/75dab8586e268424202d3a1997ef6014919c941b50642a1682df43204c22/tomli-2.4.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:5b5807f3999fb66776dbce568cc9a828544244a8eb84b84b9bafc080c99597b9", size = 163339, upload-time = "2026-01-11T11:22:27.143Z" },
-    { url = "https://files.pythonhosted.org/packages/06/e3/b904d9ab1016829a776d97f163f183a48be6a4deb87304d1e0116a349519/tomli-2.4.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c084ad935abe686bd9c898e62a02a19abfc9760b5a79bc29644463eaf2840cb0", size = 159490, upload-time = "2026-01-11T11:22:28.399Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/5a/fc3622c8b1ad823e8ea98a35e3c632ee316d48f66f80f9708ceb4f2a0322/tomli-2.4.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0f2e3955efea4d1cfbcb87bc321e00dc08d2bcb737fd1d5e398af111d86db5df", size = 269398, upload-time = "2026-01-11T11:22:29.345Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/33/62bd6152c8bdd4c305ad9faca48f51d3acb2df1f8791b1477d46ff86e7f8/tomli-2.4.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0e0fe8a0b8312acf3a88077a0802565cb09ee34107813bba1c7cd591fa6cfc8d", size = 276515, upload-time = "2026-01-11T11:22:30.327Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/ff/ae53619499f5235ee4211e62a8d7982ba9e439a0fb4f2f351a93d67c1dd2/tomli-2.4.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:413540dce94673591859c4c6f794dfeaa845e98bf35d72ed59636f869ef9f86f", size = 273806, upload-time = "2026-01-11T11:22:32.56Z" },
-    { url = "https://files.pythonhosted.org/packages/47/71/cbca7787fa68d4d0a9f7072821980b39fbb1b6faeb5f5cf02f4a5559fa28/tomli-2.4.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:0dc56fef0e2c1c470aeac5b6ca8cc7b640bb93e92d9803ddaf9ea03e198f5b0b", size = 281340, upload-time = "2026-01-11T11:22:33.505Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/00/d595c120963ad42474cf6ee7771ad0d0e8a49d0f01e29576ee9195d9ecdf/tomli-2.4.0-cp314-cp314t-win32.whl", hash = "sha256:d878f2a6707cc9d53a1be1414bbb419e629c3d6e67f69230217bb663e76b5087", size = 108106, upload-time = "2026-01-11T11:22:34.451Z" },
-    { url = "https://files.pythonhosted.org/packages/de/69/9aa0c6a505c2f80e519b43764f8b4ba93b5a0bbd2d9a9de6e2b24271b9a5/tomli-2.4.0-cp314-cp314t-win_amd64.whl", hash = "sha256:2add28aacc7425117ff6364fe9e06a183bb0251b03f986df0e78e974047571fd", size = 120504, upload-time = "2026-01-11T11:22:35.764Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/9f/f1668c281c58cfae01482f7114a4b88d345e4c140386241a1a24dcc9e7bc/tomli-2.4.0-cp314-cp314t-win_arm64.whl", hash = "sha256:2b1e3b80e1d5e52e40e9b924ec43d81570f0e7d09d11081b797bc4692765a3d4", size = 99561, upload-time = "2026-01-11T11:22:36.624Z" },
-    { url = "https://files.pythonhosted.org/packages/23/d1/136eb2cb77520a31e1f64cbae9d33ec6df0d78bdf4160398e86eec8a8754/tomli-2.4.0-py3-none-any.whl", hash = "sha256:1f776e7d669ebceb01dee46484485f43a4048746235e683bcdffacdf1fb4785a", size = 14477, upload-time = "2026-01-11T11:22:37.446Z" },
-]
-
-[[package]]
-name = "tomli-w"
-version = "1.2.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/19/75/241269d1da26b624c0d5e110e8149093c759b7a286138f4efd61a60e75fe/tomli_w-1.2.0.tar.gz", hash = "sha256:2dd14fac5a47c27be9cd4c976af5a12d87fb1f0b4512f81d69cce3b35ae25021", size = 7184, upload-time = "2025-01-15T12:07:24.262Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c7/18/c86eb8e0202e32dd3df50d43d7ff9854f8e0603945ff398974c1d91ac1ef/tomli_w-1.2.0-py3-none-any.whl", hash = "sha256:188306098d013b691fcadc011abd66727d3c414c571bb01b1a174ba8c983cf90", size = 6675, upload-time = "2025-01-15T12:07:22.074Z" },
-]
-
-[[package]]
-name = "tox"
-version = "4.50.3"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "cachetools" },
-    { name = "colorama" },
-    { name = "filelock" },
-    { name = "packaging" },
-    { name = "platformdirs" },
-    { name = "pluggy" },
-    { name = "pyproject-api" },
-    { name = "tomli", marker = "python_full_version < '3.11'" },
-    { name = "tomli-w" },
-    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
-    { name = "virtualenv" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/ae/45/e4c0ac54af794f992790abe350770bb1fa6d5a85b25d47b6182c83ec7915/tox-4.50.3.tar.gz", hash = "sha256:c745641de6cc4f19d066bd9f98c1c25f7affb005b381b7f3694a1f142ea0946b", size = 266455, upload-time = "2026-03-20T01:17:59.351Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fe/ab/369d60db70d9031341082842071541f2497741b04140816c7df82734faf6/tox-4.50.3-py3-none-any.whl", hash = "sha256:5e788a512bfe6f7447e0c8d7c1b666eb2e56e5e676c65717490423bec37d1a07", size = 207667, upload-time = "2026-03-20T01:17:57.553Z" },
-]
-
-[[package]]
-name = "typing-extensions"
-version = "4.15.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
-]
-
-[[package]]
-name = "virtualenv"
-version = "21.2.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "distlib" },
-    { name = "filelock" },
-    { name = "platformdirs" },
-    { name = "python-discovery" },
-    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/aa/92/58199fe10049f9703c2666e809c4f686c54ef0a68b0f6afccf518c0b1eb9/virtualenv-21.2.0.tar.gz", hash = "sha256:1720dc3a62ef5b443092e3f499228599045d7fea4c79199770499df8becf9098", size = 5840618, upload-time = "2026-03-09T17:24:38.013Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c6/59/7d02447a55b2e55755011a647479041bc92a82e143f96a8195cb33bd0a1c/virtualenv-21.2.0-py3-none-any.whl", hash = "sha256:1bd755b504931164a5a496d217c014d098426cddc79363ad66ac78125f9d908f", size = 5825084, upload-time = "2026-03-09T17:24:35.378Z" },
-]

From cae9721b53656cd58ea6d9154b6dcb48b11dd809 Mon Sep 17 00:00:00 2001
From: Nasser Alansari <dacrystal@users.noreply.github.com>
Date: Tue, 7 Apr 2026 12:40:47 +0000
Subject: [PATCH 4/9] fix: add click to tox deps (skip_install=true bypasses
 pyproject.toml)

---
 tox.ini | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tox.ini b/tox.ini
index c6704df..950f83d 100644
--- a/tox.ini
+++ b/tox.ini
@@ -7,5 +7,6 @@ deps =
     pytest
     pytest-cov
     pyfiglet
+    click>=8.0
 commands =
     pytest --cov=src --cov-report=term-missing --cov-report=xml

From 99aed269a6da91163250146760ffa4d9943b16bd Mon Sep 17 00:00:00 2001
From: Nasser Alansari <dacrystal@users.noreply.github.com>
Date: Tue, 7 Apr 2026 12:45:42 +0000
Subject: [PATCH 5/9] fix: handle missing package metadata for --version in tox
 skip_install env

_get_version() falls back to "(dev)" when the package is not installed,
preventing PackageNotFoundError when tox runs with skip_install = true.
---
 src/devcode.py | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/devcode.py b/src/devcode.py
index ed953d3..ccbf89b 100644
--- a/src/devcode.py
+++ b/src/devcode.py
@@ -31,6 +31,13 @@
     "default_template": "dev-code",
 }
 
+def _get_version() -> str:
+    try:
+        return importlib.metadata.version("dev-code")
+    except importlib.metadata.PackageNotFoundError:
+        return "(dev)"
+
+
 def _configure_logging(verbose: bool) -> None:
     """Configure the module logger. Guard prevents double-registration."""
     if logger.handlers:
@@ -675,7 +682,7 @@ def _complete_templates(ctx, param, incomplete):
 
 
 @click.group(invoke_without_command=True)
-@click.version_option(package_name="dev-code", prog_name="devcode")
+@click.version_option(version=_get_version(), prog_name="devcode")
 @click.option(
     "-v", "--verbose",
     is_flag=True,

From f561aa4bbe42c71a179846db5f32771c6bffc1e5 Mon Sep 17 00:00:00 2001
From: Nasser Alansari <dacrystal@users.noreply.github.com>
Date: Tue, 7 Apr 2026 12:47:01 +0000
Subject: [PATCH 6/9] Revert "fix: handle missing package metadata for
 --version in tox skip_install env"

This reverts commit 99aed269a6da91163250146760ffa4d9943b16bd.
---
 src/devcode.py | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/src/devcode.py b/src/devcode.py
index ccbf89b..ed953d3 100644
--- a/src/devcode.py
+++ b/src/devcode.py
@@ -31,13 +31,6 @@
     "default_template": "dev-code",
 }
 
-def _get_version() -> str:
-    try:
-        return importlib.metadata.version("dev-code")
-    except importlib.metadata.PackageNotFoundError:
-        return "(dev)"
-
-
 def _configure_logging(verbose: bool) -> None:
     """Configure the module logger. Guard prevents double-registration."""
     if logger.handlers:
@@ -682,7 +675,7 @@ def _complete_templates(ctx, param, incomplete):
 
 
 @click.group(invoke_without_command=True)
-@click.version_option(version=_get_version(), prog_name="devcode")
+@click.version_option(package_name="dev-code", prog_name="devcode")
 @click.option(
     "-v", "--verbose",
     is_flag=True,

From 777b66e469a80cf80c840bc1059b599184d70f23 Mon Sep 17 00:00:00 2001
From: Nasser Alansari <dacrystal@users.noreply.github.com>
Date: Tue, 7 Apr 2026 12:55:26 +0000
Subject: [PATCH 7/9] =?UTF-8?q?fix:=20proper=20tox/pytest=20setup=20?=
 =?UTF-8?q?=E2=80=94=20remove=20skip=5Finstall,=20split=20dependency=20gro?=
 =?UTF-8?q?ups?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Remove skip_install=true and manual deps list from tox.ini; use
  dependency_groups = test so tox installs the package (and its deps)
  from pyproject.toml properly
- Split dependency-groups into test (pytest, pytest-cov) and dev (tox,
  pyyaml, git-cliff); drop unused pyfiglet
- Add pythonpath = ["src"] to pytest config as safety net for direct runs
---
 pyproject.toml | 11 +++--------
 tox.ini        |  7 +------
 2 files changed, 4 insertions(+), 14 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index e3b04d8..54ec474 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -36,16 +36,11 @@ force-include = {"src/devcode.py" = "devcode.py", "src/templates" = "dev_code_te
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
+pythonpath = ["src"]
 
 [dependency-groups]
-dev = [
-    "pytest>=7.0.1",
-    "pyfiglet>=1.0.4",
-    "pytest-cov>=4.0",
-    "tox>=4.0",
-    "pyyaml>=6.0",
-    "git-cliff>=2.0",
-]
+test = ["pytest>=7", "pytest-cov>=4"]
+dev = ["tox>=4", "pyyaml>=6", "git-cliff>=2"]
 
 [tool.hatch.metadata.hooks.fancy-pypi-readme]
 content-type = "text/markdown"
diff --git a/tox.ini b/tox.ini
index 950f83d..661c4f6 100644
--- a/tox.ini
+++ b/tox.ini
@@ -2,11 +2,6 @@
 envlist = py310, py311, py312, py313
 
 [testenv]
-skip_install = true
-deps =
-    pytest
-    pytest-cov
-    pyfiglet
-    click>=8.0
+dependency_groups = test
 commands =
     pytest --cov=src --cov-report=term-missing --cov-report=xml

From d36dcde1df9dd56fc3b3c7f7ab5413f1fdd800ae Mon Sep 17 00:00:00 2001
From: Nasser Alansari <dacrystal@users.noreply.github.com>
Date: Tue, 7 Apr 2026 12:59:34 +0000
Subject: [PATCH 8/9] fix: use os.path.join and os.path.isabs in tests for
 Windows compatibility

Path separator is \ on Windows; hardcoded forward-slash assertions failed
on windows-latest CI runner.
---
 tests/test_dev_code.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/test_dev_code.py b/tests/test_dev_code.py
index d62a7ee..57ce026 100644
--- a/tests/test_dev_code.py
+++ b/tests/test_dev_code.py
@@ -274,7 +274,7 @@ def test_falls_back_to_xdg_config_home(self):
                if k not in ("DEVCODE_CONF_DIR", "XDG_CONFIG_HOME")}
         env["XDG_CONFIG_HOME"] = "/xdg/config"
         with patch.dict(os.environ, env, clear=True):
-            self.assertEqual(devcode._conf_dir(), "/xdg/config/dev-code")
+            self.assertEqual(devcode._conf_dir(), os.path.join("/xdg/config", "dev-code"))
 
     def test_falls_back_to_default_config_dir(self):
         env = {k: v for k, v in os.environ.items()
@@ -328,7 +328,7 @@ def test_uses_template_sources_from_settings(self):
     def test_expands_tilde_in_sources(self):
         with patch.object(devcode, "_load_settings", return_value={"template_sources": ["~/templates"]}):
             result = devcode.resolve_template_search_path()
-        self.assertTrue(result[0].startswith("/"))
+        self.assertTrue(os.path.isabs(result[0]))
         self.assertNotIn("~", result[0])
 
     def test_falls_back_to_xdg_data_home_when_no_sources(self):
@@ -337,7 +337,7 @@ def test_falls_back_to_xdg_data_home_when_no_sources(self):
         with patch.object(devcode, "_load_settings", return_value={}):
             with patch.dict(os.environ, env, clear=True):
                 result = devcode.resolve_template_search_path()
-        self.assertEqual(result, ["/xdg/data/dev-code/templates"])
+        self.assertEqual(result, [os.path.join("/xdg/data", "dev-code", "templates")])
 
     def test_skips_empty_entries(self):
         with patch.object(devcode, "_load_settings", return_value={"template_sources": ["/a", "", "/b"]}):

From 0357a9a9bf3d95999beb66e3d4f69de324ccfa08 Mon Sep 17 00:00:00 2001
From: Nasser Alansari <dacrystal@users.noreply.github.com>
Date: Tue, 7 Apr 2026 13:03:07 +0000
Subject: [PATCH 9/9] ci: only run on push/PR to main

---
 .github/workflows/ci.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 0cfc785..f6912e8 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -2,9 +2,9 @@ name: CI
 
 on:
   push:
-    branches: ["**"]
+    branches: ["main"]
   pull_request:
-    branches: ["**"]
+    branches: ["main"]
 
 jobs:
   test: