katalyst-taxonomy-cli 2.0.1a3__tar.gz → 2.0.1a5__tar.gz

{katalyst_taxonomy_cli-2.0.1a3 → katalyst_taxonomy_cli-2.0.1a5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: katalyst-taxonomy-cli
-Version: 2.0.1a3
+Version: 2.0.1a5
 Summary: CLI for katalyst-taxonomy — the kata command
 Author: eSimplicity
 License: Proprietary

{katalyst_taxonomy_cli-2.0.1a3 → katalyst_taxonomy_cli-2.0.1a5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "katalyst-taxonomy-cli"
-version = "2.0.1a3"
+version = "2.0.1a5"
 description = "CLI for katalyst-taxonomy — the kata command"
 license = { text = "Proprietary" }
 requires-python = ">=3.12"

{katalyst_taxonomy_cli-2.0.1a3 → katalyst_taxonomy_cli-2.0.1a5}/src/katalyst_taxonomy_cli/app.py

@@ -206,6 +206,13 @@ def _installed_katalyst_packages() -> list[tuple[str, str]]:
     return sorted(found.items())
 
 
+def _schema_versions() -> list[tuple[str, str]]:
+    """Every schema installed (katalyst-core, and each bundle), with its version."""
+    from katalyst_engine.evolution import installed_releases
+
+    return [(release.name, str(release.version)) for release in installed_releases()]
+
+
 def _print_version(ctx: click.Context, _param: click.Parameter, value: bool) -> None:
     if not value or ctx.resilient_parsing:
         return
@@ -217,6 +224,12 @@ def _print_version(ctx: click.Context, _param: click.Parameter, value: bool) ->
     click.echo(f"kata {__version__}")
     for name, version in _installed_katalyst_packages():
         click.echo(f"  {name} {version}")
+    click.echo("schemas:")
+    try:
+        for name, version in _schema_versions():
+            click.echo(f"  {name} {version}")
+    except Exception as exc:  # a bundle that does not load must not hide the versions
+        click.echo(f"  unavailable: {exc}")
     for line in install_lines():
         click.echo(line)
     try:
@@ -274,8 +287,8 @@ def _select_home(ctx: click.Context, _param: click.Parameter, value: str | None)
     # Not eager, so it runs after --home (which is) and reports the home chosen.
     callback=_print_version,
     help=(
-        "Show the kata version, every installed Katalyst package, the install (and what it "
-        "was built from) and the home, then exit."
+        "Show the kata version, every installed Katalyst package, the schema bundles with "
+        "their versions, the install (and what it was built from) and the home, then exit."
     ),
 )
 @click.option(
@@ -298,14 +311,15 @@ def cli(ctx: click.Context, profile: str | None) -> None:
         ctx.meta[ROOT_PROFILE_META_KEY] = profile
     _configure_logging()
     # A KATALYST_HOME that names no home fails every command here, before any of them
-    # reads or writes anything (`--home` was checked as it was parsed).
-    from katalyst_taxonomy.adapters.filesystem.homes import resolve_existing_home
+    # reads or writes anything (`--home` was checked as it was parsed) — unless
+    # KATALYST_HOME_SOURCE says what to create it from.
+    from katalyst_taxonomy.adapters.config_sources.homes import resolve_home_on_demand
     from katalyst_taxonomy.domain.homes import HomeError
 
     from .install import refuse_default_home_for_development
 
     try:
-        home = resolve_existing_home()
+        home = resolve_home_on_demand(announce=lambda m: click.echo(m, err=True))
     except HomeError as exc:
         raise click.ClickException(str(exc)) from exc
     # `kata config` decides for itself: `kata config home …` manages homes, not uses one.
@@ -525,6 +539,7 @@ def _register_core_commands() -> None:
         relate,
         relocate,
         remove,
+        rescaffold,
         resolve,
         rollback,
         self_update,
@@ -582,6 +597,7 @@ def _register_core_commands() -> None:
     tax.add_command(export.export)
     tax.add_command(backend.backend)
     tax.add_command(remove.remove)
+    tax.add_command(rescaffold.rescaffold)
 
 
 def resolve_plugin_commands() -> None:

{katalyst_taxonomy_cli-2.0.1a3 → katalyst_taxonomy_cli-2.0.1a5}/src/katalyst_taxonomy_cli/commands/config_home.py

@@ -4,7 +4,7 @@ A home is the config, state and cache a process uses (:mod:`katalyst_taxonomy.do
 ``kata --home NAME`` or ``KATALYST_HOME=NAME`` selects one; a named home must exist first::
 
     kata config home list
-    kata config home create NAME [--from HOME]
+    kata config home create NAME [--from HOME | --source URI [--source-profile P]]
     kata config home rm NAME [--yes]
 
 Path homes (an absolute ``KATALYST_HOME``, for tests and CI) are never listed: they are
@@ -14,7 +14,6 @@ wherever their caller put them.
 from __future__ import annotations
 
 import json
-import os
 import shutil
 from typing import Any
 
@@ -32,6 +31,7 @@ from katalyst_taxonomy.domain.homes import (
     resolve_home,
 )
 from katalyst_taxonomy.domain.paths import CONFIG_FILE_NAME
+from katalyst_taxonomy.processes import is_process_running
 
 from ..output import ConsoleOutput
 
@@ -52,9 +52,7 @@ def _running_api(home: Home) -> dict[str, Any] | None:
         pid, host, port = int(record["pid"]), str(record["host"]), int(record["port"])
     except (OSError, ValueError, KeyError, TypeError):
         return None
-    try:
-        os.kill(pid, 0)
-    except OSError:
+    if not is_process_running(pid):
         return None
     return {"pid": pid, "url": f"http://{host}:{port}"}
 
@@ -121,15 +119,56 @@ def home_list(fmt: str) -> None:
 @click.argument("name")
 @click.option(
     "--from",
-    "source",
+    "copy_from",
     default=None,
     metavar="HOME",
     help="Copy config.yaml (only) from this home: 'default', a name, or an absolute path.",
 )
-def home_create(name: str, source: str | None) -> None:
-    """Create the named home NAME, empty or with another home's config.yaml."""
+@click.option(
+    "--source",
+    "profile_source",
+    default=None,
+    metavar="URI",
+    help=(
+        "Give the home one read-only profile sourced from URI, such as home:default "
+        "(another home: the same repositories), then sync it."
+    ),
+)
+@click.option(
+    "--source-profile",
+    default=None,
+    metavar="PROFILE",
+    help="The profile in the source's configuration (default: @active, whichever is active there).",
+)
+def home_create(
+    name: str, copy_from: str | None, profile_source: str | None, source_profile: str | None
+) -> None:
+    """Create the named home NAME: empty, with another home's config.yaml, or sourced.
+
+    With --source, NAME's config.yaml holds one profile sourced from URI, and nothing
+    else. By default it follows the source's active profile (@active), at every sync. A
+    home: source's profile reads the other home's repositories; its state (the API's
+    record and token) and cache are never read.
+    """
+    if copy_from is not None and profile_source is not None:
+        raise click.ClickException("give --from or --source, not both")
+    if source_profile is not None and profile_source is None:
+        raise click.ClickException("--source-profile needs --source")
+    out = ConsoleOutput()
+    if profile_source is not None:
+        from katalyst_taxonomy.adapters.config_sources.homes import create_sourced_home
+        from katalyst_taxonomy.config.profile_sources import ACTIVE_PROFILE
+
+        wanted = source_profile or ACTIVE_PROFILE
+        try:
+            created, pin = create_sourced_home(name, profile_source, source_profile=wanted)
+        except HomeError as exc:
+            raise click.ClickException(str(exc)) from exc
+        out.success(f"Created home {created.label}, with profile {wanted!r} of {profile_source}")
+        out.info(f"Synced it: pinned {pin}")
+        return
     try:
-        origin = home_for(source) if source is not None else None
+        origin = home_for(copy_from) if copy_from is not None else None
         created = create_home(name)
     except HomeError as exc:
         raise click.ClickException(str(exc)) from exc
@@ -139,7 +178,7 @@ def home_create(name: str, source: str | None) -> None:
         if config_file.is_file():
             shutil.copy2(config_file, created.config_dir / CONFIG_FILE_NAME)
             copied = f", with config.yaml from {origin.name}"
-    ConsoleOutput().success(f"Created home {created.label}{copied}")
+    out.success(f"Created home {created.label}{copied}")
 
 
 @home.command("rm")

{katalyst_taxonomy_cli-2.0.1a3 → katalyst_taxonomy_cli-2.0.1a5}/src/katalyst_taxonomy_cli/commands/config_profile.py

@@ -318,7 +318,8 @@ def profile_show(name: str, fmt: str) -> None:
     metavar="URI",
     help=(
         "Read the profile from elsewhere: git:<url>[@<ref>][#path=<file>], "
-        "github:<owner>/<repo>[@<ref>][#path=<file>], or a kata API's https:// URL."
+        "github:<owner>/<repo>[@<ref>][#path=<file>], a kata API's https:// URL, or "
+        "home:<home> (another home on this machine)."
     ),
 )
 @click.option(

{katalyst_taxonomy_cli-2.0.1a3 → katalyst_taxonomy_cli-2.0.1a5}/src/katalyst_taxonomy_cli/commands/config_schemas.py

@@ -60,7 +60,11 @@ def build_schemas_payload(
     from katalyst_taxonomy.config.schemas import selection_from_config
     from katalyst_taxonomy.engine import bridge
     from katalyst_taxonomy.services.schema_gate import check_declared_bundles
-    from katalyst_taxonomy.services.schema_report import schemas_payload
+    from katalyst_taxonomy.services.schema_report import (
+        core_schema,
+        schema_versions,
+        schemas_payload,
+    )
     from katalyst_taxonomy.sources.template_resolver import TemplateResolver
 
     effective = config_resolver().resolve(profile=profile)
@@ -90,6 +94,8 @@ def build_schemas_payload(
                 if candidate.distribution
             },
             declared=declared,
+            schema_versions=schema_versions(candidates),
+            core_schema=core_schema(),
             scaffold_providers=resolver.scaffold_template_providers(),
             repo_root=None,
             filesystem=RealFilesystem(),
@@ -155,19 +161,24 @@ def _render_text(out: OutputPort, payload: dict[str, Any]) -> None:
         ]
     )
 
+    core = payload.get("core")
+    if core:
+        out.key_value([("katalyst-core schema", _schema_text(core))])
+
     out.heading("Bundles")
     bundles: list[dict[str, Any]] = payload["bundles"]
     if not bundles:
         out.info("No schema bundles discovered.")
     else:
         out.table(
-            ["", "bundle", "distribution", "version", "kinds", "note"],
+            ["", "bundle", "distribution", "version", "schema", "kinds", "note"],
             [
                 [
                     "*" if entry["enabled"] else "x",
                     str(entry["name"]),
                     str(entry.get("distribution") or "-"),
                     str(entry.get("resolvedVersion") or entry["version"] or "-"),
+                    _schema_text(entry.get("schema")),
                     str(len(entry["kinds"])),
                     str(
                         entry["reason"] or entry.get("sourceWarning") or entry["entryPoint"] or "-"
@@ -239,6 +250,19 @@ def _render_text(out: OutputPort, payload: dict[str, Any]) -> None:
         )
 
 
+def _schema_text(schema: dict[str, Any] | None) -> str:
+    """``9.0.0 (unreleased; latest archived 8.0.0)``: a schema's version and archive state."""
+    if not schema:
+        return "-"
+    from katalyst_engine.core.version import Version
+    from katalyst_engine.evolution import ArchiveState
+
+    archive = schema["archive"]
+    latest = archive["latest"]
+    state = ArchiveState(archive["state"], Version.parse(latest) if latest else None)
+    return f"{schema['version']} ({state})"
+
+
 def attach(group: click.Group) -> None:
     """Add ``schemas`` to the ``kata config`` group.
 

{katalyst_taxonomy_cli-2.0.1a3 → katalyst_taxonomy_cli-2.0.1a5}/src/katalyst_taxonomy_cli/commands/config_sources.py

@@ -109,9 +109,7 @@ def config_status(offline: bool, fmt: str) -> None:
         ["profile", "source", "pin", "fetched", "upstream"],
         [
             [
-                row.profile
-                if row.source_profile == row.profile
-                else f"{row.profile} ({row.source_profile})",
+                _profile_label(row),
                 row.source,
                 _short(row.pin) if row.pin else "never fetched",
                 row.fetched_at or "-",
@@ -125,6 +123,14 @@ def config_status(offline: bool, fmt: str) -> None:
             out.warning(f"{row.profile}: {row.error}")
 
 
+def _profile_label(row: Any) -> str:
+    if row.source_profile == row.profile:
+        return str(row.profile)
+    if row.pinned_profile and row.pinned_profile != row.source_profile:
+        return f"{row.profile} ({row.source_profile}: {row.pinned_profile})"
+    return f"{row.profile} ({row.source_profile})"
+
+
 def _upstream(row: Any, offline: bool) -> str:
     if offline:
         return "not checked"

{katalyst_taxonomy_cli-2.0.1a3 → katalyst_taxonomy_cli-2.0.1a5}/src/katalyst_taxonomy_cli/commands/core.py

@@ -23,6 +23,12 @@
                                        the diff
     kata core schema archive --bundle B
                                        archive the current modules as the released version
+    kata core schema docs [PATH...] [--bundle B] [--check] [--kind K]
+                                       write the generated field tables of the pages
+                                       under PATH; --check fails when any is stale
+    kata core schema changelog [--bundle B] [--from VERSION]
+                                       the "Schema changes" section of a release: what was
+                                       added, what broke, and the migration step for each
 
 Records and graphs are read against every installed module (``katalyst_core.modules``).
 """
@@ -466,3 +472,118 @@ def schema_archive(bundle: str) -> None:
     except (FileExistsError, SchemaVersionMismatchError) as exc:
         raise click.ClickException(str(exc)) from exc
     click.echo(f"Archived {release.name} {release.version} in {target}")
+
+
+# Named from the function (``docs``), so no command-name literal reads as a bundle name.
+@schema.command()
+@click.argument("paths", nargs=-1, type=click.Path(exists=True, path_type=Path))
+@click.option(
+    "--bundle",
+    "bundle",
+    default=None,
+    help="Read kinds from this schema only (needed when two define the same kind).",
+)
+@click.option(
+    "--check",
+    is_flag=True,
+    help="Write nothing; fail when a generated region is stale (for CI).",
+)
+@click.option(
+    "--kind",
+    "kind",
+    default=None,
+    help="Print the markdown for one kind (to start a page), and write nothing.",
+)
+def docs(paths: tuple[Path, ...], bundle: str | None, check: bool, kind: str | None) -> None:
+    """Write the generated field tables of the markdown pages under PATH.
+
+    A page marks where a table goes with a line of its own, ``<!-- generated:kind:NAME -->``
+    (a kind's parent and fields: type, required, allowed values, references and their
+    relationship types, descriptions) or ``<!-- generated:wing:NAME -->`` (a wing's kinds:
+    where each is stored and its parent), and closes it with ``<!-- /generated -->``. The
+    text between is rewritten from the schemas' LinkML modules; everything else on the page
+    is yours.
+    """
+    from katalyst_engine.schema_docs import (
+        DocsError,
+        RegionError,
+        catalog_from_releases,
+        page_files,
+        refresh_page,
+        render_kind,
+    )
+
+    if kind is None and not paths:
+        raise click.UsageError("name the pages to write: one or more files or directories")
+    catalog = catalog_from_releases(_releases(bundle))
+    try:
+        if kind is not None:
+            click.echo(render_kind(catalog.kind(kind, bundle=bundle)))
+            return
+        stale_total = 0
+        for page in page_files(paths):
+            text = page.read_text(encoding="utf-8")
+            try:
+                new_text, stale = refresh_page(text, catalog, bundle=bundle)
+            except (RegionError, DocsError) as exc:
+                raise click.ClickException(f"{page}: {exc}") from exc
+            stale_total += len(stale)
+            for region in stale:
+                click.echo(f"{page}:{region.line}: generated:{region.label} is stale")
+            if stale and not check:
+                page.write_text(new_text, encoding="utf-8")
+    except DocsError as exc:
+        raise click.ClickException(str(exc)) from exc
+    if check:
+        if stale_total:
+            raise click.ClickException(
+                f"{stale_total} generated region(s) are stale; "
+                f"run kata core schema docs {' '.join(str(p) for p in paths)}"
+            )
+        click.echo("generated regions are current")
+    else:
+        click.echo(f"Updated {stale_total} generated region(s)")
+
+
+@schema.command("changelog")
+@_BUNDLE
+@click.option(
+    "--from",
+    "since",
+    default=None,
+    help="The archived version to compare with (default: the latest).",
+)
+@click.option(
+    "--heading-level",
+    "level",
+    type=click.IntRange(1, 5),
+    default=2,
+    show_default=True,
+    help="The level of the section's heading (2: ##).",
+)
+def schema_changelog(bundle: str | None, since: str | None, level: int) -> None:
+    """The "Schema changes" section of a release, from the classified diff and the migration.
+
+    For each schema whose modules changed since its last archived version: what was added,
+    what broke, and for each breaking change the `kata tax migrate` step that handles it
+    (or the reason it is accepted). Markdown on stdout, for the release notes.
+    """
+    from katalyst_engine.core.version import Version
+    from katalyst_engine.evolution import build_changelog, render_changelog
+
+    logs: list[Any] = []
+    for release in _releases(bundle):
+        try:
+            old = Version.parse(since) if since else None
+            log = build_changelog(release, old)
+        except (ValueError, FileNotFoundError) as exc:
+            raise click.ClickException(str(exc)) from exc
+        if log is None:
+            click.echo(f"{release.name}: no released version is archived", err=True)
+        else:
+            logs.append(log)
+    text = render_changelog(logs, level=level)
+    if not text:
+        click.echo("No schema changes since the last released version.", err=True)
+        return
+    click.echo(text, nl=False)

{katalyst_taxonomy_cli-2.0.1a3 → katalyst_taxonomy_cli-2.0.1a5}/src/katalyst_taxonomy_cli/commands/create.py

@@ -41,7 +41,24 @@ from katalyst_taxonomy_cli.context import CliContext
     "from_file",
     default=None,
     metavar="PATH",
-    help="Spec fields from a YAML or JSON file (- for stdin); --set applies over them.",
+    help=(
+        "Spec fields from a YAML or JSON file (- for stdin), or a whole document's spec, "
+        "labels and annotations; --set, --label and --annotation apply over them."
+    ),
+)
+@click.option(
+    "--label",
+    "label_pairs",
+    multiple=True,
+    metavar="KEY=VALUE",
+    help="Set a label (metadata.labels), which filters and permission grants match. Repeat.",
+)
+@click.option(
+    "--annotation",
+    "annotation_pairs",
+    multiple=True,
+    metavar="KEY=VALUE",
+    help="Set an annotation (metadata.annotations), a record nothing matches on. Repeat.",
 )
 @click.option("--target-dir", default=None, help="Override output directory.")
 @click.option(
@@ -75,6 +92,8 @@ def create(
     scaffold_variant: str | None,
     set_fields: tuple[str, ...],
     from_file: str | None,
+    label_pairs: tuple[str, ...],
+    annotation_pairs: tuple[str, ...],
     target_dir: str | None,
     backend_target: str | None,
     dry_run: bool,
@@ -96,6 +115,11 @@ def create(
     a value of its type (boolean, integer, list, map) and allowed values, a reference
     naming a node of the referenced kind.
 
+    --label KEY=VALUE and --annotation KEY=VALUE go in the node's metadata, on any kind.
+    A key is a name of letters, digits, '-', '_' and '.' (at most 63), optionally after a
+    DNS prefix and '/' (example.org/team); a label's value is such a name (or empty), an
+    annotation's any text.
+
     Examples:
 
         kata tax create layer api --under shop.backend --set audited=false --set tier=gold
@@ -105,15 +129,20 @@ def create(
         kata tax create capability checkout --under shop --set 'hooks=[{"on":"push","branches":["main"]}]'
 
         kata tax create stack web --under shop --set limits.log_level=debug
+
+        kata tax create layer api --under shop.backend --label team=payments --annotation source=docs/api.md
     """
     from katalyst_taxonomy.adapters.orchestration import run_create
     from katalyst_taxonomy.config.routing import split_backend_prefix
 
-    from katalyst_taxonomy_cli.fields import parse_set, read_spec_file
+    from katalyst_taxonomy_cli.fields import parse_pairs, parse_set, read_node_file
 
     from .._wiring import resolve_backend
 
     resolved_parent = parent or parent_alt
+    node_file = read_node_file(from_file)
+    labels = {**node_file.labels, **parse_pairs(label_pairs, option="--label")}
+    annotations = {**node_file.annotations, **parse_pairs(annotation_pairs, option="--annotation")}
 
     # The backend is `--backend`, or the `backend:` prefix of NAME. Without either, the
     # repository is the one the current directory is inside — even with one repository,
@@ -134,7 +163,9 @@ def create(
         description=description,
         owners=owners or (),
         fields=parse_set(set_fields),
-        spec=read_spec_file(from_file),
+        spec=node_file.spec,
+        labels=labels,
+        annotations=annotations,
         parent=resolved_parent,
         scaffold_variant=scaffold_variant,
         target_dir=target_dir,

{katalyst_taxonomy_cli-2.0.1a3 → katalyst_taxonomy_cli-2.0.1a5}/src/katalyst_taxonomy_cli/commands/lifecycle.py

@@ -101,27 +101,43 @@ def restore(ctx: CliContext, address: str, backend_target: str | None) -> None:
 def import_(ctx: CliContext, file: Path, backend_target: str) -> None:
     """Create every node document of FILE (a YAML stream) in the backend, or none of them.
 
-    The whole change set passes the local shapes first, with the nodes it refers to;
-    then the nodes are created parents first, each as ``kata tax create`` creates it.
-    If one fails, the ones already created are removed again.
+    The stream is one change set: a reference resolves against every node in it as well
+    as the backend, and the whole set passes the reference checks and the local shapes
+    first. Then the nodes are created, each as ``kata tax create`` creates it, after the
+    nodes it needs (its parent, the nodes it refers to). If one fails, the ones already
+    created are removed again; so are those of an import that was killed part-way, by
+    the next one.
     """
     import yaml
-    from katalyst_taxonomy.adapters.orchestration import create_node
-    from katalyst_taxonomy.services.change_import import ImportError_, import_documents
+    from katalyst_taxonomy.adapters.orchestration import create_node, import_journal
+    from katalyst_taxonomy.services.change_import import (
+        ImportError_,
+        import_documents,
+        recover_import,
+    )
 
     from .._wiring import resolve_backend
 
     resolved = resolve_backend(ctx, backend_target)
     documents = [d for d in yaml.safe_load_all(file.read_text(encoding="utf-8")) if d]
+    journal = import_journal(resolved.backend)
     try:
+        rolled_back = recover_import(resolved.backend, journal)
+        if rolled_back:
+            ctx.output.echo(
+                "Rolled back an import that stopped part-way; removed: " + ", ".join(rolled_back)
+            )
         created = import_documents(
             resolved.backend,
             [cast("dict[str, Any]", d) for d in documents],
             create=lambda request: create_node(resolved.backend, request),
+            source=file,
+            journal=journal,
         )
     except ImportError_ as exc:
         ctx.output.echo(f"Error: {exc}")
-        ctx.output.echo("Error: nothing was imported.")
+        if not exc.left_behind:
+            ctx.output.echo("Error: nothing was imported.")
         raise SystemExit(1) from exc
     for fqtn in created:
         ctx.output.echo(f"Imported: {resolved.name}:{fqtn}")

{katalyst_taxonomy_cli-2.0.1a3 → katalyst_taxonomy_cli-2.0.1a5}/src/katalyst_taxonomy_cli/commands/plugin.py

@@ -79,7 +79,11 @@ def add_plugin(ctx: CliContext, source_uri: str, yes: bool) -> None:
 @click.option("--json", "as_json", is_flag=True, help="Machine-readable output.")
 @click.pass_obj
 def list_plugins(ctx: CliContext, as_json: bool) -> None:
-    """List plugins: entry-point packages and source installs, with their state."""
+    """List plugins: entry-point packages and source installs, with their state.
+
+    A plugin whose declared schema ranges the loaded schemas don't satisfy is
+    refused: listed, not activated, with the range and the loaded version.
+    """
     from katalyst_taxonomy.plugins.activation import current_activation
     from katalyst_taxonomy.plugins.registry import ORIGIN_SOURCE
     from katalyst_taxonomy.services.source_providers import declared_plugin_sources
@@ -102,6 +106,8 @@ def list_plugins(ctx: CliContext, as_json: bool) -> None:
                     "source": declared.get(name),
                     "enabled": activation.selection.is_enabled(name),
                     "active": activation.activated(name),
+                    "schemas": dict(manifest.schemas),
+                    "refused": activation.refused(name) or None,
                 }
             )
     for name, source in declared.items():
@@ -114,6 +120,8 @@ def list_plugins(ctx: CliContext, as_json: bool) -> None:
                     "source": source,
                     "enabled": activation.selection.is_enabled(name) if activation else True,
                     "active": False,
+                    "schemas": {},
+                    "refused": None,
                 }
             )
     rows.sort(key=lambda row: str(row["name"]))
@@ -125,9 +133,16 @@ def list_plugins(ctx: CliContext, as_json: bool) -> None:
         return
     ctx.output.echo(f"Plugins ({len(rows)}):")
     for row in rows:
-        state = "active" if row["active"] else ("enabled" if row["enabled"] else "disabled")
+        if row["active"]:
+            state = "active"
+        elif row["refused"]:
+            state = "refused"
+        else:
+            state = "enabled" if row["enabled"] else "disabled"
         source = f"  [{row['source']}]" if row["source"] else ""
         ctx.output.echo(f"  {row['name']}  v{row['version']}  {row['origin']}  {state}{source}")
+        if row["refused"]:
+            ctx.output.echo(f"    {row['refused']}")
 
 
 @plugin.command("remove")