agentbundle 0.2.0__py3-none-any.whl

agentbundle/scope.py

@@ -0,0 +1,319 @@
+"""Scope resolution + user-scope root expansion (RFC-0004 T17).
+
+Two helpers:
+
+  - :func:`resolve` resolves the install scope per the spec precedence
+    rule **CLI flag > pack default > built-in ``"repo"``**, and refuses
+    when the resolved value is not in the pack's ``allowed-scopes`` with
+    :class:`ScopeRefused`. Used by every write-capable subcommand once
+    the pack manifest is loaded.
+
+  - :func:`resolve_user_root` runs ``pathlib.Path.expanduser("~")`` once
+    and refuses with :class:`UserScopeUnresolvable` when the result is
+    the literal ``"~"`` (expansion failed) or ``"/"`` (corporate sandbox
+    with ``$HOME=/``). The CLI's top-level handler maps the exception
+    to the documented stderr text ``cannot resolve user scope: $HOME
+    unset or invalid``.
+
+The exceptions carry just enough context for the formatter at the call
+site to render the spec's exact stderr without per-call-site
+introspection: ``ScopeRefused`` holds the pack name, the requested
+scope, and the declared set; ``UserScopeUnresolvable`` holds the
+diagnostic value (``"~"`` or ``"/"``).
+
+This module is import-cheap (no I/O at import time) so the CLI's
+``--version`` print path stays fast.
+"""
+
+from __future__ import annotations
+
+import os
+import tomllib
+from pathlib import Path
+from typing import TYPE_CHECKING, Iterable
+
+if TYPE_CHECKING:
+    # TYPE_CHECKING-only — does NOT execute at runtime, so the
+    # `user_config.py → scope.py` import direction stays acyclic
+    # (only the type annotation in configured_adapter() needs the
+    # name resolved, and PEP 563 keeps it a string until anyone
+    # calls get_type_hints()).
+    from agentbundle.user_config import UserConfig
+
+
+# The spec's only legal scope values; ``global`` is deliberately absent
+# (RFC-0004 § Alternatives considered §6). Keep this single-sourced so
+# argparse's `choices=` and the runtime resolver agree.
+LEGAL_SCOPES: frozenset[str] = frozenset({"repo", "user"})
+
+# RFC-0011 / pack-allowed-adapters introduced this constant for the
+# greenfield-fallback default at user scope; RFC-0012 widens it to
+# cover both scopes (the constant is the single per-distribution
+# default, consulted at both `--scope user` and `--scope repo`).
+# Downstream catalogues can monkey-patch this constant at startup to
+# flip the default for their own distribution (e.g. an enterprise
+# rebrand sets `DEFAULT_ADAPTER = "kiro"`).
+DEFAULT_ADAPTER: str = "claude-code"
+
+
+# Deprecated alias for ``DEFAULT_ADAPTER`` — kept for one release
+# (removed in agentbundle 0.2.0 per RFC-0012 § *Module-level constant
+# rename*). PEP 562 module-level ``__getattr__`` fires only on access
+# of the deprecated name; direct access to ``DEFAULT_ADAPTER`` is
+# warning-free.
+def __getattr__(name: str) -> str:  # pragma: no cover - exercised via tests
+    if name == "DEFAULT_USER_SCOPE_ADAPTER":
+        import warnings
+
+        warnings.warn(
+            "DEFAULT_USER_SCOPE_ADAPTER is deprecated; use "
+            "DEFAULT_ADAPTER. Removed in agentbundle 0.2.0.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return DEFAULT_ADAPTER
+    raise AttributeError(
+        f"module 'agentbundle.scope' has no attribute {name!r}"
+    )
+
+
+class ScopeRefused(Exception):
+    """Raised when the resolved scope is not in the pack's allowed-scopes.
+
+    Attributes carry the three pieces the spec stderr names; the CLI's
+    top-level handler formats them as
+    ``<pack>: scope '<requested>' not in allowed-scopes <declared-set>``.
+    """
+
+    def __init__(
+        self,
+        pack_name: str,
+        requested: str,
+        allowed: Iterable[str],
+    ) -> None:
+        self.pack_name = pack_name
+        self.requested = requested
+        # Preserve the declared order — adopters reading the message
+        # want to see what *they* wrote, not a re-sorted set.
+        self.allowed = list(allowed)
+        super().__init__(
+            f"{pack_name}: scope {requested!r} not in allowed-scopes {self.allowed}"
+        )
+
+
+class UserScopeUnresolvable(Exception):
+    """Raised when ``expanduser('~')`` cannot produce a usable user root.
+
+    The two failure modes the spec names:
+
+      - expansion returned literal ``"~"`` (no home directory at all),
+      - expansion returned ``"/"`` ($HOME=/ — corporate sandbox).
+
+    The CLI's top-level handler formats this as
+    ``cannot resolve user scope: $HOME unset or invalid``.
+    """
+
+
+def resolve(
+    cli_flag: str | None,
+    pack_install: dict | None,
+    builtin_default: str = "repo",
+    *,
+    pack_name: str = "<pack>",
+) -> str:
+    """Resolve the install scope per the spec precedence rule.
+
+    Precedence: **CLI flag > pack ``default-scope`` > built-in ``repo``.**
+    The resolved value must be in the pack's ``allowed-scopes`` (resolved
+    from the install table, with the implied default
+    ``[default-scope]`` when ``allowed-scopes`` is omitted).
+
+    Args:
+        cli_flag: the ``--scope`` argparse value (``None`` if omitted).
+        pack_install: the ``[pack.install]`` table from the pack's TOML
+            (``None`` when the pack is v0.1 — see RFC-0004 § *Install-
+            scope dimension*; treated as ``{}``).
+        builtin_default: the fallback when neither CLI nor pack declares.
+        pack_name: the pack name for refusal text; the caller passes the
+            real name when known so :class:`ScopeRefused` carries the
+            spec-shaped message.
+
+    Returns:
+        The resolved scope (``"repo"`` or ``"user"``).
+
+    Raises:
+        :class:`ScopeRefused` if the resolved value is not in
+        ``allowed-scopes``.
+    """
+    install = pack_install if isinstance(pack_install, dict) else {}
+    pack_default = install.get("default-scope")
+    if not isinstance(pack_default, str) or pack_default not in LEGAL_SCOPES:
+        pack_default = builtin_default
+
+    raw_allowed = install.get("allowed-scopes")
+    if isinstance(raw_allowed, list) and raw_allowed:
+        allowed = [s for s in raw_allowed if isinstance(s, str)]
+    else:
+        # Implied default: `[default-scope]` per RFC-0004 § *Per-pack
+        # default and allowance*. v0.1 packs (no install table) fall
+        # through to `[builtin_default]` which is `"repo"`.
+        allowed = [pack_default]
+
+    requested = cli_flag if isinstance(cli_flag, str) else pack_default
+
+    if requested not in allowed:
+        raise ScopeRefused(pack_name, requested, allowed)
+    return requested
+
+
+def resolve_user_root(home: Path | None = None) -> Path:
+    """Expand the user-scope root once at scope-resolution time.
+
+    Calls ``Path.expanduser("~")`` (or accepts a stub ``home`` for
+    tests) and refuses when the result is the literal ``"~"`` (no
+    home directory) or ``"/"`` ($HOME=/ — corporate sandbox).
+
+    Returns:
+        The resolved absolute :class:`Path` for ``~``.
+
+    Raises:
+        :class:`UserScopeUnresolvable` on either documented failure.
+    """
+    if home is None:
+        try:
+            expanded = Path("~").expanduser()
+        except RuntimeError as exc:
+            # Python 3.13+ raises RuntimeError when expanduser cannot
+            # resolve (no $HOME and no pwd entry); older Pythons would
+            # return the literal "~". Both signals normalise to "user
+            # scope is unresolvable" — wrap.
+            raise UserScopeUnresolvable(
+                "expanduser('~') could not determine the home directory"
+            ) from exc
+    else:
+        expanded = Path(home)
+    if str(expanded) == "~":
+        raise UserScopeUnresolvable("expanduser returned literal '~'")
+    # Normalise before the root-check so a hostile `$HOME=/etc/..` is
+    # caught (it resolves to `/`). We use Path.resolve(strict=False)
+    # so a non-existent home doesn't raise — that's a separate failure
+    # the downstream caller can surface.
+    try:
+        normalised = expanded.resolve(strict=False)
+    except OSError as exc:
+        raise UserScopeUnresolvable(
+            f"could not resolve $HOME path {expanded}: {exc}"
+        ) from exc
+    if str(normalised) == "/":
+        raise UserScopeUnresolvable("expanduser resolved to '/' ($HOME=/)")
+    return normalised
+
+
+# ---------------------------------------------------------------------------
+# Adapter-contract introspection (RFC-0011 / pack-allowed-adapters)
+# ---------------------------------------------------------------------------
+#
+# Three pure-data helpers that derive their answers from the bundled
+# `agentbundle/_data/adapter.toml` shipped inside the wheel. The schema
+# validator (`commands/validate.py`) and the CLI argparse setup
+# (`cli.py`) both consume these so the schema enum, the argparse
+# `choices=` list, and the runtime resolver all read from one place.
+
+
+def _load_bundled_contract() -> dict:
+    """Read `_data/adapter.toml` from the installed package.
+
+    Kept private; callers go through the three high-level helpers
+    below. Re-reads on every call (cheap; ~5KB TOML parse) so a
+    monkeypatch in tests can swap the bundled file without leaking
+    a cached parse. Uses the project's zipapp-safe reader instead of
+    `Path(__file__).parent` — `__file__` inside a zipapp isn't a real
+    filesystem path and `Path.read_text()` raises NotADirectoryError.
+    """
+    from agentbundle.build.main import _read_bundled
+
+    return tomllib.loads(_read_bundled("adapter.toml"))
+
+
+def shipped_adapters_from_contract() -> tuple[str, ...]:
+    """Return every adapter declared in `[adapter.<name>]` blocks of
+    the bundled contract, alphabetic-sorted.
+
+    Consumers: the install CLI's argparse `--adapter` `choices=` list.
+    Sorted-tuple shape so `argparse --help` renders stably across
+    runs and Python versions.
+    """
+    contract = _load_bundled_contract()
+    return tuple(sorted(contract.get("adapter", {}).keys()))
+
+
+def user_scope_capable_adapters_from_contract() -> tuple[str, ...]:
+    """Return adapters that declare `[adapter.<name>.scope].user` —
+    the set that can target user scope at all.
+
+    Consumers: the schema validator's `allowed-adapters` cross-field
+    refusal; the install handler's `--adapter` user-scope-capability
+    check. Sorted-tuple for the same stability reason as above.
+    """
+    contract = _load_bundled_contract()
+    capable = []
+    for name, block in contract.get("adapter", {}).items():
+        scope = block.get("scope")
+        if isinstance(scope, dict) and "user" in scope:
+            capable.append(name)
+    return tuple(sorted(capable))
+
+
+# Contract versions that pre-date hook-wiring (RFC-0005). The
+# `_kiro_target_adapters` rail and any future hook-related code path
+# checks this; a literal-set check would silently break on the next
+# contract bump (v0.7+), so the predicate is the load-bearing form.
+_PRE_HOOK_WIRING_CONTRACT_VERSIONS: frozenset[str] = frozenset({"0.1", "0.2"})
+
+
+def configured_adapter(user_config: "UserConfig | None") -> str | None:
+    """Report the user-configured adapter when set and known by the
+    bundled adapter contract.
+
+    Returns `user_config.adapter` when set AND in
+    `shipped_adapters_from_contract()`; returns `None` otherwise.
+
+    Scope-agnostic and pack-agnostic by design. Scope-capability and
+    pack-`allowed_adapters` enforcement live in the resolver's
+    pre-flight (`_resolve_target_adapter` in `commands/install.py`),
+    not here. The `None` return is load-bearing: it lets the resolver
+    distinguish "user configured something usable" from "nothing
+    configured, fall through to existing defaults" so that the probe
+    and `DEFAULT_ADAPTER` cascade preserved for users who never ran
+    `agentbundle config set`.
+
+    The `shipped` check is the contract-drift guard: an adapter
+    dropped from the contract since the user wrote their config
+    returns None here and falls through to the constant — same
+    fail-soft contract as `read_user_config`'s warning path. The
+    annotation is a string under `from __future__ import annotations`,
+    so this module does NOT import `agentbundle.user_config` at
+    runtime — that keeps the cycle broken
+    (`user_config.py → scope.py` is the only direction).
+    """
+    if user_config is None or user_config.adapter is None:
+        return None
+    if user_config.adapter not in shipped_adapters_from_contract():
+        return None
+    return user_config.adapter
+
+
+def contract_supports_hook_wiring(version: str | None) -> bool:
+    """True for any contract version that ships hook-wiring as a
+    first-class primitive (v0.3 and later).
+
+    The semantic predicate replaces the literal `version != "0.3"`
+    check that lived at `validate.py:379` pre-RFC-0011 — that check
+    silently dropped v0.6+ packs from the kiro-targeting rail and
+    would re-break on v0.7. None / unknown values return False
+    (conservative: a pack with no declared contract version is
+    treated as pre-hook-wiring).
+    """
+    if not isinstance(version, str):
+        return False
+    return version not in _PRE_HOOK_WIRING_CONTRACT_VERSIONS

agentbundle/user_config.py

@@ -0,0 +1,284 @@
+"""User-scope CLI config: read, write, unset of `~/.../agentbundle/config.toml`.
+
+The file holds adapter-scoped settings the user can change post-pip-install
+without monkey-patching `scope.DEFAULT_ADAPTER`. See
+`docs/specs/agentbundle-config-subcommand/spec.md` for the contract.
+
+Module surface:
+  - `UserConfig` — frozen dataclass; today only `adapter: str | None`.
+  - `_user_config_path(*, platform, env, home)` — pure path resolver.
+  - `read_user_config(path)` — fail-soft loader (warns on malformed
+    TOML or unknown adapter value; never raises).
+  - `load_user_config()` — convenience: `read_user_config(_user_config_path())`.
+  - `write_setting(path, key, value)` — validates and writes.
+  - `unset_setting(path, key)` — removes and (when empty) deletes the file.
+
+`UserConfig` is referenced from `agentbundle.scope.configured_adapter` only
+as a forward-declared annotation (`from __future__ import annotations`), so
+`scope.py` does not import this module at runtime. That keeps the cycle
+broken: `user_config.py → scope.py` (for the shipped-adapter sanity check
+in `read_user_config`) is the only direction.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import tomllib
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Mapping
+
+from agentbundle.config import _emit_basic_string
+
+
+_KNOWN_KEYS: tuple[str, ...] = ("adapter",)
+
+
+@dataclass(frozen=True)
+class UserConfig:
+    """Parsed `[settings]` table from the user-scope config file.
+
+    `None` means "the key was absent from the file, the file did not
+    exist, or the on-disk value failed validation." Callers cannot
+    distinguish these three from the dataclass alone; the loader emits
+    a stderr warning when validation drops a value.
+    """
+
+    adapter: str | None = None
+
+
+# ---------------------------------------------------------------------------
+# Path resolution
+# ---------------------------------------------------------------------------
+
+
+def _user_config_path(
+    *,
+    platform: str | None = None,
+    env: Mapping[str, str] | None = None,
+    home: Path | None = None,
+) -> Path:
+    """Resolve the OS-conventional path to `<dir>/agentbundle/config.toml`.
+
+    Pure: no disk I/O. Defaults to `sys.platform`, `os.environ`,
+    `Path.home()` for production callers; tests pass explicit values.
+    """
+    p = platform if platform is not None else sys.platform
+    e: Mapping[str, str] = env if env is not None else os.environ
+    h = home if home is not None else Path.home()
+    if p == "darwin":
+        base = h / "Library" / "Application Support"
+    elif p == "win32":
+        appdata = e.get("APPDATA")
+        base = Path(appdata) if appdata else h / "AppData" / "Roaming"
+    else:
+        # Linux + every other POSIX falls back to XDG.
+        xdg = e.get("XDG_CONFIG_HOME")
+        base = Path(xdg) if xdg else h / ".config"
+    return base / "agentbundle" / "config.toml"
+
+
+# ---------------------------------------------------------------------------
+# Read / load
+# ---------------------------------------------------------------------------
+
+
+def read_user_config(path: Path) -> UserConfig:
+    """Load the config file fail-soft.
+
+    A missing file returns `UserConfig()`. A malformed file emits a
+    one-line stderr warning and returns `UserConfig()`. An on-disk
+    `adapter` value not in `shipped_adapters_from_contract()` emits
+    a one-line stderr warning listing the admissible names and
+    returns `UserConfig()`.
+
+    The fail-soft contract is load-bearing: `cli.py:main()` calls
+    `load_user_config()` on every invocation including `--help` and
+    `config path`, so a broken file must not block recovery commands.
+    """
+    if not path.exists():
+        return UserConfig()
+    try:
+        with path.open("rb") as fh:
+            parsed = tomllib.load(fh)
+    except tomllib.TOMLDecodeError as exc:
+        print(
+            f"agentbundle: warning: user config at {path} is malformed "
+            f"({exc}); ignoring. Edit or remove the file with "
+            f"`agentbundle config unset adapter` or hand-edit "
+            f"`{path}`.",
+            file=sys.stderr,
+        )
+        return UserConfig()
+
+    settings = parsed.get("settings", {})
+    if not isinstance(settings, dict):
+        # An on-disk [settings] that's not a table is structurally
+        # invalid — same fail-soft contract.
+        print(
+            f"agentbundle: warning: user config at {path} has a "
+            f"non-table `settings` entry; ignoring.",
+            file=sys.stderr,
+        )
+        return UserConfig()
+
+    raw_adapter = settings.get("adapter")
+    if raw_adapter is None:
+        return UserConfig()
+    if not isinstance(raw_adapter, str):
+        print(
+            f"agentbundle: warning: user config at {path} has a "
+            f"non-string `adapter` value ({type(raw_adapter).__name__}); "
+            f"ignoring.",
+            file=sys.stderr,
+        )
+        return UserConfig()
+
+    # Validate against the shipped adapter contract. Late import to
+    # avoid a circular import at module load.
+    from agentbundle.scope import shipped_adapters_from_contract
+
+    shipped = shipped_adapters_from_contract()
+    if raw_adapter not in shipped:
+        print(
+            f"agentbundle: warning: user config at {path} has an "
+            f"adapter value ({raw_adapter!r}) that is not in the "
+            f"current adapter contract. Admissible: {sorted(shipped)}. "
+            f"Falling back to the built-in default; either edit the "
+            f"file or run `agentbundle config set adapter <name>`.",
+            file=sys.stderr,
+        )
+        return UserConfig()
+
+    return UserConfig(adapter=raw_adapter)
+
+
+def load_user_config() -> UserConfig:
+    """Convenience: `read_user_config(_user_config_path())`.
+
+    `cli.py:main()` calls this once per invocation and attaches the
+    result to `args._user_config` before dispatching.
+    """
+    return read_user_config(_user_config_path())
+
+
+# ---------------------------------------------------------------------------
+# Write / unset (shared invariants)
+# ---------------------------------------------------------------------------
+
+
+def _parse_known_or_raise(path: Path) -> dict[str, Any]:
+    """Parse the file as TOML and refuse any shape this writer can't
+    safely round-trip.
+
+    The fail-loud guards: any non-`[settings]` top-level table or any
+    non-string value under `[settings]` (including nested tables, which
+    `tomllib` materialises as dict values). Both cases raise with the
+    same "future setting type not yet supported" message; the caller is
+    expected to leave the file untouched.
+    """
+    if not path.exists():
+        return {}
+    with path.open("rb") as fh:
+        parsed = tomllib.load(fh)
+    for top_key, value in parsed.items():
+        if top_key != "settings":
+            raise ValueError(
+                f"agentbundle: future setting table not yet supported: "
+                f"[{top_key}] in {path}. Hand-edit or remove the file."
+            )
+        if not isinstance(value, dict):
+            raise ValueError(
+                f"agentbundle: future setting type not yet supported: "
+                f"non-table `settings` in {path}."
+            )
+        for k, v in value.items():
+            if not isinstance(v, str):
+                raise ValueError(
+                    f"agentbundle: future setting type not yet supported: "
+                    f"non-string value under [settings] (key {k!r}, "
+                    f"type {type(v).__name__}) in {path}. Hand-edit or "
+                    f"remove the file."
+                )
+    return parsed
+
+
+def _emit_settings(settings: dict[str, str]) -> bytes:
+    """Render `{key: str_value}` into a deterministic TOML file body.
+
+    Keys are emitted in sorted order; values go through
+    `_emit_basic_string` (same helper `agentbundle.config` uses for
+    state-file writes). Empty `settings` returns empty bytes — the
+    caller decides whether to write or delete.
+    """
+    if not settings:
+        return b""
+    lines = ["[settings]"]
+    for k in sorted(settings):
+        lines.append(f"{k} = {_emit_basic_string(settings[k])}")
+    lines.append("")  # trailing newline
+    return "\n".join(lines).encode("utf-8")
+
+
+def _validate_key_value(key: str, value: str) -> None:
+    """Refuse unknown keys; for `adapter`, refuse unknown values."""
+    if key not in _KNOWN_KEYS:
+        raise ValueError(
+            f"agentbundle: unknown setting {key!r}. Known settings: "
+            f"{list(_KNOWN_KEYS)}."
+        )
+    if key == "adapter":
+        from agentbundle.scope import shipped_adapters_from_contract
+
+        shipped = shipped_adapters_from_contract()
+        if value not in shipped:
+            raise ValueError(
+                f"agentbundle: unknown adapter {value!r}. Admissible: "
+                f"{sorted(shipped)}."
+            )
+
+
+def write_setting(path: Path, key: str, value: str) -> None:
+    """Validate `(key, value)`, then write the file (creating parents).
+
+    Idempotent on repeat with the same value (same bytes are written).
+    Raises `ValueError` on validation failure or on a file shape this
+    writer refuses; the on-disk file is not mutated in those cases.
+    """
+    _validate_key_value(key, value)
+    parsed = _parse_known_or_raise(path)
+    settings = dict(parsed.get("settings", {}))
+    settings[key] = value
+    body = _emit_settings(settings)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_bytes(body)
+
+
+def unset_setting(path: Path, key: str) -> None:
+    """Remove `key` from `[settings]`. Delete the file if it becomes
+    empty AND no other top-level tables are present.
+
+    Idempotent: unsetting a missing key (or operating on a missing
+    file) is a no-op. Raises `ValueError` on an unknown key or on a
+    file shape this writer refuses; the on-disk file is not mutated
+    in those cases.
+    """
+    if key not in _KNOWN_KEYS:
+        raise ValueError(
+            f"agentbundle: unknown setting {key!r}. Known settings: "
+            f"{list(_KNOWN_KEYS)}."
+        )
+    if not path.exists():
+        return
+    parsed = _parse_known_or_raise(path)
+    settings = dict(parsed.get("settings", {}))
+    if key not in settings:
+        return
+    del settings[key]
+    other_tables = [k for k in parsed if k != "settings"]
+    if not settings and not other_tables:
+        path.unlink()
+        return
+    body = _emit_settings(settings)
+    path.write_bytes(body)

agentbundle/version.py

@@ -0,0 +1,49 @@
+"""Version constants — CLI version and spec version both pinned at import time.
+
+Spec version is parsed from the bundled canonical `adapter.toml` once, at
+module import; mutating the on-disk file after import has no effect on
+`SPEC_VERSION`. This pins the contract version the running CLI ships against
+to the value present when the process started — which is the value users see
+in `agentbundle --version` and the value every pack-version-mismatch refusal
+cites.
+"""
+
+from __future__ import annotations
+
+import tomllib
+from importlib.resources import files
+from pathlib import Path
+
+CLI_VERSION = "0.1.0"
+
+_HERE = Path(__file__).resolve().parent
+
+
+def _read_bundled_adapter_toml_text() -> str:
+    """Read the canonical adapter.toml as text.
+
+    Resolution:
+      1. `agentbundle._data/adapter.toml` via `importlib.resources` —
+         works inside a `zipapp`, a `pip install`, and a dev checkout
+         that has `_data/` populated.
+      2. `<repo>/docs/contracts/adapter.toml` — dev-checkout fallback
+         for the (rare) case where `_data/` is missing in the source
+         tree (mostly during initial scaffolding).
+    """
+    try:
+        resource = files("agentbundle").joinpath("_data/adapter.toml")
+        if resource.is_file():
+            return resource.read_text(encoding="utf-8")
+    except (FileNotFoundError, ModuleNotFoundError):
+        pass
+
+    fallback = _HERE.parent.parent.parent / "docs" / "contracts" / "adapter.toml"
+    return fallback.read_text(encoding="utf-8")
+
+
+def _read_spec_version() -> str:
+    data = tomllib.loads(_read_bundled_adapter_toml_text())
+    return data["contract"]["version"]
+
+
+SPEC_VERSION: str = _read_spec_version()

agentbundle-0.2.0.dist-info/METADATA

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: agentbundle
+Version: 0.2.0
+Summary: Reference CLI and distribution pipeline for the agent-ready-repo adapter contract.
+Author-email: eugenelim <eugenelim@users.noreply.github.com>
+License: Apache-2.0 OR MIT
+Project-URL: Homepage, https://github.com/eugenelim/agent-ready-repo
+Project-URL: Source, https://github.com/eugenelim/agent-ready-repo
+Project-URL: Documentation, https://github.com/eugenelim/agent-ready-repo/blob/main/docs/guides/how-to/install-agentbundle-from-clone.md
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# agentbundle
+
+Runtime library and reference CLI for the
+[agent-ready-repo](https://github.com/eugenelim/agent-ready-repo) adapter
+contract. Ships the `agentbundle` console script — install, validate,
+adapt, and inspect packs — plus the build pipeline (`agentbundle.build`)
+that projects pack sources into adapter-shaped trees.
+
+As of 0.2.0, credential resolution lives in the build-projected
+`credentials_shim` sibling that the `credential-brokers` pack drops
+alongside each `auth: creds` consumer skill's `scripts/`. The
+`agentbundle.credentials` module that previous releases (0.1.x)
+exposed has been removed; consumers import `from .credentials_shim
+import …` against the projected sibling instead. See the
+`credential-broker-contract` spec and this package's `CHANGELOG.md`
+for the migration recipe.
+
+See the [top-level README](https://github.com/eugenelim/agent-ready-repo#readme)
+for install routes, the pack catalogue, and the adapter contract.