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

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

@@ -7,6 +7,59 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.7.6] - 2026-10-15
+
+### Added
+
+- A `repo` extra (`repopath[uri]`) for overlay sources at `github:`, `gitlab:` and
+  `repo:` URIs, which the `uri` extra no longer brings.
+
+### Changed
+
+- dotagents depends on `pathapi` (`>=0.1.0,<0.2`), the new name of `pathlib_next`,
+  instead of `pathlib_next`. The `.pyz` vendors it; `build-pyz --pathapi-version`
+  names its pin, and `--pathlib-next-version` still works. On Python 3.9 nothing
+  else has to be installed for it.
+- The extras install pathapi's own distributions: `uri` and `http` install
+  `pathapi-uri` (the URI layer, imported as `uripath`, with `file:`, `http(s):`,
+  `dav:`, `ftp:`, `zip:` and `tar:` on the standard library); `sftp` adds
+  `sftppath[paramiko]` and `s3` adds `objpath[s3]`. Overlay sources are read as
+  before. A `git:` URI is not a scheme any more; a repository tree is a `repo:` URI.
+- `build-pyz --extras` vendors what the named extras install, each distribution at
+  its floor, and refuses an extra it does not know.
+- `about` lists `pathapi`, `pathapi-uri`, `netimps` and the plugin distributions in
+  place of `pathlib_next`, `uritools` and `requests`.
+
+### Removed
+
+- The `.pyz` no longer extracts the built-in command modules' sources to temporary
+  files at startup: duho reads a command's flags and help through the zip importer
+  when the module has no file on disk.
+
+## [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 +1470,9 @@ 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.6...HEAD
+[0.7.6]: https://github.com/jose-pr/dotagents/compare/v0.7.5...v0.7.6
+[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.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: dotagents-cli
-Version: 0.7.4
+Version: 0.7.6
 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,13 +23,13 @@ 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: pathlib-next<0.10,>=0.9.0
+Requires-Dist: duho<0.8,>=0.7.5
+Requires-Dist: pathapi<0.2,>=0.1.0
 Requires-Dist: tomli>=1.1.0; python_version < '3.11'
 Provides-Extra: dev
 Requires-Dist: build; extra == 'dev'
 Requires-Dist: hatchling>=1.27; extra == 'dev'
-Requires-Dist: pathlib-next[http]; extra == 'dev'
+Requires-Dist: pathapi-uri<0.2,>=0.1.0; extra == 'dev'
 Requires-Dist: pytest; extra == 'dev'
 Requires-Dist: pyyaml; extra == 'dev'
 Provides-Extra: docs
@@ -37,13 +37,18 @@ Requires-Dist: mkdocs-material>=9.5; extra == 'docs'
 Requires-Dist: mkdocs>=1.5; extra == 'docs'
 Requires-Dist: mkdocstrings[python]>=0.24; extra == 'docs'
 Provides-Extra: http
-Requires-Dist: pathlib-next[http]; extra == 'http'
+Requires-Dist: pathapi-uri<0.2,>=0.1.0; extra == 'http'
+Provides-Extra: repo
+Requires-Dist: pathapi-uri<0.2,>=0.1.0; extra == 'repo'
+Requires-Dist: repopath[uri]<0.2,>=0.1.0; extra == 'repo'
 Provides-Extra: s3
-Requires-Dist: pathlib-next[s3]; extra == 's3'
+Requires-Dist: objpath[s3]<0.2,>=0.1.0; extra == 's3'
+Requires-Dist: pathapi-uri<0.2,>=0.1.0; extra == 's3'
 Provides-Extra: sftp
-Requires-Dist: pathlib-next[sftp]; extra == 'sftp'
+Requires-Dist: pathapi-uri<0.2,>=0.1.0; extra == 'sftp'
+Requires-Dist: sftppath[paramiko]<0.2,>=0.1.0; extra == 'sftp'
 Provides-Extra: uri
-Requires-Dist: pathlib-next[uri]; extra == 'uri'
+Requires-Dist: pathapi-uri<0.2,>=0.1.0; extra == 'uri'
 Provides-Extra: yaml
 Requires-Dist: pyyaml; extra == 'yaml'
 Description-Content-Type: text/markdown
@@ -156,7 +161,8 @@ dotagents init --force                  # replace AGENTS.md's content wholesale
 
 `--from <source>` selects another *base*: a base overlay directory, a dotagents
 checkout (its `src/dotagents/_overlay`), a `file:`, `http(s):`, `zip:`, `sftp:` or `s3:`
-URI (`pip install "dotagents-cli[uri]"` for all but `file:`), or a git repository
+URI (`pip install "dotagents-cli[uri]"` for all but `file:`, plus `[sftp]` or `[s3]`
+for those schemes), or a git repository
 (`repo[@ref][#path]`). A remote one is fetched into `<user store>/.cache/overlays/`.
 The bundled base ships inside the package, so `--from` is only for a base of your own.
 `init` records it (without any credentials in the URL), and later `init` and
@@ -239,7 +245,7 @@ authors:
 
 ### Downloadable `dotagents.pyz`
 
-A self-contained zipapp with `duho`, `pathlib_next` and `tomli` bundled in (pure
+A self-contained zipapp with `duho`, `pathapi` and `tomli` bundled in (pure
 Python, so one file runs on any OS and on Python 3.9+), so it needs no
 `pip install`. Each release attaches one:
 <https://github.com/jose-pr/dotagents/releases/latest/download/dotagents.pyz>.

{dotagents_cli-0.7.4 → dotagents_cli-0.7.6}/README.md

@@ -106,7 +106,8 @@ dotagents init --force                  # replace AGENTS.md's content wholesale
 
 `--from <source>` selects another *base*: a base overlay directory, a dotagents
 checkout (its `src/dotagents/_overlay`), a `file:`, `http(s):`, `zip:`, `sftp:` or `s3:`
-URI (`pip install "dotagents-cli[uri]"` for all but `file:`), or a git repository
+URI (`pip install "dotagents-cli[uri]"` for all but `file:`, plus `[sftp]` or `[s3]`
+for those schemes), or a git repository
 (`repo[@ref][#path]`). A remote one is fetched into `<user store>/.cache/overlays/`.
 The bundled base ships inside the package, so `--from` is only for a base of your own.
 `init` records it (without any credentials in the URL), and later `init` and
@@ -189,7 +190,7 @@ authors:
 
 ### Downloadable `dotagents.pyz`
 
-A self-contained zipapp with `duho`, `pathlib_next` and `tomli` bundled in (pure
+A self-contained zipapp with `duho`, `pathapi` and `tomli` bundled in (pure
 Python, so one file runs on any OS and on Python 3.9+), so it needs no
 `pip install`. Each release attaches one:
 <https://github.com/jose-pr/dotagents/releases/latest/download/dotagents.pyz>.

{dotagents_cli-0.7.4 → dotagents_cli-0.7.6}/docs/guide/commands.md

@@ -359,7 +359,7 @@ form and drop names that are not shell identifiers.
    `<NAME_OVERLAY_ROOT>` placeholder, so an env file and a context file refer to an
    overlay's install dir by one name. When `dotagents` runs from a `.pyz`,
    `AGENTS_PYLIB` names that archive: the libraries it bundles (duho,
-   pathlib_next) import from it, so an overlay built on them appends it to
+   pathapi) import from it, so an overlay built on them appends it to
    `sys.path` when its own import fails. An installed `dotagents` sets nothing,
    since those libraries are already in `AGENTS_PYTHON`'s site-packages. It is
    never put on `PYTHONPATH`, where it would shadow a project's own copy.
@@ -572,35 +572,38 @@ See [Private sync](private-sync.md) for the full walkthrough.
 ## about
 
 ```bash
-dotagents about          # dotagents-cli <version>, then duho, pathlib_next, ...
+dotagents about          # dotagents-cli <version>, then duho, pathapi, ...
 dotagents about --json   # the same, plus where it runs from and the Python
 ```
 
 One `<distribution> <version>` per line, the CLI first. From a built `.pyz` the
 list is exactly what `build-pyz` vendored (it records the names and versions in
 `dotagents/_bundle.json` before stripping the `dist-info` dirs the zipapp would
-otherwise carry, so `--extras uri,http` shows up here as `uritools`, `requests`
-and friends). From a plain install it is whichever of a fixed set is installed:
-`duho`, `pathlib_next`, `uritools`, `netimps` and `requests`. A package outside that
-set, such as a client the `sftp` or `s3` extra pulls in, is not listed.
+otherwise carry, so `--extras uri` shows up here as `pathapi-uri` and `netimps`).
+From a plain install it is whichever of a fixed set is installed: `duho`, `pathapi`,
+`pathapi-uri`, `netimps`, `sftppath`, `objpath` and `repopath`. A package outside
+that set, such as a client the `sftp` or `s3` extra pulls in (`paramiko`, `boto3`),
+is not listed.
 
 ## build-pyz
 
 ```bash
 python -m dotagents build-pyz --out dist/dotagents.pyz
-python -m dotagents build-pyz --extras uri,http     # also vendor pathlib_next's extras
+python -m dotagents build-pyz --extras uri,repo     # also vendor what those extras install
 ```
 
-Builds a self-contained zipapp from a source checkout, with `duho` and `pathlib_next`
-vendored (plus the `pathlib_next` extras named by `--extras`), so it runs with no
+Builds a self-contained zipapp from a source checkout, with `duho` and `pathapi`
+vendored (plus what the dotagents-cli extras named by `--extras` install), so it runs with no
 `pip install`. The repo's `tools/` never ships in it. Flags:
 
 - `--out <path>` — where to write it (default `dist/dotagents.pyz`).
 - `--python <shebang>` — the interpreter line embedded in it (default
   `/usr/bin/env python3`).
-- `--duho-version`, `--pathlib-next-version` — the versions vendored (defaults: the
-  floors the package declares).
-- `--extras <a,b>` — `pathlib_next` extras to vendor too (`uri`, `http`, `s3`),
+- `--duho-version`, `--pathapi-version` — the versions vendored (defaults: the
+  floors the package declares). `--pathlib-next-version` is the old name of the
+  second.
+- `--extras <a,b>` — dotagents-cli extras to vendor too (`uri`, `http`, `s3`, `repo`),
+  each distribution they install at its floor,
   so the `.pyz` can read those overlay sources; none by default. Everything is
   vendored as pure-Python wheels resolved for Python 3.9, so the file does not
   depend on the machine that built it; `sftp` needs native modules and fails the

{dotagents_cli-0.7.4 → dotagents_cli-0.7.6}/docs/guide/install.md

@@ -5,7 +5,9 @@ pip install dotagents-cli              # the `dotagents` command and `import dot
 pip install "dotagents-cli[uri]"       # + remote overlay sources beyond git and http(s) registries
 ```
 
-The `http`, `sftp` and `s3` extras add those schemes' own clients to `uri`. With no
+`uri` installs `pathapi-uri`: `file:`, `http(s):`, `dav:`, `ftp:`, `zip:` and `tar:` on
+the standard library. `sftp`, `s3` and `repo` add `sftp:`, `s3:` and `github:` /
+`gitlab:` / `repo:` to it; `http` installs the same as `uri`. With no
 `pip` at all, use the [downloadable `dotagents.pyz`](#downloadable-dotagentspyz).
 
 `dotagents init` then lays down the neutral **base config**. Opinionated content is
@@ -49,7 +51,8 @@ dotagents init --force                  # replace AGENTS.md's content wholesale
 
 `--from <source>` selects another *base*: a base overlay directory, a dotagents
 checkout (its `src/dotagents/_overlay`), a `file:`, `http(s):`, `zip:`, `sftp:` or `s3:`
-URI (`pip install "dotagents-cli[uri]"` for all but `file:`), or a git repository
+URI (`pip install "dotagents-cli[uri]"` for all but `file:`, plus `[sftp]` or `[s3]`
+for those schemes), or a git repository
 (`repo[@ref][#path]`). A remote one is fetched into `<user store>/.cache/overlays/`.
 The bundled base ships inside the package, so `--from` is only for a base of your own.
 `init` records it in
@@ -58,7 +61,7 @@ The bundled base ships inside the package, so `--from` is only for a base of you
 
 ## Downloadable `dotagents.pyz`
 
-A self-contained zipapp with `duho`, `pathlib_next` and `tomli` bundled in as
+A self-contained zipapp with `duho`, `pathapi` and `tomli` bundled in as
 pure-Python wheels (plus whatever `build-pyz --extras` added), so it needs no
 `pip install` and runs on any OS with Python 3.9+. Each release attaches one:
 <https://github.com/jose-pr/dotagents/releases/latest/download/dotagents.pyz>.

{dotagents_cli-0.7.4 → dotagents_cli-0.7.6}/docs/guide/overlays.md

@@ -124,9 +124,10 @@ in what the path names:
   `…/dotagents.git@repo#overlays/net` is the `net` overlay itself. Given as `--repo`,
   that form would list `net`'s own subdirectories as overlays.
 
-A `scheme://` location that is not git is a **pathlib_next path**. With the `uri`
-extra (`pip install 'dotagents-cli[uri]'`; `[http]`, `[sftp]`, `[s3]` add the schemes'
-own clients) any scheme pathlib_next speaks works like a local path: an `http(s)://`
+A `scheme://` location that is not git is a **uripath path** (pathapi's URI layer, the
+`pathapi-uri` distribution). With the `uri` extra (`pip install 'dotagents-cli[uri]'`;
+`[sftp]`, `[s3]` and `[repo]` add `sftp:`, `s3:` and `github:` / `gitlab:` / `repo:`)
+any scheme uripath speaks works like a local path: an `http(s)://`
 directory listing, an `sftp`, `s3`, `dav` or `github` tree is a directory of overlays
 as a repo or one overlay as a source, a file is a registry; an archive is a tree too —
 `zip:<archive-uri>!/<inner path>` (`tar:`, or `archive:` to auto-detect), the archive
@@ -135,7 +136,7 @@ materialized into `<user store>/.cache/overlays/uri/`, synced once per run, and
 from there; `file://` is a local path, no copy. Without the extra, an `http(s)://`
 location can still be a registry file (fetched with the standard library), and
 anything else says which extra it needs. The `.pyz` vendors none of this unless built
-with `build-pyz --extras uri,http`.
+with `build-pyz --extras uri`.
 
 A source written as a **relative path** (`./python`, `../shared/net`, `overlays/rust`)
 is relative to the registry it is in: the registry file's directory for a local file,

{dotagents_cli-0.7.4 → dotagents_cli-0.7.6}/install.py

@@ -5,7 +5,7 @@ Thin front over ``dotagents.cli.main()``, kept at this filename so existing
 muscle-memory/docs pointing at ``python install.py`` still work.
 
 Self-bootstrapping, inside a virtual environment: the CLI needs the
-``dotagents`` package and its ``duho``/``pathlib_next`` dependencies
+``dotagents`` package and its ``duho``/``pathapi`` dependencies
 importable. If they aren't -- e.g. a fresh venv with nothing installed yet --
 this shim installs this checkout **into the interpreter that is running it**
 (``sys.executable -m pip install -e .``) and retries, exactly once. When
@@ -49,7 +49,7 @@ def _import_main():
     """Return ``dotagents.cli.main`` if importable, else None.
 
     The ``src/`` fallback lets an un-pip-installed checkout resolve its
-    ``src/`` layout directly, provided ``duho``/``pathlib_next`` are importable
+    ``src/`` layout directly, provided ``duho``/``pathapi`` are importable
     some other way. A plain editable install makes all three importable without
     the fallback.
     """

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

@@ -35,20 +35,27 @@ 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",
-    "pathlib_next>=0.9.0,<0.10",
+    "duho>=0.7.5,<0.8",
+    "pathapi>=0.1.0,<0.2",
     # overlay.toml manifests and TOML registries; tomllib is stdlib from 3.11.
     'tomli>=1.1.0; python_version < "3.11"',
 ]
 
+# Overlay sources at a URI. `pathapi-uri` (import name `uripath`) gives the
+# file:, http(s):, dav:, ftp:, zip: and tar: schemes on the standard library;
+# the other distributions add their schemes to it. `build-pyz --extras` vendors
+# the floor of each (EXTRA_REQUIREMENTS in src/dotagents/cli/build_pyz.py).
 [project.optional-dependencies]
-uri = ["pathlib_next[uri]"]
-http = ["pathlib_next[http]"]
-sftp = ["pathlib_next[sftp]"]
-s3 = ["pathlib_next[s3]"]
+uri = ["pathapi-uri>=0.1.0,<0.2"]
+# http(s) is part of `uri` now; kept so `dotagents-cli[http]` still installs.
+http = ["pathapi-uri>=0.1.0,<0.2"]
+sftp = ["pathapi-uri>=0.1.0,<0.2", "sftppath[paramiko]>=0.1.0,<0.2"]
+s3 = ["pathapi-uri>=0.1.0,<0.2", "objpath[s3]>=0.1.0,<0.2"]
+# github:, gitlab: and repo: (a repository's tree at a ref).
+repo = ["pathapi-uri>=0.1.0,<0.2", "repopath[uri]>=0.1.0,<0.2"]
 # YAML overlay-repo registries (dotagents.yaml / *.yml).
 yaml = ["pyyaml"]
-dev = ["build", "hatchling>=1.27", "pytest", "pyyaml", "pathlib_next[http]"]
+dev = ["build", "hatchling>=1.27", "pytest", "pyyaml", "pathapi-uri>=0.1.0,<0.2"]
 docs = [
     "mkdocs>=1.5",
     "mkdocs-material>=9.5",

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

@@ -42,7 +42,7 @@ and an error saying a command is required, and exits 2.
 | `launch [AGENT] [-g] [--command PROG] [--no-context] [--inline] [--write-agent] [--dry-run] [-- ARGS...]` | Run the agent's CLI with the env applied and the context handed over; the exit code is the harness's (`128+N` on signal N). |
 | `findings add\|list\|show\|done\|reopen\|remove\|index\|path [-g] [--dir D]` | The findings queue at `<store>/findings/` (`--dir` overrides): one markdown file per finding, `done` moves it to `processed/` with a required resolution, `INDEX.md` regenerated on every change. The frontmatter is valid YAML (a value is double-quoted when it must be); `index --requote` fixes values written bare in existing files, touching nothing else. |
 | `about [--json]` | `dotagents-cli <version>`, then `<distribution> <version>` per bundled (`.pyz`) or installed package. |
-| `build-pyz [--out P] [--python SHEBANG] [--duho-version V] [--pathlib-next-version V] [--extras a,b]` | Build a zipapp from a source checkout; errors elsewhere. |
+| `build-pyz [--out P] [--python SHEBANG] [--duho-version V] [--pathapi-version V] [--extras a,b]` | Build a zipapp from a source checkout; errors elsewhere. |
 
 **Every command but `env` is also an MCP tool.** With `DOTAGENTS_MCP=stdio` in its
 environment, `dotagents` serves the command set — built-in, bundled and discovered —
@@ -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).
@@ -142,7 +146,7 @@ The package's own data; library code, importing nothing from `dotagents.cli`.
   absolute POSIX path of `<dest>/AGENTS.md`.
 - `pyz_archive() -> str | None` — the `.pyz` this dotagents is imported from (the
   ancestor of the module's `__file__` that is a file), or `None` for a plain
-  install. The archive also holds the vendored duho and pathlib_next; `env`
+  install. The archive also holds the vendored duho and pathapi; `env`
   exports it as `AGENTS_PYLIB`.
 
 ## Commands — `dotagents.cli.init`, `dotagents.cli.overlays`, `dotagents.cli.context`, `dotagents.cli.env`, `dotagents.cli.path`, `dotagents.cli.about`, `dotagents.cli.build_pyz`
@@ -163,11 +167,16 @@ returns the exit code.
   `--diff --format export`, a `PATH` that is the caller's with entries in front is
   written as `export PATH='<prefix>'"${PATH:+:$PATH}"`.
 - `about`: `DISTRIBUTION = "dotagents-cli"`, `BUNDLE_FILE = "_bundle.json"` (written
-  by `build-pyz` into the package), `RUNTIME_PACKAGES = ("duho", "pathlib_next",
-  "uritools", "netimps", "requests")` (the only packages a plain install reports);
+  by `build-pyz` into the package), `RUNTIME_PACKAGES = ("duho", "pathapi",
+  "pathapi-uri", "netimps", "sftppath", "objpath", "repopath")` (the only packages a
+  plain install reports);
   `bundle_manifest() -> Optional[dict]`, `installed_packages() -> dict[str, str]`,
   `packages() -> tuple[dict[str, str], Optional[dict]]` (the bundle's packages, else
   the installed ones; the CLI itself in neither).
+- `build_pyz`: `EXTRA_REQUIREMENTS` — `{extra: (requirement, ...)}`, what each
+  dotagents-cli extra installs (`uri`, `http`, `sftp`, `s3`, `repo`), kept equal to
+  `pyproject.toml`; `--extras` vendors each requirement at its floor and refuses a
+  name not in it.
 
 ## `dotagents._scope`
 
@@ -314,7 +323,8 @@ a directory of overlays or a registry file (default: the root); for a **source**
 - `parse_spec(text) -> Spec` — `ValueError` when empty; `SourceError` when a git
   location or ref starts with `-`.
 - `redact(text) -> str` — URL userinfo removed, query values masked.
-- `uri_path_class()` — `pathlib_next.uri.UriPath`, or `None` without the `uri` extra.
+- `uri_path_class()` — `uripath.URIPath` (from `pathapi-uri`), or `None` without the
+  `uri` extra.
 - `url_scheme(location) -> str` — the lower-cased scheme.
 - `GIT_SSL_REVOKE_KEY = "git_ssl_revoke"`, `GIT_SSL_REVOKE_VALUES = ("best-effort",
   "true", "false")`, `GIT_SSL_REVOKE_DEFAULT = "best-effort"`;
@@ -379,7 +389,7 @@ proxy model.
   `scope.overlays` (a value pinned to the user store's copy is re-pointed when a
   project copy shadows it). `AGENTS_PYLIB` (`_env.PYLIB_VAR`): the `.pyz` when
   dotagents runs from one (`_resources.pyz_archive()`), else not set — where its
-  own libraries (duho, pathlib_next) import from by zipimport for an overlay
+  own libraries (duho, pathapi) import from by zipimport for an overlay
   built on them. Never added to `PYTHONPATH`: a consumer appends it to
   `sys.path` when its import fails.
 - `PATH`: every level's `bin` (contract A, not project-root, missing dirs included)
@@ -697,7 +707,7 @@ Read:
 - `AGENTS_HARNESS` — the running harness (registry name or harness id), for
   identity. `AGENTS_PYTHON` — the interpreter for `env.py`. `AGENTS_PYTHONPATH` —
   the overlay/store `lib` dirs `env` put on `PYTHONPATH`, highest precedence first.
-  `AGENTS_PYLIB` — the `.pyz` dotagents runs from (duho and pathlib_next import
+  `AGENTS_PYLIB` — the `.pyz` dotagents runs from (duho and pathapi import
   from it), unset for an installed dotagents.
 - Harness config dirs: `CLAUDE_CONFIG_DIR`, `CODEX_HOME`, `PI_CODING_AGENT_DIR`.
   Harness markers: `CLAUDECODE`, `CLAUDE_CODE_ENTRYPOINT`, `GEMINI_CLI`,
@@ -723,11 +733,11 @@ Set for an overlay's `setup.py`: `AGENTS_HOME` (user store), `AGENTS_SCOPE_ROOT`
 
 - **Python 3.9 floor.** Runtime-evaluated annotations need `from __future__ import
   annotations` for `X | Y`; `Path.write_text(newline=)` is 3.10+ (use
-  `_fs.write_text_lf`). On 3.9, `pathlib_next` needs `typing_extensions` installed.
+  `_fs.write_text_lf`).
 - **Inside a `.pyz`** `Path(__file__)` is not a real file: package data is reached
   through `_resources._package_data_dir(name)` (extracted once to a per-process
-  scratch dir removed at exit), and `cli.main()` repoints the built-in command
-  modules' sources so `duho` still reads their flags and help.
+  scratch dir removed at exit); `duho` reads the command modules' flags and help
+  through the zip importer.
 - **Writes are LF-only.** Use `_fs.write_text_lf`, never `Path.write_text`.
 - **`env` output is sensitive**: it prints resolved values. Nothing in the package
   logs a value, only names.

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

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

{dotagents_cli-0.7.4 → dotagents_cli-0.7.6}/src/dotagents/_env.py

@@ -61,7 +61,7 @@ The identity/proxy model is wired into the output around the file chain:
     the same name ``dotagents context`` expands as a placeholder), so an env
     file can reference an overlay's install dir by name. ``AGENTS_PYLIB``
     (:data:`PYLIB_VAR`) names the ``.pyz`` when dotagents runs from one --
-    where its own libraries (duho, pathlib_next) import from for an overlay
+    where its own libraries (duho, pathapi) import from for an overlay
     built on them; never put on ``PYTHONPATH``.
   * **Proxy** is normalized AFTER the file chain: ``AGENTS_PROXY`` is seeded if
     unset (from ``AGENTS_WEBFETCH_PROXY_URL`` else the global
@@ -1055,7 +1055,7 @@ def get_environment(
     # `sys.executable` is '' or None under an embedding host: then nothing is
     # exported rather than an empty command name.
     _seed("AGENTS_PYTHON", sys.executable)
-    # --- AGENTS_PYLIB --- where dotagents' own libraries (duho, pathlib_next)
+    # --- AGENTS_PYLIB --- where dotagents' own libraries (duho, pathapi)
     # import from for an overlay that builds on them. Set only when dotagents
     # runs from a .pyz: the archive, importable by zipimport. An installed
     # dotagents has them in AGENTS_PYTHON's site-packages already. Never put on

{dotagents_cli-0.7.4 → dotagents_cli-0.7.6}/src/dotagents/_resources.py

@@ -26,7 +26,7 @@ _scratch: "Path | None" = None
 
 def _scratch_dir() -> Path:
     """The ONE per-process temp directory for anything extracted out of a
-    zipapp (package data, the repointed module sources) and for `launch`'s
+    zipapp (package data) and for `launch`'s
     context file, created lazily on first use and removed at interpreter exit."""
     global _scratch
     if _scratch is None:
@@ -42,7 +42,7 @@ def pyz_archive() -> "str | None":
     install. Inside a zipapp a module's ``__file__`` is a path INTO the
     archive (``.../dotagents.pyz/dotagents/_resources.py``), so the archive
     is the ancestor that is a file. It also holds the vendored runtime
-    dependencies (duho, pathlib_next), importable from it by zipimport."""
+    dependencies (duho, pathapi), importable from it by zipimport."""
     for parent in Path(__file__).parents:
         if parent.is_file():
             return str(parent)

{dotagents_cli-0.7.4 → dotagents_cli-0.7.6}/src/dotagents/_skills.py

@@ -8,7 +8,7 @@ Removing an overlay unpublishes only the skills **it** published (matched agains
 its own ``skills/`` source), never a skill another overlay or the user placed there,
 then sweeps any now-broken symlinks.
 
-Pure stdlib (``os``/``shutil``) -- no ``pathlib_next`` -- so it works in a plain
+Pure stdlib (``os``/``shutil``) -- no ``pathapi`` -- so it works in a plain
 ``pip install`` and inside the ``.pyz``. Symlink-preferred with a copy fallback is
 the contract (on Windows a directory junction is tried between the two: it
 needs no privilege and, like a symlink, is always current); ``--copy`` forces

{dotagents_cli-0.7.4 → dotagents_cli-0.7.6}/src/dotagents/_sources.py

@@ -26,9 +26,10 @@ directory (of overlays) or a registry file, the checkout root when absent;
 for a **source** it is the overlay's root directory, and when absent *the
 repository root is the overlay*.
 
-A ``scheme://`` location that is not git is a **pathlib_next** path. With
-the ``uri`` extra installed (``dotagents-cli[uri]``; ``[http]``, ``[sftp]``,
-``[s3]`` add the schemes' own clients) any scheme pathlib_next speaks works
+A ``scheme://`` location that is not git is a **uripath** path (pathapi's
+URI layer). With the ``uri`` extra installed (``dotagents-cli[uri]``;
+``[sftp]``, ``[s3]`` and ``[repo]`` add the ``sftp:``, ``s3:`` and
+``github:`` / ``gitlab:`` / ``repo:`` schemes) any scheme uripath speaks works
 the way a local path does: an ``http(s)://`` directory listing, an ``sftp``,
 ``s3``, ``dav`` or ``github`` tree is a directory of overlays (as a repo) or
 one overlay (as a source), a file is a registry; so is an archive --
@@ -188,14 +189,14 @@ def parse_spec(text: str) -> Spec:
 # --------------------------------------------------------------------------
 
 def uri_path_class() -> "Any":
-    """``pathlib_next.uri.UriPath`` when the ``uri`` extra is installed, else
-    ``None`` -- the switch between "any scheme pathlib_next speaks" and the
-    standard-library http(s) registry fetch."""
+    """``uripath.URIPath`` when the ``uri`` extra (``pathapi-uri``) is
+    installed, else ``None`` -- the switch between "any scheme uripath speaks"
+    and the standard-library http(s) registry fetch."""
     try:
-        from pathlib_next.uri import UriPath
+        from uripath import URIPath
     except ImportError:
         return None
-    return UriPath
+    return URIPath
 
 
 def _local_from_file_url(url: str) -> Path:
@@ -261,7 +262,7 @@ class SourceCache(object):
     location AND ref (two registry entries naming the same repository at
     different refs -- ``@main`` for one overlay, ``@dev`` for another -- must
     each see their own tree, since the commands resolve every source before
-    copying any), and materializations of pathlib_next paths under ``uri/``
+    copying any), and materializations of uripath paths under ``uri/``
     (a remote directory synced down, a remote file copied), each refreshed
     once per process."""
 
@@ -271,7 +272,7 @@ class SourceCache(object):
         self.ssl_revoke = ssl_revoke  # git's http.schannelCheckRevoke (GIT_SSL_REVOKE_KEY)
         self._fresh: "set[str]" = set()  # locations fetched during this process
 
-    # --- pathlib_next paths ----------------------------------------------
+    # --- uripath paths ---------------------------------------------------
 
     def materialize(self, spec: Spec) -> Path:
         """The local path a ``url`` spec resolves to: the path itself for
@@ -288,17 +289,17 @@ class SourceCache(object):
             if not target.exists():
                 raise SourceError("error: overlay source does not exist: %s" % target)
             return target
-        UriPath = uri_path_class()
-        if UriPath is None:
+        URIPath = uri_path_class()
+        if URIPath is None:
             raise SourceError(
-                "error: %s: a %s:// source needs the pathlib_next uri extra "
-                "(pip install 'dotagents-cli[uri]', or [http] / [sftp] / [s3] for the "
-                "scheme's own client)" % (redact(spec.location), url_scheme(spec.location))
+                "error: %s: a %s:// source needs the uri extra "
+                "(pip install 'dotagents-cli[uri]', or [sftp] / [s3] / [repo] for those "
+                "schemes)" % (redact(spec.location), url_scheme(spec.location))
             )
-        from pathlib_next import LocalPath
-        from pathlib_next.utils.sync import PathSyncer
+        from pathapi import LocalPath
+        from pathapi.sync import PathSyncer
 
-        remote = UriPath(spec.location)
+        remote = URIPath(spec.location)
         if spec.path:
             remote = remote / spec.path
         shown = redact(spec.display())