katalyst-taxonomy-cli 2.0.1a7__tar.gz → 2.0.1a8__tar.gz

{katalyst_taxonomy_cli-2.0.1a7 → katalyst_taxonomy_cli-2.0.1a8}/PKG-INFO

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

{katalyst_taxonomy_cli-2.0.1a7 → katalyst_taxonomy_cli-2.0.1a8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "katalyst-taxonomy-cli"
-version = "2.0.1a7"
+version = "2.0.1a8"
 description = "CLI for katalyst-taxonomy — the kata command"
 license = { text = "Proprietary" }
 requires-python = ">=3.12"
@@ -41,3 +41,37 @@ packages = ["src/katalyst_taxonomy_cli"]
 
 [tool.hatch.build.targets.wheel.sources]
 "src" = ""
+
+[dependency-groups]
+dev = [
+    "katalyst-test-bundle",
+    "pytest>=8.2",
+    "pytest-cov>=5.0",
+    "ruff>=0.5",
+    "pyright>=1.1",
+]
+
+[tool.pytest.ini_options]
+addopts = ["-ra"]
+testpaths = ["tests"]
+pythonpath = ["src"]
+
+[tool.ruff]
+target-version = "py312"
+line-length = 100
+# As at the repository root, no first-party sources: every import sorts as a third-party one.
+src = []
+
+[tool.ruff.lint]
+select = ["E4", "E7", "E9", "F", "B", "I"]
+
+[tool.ruff.format]
+quote-style = "double"
+
+[tool.pyright]
+include = ["src", "tests"]
+exclude = ["**/node_modules", "**/__pycache__", "**/.*"]
+venvPath = "."
+venv = ".venv"
+pythonVersion = "3.12"
+typeCheckingMode = "strict"

katalyst_taxonomy_cli-2.0.1a8/src/Justfile

@@ -0,0 +1,2 @@
+# katalyst-taxonomy-cli: the Circuit's recipes, run from the package directory (cli/).
+import '../../scripts/package.just'

{katalyst_taxonomy_cli-2.0.1a7 → katalyst_taxonomy_cli-2.0.1a8}/src/katalyst_taxonomy_cli/app.py

@@ -413,6 +413,7 @@ def tax(
         profile=profile,
     )
     _register_source_providers(profile)
+    _report_pending_sources()
     if ctx.invoked_subcommand == "plugin":
         # `kata tax plugin remove` is how a broken source plugin is taken out; a plugin
         # that will not activate must not stop the command that removes it.
@@ -469,6 +470,24 @@ def _register_source_providers(profile: str | None) -> None:
     ensure_source_providers(True, profile=profile)
 
 
+def _report_pending_sources() -> None:
+    """Say which plugins and schema bundles a sourced profile declares that are not loaded.
+
+    Loading one runs its code, so it waits for the user to accept it
+    (:mod:`katalyst_taxonomy.services.source_consent`). This only reports, on stderr and
+    never failing the command; ``kata config sync`` is where it is accepted.
+    """
+    from katalyst_taxonomy.adapters.orchestration import pending_source_declarations
+
+    for declaration in pending_source_declarations():
+        click.echo(
+            f"{declaration.describe()}; it is not loaded, because it runs code. Run "
+            f"'kata config sync {declaration.profile}' to review and accept it, or "
+            f"'{declaration.install_command} {declaration.shown_source}' to install it yourself.",
+            err=True,
+        )
+
+
 # ---------------------------------------------------------------------------
 # Plugin activation (#219)
 # ---------------------------------------------------------------------------

{katalyst_taxonomy_cli-2.0.1a7 → katalyst_taxonomy_cli-2.0.1a8}/src/katalyst_taxonomy_cli/commands/bundle.py

@@ -45,13 +45,11 @@ def add_bundle(ctx: CliContext, source_uri: str, yes: bool) -> None:
     that depend solely on katalyst-engine are accepted.
     """
     from katalyst_taxonomy.services.bundle_service import install_bundle
+    from katalyst_taxonomy.services.source_consent import CONFIRM_PROMPT, consent_notice
 
     if not yes:
-        click.echo(
-            "Installing a remote bundle path-imports and executes its Python code.\n"
-            f"Source: {source_uri}"
-        )
-        if not click.confirm("Proceed?", default=False):
+        click.echo(consent_notice("schemas", source_uri))
+        if not click.confirm(CONFIRM_PROMPT, default=False):
             ctx.output.echo("Aborted.")
             raise SystemExit(1)
 
@@ -90,6 +88,10 @@ def list_bundles(ctx: CliContext) -> None:
             f"  {b.name or b.fqn or '(unnamed)'}{version}  [{shown_source(b.source)}]  "
             f"{pin}, {b.state}  kinds: {kinds}"
         )
+        if b.error:
+            ctx.output.echo(f"    error: {b.error}")
+    if any(b.state == "failed" for b in bundles):
+        ctx.output.echo("A failed bundle is skipped. `kata tax bundle remove <name>` drops it.")
 
 
 @bundle.command("remove")

{katalyst_taxonomy_cli-2.0.1a7 → katalyst_taxonomy_cli-2.0.1a8}/src/katalyst_taxonomy_cli/commands/config_sources.py

@@ -15,6 +15,7 @@ other command reads the pinned copy.
 
 from __future__ import annotations
 
+from collections.abc import Callable
 from typing import TYPE_CHECKING, Any
 
 import click
@@ -22,6 +23,7 @@ import click
 from ..output import ConsoleOutput, OutputPort
 
 if TYPE_CHECKING:  # pragma: no cover - typing only
+    from katalyst_taxonomy.config.profile_sources import SourceDeclaration
     from katalyst_taxonomy.services.config_sources import SourceStatus, SourceSync
 
 __all__ = ["attach"]
@@ -42,22 +44,55 @@ def _short(pin: str | None) -> str:
     return pin[:12] if len(pin) in (40, 64) else pin
 
 
+def _asker(out: OutputPort, *, yes: bool, interactive: bool) -> Callable[[SourceDeclaration], bool]:
+    """What decides, per declaration, whether the user accepts code from a source."""
+    from katalyst_taxonomy.services.source_consent import CONFIRM_PROMPT, consent_notice
+
+    def ask(declaration: SourceDeclaration) -> bool:
+        if yes:
+            return True
+        if not interactive:
+            return False
+        out.info(declaration.describe() + ".")
+        click.echo(consent_notice(declaration.section, declaration.source))
+        try:
+            return click.confirm(CONFIRM_PROMPT, default=False)
+        except click.Abort:
+            click.echo()
+            return False
+
+    return ask
+
+
 @click.command("sync")
 @click.argument("names", nargs=-1, metavar="[PROFILE]...")
 @click.option("--format", "fmt", type=_FORMAT_CHOICE, default="text")
-def config_sync(names: tuple[str, ...], fmt: str) -> None:
+@click.option(
+    "-y",
+    "--yes",
+    is_flag=True,
+    help="Accept every plugin and schema bundle a profile declares, without asking.",
+)
+def config_sync(names: tuple[str, ...], fmt: str, yes: bool) -> None:
     """Fetch every sourced profile (or each PROFILE) and pin it.
 
     A git source is pinned to its commit, a kata API to its ETag or content hash. Each
     repository a sourced profile's filesystem backends name is found under
     spec.workspace by its remote URL, or cloned there. Exits 1 if any fetch failed; a
     failed one keeps its previous pin.
+
+    A plugin or schema bundle with a source that a profile declares runs code when it is
+    loaded, so it is not loaded until you accept it: this asks about each one that is new
+    (or whose pin changed), as 'kata tax plugin add' does. A declined one stays unloaded
+    and is asked about again at the next sync. With --format json nothing is asked; only
+    --yes accepts.
     """
     from katalyst_taxonomy.adapters.orchestration import sync_config_sources
 
     out = _output()
+    accept = _asker(out, yes=yes, interactive=fmt == "text")
     try:
-        results: list[SourceSync] = sync_config_sources(names)
+        results: list[SourceSync] = sync_config_sources(names, accept=accept)
     except ValueError as exc:
         raise click.ClickException(str(exc)) from exc
     if fmt == "json":
@@ -79,6 +114,14 @@ def config_sync(names: tuple[str, ...], fmt: str) -> None:
         for clone in result.clones:
             how = "cloned to" if clone.cloned else "using"
             out.info(f"  {clone.repository}: {how} {clone.path}")
+        for declaration in result.accepted:
+            out.info(f"  Accepted {declaration.kind} {declaration.name!r}.")
+        for declaration in result.pending:
+            out.warning(
+                f"Not accepted: {declaration.kind} {declaration.name!r} from "
+                f"{declaration.shown_source}. It is not loaded; 'kata config sync "
+                f"{result.profile}' asks again."
+            )
     if any(not r.ok for r in results):
         raise SystemExit(1)
 

{katalyst_taxonomy_cli-2.0.1a7 → katalyst_taxonomy_cli-2.0.1a8}/src/katalyst_taxonomy_cli/commands/create.py

@@ -71,6 +71,16 @@ from katalyst_taxonomy_cli.context import CliContext
         "it must be named."
     ),
 )
+@click.option(
+    "--force",
+    is_flag=True,
+    default=False,
+    help=(
+        "Create it in a state the lifecycle does not start a node in, or without the "
+        "fields and links the state's gate needs. Needs --reason; recorded in the node."
+    ),
+)
+@click.option("--reason", default="", help="With --force: why the lifecycle is overridden.")
 @click.option(
     "--dry-run",
     is_flag=True,
@@ -96,6 +106,8 @@ def create(
     annotation_pairs: tuple[str, ...],
     target_dir: str | None,
     backend_target: str | None,
+    force: bool,
+    reason: str,
     dry_run: bool,
 ) -> None:
     """Create a NODE_TYPE node called NAME, in the backend --backend names.
@@ -115,6 +127,9 @@ def create(
     a value of its type (boolean, integer, list, map) and allowed values, a reference
     naming a node of the referenced kind.
 
+    A node starts active, or as a draft (--set lifecycle_state=draft); the lifecycle and
+    the gates of its kind are held on create as on update.
+
     --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
@@ -139,6 +154,8 @@ def create(
 
     from .._wiring import resolve_backend
 
+    if force and not reason.strip():
+        raise click.UsageError("--force needs --reason: a forced move is recorded with why.")
     resolved_parent = parent or parent_alt
     node_file = read_node_file(from_file)
     labels = {**node_file.labels, **parse_pairs(label_pairs, option="--label")}
@@ -171,6 +188,8 @@ def create(
         target_dir=target_dir,
         profile=ctx.profile,
         dry_run=dry_run,
+        force=force,
+        reason=reason,
     )
     if exit_code != 0:
         raise SystemExit(exit_code)

katalyst_taxonomy_cli-2.0.1a8/src/katalyst_taxonomy_cli/commands/drafts.py

@@ -0,0 +1,103 @@
+"""kata tax drafts — List the drafts: nodes in a draft state, and a promotable backend's draft rows."""
+
+from __future__ import annotations
+
+import click
+
+from katalyst_taxonomy_cli.context import CliContext
+
+
+@click.command("drafts")
+@click.option(
+    "--schema", "show_schema", is_flag=True, help="Show draft schema definitions instead of nodes."
+)
+@click.option(
+    "--backend",
+    "backend_target",
+    default=None,
+    help="Backend to operate on.",
+)
+@click.pass_obj
+def drafts(
+    ctx: CliContext,
+    show_schema: bool,
+    backend_target: str | None,
+) -> None:
+    """List the drafts.
+
+    On any backend, a draft is a node in a draft state of its lifecycle
+    (``lifecycle_state: draft``): written, not accepted, and left out of normal reads.
+    Move it on with ``kata tax update --set lifecycle_state=…``. Without --backend, the
+    drafts of every backend the profile reads.
+
+    On a promotable backend (Databricks) the rows synced or created but not yet promoted
+    to active are listed too, and --schema lists draft schema definitions. Those rows are
+    a backend revision, not a lifecycle state; ``kata tax promote`` moves them.
+
+    Examples:
+
+        kata tax drafts
+
+        kata tax drafts --backend local
+
+        kata tax drafts --schema
+    """
+    from katalyst_taxonomy.ports.backend import PromotableBackend
+
+    from .._wiring import resolve_backend, resolve_promotable_backend
+
+    if not show_schema and (
+        backend_target is None
+        or not isinstance(resolve_backend(ctx, backend_target).backend, PromotableBackend)
+    ):
+        _list_draft_nodes(ctx, backend_target)
+        return
+
+    _, backend, _ = resolve_promotable_backend(ctx, backend_target)
+
+    if show_schema:
+        items = backend.list_draft_schema()
+        label = "Draft schema definitions"
+    else:
+        items = backend.list_drafts()
+        label = "Draft nodes"
+
+    if not items:
+        ctx.output.echo(f"No {label.lower()} found.")
+        return
+
+    ctx.output.echo(f"{label} ({len(items)}):")
+    ctx.output.echo("")
+    for item in items:
+        if show_schema:
+            kind = item.get("kind", "?")
+            wing = item.get("wing", "?")
+            ctx.output.echo(f"  [{kind:15s}] wing={wing}")
+        else:
+            fqtn = item.get("fqtn", "?")
+            kind = item.get("kind", "?")
+            name = item.get("name", "?")
+            ctx.output.echo(f"  [{kind:15s}] {name:30s} ({fqtn})")
+
+
+def _list_draft_nodes(ctx: CliContext, backend_target: str | None) -> None:
+    """The nodes of the backend that are in a state the lifecycle hides."""
+    from katalyst_taxonomy.engine.accessors import get_identity_fqtn
+    from katalyst_taxonomy.engine.bridge import get_default_registry
+    from katalyst_taxonomy.services.filters import StateView, narrow_to_states
+
+    from .._wiring import resolve_read
+
+    lifecycle = get_default_registry().lifecycle
+    resolved = resolve_read(ctx, backend_target)
+    nodes = narrow_to_states(
+        tuple(node for _, backend in resolved.sources for node in backend.list_nodes()),
+        StateView(states=lifecycle.hidden),
+    )
+    if not nodes:
+        ctx.output.echo("No draft nodes found.")
+        return
+    ctx.output.echo(f"Draft nodes ({len(nodes)}):")
+    ctx.output.echo("")
+    for node in nodes:
+        ctx.output.echo(f"  [{node.kind:15s}] {node.name:30s} ({get_identity_fqtn(node)})")

{katalyst_taxonomy_cli-2.0.1a7 → katalyst_taxonomy_cli-2.0.1a8}/src/katalyst_taxonomy_cli/commands/lifecycle.py

@@ -24,6 +24,24 @@ from katalyst_taxonomy_cli.context import CliContext
 __all__ = ["delete", "import_", "restore"]
 
 
+_FORCE = click.option(
+    "--force",
+    is_flag=True,
+    help=(
+        "Move the node against the lifecycle (or past a gate of its kind). Needs --reason; "
+        "recorded in the node's provenance."
+    ),
+)
+_REASON = click.option(
+    "--reason", default="", help="With --force: why the lifecycle is overridden."
+)
+
+
+def _check_force(force: bool, reason: str) -> None:
+    if force and not reason.strip():
+        raise click.UsageError("--force needs --reason: a forced move is recorded with why.")
+
+
 def _service(ctx: CliContext, backend_target: str | None, address: str) -> tuple[Any, Any]:
     from katalyst_taxonomy.engine.bridge import get_default_registry
     from katalyst_taxonomy.services.node_lifecycle import NodeLifecycleService
@@ -45,21 +63,33 @@ def _service(ctx: CliContext, backend_target: str | None, address: str) -> tuple
     help="Take the node out of the backend instead of retiring it.",
 )
 @click.option("--dry-run", is_flag=True, help="With --remove: show the impact; change nothing.")
+@_FORCE
+@_REASON
 @click.pass_obj
 def delete(
-    ctx: CliContext, address: str, backend_target: str | None, remove: bool, dry_run: bool
+    ctx: CliContext,
+    address: str,
+    backend_target: str | None,
+    remove: bool,
+    dry_run: bool,
+    force: bool,
+    reason: str,
 ) -> None:
     """Delete the node ADDRESS (``backend:fqtn``) names: retire it, or with --remove, remove it.
 
     A removal follows each referring relationship's delete policy: block (refused),
     cascade (removed too), detach (dropped from the referrer) or redirect (moved to the
     node's replacement). It is shown first with --dry-run, and is all or nothing.
+
+    A retire is a move to the lifecycle's retired state, held to the lifecycle as an
+    update is (--force --reason overrides).
     """
+    _check_force(force, reason)
     service, resolved = _service(ctx, backend_target, address)
     if not remove:
         if dry_run:
             raise click.UsageError("--dry-run goes with --remove; a retire changes one field.")
-        outcome = service.retire(resolved.address)
+        outcome = service.retire(resolved.address, force=force, reason=reason)
         if not outcome.success:
             ctx.output.echo(f"Error: {outcome.error}")
             raise SystemExit(1)
@@ -81,11 +111,20 @@ def delete(
 @click.option(
     "--backend", "backend_target", default=None, help="The backend, when ADDRESS has no prefix."
 )
+@_FORCE
+@_REASON
 @click.pass_obj
-def restore(ctx: CliContext, address: str, backend_target: str | None) -> None:
-    """Return the retired node ADDRESS to service, after the local shapes pass on it."""
+def restore(
+    ctx: CliContext, address: str, backend_target: str | None, force: bool, reason: str
+) -> None:
+    """Return the retired node ADDRESS to service, after the local shapes pass on it.
+
+    Only a retired node is restored; any other state moves with ``kata tax update --set
+    lifecycle_state=STATE``.
+    """
+    _check_force(force, reason)
     service, resolved = _service(ctx, backend_target, address)
-    outcome = service.restore(resolved.address)
+    outcome = service.restore(resolved.address, force=force, reason=reason)
     if not outcome.success:
         ctx.output.echo(f"Error: {outcome.error}")
         raise SystemExit(1)

{katalyst_taxonomy_cli-2.0.1a7 → katalyst_taxonomy_cli-2.0.1a8}/src/katalyst_taxonomy_cli/commands/lint.py

@@ -126,6 +126,7 @@ def lint(ctx: CliContext, verbose: bool, strict: bool, backend: str | None) -> N
         for title, found in (
             ("Undeclared spec keys", result.undeclared_fields),
             ("Misplaced documents", result.misplaced_documents),
+            ("Forced lifecycle moves", result.forced_moves),
             ("Relationships no kind carries", result.uncarried_relationships),
             ("Shape findings", result.shape_findings),
             ("Shape warnings", result.shape_warnings),
@@ -151,6 +152,7 @@ def lint(ctx: CliContext, verbose: bool, strict: bool, backend: str | None) -> N
         + len(result.duplicate_names)
         + len(result.undeclared_fields)
         + len(result.misplaced_documents)
+        + len(result.forced_moves)
         + len(result.uncarried_relationships)
         + len(result.shape_findings)
         + len(result.shape_warnings)

{katalyst_taxonomy_cli-2.0.1a7 → katalyst_taxonomy_cli-2.0.1a8}/src/katalyst_taxonomy_cli/commands/plugin.py

@@ -50,13 +50,12 @@ def add_plugin(ctx: CliContext, source_uri: str, yes: bool) -> None:
     katalyst_taxonomy.plugins entry point and depends only on katalyst-engine and
     katalyst-taxonomy. Installing executes the plugin's Python code.
     """
+    from katalyst_taxonomy.services.source_consent import CONFIRM_PROMPT, consent_notice
     from katalyst_taxonomy.sources.schemes import BUNDLE_SOURCE_SCHEMES, reject_unknown_scheme
 
     if not yes:
-        click.echo(
-            f"Installing a plugin path-imports and executes its Python code.\nSource: {source_uri}"
-        )
-        if not click.confirm("Proceed?", default=False):
+        click.echo(consent_notice("plugins", source_uri))
+        if not click.confirm(CONFIRM_PROMPT, default=False):
             ctx.output.echo("Aborted.")
             raise SystemExit(1)
     try:

{katalyst_taxonomy_cli-2.0.1a7 → katalyst_taxonomy_cli-2.0.1a8}/src/katalyst_taxonomy_cli/commands/query.py

@@ -7,6 +7,7 @@ from typing import TYPE_CHECKING
 import click
 
 from katalyst_taxonomy_cli.context import CliContext
+from katalyst_taxonomy_cli.options import state_options, state_view
 
 if TYPE_CHECKING:  # pragma: no cover - typing only
     from katalyst_engine.model.node import Node
@@ -55,6 +56,7 @@ if TYPE_CHECKING:  # pragma: no cover - typing only
         "(its declaration's holds); each is shown with that directory."
     ),
 )
+@state_options
 @click.pass_obj
 def query(
     ctx: CliContext,
@@ -64,12 +66,18 @@ def query(
     fqtn: str | None,
     name: str | None,
     holds: str | None,
+    include_drafts: bool,
+    state_names: tuple[str, ...],
 ) -> None:
     """Query nodes and relationships from a backend.
 
     Uses the unified TaxonomyBackend.list_nodes() and list_relationships()
     interface — works against any backend implementation.
 
+    A node in a state other than active is marked with it, `(draft)`, `(retired)`. Drafts
+    are left out unless --include-drafts or --state draft asks for them. Asked about one
+    node (--fqtn naming exactly one), the output also says where it may move next.
+
     Examples:
 
         kata tax query --kind tool
@@ -85,6 +93,10 @@ def query(
         kata tax query --fqtn prod-graph:payments
 
         kata tax query --fqtn repo:shop.web --holds ROLE
+
+        kata tax query --state draft
+
+        kata tax query --include-drafts --kind capability
     """
     from .._wiring import resolve_read
 
@@ -131,7 +143,9 @@ def query(
         from katalyst_taxonomy.services.filters import visible_nodes
 
         try:
-            nodes = visible_nodes(ctx.cwd, nodes, profile=ctx.profile)
+            nodes = visible_nodes(
+                ctx.cwd, nodes, profile=ctx.profile, states=state_view(include_drafts, state_names)
+            )
         except ValueError as exc:
             raise click.ClickException(str(exc)) from exc
         held: dict[int, str] = {}
@@ -148,6 +162,12 @@ def query(
         ctx.output.echo(f"Nodes ({len(nodes)}):")
         ctx.output.echo("")
         from katalyst_taxonomy.engine.accessors import get_identity_fqtn
+        from katalyst_taxonomy.engine.bridge import get_default_registry
+        from katalyst_taxonomy.services.lifecycle_rule import LifecycleRule
+
+        registry = get_default_registry()
+        rule = LifecycleRule(registry)
+        lifecycle = registry.lifecycle
 
         for node in nodes:
             # Qualified, because the same name in two backends is two nodes.
@@ -157,9 +177,14 @@ def query(
                 )
                 continue
             desc = (node.description or "")[:55]
-            # A retired node is still in the graph; say so (katalyst-core's lifecycle).
-            retired = " (retired)" if node.spec.get("lifecycle_state") == "retired" else ""
-            ctx.output.echo(f"  [{node.kind:15s}] {get_identity_fqtn(node):40s} {desc}{retired}")
+            # A node out of the default state says so (katalyst-core's lifecycle): `(draft)`,
+            # `(retired)`. Retired nodes are still in the graph; drafts only when asked for.
+            marked = f" ({state})" if (state := rule.state_of(node)) != lifecycle.default else ""
+            ctx.output.echo(f"  [{node.kind:15s}] {get_identity_fqtn(node):40s} {desc}{marked}")
+        if len(nodes) == 1:
+            moves = ", ".join(rule.next_moves(nodes[0])) or "none"
+            ctx.output.echo("")
+            ctx.output.echo(f"State: {rule.state_of(nodes[0])}; may move to: {moves}")
 
 
 def _narrow_to_selected_subtree(

{katalyst_taxonomy_cli-2.0.1a7 → katalyst_taxonomy_cli-2.0.1a8}/src/katalyst_taxonomy_cli/commands/rescaffold.py

@@ -80,6 +80,7 @@ def rescaffold(
     from katalyst_taxonomy.engine.accessors import get_source_path
     from katalyst_taxonomy.engine.qualification import match_fqtn_in
     from katalyst_taxonomy.ports.backend import repository_root_of
+    from katalyst_taxonomy.services.filters import SHOW_ALL_STATES
     from katalyst_taxonomy.services.rescaffold import rescaffold_node
     from katalyst_taxonomy.services.template_install import template_base_resolver
 
@@ -118,7 +119,7 @@ def rescaffold(
         mode=mode,
         dry_run=dry_run,
         create_hooks=create_hooks(),
-        load_taxonomy=lambda: load_taxonomy(root, profile=ctx.profile),
+        load_taxonomy=lambda: load_taxonomy(root, profile=ctx.profile, states=SHOW_ALL_STATES),
     )
     if not outcome.success:
         ctx.output.echo(f"Error: {outcome.error}")

{katalyst_taxonomy_cli-2.0.1a7 → katalyst_taxonomy_cli-2.0.1a8}/src/katalyst_taxonomy_cli/commands/show.py

@@ -5,18 +5,26 @@ from __future__ import annotations
 import click
 
 from katalyst_taxonomy_cli.context import CliContext
+from katalyst_taxonomy_cli.options import state_options, state_view
 
 
 @click.command("show")
 @click.option("--format", "fmt", type=click.Choice(["tree", "list", "json"]), default=None)
+@state_options
 @click.pass_obj
-def show(ctx: CliContext, fmt: str | None) -> None:
-    """Show the taxonomy structure."""
+def show(
+    ctx: CliContext, fmt: str | None, include_drafts: bool, state_names: tuple[str, ...]
+) -> None:
+    """Show the taxonomy structure.
+
+    Drafts are left out unless --include-drafts or --state asks for them.
+    """
     import json as json_module
 
     from katalyst_taxonomy.services.serialization import build_tree_lines, serialize_taxonomy
 
     fmt = fmt or ctx.output_format or "tree"
+    ctx.states = state_view(include_drafts, state_names)
     service = ctx.taxonomy_service
 
     if fmt == "json":