agentbundle 0.9.0__tar.gz → 0.10.0__tar.gz

{agentbundle-0.9.0 → agentbundle-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentbundle
-Version: 0.9.0
+Version: 0.10.0
 Summary: npm for your coding agent. Install packs of skills, subagents, and hooks into any repo, for every major agent.
 Author-email: eugenelim <eugenelim@users.noreply.github.com>
 License: Apache-2.0 OR MIT
@@ -55,6 +55,12 @@ The install auto-detects your agent (`--adapter` overrides). Multi-IDE? Install
 agentbundle list-packs
 agentbundle list-profiles
 
+# See what YOU have installed — pack, adapter, scope, version, and whether
+# an upgrade is available (both scopes by default)
+agentbundle list-installed
+agentbundle list-installed --no-check       # skip the catalogue check (offline, fast)
+agentbundle list-installed --check-drift    # also count locally edited files
+
 # Install a whole curated profile — a single-scope set of packs — in one command
 agentbundle install --profile inception
 
@@ -70,6 +76,8 @@ agentbundle uninstall --pack core --dry-run
 agentbundle uninstall --pack core --yes
 ```
 
+**`list-installed`** reads your state files (not the catalogue) and reports every installed `(pack, adapter)` at each scope with its version and an `up-to-date` / `upgrade-available` / `unknown` status; it degrades to `unknown` (never an error) when the catalogue can't be resolved, and `--no-check` skips the check entirely.
+
 A **profile** is a catalogue-curated, single-scope set of packs you install in one command — it declares its own scope, so `--scope` doesn't apply. **Upgrade takes no version** — the target is whatever the catalogue you point at declares; to pin a past version, point the catalogue at that git ref. Install a pack that's **already there** and `agentbundle` offers to `upgrade` it instead (`--yes` runs it straight away).
 
 **Mutating commands ask first.** `uninstall`, the `--force` cleanup, and the upgrade offer all preview what they'll do and confirm before touching anything; `--dry-run` previews without writing, and `--yes` skips the prompt for non-interactive / CI use (where, without it, they refuse rather than hang).

{agentbundle-0.9.0 → agentbundle-0.10.0}/README.md

@@ -37,6 +37,12 @@ The install auto-detects your agent (`--adapter` overrides). Multi-IDE? Install
 agentbundle list-packs
 agentbundle list-profiles
 
+# See what YOU have installed — pack, adapter, scope, version, and whether
+# an upgrade is available (both scopes by default)
+agentbundle list-installed
+agentbundle list-installed --no-check       # skip the catalogue check (offline, fast)
+agentbundle list-installed --check-drift    # also count locally edited files
+
 # Install a whole curated profile — a single-scope set of packs — in one command
 agentbundle install --profile inception
 
@@ -52,6 +58,8 @@ agentbundle uninstall --pack core --dry-run
 agentbundle uninstall --pack core --yes
 ```
 
+**`list-installed`** reads your state files (not the catalogue) and reports every installed `(pack, adapter)` at each scope with its version and an `up-to-date` / `upgrade-available` / `unknown` status; it degrades to `unknown` (never an error) when the catalogue can't be resolved, and `--no-check` skips the check entirely.
+
 A **profile** is a catalogue-curated, single-scope set of packs you install in one command — it declares its own scope, so `--scope` doesn't apply. **Upgrade takes no version** — the target is whatever the catalogue you point at declares; to pin a past version, point the catalogue at that git ref. Install a pack that's **already there** and `agentbundle` offers to `upgrade` it instead (`--yes` runs it straight away).
 
 **Mutating commands ask first.** `uninstall`, the `--force` cleanup, and the upgrade offer all preview what they'll do and confirm before touching anything; `--dry-run` previews without writing, and `--yes` skips the prompt for non-interactive / CI use (where, without it, they refuse rather than hang).

{agentbundle-0.9.0 → agentbundle-0.10.0}/agentbundle/cli.py

@@ -230,6 +230,50 @@ def _build_parser() -> argparse.ArgumentParser:
     )
     sp.set_defaults(func=_lazy("list_targets"))
 
+    # --- list-installed --- (state-file reader; both scopes by default)
+    sp = subparsers.add_parser(
+        "list-installed",
+        help=(
+            "List installed packs across user and repo scope with version and "
+            "up-to-date status (vs. a catalogue). Read-only."
+        ),
+    )
+    sp.add_argument(
+        "catalogue",
+        nargs="?",
+        default=None,
+        help=(
+            "Catalogue URI to compare installed versions against. Optional: when "
+            "omitted, the source is resolved from your config, an editable clone, "
+            "or the packaged default (RFC-0047). Ignored under --no-check."
+        ),
+    )
+    sp.add_argument("--root", default=".")
+    sp.add_argument(
+        "--scope",
+        choices=("repo", "user"),
+        help="Limit the listing to one scope. Default: both user and repo.",
+    )
+    sp.add_argument(
+        "--no-check",
+        "--offline",
+        dest="no_check",
+        action="store_true",
+        help=(
+            "Skip the catalogue up-to-date check (no network): print only "
+            "pack/adapter/scope/installed, omitting LATEST and STATUS."
+        ),
+    )
+    sp.add_argument(
+        "--check-drift",
+        action="store_true",
+        help=(
+            "Add a DRIFT column counting installed files locally edited since "
+            "install (on-disk SHA differs from the recorded SHA)."
+        ),
+    )
+    sp.set_defaults(func=_lazy("list_installed"))
+
     # --- scaffold --- (no --scope; always repo-targeted)
     sp = subparsers.add_parser(
         "scaffold",

{agentbundle-0.9.0 → agentbundle-0.10.0}/agentbundle/commands/_common.py

@@ -16,6 +16,7 @@ from agentbundle.version import SPEC_VERSION
 if TYPE_CHECKING:
     import argparse
 
+    from agentbundle.config import PackState
     from agentbundle.safety import Tier
 
 
@@ -199,6 +200,45 @@ def _major(version: str) -> str:
     return v.split(".")[0]
 
 
+def format_adapter_versions(rows: "dict[str, PackState]") -> str:
+    """Render sorted ``adapter (version)`` pairs for a multi-adapter
+    disambiguator message (RFC-0052).
+
+    ``rows`` is a ``{adapter: PackState}`` mapping (the shape
+    ``State.rows_for_pack`` returns). Output e.g. ``claude-code (0.9.0),
+    codex (0.9.0)`` — so a "pass --adapter" refusal names not just *which*
+    adapters are installed but *at what version*, making the next command
+    actionable without a second lookup.
+    """
+    return ", ".join(
+        f"{adapter} ({rows[adapter].installed_version})" for adapter in sorted(rows)
+    )
+
+
+def count_drifted_files(pack_state: "PackState", root: Path) -> int:
+    """Count *pack_state*'s files whose on-disk SHA differs from the recorded SHA.
+
+    Row-scoped drift (Tier-2): compares each file against this row's own
+    recorded SHA — **not** ``safety.classify``, which resolves against the SHA
+    set across *all* rows and would undercount a co-owned path. A file absent on
+    disk is not drift (it is Tier-1, "about to (re)write"). Render-free: needs
+    only the loaded state plus on-disk bytes, so it is cheap enough to run
+    before an upgrade confirm. Shared by ``list-installed --check-drift`` and
+    the upgrade upfront drift notice.
+    """
+    from agentbundle.safety import sha256_file
+
+    count = 0
+    for relpath in pack_state.files:
+        on_disk = root / relpath
+        if not on_disk.exists():
+            continue
+        recorded = pack_state.file_sha(relpath)
+        if recorded is not None and sha256_file(on_disk) != recorded:
+            count += 1
+    return count
+
+
 # ---------------------------------------------------------------------------
 # Dry-run plan formatting (shared by `install --dry-run` and `upgrade --dry-run`)
 # ---------------------------------------------------------------------------

{agentbundle-0.9.0 → agentbundle-0.10.0}/agentbundle/commands/diff.py

@@ -113,10 +113,12 @@ def run(args: argparse.Namespace) -> int:
         elif len(_rows) == 1:
             pack_state = next(iter(_rows.values()))
         elif len(_rows) > 1:
+            from agentbundle.commands._common import format_adapter_versions
+
             print(
                 f"diff: {pack_name} installed for multiple adapters at "
-                f"{effective_scope} scope ({', '.join(sorted(_rows))}); "
-                f"pass --adapter",
+                f"{effective_scope} scope; pass --adapter to pick one: "
+                f"{format_adapter_versions(_rows)}",
                 file=sys.stderr,
             )
             return 1

agentbundle-0.10.0/agentbundle/commands/list_installed.py

@@ -0,0 +1,223 @@
+"""``agentbundle list-installed`` subcommand.
+
+Lists every installed ``(pack, adapter)`` row across the user and repo scope —
+the state-file complement to ``list-packs`` (which queries a *catalogue* of
+what is *available*). Reads the state files **read-only**; never writes.
+
+By default it also resolves the catalogue once and joins each row against the
+catalogue's ``pack.toml`` version to report a status (``up-to-date`` /
+``upgrade-available`` / ``unknown``). ``--no-check`` (alias ``--offline``) skips
+that join and prints only the state-only columns. ``--check-drift`` adds a
+per-row count of locally edited files (on-disk SHA ≠ the SHA recorded in state).
+
+Exit codes:
+  0  — success (including "no packs installed" and an unresolvable catalogue).
+  1  — only on an argument/environment error the listing genuinely can't survive.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import argparse
+
+    from agentbundle.config import State
+
+
+def run(args: "argparse.Namespace") -> int:
+    """Entry point for ``agentbundle list-installed``."""
+    import sys
+
+    from agentbundle import scope as scope_mod
+    from agentbundle.config import ConfigError, load_state
+
+    requested_scope = getattr(args, "scope", None)
+    scopes = [requested_scope] if requested_scope else ["user", "repo"]
+    check = not getattr(args, "no_check", False)
+    want_drift = getattr(args, "check_drift", False)
+
+    # ── Gather (scope, root, State) read-only ─────────────────────────────────
+    repo_root = Path(getattr(args, "root", ".")).resolve()
+    scope_states: list[tuple[str, Path, "State"]] = []
+    for sc in scopes:
+        if sc == "repo":
+            base, state_path = repo_root, repo_root / ".agentbundle-state.toml"
+        else:  # user
+            try:
+                base = scope_mod.resolve_user_root()
+            except scope_mod.UserScopeUnresolvable:
+                # No resolvable home → no user-scope state to list. Not an error.
+                continue
+            state_path = base / ".agentbundle" / "state.toml"
+        try:
+            state = load_state(state_path)
+        except ConfigError as exc:
+            # An incompatible (e.g. legacy-schema) state file is a hard refusal
+            # on read (RFC-0052). Warn and skip that scope rather than abort —
+            # the other scope stays listable.
+            print(f"list-installed: skipping {sc} scope: {exc}", file=sys.stderr)
+            continue
+        scope_states.append((sc, base, state))
+
+    rows = _collect_rows(scope_states)
+    if not rows:
+        where = f"{requested_scope} scope" if requested_scope else "user or repo scope"
+        print(f"no packs installed at {where}.")
+        return 0
+
+    # ── Catalogue join for LATEST / STATUS (unless --no-check) ─────────────────
+    catalogue_resolved = False
+    latest_by_pack: dict[str, str | None] = {}
+    if check:
+        catalogue_resolved, latest_by_pack = _resolve_latest(args)
+
+    # ── Drift count (only when requested) ─────────────────────────────────────
+    if want_drift:
+        from agentbundle.commands._common import count_drifted_files
+
+        for row in rows:
+            row["drift"] = count_drifted_files(row["_pack_state"], row["_root"])
+
+    _print_table(rows, check=check, want_drift=want_drift,
+                 catalogue_resolved=catalogue_resolved, latest_by_pack=latest_by_pack)
+    return 0
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _collect_rows(
+    scope_states: list[tuple[str, Path, "State"]],
+) -> list[dict]:
+    """Flatten every ``(pack, adapter)`` row across scopes into sorted dicts.
+
+    Each row carries the display fields plus ``_pack_state`` / ``_root`` for a
+    later (optional) drift pass. Sorted by (pack, adapter, scope) so output is
+    deterministic.
+    """
+    rows: list[dict] = []
+    for scope_name, root, state in scope_states:
+        for (pack, adapter), ps in state.packs.items():
+            rows.append(
+                {
+                    "pack": pack,
+                    "adapter": adapter,
+                    "scope": scope_name,
+                    "installed": ps.installed_version,
+                    "_pack_state": ps,
+                    "_root": root,
+                }
+            )
+    rows.sort(key=lambda r: (r["pack"], r["adapter"], r["scope"]))
+    return rows
+
+
+def _resolve_latest(args: "argparse.Namespace") -> tuple[bool, dict[str, str | None]]:
+    """Resolve the catalogue once and map each pack name to its latest version.
+
+    Returns ``(catalogue_resolved, {pack_name: version_or_None})``. On an
+    unresolvable catalogue returns ``(False, {})`` — the caller degrades every
+    row to ``unknown`` rather than failing. A pack present in the catalogue but
+    declaring an incompatible major version maps to ``None`` (also ``unknown``),
+    detected directly (``pack_spec_version`` + ``_major``) so no refusal is
+    printed — unlike ``check_spec_version_gate``, which prints and aborts.
+    """
+    from agentbundle.catalogue import CatalogueError, resolve_catalogue
+    from agentbundle.commands._common import _major, resolve_catalogue_uri
+    from agentbundle.config import ConfigError, load_pack_toml, pack_spec_version
+    from agentbundle.version import SPEC_VERSION
+
+    try:
+        catalogue_dir = resolve_catalogue(resolve_catalogue_uri(args))
+    except CatalogueError:
+        return False, {}
+
+    # Reuse list-packs' discovery so the layouts accepted stay identical.
+    from agentbundle.commands.list_packs import _discover_pack_dirs
+
+    cli_major = _major(SPEC_VERSION)
+    latest: dict[str, str | None] = {}
+    for pack_dir in _discover_pack_dirs(catalogue_dir):
+        try:
+            toml = load_pack_toml(pack_dir / "pack.toml")
+        except ConfigError:
+            continue
+        pack = toml.get("pack", {})
+        name = pack.get("name") or pack_dir.name
+        declared = pack_spec_version(toml)
+        if declared is not None and _major(declared) != cli_major:
+            latest[name] = None  # incompatible major → unknown, don't compare
+            continue
+        latest[name] = pack.get("version") or None
+    return True, latest
+
+
+def _version_key(version: str) -> tuple[int, ...] | None:
+    """Parse a dotted version into a comparable int tuple, or None if not numeric.
+
+    A non-numeric segment (a pre-release / build tag like ``1.2.0-rc1`` or
+    ``1.2.post1``) intentionally yields ``None`` → the row reads ``unknown``
+    rather than risking a wrong comparison; packs ship plain numeric versions.
+    """
+    parts = version.lstrip("v").split(".")
+    try:
+        return tuple(int(p) for p in parts)
+    except ValueError:
+        return None
+
+
+def _status_for(installed: str, latest: str | None, *, catalogue_resolved: bool) -> str:
+    """Compute a row's status from (installed, latest, resolvable?).
+
+    ``up-to-date`` when installed is at or beyond latest; ``upgrade-available``
+    when latest is strictly greater; ``unknown`` when the catalogue could not be
+    resolved, the pack is absent from it, or either version isn't comparable.
+    """
+    if not catalogue_resolved or latest is None:
+        return "unknown"
+    a, b = _version_key(installed), _version_key(latest)
+    if a is None or b is None:
+        return "unknown"
+    # Zero-pad to equal length so `0.9` vs `0.9.0` compares equal rather than
+    # `(0,9) < (0,9,0)` reading as upgrade-available.
+    width = max(len(a), len(b))
+    a += (0,) * (width - len(a))
+    b += (0,) * (width - len(b))
+    return "upgrade-available" if b > a else "up-to-date"
+
+
+def _print_table(
+    rows: list[dict],
+    *,
+    check: bool,
+    want_drift: bool,
+    catalogue_resolved: bool,
+    latest_by_pack: dict[str, str | None],
+) -> None:
+    """Render the installed-packs table to stdout."""
+    from agentbundle.commands._common import render_table
+
+    headers = ["PACK", "ADAPTER", "SCOPE", "INSTALLED"]
+    if check:
+        headers += ["LATEST", "STATUS"]
+    if want_drift:
+        headers += ["DRIFT"]
+
+    table_rows: list[list[str]] = []
+    for r in rows:
+        cells = [r["pack"], r["adapter"], r["scope"], r["installed"]]
+        if check:
+            latest = latest_by_pack.get(r["pack"])
+            status = _status_for(
+                r["installed"], latest, catalogue_resolved=catalogue_resolved
+            )
+            cells += [latest or "—", status]
+        if want_drift:
+            cells += [str(r.get("drift", 0))]
+        table_rows.append(cells)
+
+    render_table(headers, table_rows)

{agentbundle-0.9.0 → agentbundle-0.10.0}/agentbundle/commands/uninstall.py

@@ -141,9 +141,12 @@ def run(args: "argparse.Namespace") -> int:
     elif len(rows) == 1:
         target_adapter = next(iter(rows))
     else:
+        from agentbundle.commands._common import format_adapter_versions
+
         print(
             f"uninstall: {pack_name} installed for multiple adapters at "
-            f"{effective_scope} scope ({', '.join(sorted(rows))}); pass --adapter",
+            f"{effective_scope} scope; pass --adapter to pick one: "
+            f"{format_adapter_versions(rows)}",
             file=sys.stderr,
         )
         return 1

{agentbundle-0.9.0 → agentbundle-0.10.0}/agentbundle/commands/upgrade.py

@@ -38,7 +38,6 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     import argparse
 
-    from agentbundle.config import State
     from agentbundle.user_config import UserConfig
 
 
@@ -182,9 +181,12 @@ def run(args: "argparse.Namespace") -> int:
     elif len(_rows) == 1:
         target_adapter = next(iter(_rows))
     elif len(_rows) > 1:
+        from agentbundle.commands._common import format_adapter_versions
+
         print(
             f"upgrade: {pack_name} installed for multiple adapters at "
-            f"{effective_scope} scope ({', '.join(sorted(_rows))}); pass --adapter",
+            f"{effective_scope} scope; pass --adapter to pick one: "
+            f"{format_adapter_versions(_rows)}",
             file=sys.stderr,
         )
         return 1
@@ -322,6 +324,25 @@ def run(args: "argparse.Namespace") -> int:
     # write happens either way) and rare; left as-is to keep the confirm above
     # the expensive render.
 
+    # Upfront drift notice (whole-pack only): before the user confirms, tell
+    # them how many installed files have local edits that re-applying will
+    # preserve as `*.upstream` companions. Computed from on-disk-vs-state SHAs
+    # (no render needed); suppressed at zero and on a dry run (which writes
+    # nothing and already names companion actions in its plan). Gated to the
+    # whole-pack case: a per-primitive upgrade re-applies only that primitive's
+    # files, so a whole-pack count would mislead.
+    if not is_per_primitive and not getattr(args, "dry_run", False):
+        from agentbundle.commands._common import count_drifted_files
+
+        _drifted = count_drifted_files(pack_state, root)
+        if _drifted:
+            print(
+                f"upgrade: {_drifted} installed file(s) have local edits; your "
+                f"edits are preserved as .upstream companions where the file "
+                f"still ships.",
+                file=sys.stderr,
+            )
+
     # Confirm before the first write — unless ``--yes`` or ``--dry-run`` (which
     # writes nothing). A non-interactive stdin cannot answer the prompt, so
     # refuse and explain rather than block on ``input()``. ``--dry-run``
@@ -330,8 +351,10 @@ def run(args: "argparse.Namespace") -> int:
     if not getattr(args, "yes", False) and not getattr(args, "dry_run", False):
         if already_current:
             question = (
-                f"{confirm_label} is already at {to_version}. Re-apply at "
-                f"{effective_scope} scope (repairs local drift)? [y/N] "
+                f"{confirm_label} is already at {to_version} at "
+                f"{effective_scope} scope. Re-apply to restore any missing or "
+                f"reset any unmodified bundle files? Your local edits are kept "
+                f"as .upstream companions. [y/N] "
             )
         else:
             question = (
@@ -727,15 +750,19 @@ def run(args: "argparse.Namespace") -> int:
 
     if is_per_primitive:
         ptype, _src_dir = _PRIMITIVE_FLAG_MAP[prim_flag]
-        print(
-            f"upgraded: {pack_name} {ptype}/{prim_name} @ "
-            f"{effective_scope} {from_version} -> {to_version}"
-        )
+        recap_label = f"{pack_name} {ptype}/{prim_name}"
     else:
-        print(
-            f"upgraded: {pack_name} @ {effective_scope} "
-            f"{from_version} -> {to_version}"
+        recap_label = pack_name
+    print(
+        _format_recap(
+            recap_label,
+            effective_scope,
+            from_version,
+            to_version,
+            already_current=already_current,
+            companion_count=len(companions),
         )
+    )
     return 0
 
 
@@ -744,6 +771,40 @@ def run(args: "argparse.Namespace") -> int:
 # ---------------------------------------------------------------------------
 
 
+def _format_recap(
+    label: str,
+    scope: str,
+    from_version: str,
+    to_version: str,
+    *,
+    already_current: bool,
+    companion_count: int,
+) -> str:
+    """Render the post-upgrade recap line, honestly distinguishing the cases.
+
+    Three verdicts, driven by the only signals available without changing what
+    the walk writes (the walk re-writes bundle-owned files unconditionally, so
+    "nothing changed on disk" is not knowable):
+
+      - version changed → ``upgraded: <label> @ <scope> <from> -> <to>``
+      - same version, no local edits preserved →
+        ``re-applied: <label> @ <scope> <version> (already current)``
+      - same version, local edits preserved as companions →
+        ``re-applied: <label> @ <scope> <version> — N file(s) had local edits,
+        kept as .upstream companions``
+
+    It never prints ``upgraded: … X -> X`` for a same-version re-apply.
+    """
+    if not already_current:
+        return f"upgraded: {label} @ {scope} {from_version} -> {to_version}"
+    if companion_count:
+        return (
+            f"re-applied: {label} @ {scope} {to_version} — "
+            f"{companion_count} file(s) had local edits, kept as .upstream companions"
+        )
+    return f"re-applied: {label} @ {scope} {to_version} (already current)"
+
+
 def _compute_new_wiring_rows(
     pack_dir: Path,
     pack_name: str,

{agentbundle-0.9.0 → agentbundle-0.10.0}/agentbundle/version.py

@@ -14,7 +14,7 @@ import tomllib
 from importlib.resources import files
 from pathlib import Path
 
-CLI_VERSION = "0.9.0"
+CLI_VERSION = "0.10.0"
 
 _HERE = Path(__file__).resolve().parent
 

{agentbundle-0.9.0 → agentbundle-0.10.0}/agentbundle.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentbundle
-Version: 0.9.0
+Version: 0.10.0
 Summary: npm for your coding agent. Install packs of skills, subagents, and hooks into any repo, for every major agent.
 Author-email: eugenelim <eugenelim@users.noreply.github.com>
 License: Apache-2.0 OR MIT
@@ -55,6 +55,12 @@ The install auto-detects your agent (`--adapter` overrides). Multi-IDE? Install
 agentbundle list-packs
 agentbundle list-profiles
 
+# See what YOU have installed — pack, adapter, scope, version, and whether
+# an upgrade is available (both scopes by default)
+agentbundle list-installed
+agentbundle list-installed --no-check       # skip the catalogue check (offline, fast)
+agentbundle list-installed --check-drift    # also count locally edited files
+
 # Install a whole curated profile — a single-scope set of packs — in one command
 agentbundle install --profile inception
 
@@ -70,6 +76,8 @@ agentbundle uninstall --pack core --dry-run
 agentbundle uninstall --pack core --yes
 ```
 
+**`list-installed`** reads your state files (not the catalogue) and reports every installed `(pack, adapter)` at each scope with its version and an `up-to-date` / `upgrade-available` / `unknown` status; it degrades to `unknown` (never an error) when the catalogue can't be resolved, and `--no-check` skips the check entirely.
+
 A **profile** is a catalogue-curated, single-scope set of packs you install in one command — it declares its own scope, so `--scope` doesn't apply. **Upgrade takes no version** — the target is whatever the catalogue you point at declares; to pin a past version, point the catalogue at that git ref. Install a pack that's **already there** and `agentbundle` offers to `upgrade` it instead (`--yes` runs it straight away).
 
 **Mutating commands ask first.** `uninstall`, the `--force` cleanup, and the upgrade offer all preview what they'll do and confirm before touching anything; `--dry-run` previews without writing, and `--yes` skips the prompt for non-interactive / CI use (where, without it, they refuse rather than hang).

{agentbundle-0.9.0 → agentbundle-0.10.0}/agentbundle.egg-info/SOURCES.txt

@@ -111,6 +111,7 @@ agentbundle/commands/config.py
 agentbundle/commands/diff.py
 agentbundle/commands/init_state.py
 agentbundle/commands/install.py
+agentbundle/commands/list_installed.py
 agentbundle/commands/list_packs.py
 agentbundle/commands/list_profiles.py
 agentbundle/commands/list_targets.py

{agentbundle-0.9.0 → agentbundle-0.10.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agentbundle"
-version = "0.9.0"
+version = "0.10.0"
 description = "npm for your coding agent. Install packs of skills, subagents, and hooks into any repo, for every major agent."
 requires-python = ">=3.11"
 dependencies = []