katalyst-taxonomy-cli 2.0.1a1__py3-none-any.whl

katalyst_taxonomy_cli/commands/backend.py

@@ -0,0 +1,96 @@
+"""kata tax backend — inspect backends and refresh a remote (github, git) backend's snapshot."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import click
+
+from katalyst_taxonomy_cli.context import CliContext
+
+
+@click.group("backend")
+def backend() -> None:
+    """Backend operations: status, and refreshing a github or git backend."""
+
+
+def _source(payload: dict[str, Any]) -> str:
+    """What the backend reads: ``owner/name`` (github) or the redacted URL (git)."""
+    return str(payload.get("repo") or payload.get("url") or "?")
+
+
+def _render(ctx: CliContext, payload: dict[str, Any], *, heading: str) -> None:
+    if ctx.output_format == "json":
+        ctx.output.json_out(payload)
+        return
+    ctx.output.echo(heading)
+    # Rendered from the fields the backend's status reports — a git remote is a ``url``,
+    # a github repository a ``repo`` — never from its type.
+    by_url = "url" in payload
+    rows = [
+        ("backend", str(payload.get("backend"))),
+        ("type", str(payload.get("type"))),
+        ("url" if by_url else "repo", _source(payload)),
+        (
+            "ref",
+            str(payload.get("ref") or ("(remote HEAD)" if by_url else "(default branch)")),
+        ),
+        ("path", str(payload.get("path") or "(repository root)")),
+        ("sha", str(payload.get("sha") or "(not fetched)")),
+        ("refresh", f"{payload.get('refreshSeconds')}s"),
+    ]
+    if "depth" in payload:
+        rows.append(("depth", "full" if payload.get("depth") == 0 else str(payload.get("depth"))))
+    if "auth" in payload:
+        rows.append(
+            (
+                "auth",
+                "embedded in the url (redacted)"
+                if payload.get("auth") == "url"
+                else "git (ssh-agent, ~/.ssh/config, credential helpers)",
+            )
+        )
+    if "tokenSource" in payload:
+        rows.append(("token", str(payload.get("tokenSource"))))
+    if "changed" in payload:
+        rows.append(("changed", "yes" if payload["changed"] else "no"))
+    if payload.get("lastError"):
+        rows.append(("last error", str(payload["lastError"])))
+    ctx.output.key_value(rows)
+
+
+@backend.command("refresh")
+@click.argument("name")
+@click.pass_obj
+def refresh(ctx: CliContext, name: str) -> None:
+    """Re-check github or git backend NAME's ref now, fetching the new tree if it moved.
+
+    A remote backend serves a cached snapshot and re-checks its ref once its
+    ``refresh`` window passes; this re-checks immediately. Nothing is written to the
+    repository, the remote or the configuration.
+    """
+    from katalyst_taxonomy.adapters.orchestration import refresh_backend
+
+    try:
+        payload = refresh_backend(ctx.cwd, name, profile=ctx.profile)
+    except ValueError as exc:
+        raise click.ClickException(str(exc)) from exc
+    sha = str(payload.get("sha") or "")[:12]
+    verb = "updated to" if payload.get("changed") else "unchanged at"
+    _render(ctx, payload, heading=f"Refreshed {name}: {_source(payload)} {verb} {sha}")
+
+
+@backend.command("status")
+@click.argument("name")
+@click.pass_obj
+def status(ctx: CliContext, name: str) -> None:
+    """Show what github or git backend NAME is serving, without fetching."""
+    from katalyst_taxonomy.adapters.orchestration import refreshable_backend
+
+    from .._wiring import load_registry
+
+    try:
+        inner = refreshable_backend(load_registry(ctx), name)
+    except ValueError as exc:
+        raise click.ClickException(str(exc)) from exc
+    _render(ctx, inner.status(), heading=f"Backend {name}")

katalyst_taxonomy_cli/commands/bundle.py

@@ -0,0 +1,106 @@
+"""kata tax bundle — manage schema bundles installed from a source (add / list / remove)."""
+
+from __future__ import annotations
+
+import click
+
+from katalyst_taxonomy_cli._wiring import create_bundle_service
+from katalyst_taxonomy_cli.context import CliContext
+
+
+@click.group("bundle")
+def bundle() -> None:
+    """Manage schema bundles installed from a source.
+
+    Bundles are fetched from PyPI, git, GitHub, or a local path into the shared source
+    cache, then path-imported and registered into the taxonomy at runtime. The pinned
+    source (an exact commit or version) is recorded in config.yaml's spec.schemas, so
+    every process — and every machine with that config — loads the same bundle.
+    """
+
+
+@bundle.command("add")
+@click.argument("source_uri")
+@click.option("-y", "--yes", is_flag=True, help="Skip the confirmation prompt.")
+@click.pass_obj
+def add_bundle(ctx: CliContext, source_uri: str, yes: bool) -> None:
+    """Install a schema bundle from SOURCE_URI.
+
+    SOURCE_URI may be:
+
+        pypi:<name>[==<version>]      e.g. pypi:acme-bundle==1.2.0
+
+        git:<url>[@<ref>]             e.g. git:git@github.com:acme/b.git@v1
+
+        github:<owner>/<repo>[@<ref>] e.g. github:acme/bundle@v1.0.0
+
+        file://<path> or a local path
+
+    git:, github: and file:// take an optional trailing #path=<sub/dir> for a
+    bundle in a subdirectory (monorepo), e.g. github:acme/mono@v2#path=bundles/acme.
+    A private github: repository reads GITHUB_TOKEN / GH_TOKEN, then `gh auth token`.
+
+    A git:/github: ref is pinned to its commit and a pypi: name to its version in
+    config.yaml. Installing executes the bundle's Python at load time. Only bundles
+    that depend solely on katalyst-engine are accepted.
+    """
+    from katalyst_taxonomy.services.bundle_service import install_bundle
+
+    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):
+            ctx.output.echo("Aborted.")
+            raise SystemExit(1)
+
+    try:
+        result = install_bundle(create_bundle_service(), source_uri)
+    except Exception as exc:  # noqa: BLE001
+        ctx.output.echo(f"Error: {exc}")
+        raise SystemExit(1) from exc
+
+    kinds = ", ".join(result.provided_kinds) or "(none)"
+    ctx.output.echo(
+        f"Installed bundle '{result.fqn}' v{result.version}\n"
+        f"  source: {result.resolved_source}\n"
+        f"  kinds:  {kinds}"
+    )
+
+
+@bundle.command("list")
+@click.pass_obj
+def list_bundles(ctx: CliContext) -> None:
+    """List schema bundles declared with a source in config.yaml."""
+    from katalyst_taxonomy.services.source_providers import source_bundle_infos
+    from katalyst_taxonomy.sources.bundle_sources import shown_source
+    from katalyst_taxonomy.sources.cache import is_pinned
+
+    bundles = [i for i in source_bundle_infos(ctx.profile) if i.state != "not-a-bundle"]
+    if not bundles:
+        ctx.output.echo("No schema bundles installed from a source.")
+        return
+    ctx.output.echo(f"Schema bundles from sources ({len(bundles)}):")
+    for b in bundles:
+        version = f"  v{b.version}" if b.version else ""
+        kinds = ", ".join(b.provided_kinds) or "(none)"
+        pin = "pinned" if is_pinned(b.source) else "unpinned"
+        ctx.output.echo(
+            f"  {b.name or b.fqn or '(unnamed)'}{version}  [{shown_source(b.source)}]  "
+            f"{pin}, {b.state}  kinds: {kinds}"
+        )
+
+
+@bundle.command("remove")
+@click.argument("name")
+@click.pass_obj
+def remove_bundle(ctx: CliContext, name: str) -> None:
+    """Remove a schema bundle installed from a source, by name or FQN."""
+    from katalyst_taxonomy.services.bundle_service import remove_bundle as remove
+
+    result = remove(name)
+    if not result.success:
+        ctx.output.echo(f"Error: {result.error}")
+        raise SystemExit(1)
+    ctx.output.echo(f"Removed bundle '{result.name}' ({result.source_uri}).")

katalyst_taxonomy_cli/commands/clone.py

@@ -0,0 +1,68 @@
+"""kata tax clone — Clone an existing taxonomy node."""
+
+from __future__ import annotations
+
+import click
+
+from katalyst_taxonomy_cli.context import CliContext
+
+
+@click.command("clone")
+@click.argument("node_type")
+@click.argument("source_name")
+@click.argument("target_name")
+@click.option("--source-system", default=None, help="Source system name.")
+@click.option("--source-subsystem", default=None, help="Source subsystem name.")
+@click.option("--source-stack", default=None, help="Source stack name.")
+@click.option("--target-system", default=None, help="Target system name.")
+@click.option("--target-subsystem", default=None, help="Target subsystem name.")
+@click.option("--target-stack", default=None, help="Target stack name.")
+@click.option("--description", default=None, help="New description for cloned node.")
+@click.option("-y", "--yes", "non_interactive", is_flag=True, help="Non-interactive mode.")
+@click.option(
+    "--backend",
+    "backend",
+    default=None,
+    help=(
+        "Filesystem backend (repository) to clone within. Defaults to the profile's only "
+        "filesystem backend, else the one the current directory is inside."
+    ),
+)
+@click.pass_obj
+def clone(
+    ctx: CliContext,
+    node_type: str,
+    source_name: str,
+    target_name: str,
+    source_system: str | None,
+    source_subsystem: str | None,
+    source_stack: str | None,
+    target_system: str | None,
+    target_subsystem: str | None,
+    target_stack: str | None,
+    description: str | None,
+    non_interactive: bool,
+    backend: str | None,
+) -> None:
+    """Clone an existing taxonomy node to a new name, within one repository."""
+    from katalyst_taxonomy.adapters.orchestration import run_clone
+    from katalyst_taxonomy.services.permissions import refuse_read_only_addresses
+
+    # A source or target in a read-only backend (github, git) is refused before any
+    # repository is chosen: naming one is the error, not an ambiguity.
+    refuse_read_only_addresses(ctx.cwd, "clone", source_name, target_name, profile=ctx.profile)
+    exit_code = run_clone(
+        path=ctx.repository(backend).root,
+        node_type=node_type,
+        source_name=source_name,
+        target_name=target_name,
+        source_system=source_system,
+        source_stack=source_stack,
+        target_system=target_system,
+        target_stack=target_stack,
+        description=description,
+        yes=non_interactive,
+        output=None,
+        err_output=None,
+    )
+    raise SystemExit(exit_code)