ecosyste-ms-cli 1.4.0__tar.gz → 1.4.2__tar.gz

ecosyste_ms_cli-1.4.2/CHANGELOG.md

@@ -0,0 +1,21 @@
+# Changelog for v1.4.2
+
+## Changes since v1.4.1
+
+- refactor: call_tool tests (42a5ae5)
+- refactor: sleep handling in polling (6566f5e)
+- fix: date putput in json (9d87d5e)
+- fix: Non-dict list responses crash table/TSV output. (cf09255)
+- refactor: merge purl precedence (31bc8b8)
+- refactor: merge purl precedence code (a19038b)
+- refactor: archives handler simplified (51ec6cc)
+- refactor: Unify the three `--purl` mechanisms. (86cc871)
+- refactor: Delete `DefaultOperationHandler`'s stale config (1826703)
+- refactor: add tests for openapi (5597b66)
+- fix: passed body to request (159ecb7)
+- refactor: several fixes\ \ * JSONL/TSV wrapping error fixed\ * poll loop with timeout\ * mcp events improved \ * default --max-wait of 600s \ (29f1b8d)
+- refactor: the big clean\ \ * remove dead code\ * sync experimental mcp with all apis\ * handler consolidation completed\ * polling simplified and less duplicated code\ * packages.py --purl cleanup (a1b8915)
+- refactor: replace_auto_command and Lift `_extract_param` to `handlers/base.py` (4171d09)
+- refactor: polling (3a77384)
+- refactor: star maintianing a build kwargs method (f12e930)
+- refactor: Appending the apply_purl helper (d2a0eb0)

{ecosyste_ms_cli-1.4.0/ecosyste_ms_cli.egg-info → ecosyste_ms_cli-1.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ecosyste_ms_cli
-Version: 1.4.0
+Version: 1.4.2
 Summary: CLI for ecosyste.ms API
 Author-email: Sebastian Schürmann <sebs@2xs.org>
 License-Expression: MIT

{ecosyste_ms_cli-1.4.0 → ecosyste_ms_cli-1.4.2/ecosyste_ms_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ecosyste_ms_cli
-Version: 1.4.0
+Version: 1.4.2
 Summary: CLI for ecosyste.ms API
 Author-email: Sebastian Schürmann <sebs@2xs.org>
 License-Expression: MIT

{ecosyste_ms_cli-1.4.0 → ecosyste_ms_cli-1.4.2}/ecosyste_ms_cli.egg-info/SOURCES.txt

@@ -51,6 +51,7 @@ ecosystems_cli/commands/mcp.py
 ecosystems_cli/commands/opencollective.py
 ecosystems_cli/commands/packages.py
 ecosystems_cli/commands/parser.py
+ecosystems_cli/commands/purl_options.py
 ecosystems_cli/commands/repos.py
 ecosystems_cli/commands/resolve.py
 ecosystems_cli/commands/sbom.py
@@ -78,10 +79,12 @@ ecosystems_cli/commands/handlers/sbom.py
 ecosystems_cli/commands/handlers/sponsors.py
 ecosystems_cli/commands/handlers/summary.py
 ecosystems_cli/commands/handlers/timeline.py
+ecosystems_cli/helpers/build_kwargs.py
 ecosystems_cli/helpers/click_params.py
 ecosystems_cli/helpers/flatten_dict.py
 ecosystems_cli/helpers/format_value.py
 ecosystems_cli/helpers/get_domain.py
+ecosystems_cli/helpers/job_polling.py
 ecosystems_cli/helpers/load_api_spec.py
 ecosystems_cli/helpers/print_error.py
 ecosystems_cli/helpers/print_operations.py
@@ -91,6 +94,7 @@ tests/test_cli.py
 tests/test_cli_domain.py
 tests/test_constants.py
 tests/test_format_value.py
+tests/test_handlers.py
 tests/test_help_output.py
 tests/test_load_api_spec.py
 tests/test_mcp_server.py

{ecosyste_ms_cli-1.4.0 → ecosyste_ms_cli-1.4.2}/ecosystems_cli/__init__.py

@@ -1,3 +1,3 @@
 """Ecosystems CLI tool for interacting with ecosyste.ms APIs."""
 
-__version__ = "1.4.0"
+__version__ = "1.4.2"

{ecosyste_ms_cli-1.4.0 → ecosyste_ms_cli-1.4.2}/ecosystems_cli/cli.py

@@ -1,11 +1,6 @@
 """Command line interface for ecosystems CLI."""
 
-import json
-from typing import Any, Dict, List, Optional
-
 import click
-from rich.console import Console
-from rich.panel import Panel
 
 from ecosystems_cli import __version__
 from ecosystems_cli.commands.advisories import advisories
@@ -29,18 +24,8 @@ from ecosystems_cli.commands.timeline import timeline
 from ecosystems_cli.constants import (
     DEFAULT_OUTPUT_FORMAT,
     DEFAULT_TIMEOUT,
-    ERROR_PANEL_STYLE,
-    ERROR_PREFIX,
     OUTPUT_FORMATS,
 )
-from ecosystems_cli.exceptions import EcosystemsCLIError, JSONParseError
-from ecosystems_cli.helpers.format_value import format_value
-from ecosystems_cli.helpers.get_domain import build_base_url, get_domain_with_precedence
-from ecosystems_cli.helpers.print_operations import print_operations
-from ecosystems_cli.helpers.print_output import print_output
-from ecosystems_cli.openapi_client import _factory as api_factory
-
-console = Console()
 
 
 @click.group(invoke_without_command=True)
@@ -97,20 +82,8 @@ def main(ctx, timeout, format, domain, mailto, install_completion):
     ctx.obj["mailto"] = mailto
 
 
-# Command Registration Strategy:
-# We use a hybrid approach for command registration to balance usability and flexibility:
-#
-# 1. High-level API commands (e.g., 'ecosystems repos', 'ecosystems packages')
-#    - Registered via COMMAND_REGISTRY below
-#    - Provide user-friendly commands with custom logic and convenience methods
-#    - Each command is a BaseCommand subclass with tailored functionality
-#
-# 2. Low-level operation commands (e.g., 'ecosystems op repos get_topic')
-#    - Registered dynamically in register_op_commands()
-#    - Provide direct access to all API operations
-#    - Auto-generated from OpenAPI specifications
-
 # Command registry - maps API names to their command instances
+# (each value is a Click group generated from an OpenAPI spec).
 COMMAND_REGISTRY = {
     "advisories": advisories,
     "archives": archives,
@@ -137,84 +110,9 @@ for api_name, command in COMMAND_REGISTRY.items():
 
 # Register MCP server command
 main.add_command(mcp)
-# Dynamic op commands have been removed
 
 
 @main.command(name="version", help="Show the ecosystems CLI version and exit.")
 def version():
     """Print the installed ecosystems CLI version."""
     click.echo(__version__)
-
-
-def _parse_json_param(param: Optional[str]) -> Optional[Dict]:
-    """Parse JSON parameter if provided."""
-    if not param:
-        return None
-    try:
-        return json.loads(param)
-    except json.JSONDecodeError as e:
-        raise JSONParseError(f"Invalid JSON: {param}. Error: {str(e)}")
-
-
-def _call_operation(api: str, operation: str, path_params: str, query_params: str, body: str, context=None):
-    """Call an operation on the specified API."""
-    # Get timeout, format, and domain from context if available
-    if context and hasattr(context, "obj"):
-        timeout = context.obj.get("timeout", DEFAULT_TIMEOUT)
-        format_type = context.obj.get("format", DEFAULT_OUTPUT_FORMAT)
-        domain = context.obj.get("domain")
-    else:
-        timeout = DEFAULT_TIMEOUT
-        format_type = DEFAULT_OUTPUT_FORMAT
-        domain = None
-
-    # Get domain with proper precedence
-    final_domain = get_domain_with_precedence(api, domain)
-    base_url = build_base_url(final_domain, api)
-
-    try:
-        # Parse parameters
-        path_params_dict = _parse_json_param(path_params)
-        query_params_dict = _parse_json_param(query_params)
-        body_dict = _parse_json_param(body)
-
-        result = api_factory.call(
-            api_name=api,
-            operation_id=operation,
-            path_params=path_params_dict,
-            query_params=query_params_dict,
-            body=body_dict,
-            timeout=timeout,
-            base_url=base_url,
-        )
-        _print_output(result, format_type)
-    except JSONParseError as e:
-        _print_error(str(e))
-    except EcosystemsCLIError as e:
-        _print_error(str(e))
-    except Exception as e:
-        _print_error(f"Unexpected error: {str(e)}")
-
-
-def _print_output(data: Any, format_type: str = "table"):
-    """Print data in the specified format."""
-    print_output(data, format_type, console=console)
-
-
-def _format_value(value: Any) -> str:
-    """Deprecated: use format_value from helpers.format_value instead."""
-    return format_value(value)
-
-
-def _print_json(data: Any):
-    """Print JSON data in a nicely formatted way."""
-    _print_output(data, "json")
-
-
-def _print_error(error_msg: str):
-    """Print error message in a nicely formatted way."""
-    console.print(Panel(f"{ERROR_PREFIX} {error_msg}", border_style=ERROR_PANEL_STYLE))
-
-
-def _print_operations(operations: List[Dict]):
-    print_operations(operations, console=console)

{ecosyste_ms_cli-1.4.0 → ecosyste_ms_cli-1.4.2}/ecosystems_cli/commands/advisories.py

@@ -4,20 +4,16 @@ from typing import Optional
 
 import click
 
-from ecosystems_cli.commands.decorators import common_options
+from ecosystems_cli.commands.decorators import common_options, override_auto_command
 from ecosystems_cli.commands.execution import execute_api_call, update_context
 from ecosystems_cli.commands.generator import APICommandGenerator
-from ecosystems_cli.helpers.purl_parser import parse_purl
+from ecosystems_cli.helpers.build_kwargs import build_kwargs
+from ecosystems_cli.helpers.purl_parser import apply_purl
 
 advisories = APICommandGenerator.create_api_group("advisories")
 
 
-# Remove auto-generated get_advisories command to replace with custom implementation
-if "get_advisories" in advisories.commands:
-    del advisories.commands["get_advisories"]
-
-
-@advisories.command(name="get_advisories", help="list advisories")
+@override_auto_command(advisories, "get_advisories", help="list advisories")
 @click.option("--purl", type=str, default=None, help="Package URL (PURL). Example: pkg:npm/fsa")
 @click.option("--ecosystem", type=str, default=None, help="Ecosystem to filter by")
 @click.option("--package-name", type=str, default=None, help="Package to filter by")
@@ -73,37 +69,24 @@ def get_advisories(
     """
     update_context(ctx, timeout, format, domain, mailto)
 
-    # If PURL is provided, parse it and override ecosystem/package_name
-    if purl:
-        parsed_ecosystem, parsed_package_name = parse_purl(purl)
-        if parsed_ecosystem:
-            ecosystem = parsed_ecosystem
-        if parsed_package_name:
-            package_name = parsed_package_name
+    # Explicit flags win over PURL-derived values.
+    parsed = apply_purl(purl)
+    ecosystem = ecosystem or parsed.get("ecosystem")
+    package_name = package_name or parsed.get("package_name")
 
     # Build kwargs for the API call
-    kwargs = {}
-    if ecosystem is not None:
-        kwargs["ecosystem"] = ecosystem
-    if package_name is not None:
-        kwargs["package_name"] = package_name
-    if severity is not None:
-        kwargs["severity"] = severity
-    if repository_url is not None:
-        kwargs["repository_url"] = repository_url
-    if page is not None:
-        kwargs["page"] = page
-    if per_page is not None:
-        kwargs["per_page"] = per_page
-    if created_after is not None:
-        kwargs["created_after"] = created_after
-    if updated_after is not None:
-        kwargs["updated_after"] = updated_after
-    if sort is not None:
-        kwargs["sort"] = sort
-    if order is not None:
-        kwargs["order"] = order
-    if source is not None:
-        kwargs["source"] = source
+    kwargs = build_kwargs(
+        ecosystem=ecosystem,
+        package_name=package_name,
+        severity=severity,
+        repository_url=repository_url,
+        page=page,
+        per_page=per_page,
+        created_after=created_after,
+        updated_after=updated_after,
+        sort=sort,
+        order=order,
+        source=source,
+    )
 
     execute_api_call(ctx, "advisories", operation_id="getAdvisories", call_args=(), call_kwargs=kwargs)

ecosyste_ms_cli-1.4.2/ecosystems_cli/commands/decorators.py

@@ -0,0 +1,77 @@
+"""Decorators for ecosystems CLI commands."""
+
+from functools import wraps
+
+import click
+
+from ecosystems_cli.constants import (
+    DEFAULT_OUTPUT_FORMAT,
+    DEFAULT_TIMEOUT,
+    OUTPUT_FORMATS,
+)
+
+
+def common_options(f):
+    """Decorator to add common options to commands."""
+    f = click.option(
+        "--format",
+        default=DEFAULT_OUTPUT_FORMAT,
+        type=click.Choice(OUTPUT_FORMATS),
+        help=f"Output format. Default is {DEFAULT_OUTPUT_FORMAT}.",
+    )(f)
+    f = click.option(
+        "--timeout",
+        default=DEFAULT_TIMEOUT,
+        help=f"Timeout in seconds for API requests. Default is {DEFAULT_TIMEOUT} seconds.",
+    )(f)
+    f = click.option(
+        "--domain",
+        default=None,
+        help="Override the API domain. Example: api.example.com",
+    )(f)
+    f = click.option(
+        "--mailto",
+        default=None,
+        help="Email address for polite pool access. Example: you@example.com",
+    )(f)
+    return f
+
+
+def override_auto_command(group: click.Group, name: str, **command_kwargs):
+    """Register a custom command in place of an auto-generated one.
+
+    Drops any command already registered on ``group`` under ``name`` (the
+    auto-generated version), then registers the decorated function via
+    ``group.command(name=name, **command_kwargs)``. Use this as the outermost
+    decorator instead of a bare ``del group.commands[name]`` followed by
+    ``@group.command(name=name, ...)``.
+    """
+
+    def decorator(func):
+        group.commands.pop(name, None)
+        return group.command(name=name, **command_kwargs)(func)
+
+    return decorator
+
+
+def api_command(api_name: str, operation_id: str):
+    """Decorator that wraps a command to execute an API operation.
+
+    Args:
+        api_name: Name of the API (e.g., 'repos', 'packages')
+        operation_id: Operation ID to execute
+    """
+
+    def decorator(func):
+        @common_options
+        @click.pass_context
+        @wraps(func)
+        def wrapper(ctx, timeout, format, domain, mailto, *args, **kwargs):
+            from ecosystems_cli.commands.execution import execute_api_call, update_context
+
+            update_context(ctx, timeout, format, domain, mailto)
+            execute_api_call(ctx, api_name, operation_id=operation_id, call_args=args, call_kwargs=kwargs)
+
+        return wrapper
+
+    return decorator

ecosyste_ms_cli-1.4.2/ecosystems_cli/commands/dependabot.py

@@ -0,0 +1,16 @@
+"""Commands for the dependabot API."""
+
+from ecosystems_cli.commands.generator import APICommandGenerator
+from ecosystems_cli.commands.purl_options import attach_purl_option
+
+dependabot = APICommandGenerator.create_api_group("dependabot")
+
+# getAdvisories filters by ecosystem name and package_name (query options), so the
+# PURL type is passed through unmapped and both parts stay optional filters.
+attach_purl_option(
+    dependabot,
+    "get_advisories",
+    targets=("ecosystem", "package_name"),
+    map_types=False,
+    example="pkg:npm/fsa. Decomposes into --ecosystem and --package-name.",
+)

ecosyste_ms_cli-1.4.2/ecosystems_cli/commands/diff.py

@@ -0,0 +1,58 @@
+"""Commands for the diff API."""
+
+from typing import Optional
+
+import click
+
+from ecosystems_cli.commands.decorators import common_options, override_auto_command
+from ecosystems_cli.commands.execution import update_context
+from ecosystems_cli.commands.generator import APICommandGenerator
+from ecosystems_cli.constants import DEFAULT_MAX_POLL_WAIT
+from ecosystems_cli.helpers.job_polling import submit_and_poll
+
+diff = APICommandGenerator.create_api_group("diff")
+
+
+@override_auto_command(diff, "create_job", help="Submit a diff job with two URLs to compare")
+@click.argument("url_1", required=True)
+@click.argument("url_2", required=True)
+@click.option(
+    "--polling-interval",
+    type=float,
+    default=None,
+    help="Polling interval in seconds. If set, the command will poll the job status until completion.",
+)
+@click.option(
+    "--max-wait",
+    type=float,
+    default=DEFAULT_MAX_POLL_WAIT,
+    help=f"Maximum seconds to poll before giving up. Default is {DEFAULT_MAX_POLL_WAIT}.",
+)
+@common_options
+@click.pass_context
+def create_job(
+    ctx,
+    timeout: int,
+    format: str,
+    domain: Optional[str],
+    mailto: Optional[str],
+    url_1: str,
+    url_2: str,
+    polling_interval: Optional[float],
+    max_wait: float,
+):
+    """Submit a diff job with two URLs to compare.
+
+    Args:
+        ctx: Click context
+        timeout: Request timeout
+        format: Output format
+        domain: API domain
+        mailto: Email for polite pool access
+        url_1: First URL of file or zip/tar archive
+        url_2: Second URL of file or zip/tar archive
+        polling_interval: Optional polling interval in seconds
+        max_wait: Maximum seconds to poll before giving up
+    """
+    update_context(ctx, timeout, format, domain, mailto)
+    submit_and_poll(ctx, "diff", {"url_1": url_1, "url_2": url_2}, polling_interval=polling_interval, max_wait=max_wait)

{ecosyste_ms_cli-1.4.0 → ecosyste_ms_cli-1.4.2}/ecosystems_cli/commands/execution.py

@@ -16,7 +16,14 @@ console = Console()
 
 
 def update_context(ctx, timeout: int, format: str, domain: Optional[str], mailto: Optional[str] = None):
-    """Update context with command-level options if they differ from defaults.
+    """Merge command-level options into ``ctx.obj``.
+
+    The single context-precedence mechanism, used by both the API group callback
+    and every leaf command. An option is written only when it differs from its
+    default (i.e. was explicitly set at this level); otherwise the value already
+    in ``ctx.obj`` -- inherited from the parent context -- is left untouched.
+    The net precedence is therefore: leaf option > group option > root option >
+    default.
 
     Args:
         ctx: Click context
@@ -36,61 +43,69 @@ def update_context(ctx, timeout: int, format: str, domain: Optional[str], mailto
         ctx.obj["mailto"] = mailto
 
 
+def _extract_body(call_kwargs: dict, body_keys: Optional[list]) -> dict:
+    """Pull request-body fields out of ``call_kwargs`` into a JSON body dict.
+
+    Removes each ``body_keys`` entry from ``call_kwargs`` (mutating it) so the
+    remaining kwargs map cleanly to path/query parameters. Unset values are
+    dropped; Click's repeatable options arrive as tuples and are normalized to
+    lists so they serialize as JSON arrays.
+    """
+    body: dict = {}
+    for key in body_keys or []:
+        value = call_kwargs.pop(key, None)
+        if value is None or value == ():
+            continue
+        body[key] = list(value) if isinstance(value, tuple) else value
+    return body
+
+
 def execute_api_call(
     ctx,
     api_name: str,
-    method_name: Optional[str] = None,
-    operation_id: Optional[str] = None,
+    operation_id: str,
     call_args: tuple = (),
     call_kwargs: Optional[dict] = None,
+    body_keys: Optional[list] = None,
 ):
     """Execute an API call with proper error handling.
 
     Args:
         ctx: Click context
         api_name: Name of the API (e.g., 'repos', 'packages')
-        method_name: API client method name (for direct method calls)
-        operation_id: Operation ID (for call method)
+        operation_id: Operation ID to call
         call_args: Positional arguments for the API call
         call_kwargs: Keyword arguments for the API call
+        body_keys: Names of kwargs that belong in the JSON request body rather
+            than the path/query parameters
     """
     if call_kwargs is None:
         call_kwargs = {}
 
+    # Separate request-body fields before path/query mapping.
+    body = _extract_body(call_kwargs, body_keys)
+
     # Get domain with proper precedence
     domain = get_domain_with_precedence(api_name, ctx.obj.get("domain"))
     base_url = build_base_url(domain, api_name)
 
     try:
-        if operation_id:
-            if call_args or call_kwargs:
-                # Use operation handler to build parameters
-                handler = OperationHandlerFactory.get_handler(api_name)
-                path_params, query_params = handler.build_params(operation_id, call_args, call_kwargs)
-                result = api_factory.call(
-                    api_name,
-                    operation_id,
-                    path_params=path_params,
-                    query_params=query_params,
-                    timeout=ctx.obj.get("timeout", DEFAULT_TIMEOUT),
-                    mailto=ctx.obj.get("mailto"),
-                    base_url=base_url,
-                )
-            else:
-                # Simple operation call without parameters
-                result = api_factory.call(
-                    api_name,
-                    operation_id,
-                    path_params={},
-                    query_params={},
-                    timeout=ctx.obj.get("timeout", DEFAULT_TIMEOUT),
-                    mailto=ctx.obj.get("mailto"),
-                    base_url=base_url,
-                )
-        elif method_name:
-            raise ValueError("Direct method calls not supported")
-        else:
-            raise ValueError("Either method_name or operation_id must be provided")
+        handler = OperationHandlerFactory.get_handler(api_name)
+        path_params, query_params = handler.build_params(operation_id, call_args, call_kwargs)
+
+        call_params = {
+            "path_params": path_params,
+            "query_params": query_params,
+            "timeout": ctx.obj.get("timeout", DEFAULT_TIMEOUT),
+            "mailto": ctx.obj.get("mailto"),
+            "base_url": base_url,
+        }
+        # Only send a body when there is one, so body-less calls keep their
+        # existing call signature.
+        if body:
+            call_params["body"] = body
+
+        result = api_factory.call(api_name, operation_id, **call_params)
 
         print_output(result, ctx.obj.get("format", DEFAULT_OUTPUT_FORMAT), console=console)
     except EcosystemsCLIError as e:

{ecosyste_ms_cli-1.4.0 → ecosyste_ms_cli-1.4.2}/ecosystems_cli/commands/generator.py

@@ -5,9 +5,8 @@ from typing import List
 
 import click
 
-from ecosystems_cli.commands.decorators import common_options, resolve_context_value
-from ecosystems_cli.constants import DEFAULT_OUTPUT_FORMAT, DEFAULT_TIMEOUT
-from ecosystems_cli.helpers.click_params import build_click_decorators
+from ecosystems_cli.commands.decorators import common_options
+from ecosystems_cli.helpers.click_params import build_body_decorators, build_click_decorators
 from ecosystems_cli.helpers.load_api_spec import load_api_spec
 
 
@@ -40,17 +39,11 @@ class APICommandGenerator:
         @click.pass_context
         def api_group(ctx, timeout, format, domain, mailto):
             f"""Commands for the {api_name} API."""
-            ctx.ensure_object(dict)
+            from ecosystems_cli.commands.execution import update_context
 
-            timeout = resolve_context_value(ctx, "timeout", timeout, DEFAULT_TIMEOUT)
-            format = resolve_context_value(ctx, "format", format, DEFAULT_OUTPUT_FORMAT)
-            domain = resolve_context_value(ctx, "domain", domain, None)
-            mailto = resolve_context_value(ctx, "mailto", mailto, None)
-
-            ctx.obj["timeout"] = timeout
-            ctx.obj["format"] = format
-            ctx.obj["domain"] = domain
-            ctx.obj["mailto"] = mailto
+            # Same merge rule as leaf commands: a value set at this level wins;
+            # otherwise the value inherited from the parent context is kept.
+            update_context(ctx, timeout, format, domain, mailto)
 
         api_group.name = api_name
         return api_group
@@ -70,12 +63,13 @@ class APICommandGenerator:
                     command_name = APICommandGenerator.operation_id_to_command_name(operation_id)
                     description = operation.get("summary", f"Execute {operation_id}")
                     parameters = operation.get("parameters", [])
+                    request_body = operation.get("requestBody")
 
-                    if not parameters:
+                    if not parameters and not request_body:
                         APICommandGenerator._create_simple_command(api_group, command_name, description, api_name, operation_id)
                     else:
                         APICommandGenerator._create_parameterized_command(
-                            api_group, command_name, description, api_name, operation_id, parameters
+                            api_group, command_name, description, api_name, operation_id, parameters, request_body
                         )
 
     @staticmethod
@@ -90,12 +84,22 @@ class APICommandGenerator:
 
     @staticmethod
     def _create_parameterized_command(
-        api_group: click.Group, command_name: str, description: str, api_name: str, operation_id: str, parameters: List[dict]
+        api_group: click.Group,
+        command_name: str,
+        description: str,
+        api_name: str,
+        operation_id: str,
+        parameters: List[dict],
+        request_body: dict = None,
     ):
-        """Create a command with parameters."""
+        """Create a command with parameters and/or a JSON request body."""
         click_decorators = APICommandGenerator._build_click_decorators(parameters)
+        body_params: List[str] = []
+        if request_body:
+            body_decorators, body_params = build_body_decorators(request_body)
+            click_decorators = click_decorators + body_decorators
 
-        def make_command(op_id):
+        def make_command(op_id, body_keys):
             @api_group.command(name=command_name, help=description)
             @common_options
             @click.pass_context
@@ -103,14 +107,14 @@ class APICommandGenerator:
                 from ecosystems_cli.commands.execution import execute_api_call, update_context
 
                 update_context(ctx, timeout, format, domain, mailto)
-                execute_api_call(ctx, api_name, operation_id=op_id, call_args=args, call_kwargs=kwargs)
+                execute_api_call(ctx, api_name, operation_id=op_id, call_args=args, call_kwargs=kwargs, body_keys=body_keys)
 
             for decorator in reversed(click_decorators):
                 command_impl = decorator(command_impl)
 
             return command_impl
 
-        make_command(operation_id)
+        make_command(operation_id, body_params)
 
     @staticmethod
     def create_api_group(api_name: str) -> click.Group: