ocmo-cli 0.8.19__py3-none-any.whl

ocmo_cli/commands/item_relocate.py

@@ -0,0 +1,187 @@
+"""Hand-written ``ocmo move item`` and ``ocmo copy item`` commands."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import click
+
+from .._address import (
+    parse_address_or_exit,
+    parse_simple_address_or_exit,
+    resolve_relocate_target,
+)
+from .._click_groups import attach_resource_command, ensure_resource_alias_group
+from .._client import OcmoCtx
+from .._dry_run import format_generated_dry_run
+from .._errors import sdk_command
+from .._exit import USAGE_ERROR
+from .._mutating import run_mutating
+from .._options import dry_run_option, namespace_option, yes_option
+from .._output import err, status
+
+_MOVE_ITEM_HELP = """\
+Move a tree item or folder subtree to a new path.
+
+TARGET uses Unix-style semantics: a trailing ``/`` places the source inside that
+directory (keeping its leaf name); otherwise TARGET is the exact destination path.
+
+\b
+Examples:
+  ocmo -n prod move item app/web app/archive/web
+  ocmo -n prod move item b/c/d a/
+"""
+
+_COPY_ITEM_HELP = """\
+Copy a tree item or folder subtree to a new path.
+
+When SOURCE includes ``@tag`` or ``@version``, that version is copied; otherwise
+the API default tag (``latest``) is used.
+
+TARGET uses Unix-style semantics: a trailing ``/`` places the source inside that
+directory (keeping its leaf name); otherwise TARGET is the exact destination path.
+
+\b
+Examples:
+  ocmo -n prod copy item app/web app/staging/web
+  ocmo -n prod copy item app/web@stable app/staging/
+  ocmo -n prod copy item b/c/d a/
+"""
+
+
+def _parse_source_target(
+    source: str,
+    target: str,
+    *,
+    allow_source_version: bool,
+) -> tuple[str, str | None, str]:
+    source_path, source_version = parse_address_or_exit(source)
+    target_path, target_version = parse_simple_address_or_exit(target)
+    if target_version:
+        err("TARGET does not support @version.")
+        raise SystemExit(USAGE_ERROR)
+
+    if source_version and not allow_source_version:
+        err("SOURCE does not support @version or @tag for move.")
+        raise SystemExit(USAGE_ERROR)
+
+    return source_path, source_version, target_path
+
+
+def _relocate_confirm_message(action: str, source_path: str, destination_path: str) -> str:
+    return f"{action.capitalize()} item {source_path!r} to {destination_path!r}. Continue?"
+
+
+def _relocate_success_message(action: str, source_path: str, destination_path: str) -> str:
+    past = "moved" if action == "move" else "copied"
+    return f"Item {source_path!r} was {past} to {destination_path!r}."
+
+
+def _run_item_relocate(
+    ctx: OcmoCtx,
+    *,
+    op_id: str,
+    action: str,
+    source: str,
+    target: str,
+    namespace: str | None,
+    dry_run: bool,
+    yes: bool,
+    allow_source_version: bool,
+) -> None:
+    source_path, source_version, target_path = _parse_source_target(
+        source,
+        target,
+        allow_source_version=allow_source_version,
+    )
+    destination_path = resolve_relocate_target(source_path, target_path)
+
+    sdk_kwargs: dict[str, Any] = {"target_path": destination_path}
+    if op_id == "copy_item" and source_version:
+        sdk_kwargs["tag_to_copy"] = source_version
+
+    ns = ctx.require_namespace(namespace)
+
+    def _action() -> None:
+        view = ctx.namespace_view(namespace)
+        if op_id == "move_item":
+            view.move_item(source_path, **sdk_kwargs)
+        else:
+            view.copy_item(source_path, **sdk_kwargs)
+        status(_relocate_success_message(action, source_path, destination_path))
+
+    run_mutating(
+        ctx,
+        dry_run=dry_run,
+        yes=yes,
+        plan_lines=format_generated_dry_run(
+            op_id=op_id,
+            action=action,
+            resource="item",
+            path=source_path,
+            version=source_version if op_id == "copy_item" else None,
+            namespace=ns,
+            args=[],
+            kwargs=sdk_kwargs,
+            client_scope=False,
+        ),
+        confirm_message=_relocate_confirm_message(action, source_path, destination_path),
+        action=_action,
+    )
+
+
+def _build_relocate_command(action: str) -> click.Command:
+    help_text = _MOVE_ITEM_HELP if action == "move" else _COPY_ITEM_HELP
+    op_id = "move_item" if action == "move" else "copy_item"
+    allow_source_version = action == "copy"
+
+    @click.command("item", help=help_text)
+    @click.argument("source")
+    @click.argument("target")
+    @namespace_option()
+    @yes_option()
+    @dry_run_option()
+    @click.pass_obj
+    @sdk_command
+    def relocate_cmd(
+        ctx: OcmoCtx,
+        source: str,
+        target: str,
+        namespace: str | None,
+        dry_run: bool,
+        yes: bool,
+    ) -> None:
+        _run_item_relocate(
+            ctx,
+            op_id=op_id,
+            action=action,
+            source=source,
+            target=target,
+            namespace=namespace,
+            dry_run=dry_run,
+            yes=yes,
+            allow_source_version=allow_source_version,
+        )
+
+    return relocate_cmd
+
+
+move_item_cmd = _build_relocate_command("move")
+copy_item_cmd = _build_relocate_command("copy")
+
+
+def register_item_relocate_commands(root: click.Group) -> None:
+    """Register hand-written ``move item`` / ``copy item`` commands."""
+    move_group = ensure_resource_alias_group(
+        root,
+        "move",
+        help="Move items within the tree.",
+    )
+    attach_resource_command(move_group, move_item_cmd, canonical="item", aliases=[])
+
+    copy_group = ensure_resource_alias_group(
+        root,
+        "copy",
+        help="Copy items within the tree.",
+    )
+    attach_resource_command(copy_group, copy_item_cmd, canonical="item", aliases=[])

ocmo_cli/commands/ls.py

@@ -0,0 +1,481 @@
+"""ocmo ls / ocmo tree — list or render the item tree under a path."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Any
+
+import click
+
+from .._address import parse_address_or_exit
+from .._client import OcmoCtx
+from .._errors import sdk_command
+from .._exit import USAGE_ERROR
+from .._ls_wide import (
+    LS_WIDE_SORT_CHOICES,
+    basic_ls_row,
+    enrich_ls_rows,
+    sort_wide_rows,
+)
+from .._options import namespace_option, output_option
+from .._output import as_dict, emit, emit_table, err
+from .._output_manifest import columns_for_format, get_command_spec, resolve_effective_format
+
+if TYPE_CHECKING:
+    from ocmo import NamespaceView, OcmoClient
+
+_LS_HELP = """\
+List the direct children of a tree path, or the namespace root when ADDRESS is omitted.
+
+\b
+Examples:
+  ocmo -n prod ls
+  ocmo -n prod ls app/
+  ocmo -n prod ls app/ -R
+  ocmo -n prod ls app/ --hide-folders
+  ocmo -n prod ls --hide-system
+  ocmo -n prod ls -o json
+  ocmo -n prod ls -o wide
+  ocmo -n prod ls -o wide --sort updated
+  ocmo -n prod ls -o wide --sort created
+  ocmo -n prod ls -o name
+  ocmo -n prod ls -o path
+"""
+
+_TREE_HELP = """\
+Render the subtree under a path in tree format.
+
+\b
+Examples:
+  ocmo -n prod tree
+  ocmo -n prod tree app/
+  ocmo -n prod tree --depth 2
+  ocmo -n prod tree --hide-system
+  ocmo -n prod tree --emoji
+"""
+
+_TREE_TYPE_EMOJI: dict[str, str] = {
+    "folder": "📁",
+    "config": "📄",
+    "template": "📜",
+    "secret": "🔒",
+    "resolver": "⚡",
+}
+
+
+def _navigate(
+    view: NamespaceView,
+    address: str,
+    *,
+    recursive: bool,
+    limit: int | None,
+) -> tuple[str, dict[str, Any]]:
+    kwargs: dict[str, Any] = {}
+    if recursive:
+        kwargs["recursive"] = True
+    if limit is not None:
+        kwargs["limit"] = limit
+
+    if address:
+        path, _version = parse_address_or_exit(address)
+        result = view.navigate_path(path=path, **kwargs)
+    else:
+        path = ""
+        result = view.navigate_root(**kwargs)
+
+    data = as_dict(result)
+    return path, data
+
+
+@click.command("ls", help=_LS_HELP)
+@click.argument("address", default="", required=False)
+@namespace_option()
+@output_option("ls")
+@click.option(
+    "-R",
+    "--recursive",
+    is_flag=True,
+    default=False,
+    help="Fetch the full subtree (not just direct children).",
+)
+@click.option(
+    "--limit",
+    default=None,
+    type=int,
+    help="Maximum number of items to return.",
+)
+@click.option(
+    "--hide-folders",
+    is_flag=True,
+    default=False,
+    help="Omit folder nodes from the listing.",
+)
+@click.option(
+    "--hide-system",
+    is_flag=True,
+    default=False,
+    help="Omit built-in namespace items (_permissions, _webhooks, …).",
+)
+@click.option(
+    "--sort",
+    "sort_by",
+    type=click.Choice(LS_WIDE_SORT_CHOICES, case_sensitive=False),
+    default=None,
+    help="Sort wide output by path, type, created, or update time (requires -o wide).",
+)
+@click.pass_obj
+@sdk_command
+def ls_cmd(
+    ctx: OcmoCtx,
+    address: str,
+    namespace: str | None,
+    output_fmt: str | None,
+    recursive: bool,
+    limit: int | None,
+    hide_folders: bool,
+    hide_system: bool,
+    sort_by: str | None,
+) -> None:
+    view = ctx.namespace_view(namespace)
+    client = ctx.client()
+    fmt = resolve_effective_format(output_fmt, ctx.output, get_command_spec("ls"))
+    _validate_ls_sort(sort_by, fmt)
+
+    path, data = _navigate(view, address, recursive=recursive, limit=limit)
+    system_paths = _load_system_paths(client) if hide_system else frozenset()
+    rows = _filter_navigation_rows(
+        _navigation_rows(data),
+        hide_folders=hide_folders,
+        hide_system=hide_system,
+        system_paths=system_paths,
+    )
+
+    if fmt == "wide":
+        _render_wide_table(
+            client,
+            view,
+            ctx.require_namespace(namespace),
+            rows,
+            sort_by=sort_by or "path",
+            command_name="ls",
+        )
+    elif fmt == "table":
+        _render_table(rows, command_name="ls")
+    elif fmt in ("name", "path"):
+        emit(rows, fmt)
+    elif fmt == "json":
+        import json as _json
+
+        payload = _filter_navigate_data(
+            data,
+            hide_folders=hide_folders,
+            hide_system=hide_system,
+            system_paths=system_paths,
+        )
+        print(_json.dumps(payload, default=str, indent=2))
+    elif fmt == "yaml" or (fmt and fmt.startswith("jsonpath=")):
+        emit(
+            _filter_navigate_data(
+                data,
+                hide_folders=hide_folders,
+                hide_system=hide_system,
+                system_paths=system_paths,
+            ),
+            fmt,
+        )
+    else:
+        err(f"Unsupported output format for ocmo ls: {fmt!r}")
+        raise SystemExit(USAGE_ERROR)
+
+
+@click.command("tree", help=_TREE_HELP)
+@click.argument("address", default="", required=False)
+@namespace_option()
+@click.option(
+    "--depth",
+    default=None,
+    type=click.IntRange(1),
+    help="Maximum nesting depth to display (default: unlimited).",
+)
+@click.option(
+    "--hide-system",
+    is_flag=True,
+    default=False,
+    help="Omit built-in namespace items (_permissions, _webhooks, …).",
+)
+@click.option(
+    "--emoji",
+    is_flag=True,
+    default=False,
+    help="Show item-type emojis before names instead of [type] suffixes.",
+)
+@click.pass_obj
+@sdk_command
+def tree_cmd(
+    ctx: OcmoCtx,
+    address: str,
+    namespace: str | None,
+    depth: int | None,
+    hide_system: bool,
+    emoji: bool,
+) -> None:
+    if ctx.output is not None:
+        err("ocmo tree does not support -o/--output; output is always a tree view.")
+        raise SystemExit(USAGE_ERROR)
+
+    view = ctx.namespace_view(namespace)
+    client = ctx.client()
+
+    path, data = _navigate(view, address, recursive=True, limit=None)
+    system_paths = _load_system_paths(client) if hide_system else frozenset()
+    rows = _filter_navigation_rows(
+        _navigation_rows(data),
+        hide_folders=False,
+        hide_system=hide_system,
+        system_paths=system_paths,
+    )
+
+    tree_rows = _build_tree_hierarchy(
+        rows,
+        root_prefix=path.strip("/") if address else "",
+    )
+    _render_plain_tree(tree_rows, prefix="", connector="", max_depth=depth, use_emoji=emoji)
+
+
+def _validate_ls_sort(sort_by: str | None, fmt: str | None) -> None:
+    if sort_by is not None and fmt != "wide":
+        err("--sort is only supported with -o wide.")
+        raise SystemExit(USAGE_ERROR)
+
+
+_DEFAULT_BUILTIN_NAMESPACE_PATHS = frozenset(
+    {
+        "_permissions",
+        "_permissions.schema",
+        "_webhooks",
+        "_webhooks.schema",
+        "_webhooks_secret",
+        "_git_sync",
+        "_git_sync.schema",
+        "_git_sync_secret",
+    }
+)
+
+
+def _load_system_paths(client: OcmoClient) -> frozenset[str]:
+    """Return built-in namespace tree paths from ``/api/version`` when available."""
+    version_info = None
+    if hasattr(client, "version_info"):
+        try:
+            version_info = client.version_info()
+        except Exception:
+            version_info = None
+    if not version_info:
+        return _DEFAULT_BUILTIN_NAMESPACE_PATHS
+
+    payload = version_info.get("builtin_namespace_paths") if isinstance(version_info, dict) else None
+    if not isinstance(payload, dict):
+        return _DEFAULT_BUILTIN_NAMESPACE_PATHS
+
+    order = payload.get("order")
+    if isinstance(order, list) and order:
+        return frozenset(str(path).strip("/") for path in order if str(path).strip("/"))
+
+    paths: set[str] = set()
+    for section in ("config", "secret", "schema"):
+        values = payload.get(section)
+        if isinstance(values, list):
+            paths.update(str(path).strip("/") for path in values if str(path).strip("/"))
+    return frozenset(paths) if paths else _DEFAULT_BUILTIN_NAMESPACE_PATHS
+
+
+def _node_path(node: Any) -> str:
+    item = node if isinstance(node, dict) else vars(node)
+    return str(item.get("path") or "").strip("/")
+
+
+def _node_type(node: Any) -> str:
+    item = node if isinstance(node, dict) else vars(node)
+    return item.get("node_type") or ""
+
+
+def _filter_navigation_rows(
+    rows: Sequence[Any],
+    *,
+    hide_folders: bool,
+    hide_system: bool,
+    system_paths: frozenset[str],
+) -> list[Any]:
+    if not hide_folders and not hide_system:
+        return list(rows)
+    filtered: list[Any] = []
+    for node in rows:
+        if hide_folders and _node_type(node) == "folder":
+            continue
+        if hide_system and _node_path(node) in system_paths:
+            continue
+        item = node if isinstance(node, dict) else dict(vars(node))
+        children = item.get("children") or []
+        if children:
+            item = {
+                **item,
+                "children": _filter_navigation_rows(
+                    children,
+                    hide_folders=hide_folders,
+                    hide_system=hide_system,
+                    system_paths=system_paths,
+                ),
+            }
+        filtered.append(item)
+    return filtered
+
+
+def _filter_navigate_data(
+    data: dict[str, Any],
+    *,
+    hide_folders: bool,
+    hide_system: bool,
+    system_paths: frozenset[str],
+) -> dict[str, Any]:
+    if not hide_folders and not hide_system:
+        return data
+    payload = dict(data)
+    payload["children"] = _filter_navigation_rows(
+        payload.get("children") or [],
+        hide_folders=hide_folders,
+        hide_system=hide_system,
+        system_paths=system_paths,
+    )
+    item = payload.get("item")
+    if payload.get("is_leaf") and item:
+        if hide_folders and _node_type(item) == "folder":
+            payload["item"] = None
+        elif hide_system and _node_path(item) in system_paths:
+            payload["item"] = None
+    if payload.get("children"):
+        payload["children_count"] = len(payload["children"])
+    elif (hide_folders or hide_system) and not payload.get("is_leaf"):
+        payload["children_count"] = 0
+    return payload
+
+
+def _navigation_rows(data: dict[str, Any]) -> list[Any]:
+    """Return the nodes to list for a navigate response.
+
+    Folder paths expose direct children; leaf paths expose the matched item itself.
+    """
+    children = data.get("children") or []
+    if children:
+        return children
+    item = data.get("item")
+    if data.get("is_leaf") and item:
+        return [item]
+    return []
+
+
+def _build_tree_hierarchy(nodes: Sequence[Any], *, root_prefix: str = "") -> list[dict[str, Any]]:
+    """Nest flat navigate rows (recursive API) into a path hierarchy."""
+    root_prefix = root_prefix.strip("/")
+
+    prepared: list[dict[str, Any]] = []
+    for raw in nodes:
+        item = raw if isinstance(raw, dict) else dict(vars(raw))
+        path = (item.get("path") or "").strip("/")
+        if not path or (root_prefix and path == root_prefix):
+            continue
+        prepared.append({**item, "children": []})
+
+    if not prepared:
+        return []
+
+    by_path = {node["path"]: node for node in prepared}
+    roots: list[dict[str, Any]] = []
+
+    for node in sorted(prepared, key=lambda item: item["path"]):
+        path = node["path"]
+        parent_path = path.rsplit("/", 1)[0] if "/" in path else None
+
+        if parent_path and parent_path in by_path:
+            by_path[parent_path]["children"].append(node)
+            continue
+
+        if root_prefix:
+            if parent_path == root_prefix:
+                roots.append(node)
+            else:
+                roots.append(node)
+        elif parent_path is None:
+            roots.append(node)
+        else:
+            roots.append(node)
+
+    def _sort_children(items: list[dict[str, Any]]) -> None:
+        items.sort(key=lambda item: item.get("path") or "")
+        for item in items:
+            if item["children"]:
+                _sort_children(item["children"])
+
+    _sort_children(roots)
+    return roots
+
+
+def _tree_node_label(node: dict[str, Any], *, use_emoji: bool) -> str:
+    node_name = node.get("name") or node.get("path") or str(node)
+    node_type = node.get("node_type") or ""
+    if use_emoji:
+        icon = _TREE_TYPE_EMOJI.get(node_type, "")
+        return f"{icon} {node_name}" if icon else node_name
+    type_str = f"  [{node_type}]" if node_type else ""
+    return f"{node_name}{type_str}"
+
+
+def _render_plain_tree(
+    children: Sequence[Any],
+    prefix: str,
+    connector: str = "",
+    *,
+    max_depth: int | None = None,
+    current_depth: int = 1,
+    use_emoji: bool = False,
+) -> None:
+    for i, item in enumerate(children):
+        is_last = i == len(children) - 1
+        branch = "└── " if is_last else "├── "
+        node = item if isinstance(item, dict) else vars(item)
+        print(f"{prefix}{connector}{branch}{_tree_node_label(node, use_emoji=use_emoji)}")
+        sub = node.get("children") or []
+        if sub and (max_depth is None or current_depth < max_depth):
+            child_prefix = prefix + connector + ("    " if is_last else "│   ")
+            _render_plain_tree(
+                sub,
+                prefix=child_prefix,
+                max_depth=max_depth,
+                current_depth=current_depth + 1,
+                use_emoji=use_emoji,
+            )
+
+
+def _render_table(children: Sequence[Any], *, command_name: str) -> None:
+    rows = []
+    for item in children:
+        node = item if isinstance(item, dict) else vars(item)
+        rows.append(basic_ls_row(node))
+    rows.sort(key=lambda row: row["path"])
+    spec = get_command_spec(command_name)
+    emit_table(rows, columns_for_format(spec, "table", rows))
+
+
+def _render_wide_table(
+    client: OcmoClient,
+    view: NamespaceView,
+    namespace: str,
+    children: Sequence[Any],
+    *,
+    sort_by: str = "path",
+    command_name: str,
+) -> None:
+    nodes = [item if isinstance(item, dict) else vars(item) for item in children]
+    rows = enrich_ls_rows(client=client, view=view, namespace=namespace, nodes=nodes)
+    sort_wide_rows(rows, sort_by)
+    spec = get_command_spec(command_name)
+    emit_table(rows, columns_for_format(spec, "wide", rows))