dotagents-cli 0.7.4__tar.gz → 0.7.5__tar.gz

{dotagents_cli-0.7.4 → dotagents_cli-0.7.5}/CHANGELOG.md

@@ -7,6 +7,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.7.5] - 2026-10-14
+
+### Changed
+
+- `main()` runs through `duho.run(..., exit=False)`: it always returns the status
+  instead of raising `SystemExit` for a message, `--help` or a usage error (the
+  console script, `python -m dotagents` and `install.py` exit with it as before, with
+  the same statuses and the same text on standard error). Ctrl-C now ends with
+  status 130 and no traceback, and a closed pipe on standard output ends with
+  status 1, quietly.
+- The `duho` floor moves to `>=0.7.5,<0.8` (from `>=0.6.0,<0.7`); the vendored
+  `.pyz` pin (`build-pyz --duho-version`) moves with it. No flag, exit status or
+  output changes.
+- Command modules are loaded with duho's own `discover_commands(on_error=...)`
+  instead of a copy of its loop built on a private duho name. A module that fails
+  to import is still named in a warning and skipped, and the listing order is
+  unchanged. A command module may now import a sibling helper file by its bare
+  name.
+- `kebab_name` delegates to `duho.text.kebabcase`; its results are unchanged.
+- Discovered commands are listed in discovery order with `discover_commands(sort=False)`
+  instead of being re-sorted here, and a command that cannot build its parser is
+  found out with `duho.runtime.build_command_parser` instead of a private duho
+  helper. Output, exit statuses and which commands are skipped are unchanged.
+
 ## [0.7.4] - 2026-10-14
 
 ### Added
@@ -1417,7 +1441,8 @@ Patch release: the PATH/POSIX-conversion fix above (the only change since 0.3.0)
   affected module sources (`dotagents.cli`, `duho.presets`) to extracted temp files
   before dispatch; a no-op for a plain install.
 
-[Unreleased]: https://github.com/jose-pr/dotagents/compare/v0.7.4...HEAD
+[Unreleased]: https://github.com/jose-pr/dotagents/compare/v0.7.5...HEAD
+[0.7.5]: https://github.com/jose-pr/dotagents/compare/v0.7.4...v0.7.5
 [0.7.4]: https://github.com/jose-pr/dotagents/compare/v0.7.3...v0.7.4
 [0.7.3]: https://github.com/jose-pr/dotagents/compare/v0.7.2...v0.7.3
 [0.7.2]: https://github.com/jose-pr/dotagents/compare/v0.7.1...v0.7.2

{dotagents_cli-0.7.4 → dotagents_cli-0.7.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: dotagents-cli
-Version: 0.7.4
+Version: 0.7.5
 Summary: The dotagents CLI: install and manage a portable ~/.agents config for AI coding agents
 Project-URL: Homepage, https://github.com/jose-pr/dotagents/
 Project-URL: Repository, https://github.com/jose-pr/dotagents
@@ -23,7 +23,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Requires-Python: >=3.9
-Requires-Dist: duho<0.7,>=0.6.0
+Requires-Dist: duho<0.8,>=0.7.5
 Requires-Dist: pathlib-next<0.10,>=0.9.0
 Requires-Dist: tomli>=1.1.0; python_version < '3.11'
 Provides-Extra: dev

{dotagents_cli-0.7.4 → dotagents_cli-0.7.5}/pyproject.toml

@@ -35,7 +35,7 @@ classifiers = [
 # `build-pyz` vendors the floor of each of these (src/dotagents/cli/build_pyz.py);
 # raise a floor and move its pin there in the same change.
 dependencies = [
-    "duho>=0.6.0,<0.7",
+    "duho>=0.7.5,<0.8",
     "pathlib_next>=0.9.0,<0.10",
     # overlay.toml manifests and TOML registries; tomllib is stdlib from 3.11.
     'tomli>=1.1.0; python_version < "3.11"',

{dotagents_cli-0.7.4 → dotagents_cli-0.7.5}/src/dotagents/AGENTS.md

@@ -74,7 +74,11 @@ are skipped.
 ## `dotagents.cli`
 
 - `main(argv=None) -> int` — the entry point (`dotagents` console script,
-  `python -m dotagents`, `install.py`).
+  `python -m dotagents`, `install.py`). It always returns the status and never
+  raises `SystemExit`: a `SystemExit` raised below it (a message, `--help`, a usage
+  error) comes back as its status, the message going to standard error. Ctrl-C
+  returns 130 and a closed pipe on standard output returns 1, both without a
+  traceback.
 - `class Dotagents(LoggingArgs, Cli)` — the umbrella; field `cmdspath: list[str]`.
 - `CMDS_PATH_ENV = "AGENTS_CMDS_PATH"`.
 - Re-exported for command modules: `DotAgentsArgs`, `_write_stdout` (see below).

{dotagents_cli-0.7.4 → dotagents_cli-0.7.5}/src/dotagents/__init__.py

@@ -1,3 +1,3 @@
 """dotagents: installable CLI for the dotagents agent-config payload."""
 
-__version__ = "0.7.4"
+__version__ = "0.7.5"

{dotagents_cli-0.7.4 → dotagents_cli-0.7.5}/src/dotagents/cli/__init__.py

@@ -30,6 +30,8 @@ from pathlib import Path
 
 import duho
 from duho import Cli, LoggingArgs
+from duho.runtime import build_command_parser
+from duho.text import kebabcase
 
 from dotagents import __version__
 
@@ -164,18 +166,7 @@ def _check_buildable(command) -> None:
     fields claiming the same flag, a flag the umbrella already owns) would
     otherwise fail every invocation. The parents are the umbrella's options,
     as in `duho.app`, so a clash with them surfaces here too."""
-    import argparse
-
-    base = Dotagents._parser_(add_help=False)
-    subparsers = argparse.ArgumentParser(add_help=False).add_subparsers()
-    if isinstance(command, type):
-        command._parser_(subparsers, parents=[base])
-        return
-    try:
-        from duho.runtime import _register_module_command
-    except ImportError:  # pragma: no cover -- a later duho without this helper
-        return
-    _register_module_command(subparsers, command, base, None, Dotagents)
+    build_command_parser(command, Dotagents)
 
 
 def _source_of(command) -> str:
@@ -207,18 +198,14 @@ def _buildable(commands, file=None) -> "list":
 def kebab_name(class_name: str) -> str:
     """A command class's default subcommand name: ``LeakCheck`` ->
     ``leak-check``, ``HTTPServer`` -> ``http-server``, ``my_cmd`` -> ``my-cmd``."""
-    import re
-
-    spaced = re.sub(r"(?<=[a-z0-9])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])", "-", class_name)
-    return re.sub(r"[-_]+", "-", spaced).strip("-").lower()
+    return kebabcase(class_name)
 
 
 def _named(commands) -> "list":
     """``commands``, each discovered class that declares no ``_parsername_``
-    of its own given the kebab-case of its class name (:func:`kebab_name`).
-    ``_parsername_`` is optional in a command module: duho < 0.6 derived that
-    name itself, and from 0.6.0 it uses the class name as it is (``LeakCheck``),
-    which broke ``dotagents leak-check`` for a module that relied on it."""
+    of its own given the kebab-case of its class name (:func:`kebab_name`),
+    which is also the name duho gives it. Setting it makes the name readable as
+    an attribute, which the command-set keys and the tests rely on."""
     for command in commands:
         if isinstance(command, type) and "_parsername_" not in vars(command):
             command._parsername_ = kebab_name(command.__name__)
@@ -228,46 +215,19 @@ def _named(commands) -> "list":
 def _discover_modules(directory: Path) -> "list":
     """duho's per-directory discovery, made resilient per MODULE.
 
-    duho's own loop catches only ImportError/NotImplementedError per file and
-    lets anything else propagate. Discovery runs before EVERY dotagents
-    invocation (including `env`/`context` inside the SessionStart hooks), so
-    one broken user module must not take down every command: the loop is
-    mirrored here with a catch-all per file -- the bad module is named, with
-    its exception, and skipped; the rest of the directory still loads.
-    SystemExit is included because a module that `sys.exit()`s at import is
-    not an Exception. A command that imports but cannot build its parser is
-    skipped the same way (`_buildable`). Falls back to duho's own
-    per-directory unit, with a warning, if a duho release moves these
-    helpers.
-
-    Uses duho's PUBLIC `import_from_path` (duho >= 0.6.0) for the file
-    import; `_commands_in_module` has no public counterpart yet, so it stays
-    a private import (see `duho.discovery.import_from_path`'s own docstring:
-    it is the public counterpart of the `_unique_module_name` +
-    `_import_from_path` pair this module used to call directly)."""
-    try:
-        from duho.discovery import _commands_in_module, import_from_path
-    except ImportError:  # pragma: no cover -- a later duho without these internals
-        from duho.discovery import discover_commands
-
-        _LOGGER.warning(
-            "duho's discovery internals moved; a broken module in %s now skips "
-            "the whole directory, not just itself",
-            directory,
-        )
-        return _named(_buildable(discover_commands(directory)))
-    commands = []
-    for file in sorted(directory.glob("*.py")):
-        if file.name.startswith("_"):
-            continue
-        try:
-            module = import_from_path("duho._discovered." + file.stem, file)
-            found = _commands_in_module(module, stem=file.stem)
-        except (Exception, SystemExit) as exc:  # noqa: BLE001 -- see docstring
-            _LOGGER.warning("skipping command module %s: %s", file, _describe(exc))
-            continue
-        commands.extend(_named(_buildable(found, file)))
-    return commands
+    Discovery runs before EVERY dotagents invocation (including `env`/`context`
+    inside the SessionStart hooks), so one broken user module must not take
+    down every command. `on_error` is called for any exception raised importing
+    one file, `SystemExit` included (a module that `sys.exit()`s at import is
+    not an Exception): the bad module is named, with its exception, and skipped;
+    the rest of the directory still loads. A command that imports but cannot
+    build its parser is skipped the same way (`_buildable`)."""
+
+    def skip(source, exc) -> None:
+        _LOGGER.warning("skipping command module %s: %s", source, _describe(exc))
+
+    found = duho.discover_commands(directory, on_error=skip, sort=False)
+    return _named(_buildable(found))
 
 
 def _discover_dir(source, by_name: dict) -> None:
@@ -522,13 +482,14 @@ def _repoint_zipapp_sources() -> None:
 
 def main(argv=None) -> int:
     _repoint_zipapp_sources()
-    # `duho.app` (not `duho.main`) so command discovery runs; default dispatch
-    # calls each command's `__call__`. `commands=` is the resolved built-ins +
-    # discovered set.
-    return duho.app(
+    # `commands=` makes `run` use `duho.app` (not `duho.main`) so the resolved
+    # built-ins + discovered set are the commands; dispatch calls each command's
+    # `__call__`. `exit=False` returns the status, whatever ended the run.
+    return duho.run(
         Dotagents,
+        argv,
+        exit=False,
         commands=_discover(argv),
-        argv=argv,
         name="dotagents",
     )
 

{dotagents_cli-0.7.4 → dotagents_cli-0.7.5}/src/dotagents/cli/build_pyz.py

@@ -73,7 +73,7 @@ class BuildPyz(LoggingArgs, Cmd):
     # stale pin here ships an artifact `pip install dotagents-cli` would refuse.
     # Pin the FLOOR of each declared range, not the latest patch -- the .pyz then
     # exercises the minimum the metadata promises.
-    duho_version: str = "0.6.0"
+    duho_version: str = "0.7.5"
     "Pinned duho version to vendor."
     ("--duho-version",)
 

{dotagents_cli-0.7.4 → dotagents_cli-0.7.5}/tests/test_cli_main.py

@@ -130,7 +130,7 @@ def test_reinit_after_overlays_add_keeps_the_overlay_routing(tmp_path):
 
 
 def test_init_with_an_unknown_agent_is_a_usage_error(tmp_path):
-    assert _main(["init", "--dest", str(tmp_path / "s"), "--agents", "claud", "--no-hooks"]) == 2
+    assert _main(["init", "--dest", str(tmp_path / "s"), "--agents", "claud", "--no-hooks"]) == 1
 
 
 # --------------------------------------------------------------------------

{dotagents_cli-0.7.4 → dotagents_cli-0.7.5}/tests/test_cmds_discovery.py

@@ -224,8 +224,7 @@ class LeakCheck(LoggingArgs, Cmd):
 
 
 def test_a_command_without_parsername_gets_its_kebab_class_name(monkeypatch, tmp_path, capsys):
-    """`_parsername_` is optional: duho >= 0.6.0 names such a class `LeakCheck`,
-    dotagents gives it `leak-check` (what duho < 0.6 derived)."""
+    """`_parsername_` is optional: such a class is named `leak-check`."""
     cmds = tmp_path / "extra"
     _write(cmds / "leak_check.py", UNNAMED)
     _write(cmds / "toy.py", TOY)
@@ -436,3 +435,17 @@ def test_a_module_failing_at_parser_build_does_not_take_the_cli_down(monkeypatch
     except SystemExit as exc:
         rc = exc.code
     assert rc == 0
+
+
+def test_a_directory_lists_its_commands_by_file_then_definition_order(tmp_path):
+    """The `--help` listing follows the files, not the subcommand names."""
+    template = (
+        "from duho import Cmd, LoggingArgs\n\n"
+        "class {a}(LoggingArgs, Cmd):\n    _parsername_ = '{a}'\n\n"
+        "    def __call__(self) -> int:\n        return 0\n\n"
+        "class {b}(LoggingArgs, Cmd):\n    _parsername_ = '{b}'\n\n"
+        "    def __call__(self) -> int:\n        return 0\n"
+    )
+    _write(tmp_path / "aa_first.py", template.format(a="zulu", b="alpha"))
+    _write(tmp_path / "bb_second.py", template.format(a="mike", b="bravo"))
+    assert _names(cli._discover_modules(tmp_path)) == ["zulu", "alpha", "mike", "bravo"]

{dotagents_cli-0.7.4 → dotagents_cli-0.7.5}/tests/test_fix_cli.py

@@ -211,31 +211,6 @@ def test_a_command_clashing_with_an_umbrella_flag_is_skipped(monkeypatch, tmp_pa
     assert cli.main(["about"]) == 0
 
 
-def test_moved_duho_internals_are_reported_not_silent(monkeypatch, tmp_path, caplog):
-    import builtins
-
-    cmds = tmp_path / "cmds"
-    cmds.mkdir()
-    (cmds / "good.py").write_text(GOOD, encoding="utf-8")
-    real_import = builtins.__import__
-
-    def renamed(name, globals=None, locals=None, fromlist=(), level=0):
-        # What a duho release that renamed its remaining private helper looks
-        # like to `from duho.discovery import _commands_in_module, ...` --
-        # and only to it. `import_from_path` is duho's public counterpart
-        # (duho >= 0.6.0) and stays importable; `_commands_in_module` has no
-        # public counterpart yet, so it is the one still exposed to this risk.
-        if name == "duho.discovery" and "_commands_in_module" in (fromlist or ()):
-            raise ImportError("cannot import name '_commands_in_module'")
-        return real_import(name, globals, locals, fromlist, level)
-
-    monkeypatch.setattr(builtins, "__import__", renamed)
-    with caplog.at_level(logging.WARNING):
-        commands = cli._discover_modules(cmds)
-    assert "good" in _names(commands)
-    assert any("internals moved" in r.getMessage() for r in caplog.records)
-
-
 # --------------------------------------------------------------------------- #
 # The zipapp-repointed module list is derived, not hand-kept
 # --------------------------------------------------------------------------- #

{dotagents_cli-0.7.4 → dotagents_cli-0.7.5}/tests/test_fix_init.py

@@ -246,16 +246,15 @@ def test_a_bom_in_settings_json_is_accepted_and_not_written_back(tmp_path):
 
 
 @pytest.mark.parametrize("content", [b"{not json", b"\xff\xfe{}"])
-def test_a_corrupt_settings_file_stops_init_before_anything_is_written(content):
+def test_a_corrupt_settings_file_stops_init_before_anything_is_written(content, capsys):
     """The error fired after AGENTS.md and the CLAUDE.md include were written,
     leaving a half-initialised store."""
     settings = Path.home() / ".claude" / "settings.json"
     settings.parent.mkdir(parents=True)
     settings.write_bytes(content)
 
-    with pytest.raises(SystemExit) as exc:
-        cli.main(["init", "-g", "--agents", "claude"])
-    assert str(settings) in str(exc.value)
+    assert cli.main(["init", "-g", "--agents", "claude"]) == 1
+    assert str(settings) in capsys.readouterr().err
     assert not (Path.home() / ".agents").exists()
     assert not (Path.home() / ".claude" / "CLAUDE.md").exists()
     assert settings.read_bytes() == content