cli-wizard 1.0.0__py3-none-any.whl

cli_wizard/generator/generator.py

@@ -0,0 +1,241 @@
+# Copyright (c) 2026, Giacomo Marciani
+# Licensed under the MIT License
+
+"""CLI code generator using Jinja2 templates."""
+
+import shutil
+from pathlib import Path
+from typing import Any
+
+from jinja2 import Environment, PackageLoader
+
+from cli_wizard.generator.models import CommandGroup, Operation
+
+
+def _build_url_path(op: Operation) -> str:
+    """Build URL path with Python variable substitutions."""
+    path = op.path
+    for param in op.parameters:
+        if param.location == "path":
+            path = path.replace(f"{{{param.name}}}", f"{{{param.python_name}}}")
+    return path
+
+
+class CliGenerator:
+    """Generates Click CLI code from parsed OpenAPI."""
+
+    def __init__(
+        self, config: dict[str, Any] | None = None, config_dir: Path | None = None
+    ) -> None:
+        """Initialize generator with package templates."""
+        self.config = config or {}
+        self.config_dir = config_dir or Path.cwd()
+        self.env = Environment(
+            loader=PackageLoader("cli_wizard", "templates"),
+            trim_blocks=True,
+            lstrip_blocks=True,
+        )
+        self.env.filters["url_path"] = _build_url_path
+
+    def generate(
+        self,
+        groups: dict[str, CommandGroup],
+        output_dir: Path,
+        cli_name: str,
+        package_name: str,
+    ) -> None:
+        """Generate a complete CLI project."""
+        self.package_name = package_name
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        # Create project structure
+        src_dir = output_dir / "src" / package_name
+        commands_dir = src_dir / "commands"
+        resources_dir = src_dir / "resources"
+        commands_dir.mkdir(parents=True, exist_ok=True)
+        resources_dir.mkdir(parents=True, exist_ok=True)
+
+        # Copy resources (e.g., CA file, splash file)
+        ca_file_name = self._copy_ca_file(resources_dir)
+        splash_file_name = self._copy_splash_file(resources_dir)
+
+        # Compute main_dir with variable substitution
+        main_dir = self._compute_main_dir(package_name)
+
+        # Generate project files
+        self._generate_pyproject(output_dir, cli_name, package_name)
+        self._generate_readme(output_dir, cli_name)
+        self._generate_version(output_dir)
+
+        # Generate package files
+        self._generate_package_init(src_dir, package_name)
+        self._generate_cli_main(src_dir, package_name, groups)
+        self._generate_client(src_dir)
+        self._generate_logging(src_dir)
+        self._generate_profile(src_dir)
+        self._generate_constants(src_dir, ca_file_name, splash_file_name, main_dir)
+
+        # Generate commands
+        self._generate_commands_init(commands_dir, groups)
+        self._generate_config_commands(commands_dir)
+        for tag, group in groups.items():
+            self._generate_command_group(group, commands_dir)
+
+    def _generate_pyproject(
+        self, output_dir: Path, cli_name: str, package_name: str
+    ) -> None:
+        """Generate pyproject.toml."""
+        template = self.env.get_template("pyproject.toml.j2")
+        content = template.render(
+            cli_name=cli_name,
+            package_name=package_name,
+            config=self.config,
+        )
+        with open(output_dir / "pyproject.toml", "w") as f:
+            f.write(content)
+
+    def _generate_readme(self, output_dir: Path, cli_name: str) -> None:
+        """Generate README.md."""
+        template = self.env.get_template("README.md.j2")
+        content = template.render(cli_name=cli_name, config=self.config)
+        with open(output_dir / "README.md", "w") as f:
+            f.write(content)
+
+    def _generate_version(self, output_dir: Path) -> None:
+        """Generate VERSION file."""
+        version = self.config.get("version", "0.1.0")
+        with open(output_dir / "VERSION", "w") as f:
+            f.write(f"{version}\n")
+
+    def _generate_package_init(self, src_dir: Path, package_name: str) -> None:
+        """Generate package __init__.py."""
+        template = self.env.get_template("package_init.py.j2")
+        content = template.render(package_name=package_name)
+        with open(src_dir / "__init__.py", "w") as f:
+            f.write(content)
+
+    def _generate_cli_main(
+        self, src_dir: Path, package_name: str, groups: dict[str, CommandGroup]
+    ) -> None:
+        """Generate main CLI entry point."""
+        template = self.env.get_template("cli.py.j2")
+        content = template.render(
+            package_name=package_name,
+            groups=groups,
+            config=self.config,
+        )
+        with open(src_dir / "cli.py", "w") as f:
+            f.write(content)
+
+    def _generate_client(self, src_dir: Path) -> None:
+        """Generate API client module."""
+        template = self.env.get_template("client.py.j2")
+        content = template.render(config=self.config)
+        with open(src_dir / "client.py", "w") as f:
+            f.write(content)
+
+    def _generate_logging(self, src_dir: Path) -> None:
+        """Generate logging module."""
+        template = self.env.get_template("logging.py.j2")
+        content = template.render(config=self.config)
+        with open(src_dir / "logging.py", "w") as f:
+            f.write(content)
+
+    def _generate_profile(self, src_dir: Path) -> None:
+        """Generate profile module."""
+        template = self.env.get_template("profile.py.j2")
+        content = template.render(config=self.config)
+        with open(src_dir / "profile.py", "w") as f:
+            f.write(content)
+
+    def _generate_constants(
+        self,
+        src_dir: Path,
+        ca_file_name: str | None,
+        splash_file_name: str | None,
+        main_dir: str,
+    ) -> None:
+        """Generate constants module."""
+        template = self.env.get_template("constants.py.j2")
+        content = template.render(
+            config=self.config,
+            ca_file_name=ca_file_name,
+            splash_file_name=splash_file_name,
+            main_dir=main_dir,
+        )
+        with open(src_dir / "constants.py", "w") as f:
+            f.write(content)
+
+    def _copy_ca_file(self, resources_dir: Path) -> str | None:
+        """Copy CA file to resources directory if specified in config."""
+        ca_file = self.config.get("CaFile")
+        if not ca_file:
+            return None
+
+        # Resolve CA file path relative to config directory
+        ca_path = Path(ca_file)
+        if not ca_path.is_absolute():
+            ca_path = self.config_dir / ca_file
+
+        if not ca_path.exists():
+            return None
+
+        # Copy to resources directory with original filename
+        dest_path = resources_dir / ca_path.name
+        shutil.copy2(ca_path, dest_path)
+        return ca_path.name
+
+    def _compute_main_dir(self, package_name: str) -> str:
+        """Get main directory path from config.
+
+        The #[Param] references should already be resolved by config loader.
+        ${VAR} environment variables are kept as-is for runtime expansion.
+        """
+        main_dir = self.config.get("MainDir")
+        if main_dir is not None:
+            return str(main_dir)
+        return f"${{HOME}}/.{package_name}"
+
+    def _copy_splash_file(self, resources_dir: Path) -> str | None:
+        """Copy splash file to resources directory if specified in config."""
+        splash_file = self.config.get("SplashFile")
+        if not splash_file:
+            return None
+
+        # Resolve splash file path relative to config directory
+        splash_path = Path(splash_file)
+        if not splash_path.is_absolute():
+            splash_path = self.config_dir / splash_file
+
+        if not splash_path.exists():
+            return None
+
+        # Copy to resources directory with original filename
+        dest_path = resources_dir / splash_path.name
+        shutil.copy2(splash_path, dest_path)
+        return splash_path.name
+
+    def _generate_commands_init(
+        self, commands_dir: Path, groups: dict[str, CommandGroup]
+    ) -> None:
+        """Generate commands __init__.py."""
+        template = self.env.get_template("commands_init.py.j2")
+        content = template.render(groups=groups)
+        with open(commands_dir / "__init__.py", "w") as f:
+            f.write(content)
+
+    def _generate_config_commands(self, commands_dir: Path) -> None:
+        """Generate config commands module."""
+        template = self.env.get_template("commands_config.py.j2")
+        content = template.render(package_name=self.package_name, config=self.config)
+        with open(commands_dir / "config.py", "w") as f:
+            f.write(content)
+
+    def _generate_command_group(self, group: CommandGroup, commands_dir: Path) -> None:
+        """Generate a command group file."""
+        template = self.env.get_template("command_group.py.j2")
+        content = template.render(
+            group=group, config=self.config, package_name=self.package_name
+        )
+        with open(commands_dir / f"{group.module_name}.py", "w") as f:
+            f.write(content)

cli_wizard/generator/models.py

@@ -0,0 +1,123 @@
+# Copyright (c) 2026, Giacomo Marciani
+# Licensed under the MIT License
+
+"""Data models for CLI generation."""
+
+import re
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class Parameter:
+    """Represents an API parameter."""
+
+    name: str
+    location: str  # path, query, header
+    param_type: str
+    required: bool
+    description: str = ""
+    default: Any = None
+    enum: list[str] = field(default_factory=list)
+
+    @property
+    def cli_name(self) -> str:
+        """Get CLI-friendly parameter name (kebab-case)."""
+        return re.sub(r"([a-z])([A-Z])", r"\1-\2", self.name).lower().replace("_", "-")
+
+    @property
+    def python_name(self) -> str:
+        """Get Python-friendly parameter name (snake_case)."""
+        name = re.sub(r"([a-z])([A-Z])", r"\1_\2", self.name).lower()
+        return name.replace("-", "_")
+
+    @property
+    def click_type(self) -> str:
+        """Get Click type for this parameter."""
+        type_map = {
+            "string": "str",
+            "integer": "int",
+            "number": "float",
+            "boolean": "bool",
+        }
+        return type_map.get(self.param_type, "str")
+
+
+@dataclass
+class RequestBodyProperty:
+    """Represents a request body property."""
+
+    name: str
+    prop_type: str
+    required: bool
+    description: str = ""
+
+    @property
+    def cli_name(self) -> str:
+        """Get CLI-friendly name (kebab-case)."""
+        name = re.sub(r"([a-z])([A-Z])", r"\1-\2", self.name).lower()
+        return name.replace("_", "-")
+
+    @property
+    def python_name(self) -> str:
+        """Get Python-friendly name (snake_case)."""
+        name = re.sub(r"([a-z])([A-Z])", r"\1_\2", self.name).lower()
+        return name.replace("-", "_")
+
+    @property
+    def click_type(self) -> str:
+        """Get Click type."""
+        type_map = {
+            "string": "str",
+            "integer": "int",
+            "number": "float",
+            "boolean": "bool",
+        }
+        return type_map.get(self.prop_type, "str")
+
+
+@dataclass
+class Operation:
+    """Represents an API operation."""
+
+    operation_id: str
+    method: str
+    path: str
+    summary: str
+    description: str
+    tags: list[str]
+    parameters: list[Parameter]
+    body_properties: list[RequestBodyProperty] = field(default_factory=list)
+
+    @property
+    def _base_operation_id(self) -> str:
+        """Get the base operation ID without module path (e.g., 'server.get_greetings' -> 'get_greetings')."""
+        if "." in self.operation_id:
+            return self.operation_id.rsplit(".", 1)[-1]
+        return self.operation_id
+
+    @property
+    def command_name(self) -> str:
+        """Get CLI command name from operation ID (kebab-case)."""
+        name = re.sub(r"(?<!^)(?=[A-Z])", "-", self._base_operation_id).lower()
+        return name.replace("_", "-")
+
+    @property
+    def function_name(self) -> str:
+        """Get Python function name from operation ID (snake_case)."""
+        return self.command_name.replace("-", "_")
+
+
+@dataclass
+class CommandGroup:
+    """Represents a group of commands (from a tag)."""
+
+    name: str
+    cli_name: str
+    description: str
+    operations: list[Operation] = field(default_factory=list)
+
+    @property
+    def module_name(self) -> str:
+        """Get Python module name."""
+        return self.cli_name.replace("-", "_")

cli_wizard/generator/parser.py

@@ -0,0 +1,171 @@
+# Copyright (c) 2026, Giacomo Marciani
+# Licensed under the MIT License
+
+"""OpenAPI specification parser."""
+
+import json
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from cli_wizard.generator.models import (
+    CommandGroup,
+    Operation,
+    Parameter,
+    RequestBodyProperty,
+)
+
+
+class OpenApiParser:
+    """Parses OpenAPI specification."""
+
+    def __init__(self, spec_path: str) -> None:
+        """Initialize parser with spec path."""
+        self.spec_path = Path(spec_path)
+        self.spec = self._load_spec()
+
+    def _load_spec(self) -> dict[str, Any]:
+        """Load OpenAPI spec from file (JSON or YAML)."""
+        with open(self.spec_path) as f:
+            content = f.read()
+
+        # Try JSON first, then YAML
+        if self.spec_path.suffix.lower() == ".json":
+            result = json.loads(content)
+            return dict(result) if isinstance(result, dict) else {}
+        elif self.spec_path.suffix.lower() in (".yaml", ".yml"):
+            result = yaml.safe_load(content)
+            return dict(result) if isinstance(result, dict) else {}
+        else:
+            # Try to detect format
+            try:
+                result = json.loads(content)
+                return dict(result) if isinstance(result, dict) else {}
+            except json.JSONDecodeError:
+                result = yaml.safe_load(content)
+                return dict(result) if isinstance(result, dict) else {}
+
+    def parse(
+        self,
+        exclude_tags: list[str] | None = None,
+        include_tags: list[str] | None = None,
+        tag_mapping: dict[str, str] | None = None,
+    ) -> dict[str, CommandGroup]:
+        """Parse the OpenAPI spec into command groups."""
+        exclude_tags = exclude_tags or []
+        include_tags = include_tags or []
+        tag_mapping = tag_mapping or {}
+
+        groups: dict[str, CommandGroup] = {}
+
+        for path, path_item in self.spec.get("paths", {}).items():
+            for method, operation in path_item.items():
+                if method not in ("get", "post", "put", "patch", "delete"):
+                    continue
+
+                tags = operation.get("tags", ["default"])
+                for tag in tags:
+                    if tag in exclude_tags:
+                        continue
+                    if include_tags and tag not in include_tags:
+                        continue
+
+                    if tag not in groups:
+                        cli_name = tag_mapping.get(tag, self._tag_to_cli_name(tag))
+                        groups[tag] = CommandGroup(
+                            name=tag,
+                            cli_name=cli_name,
+                            description=self._get_tag_description(tag),
+                        )
+
+                    op = self._parse_operation(path, method, operation)
+                    groups[tag].operations.append(op)
+
+        return groups
+
+    def _tag_to_cli_name(self, tag: str) -> str:
+        """Convert tag name to CLI-friendly name."""
+        return tag.lower().replace(" ", "-")
+
+    def _get_tag_description(self, tag: str) -> str:
+        """Get tag description from spec."""
+        for tag_def in self.spec.get("tags", []):
+            if tag_def.get("name") == tag:
+                desc = tag_def.get("description", f"{tag} commands")
+                return str(desc)
+        return f"{tag} commands"
+
+    def _parse_operation(
+        self, path: str, method: str, operation: dict[str, Any]
+    ) -> Operation:
+        """Parse a single operation."""
+        parameters = []
+        for param in operation.get("parameters", []):
+            parameters.append(self._parse_parameter(param))
+
+        body_properties: list[RequestBodyProperty] = []
+        if "requestBody" in operation:
+            body_properties = self._parse_request_body(operation["requestBody"])
+
+        return Operation(
+            operation_id=operation.get("operationId", f"{method}_{path}"),
+            method=method.upper(),
+            path=path,
+            summary=operation.get("summary", ""),
+            description=operation.get("description", ""),
+            tags=operation.get("tags", []),
+            parameters=parameters,
+            body_properties=body_properties,
+        )
+
+    def _parse_parameter(self, param: dict[str, Any]) -> Parameter:
+        """Parse a parameter definition."""
+        schema = param.get("schema", {})
+        return Parameter(
+            name=param["name"],
+            location=param["in"],
+            param_type=schema.get("type", "string"),
+            required=param.get("required", False),
+            description=param.get("description", ""),
+            default=schema.get("default"),
+            enum=schema.get("enum", []),
+        )
+
+    def _parse_request_body(self, body: dict[str, Any]) -> list[RequestBodyProperty]:
+        """Parse request body definition into properties."""
+        content = body.get("content", {})
+        json_content = content.get("application/json", {})
+        schema = json_content.get("schema", {})
+
+        # Handle $ref
+        if "$ref" in schema:
+            schema = self._resolve_ref(schema["$ref"])
+
+        if not schema:
+            return []
+
+        required_props = schema.get("required", [])
+        properties = []
+
+        for prop_name, prop_schema in schema.get("properties", {}).items():
+            properties.append(
+                RequestBodyProperty(
+                    name=prop_name,
+                    prop_type=prop_schema.get("type", "string"),
+                    required=prop_name in required_props,
+                    description=prop_schema.get("description", ""),
+                )
+            )
+
+        return properties
+
+    def _resolve_ref(self, ref: str) -> dict[str, Any]:
+        """Resolve a $ref to its schema."""
+        parts = ref.split("/")
+        if len(parts) != 4 or parts[1] != "components":
+            return {}
+
+        schema_name = parts[3]
+        result = self.spec.get("components", {}).get("schemas", {}).get(schema_name, {})
+        return dict(result) if isinstance(result, dict) else {}

cli_wizard/templates/README.md.j2

@@ -0,0 +1,31 @@
+# {{ cli_name }}
+
+CLI generated by [cli-wizard](https://github.com/gmarciani/cli-wizard) from OpenAPI specification.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+```bash
+{{ cli_name }} --help
+```
+
+{% if config.api and config.api.default_base_url %}
+## Configuration
+
+Set the API base URL:
+
+```bash
+export API_BASE_URL="{{ config.api.default_base_url }}"
+```
+
+Set the API key (if required):
+
+```bash
+export API_KEY="your-api-key"
+```
+{% endif %}

cli_wizard/templates/cli.py.j2

@@ -0,0 +1,85 @@
+# AUTO-GENERATED FILE - DO NOT EDIT
+# Generated from OpenAPI specification by cli-wizard
+
+"""Main CLI entry point."""
+
+import os
+import sys
+from pathlib import Path
+
+import click
+
+from {{ package_name }}.constants import __version__, DEFAULT_BASE_URL, DEFAULT_CA_FILE, SPLASH_ENABLED, SPLASH_FILE, SPLASH_COLOR
+from {{ package_name }}.logging import set_debug
+from {{ package_name }}.profile import load_profile
+from {{ package_name }}.commands.config import config
+{% for tag, group in groups.items() %}
+from {{ package_name }}.commands.{{ group.module_name }} import {{ group.module_name }}
+{% endfor %}
+
+
+def _hex_to_rgb(hex_color: str) -> tuple[int, int, int]:
+    """Convert hex color to RGB tuple."""
+    hex_color = hex_color.lstrip("#")
+    return tuple(int(hex_color[i : i + 2], 16) for i in (0, 2, 4))
+
+
+def _show_splash() -> None:
+    """Display splash screen if enabled."""
+    if SPLASH_ENABLED and SPLASH_FILE and SPLASH_FILE.exists():
+        splash_text = SPLASH_FILE.read_text()
+        if SPLASH_COLOR:
+            rgb = _hex_to_rgb(SPLASH_COLOR)
+            click.secho(splash_text, fg=rgb)
+        else:
+            click.echo(splash_text)
+
+
+# Show splash on startup (before Click processes --help or --version)
+_show_splash()
+
+
+@click.group(invoke_without_command=True)
+@click.version_option(version=__version__)
+@click.option("--profile", "-p", default="default", help="Profile name to use")
+@click.option("--debug", "-d", is_flag=True, help="Enable debug output")
+@click.option("--base-url", "-u", envvar="API_BASE_URL", help="API base URL")
+@click.option("--no-verify-ssl", is_flag=True, default=False, help="Disable SSL certificate verification")
+@click.option("--ca-file", type=click.Path(exists=True, dir_okay=False, path_type=Path), help="CA certificate file for SSL verification")
+@click.pass_context
+def main(
+    ctx: click.Context,
+    profile: str,
+    debug: bool,
+    base_url: str | None,
+    no_verify_ssl: bool,
+    ca_file: Path | None,
+) -> None:
+    """{{ config.get('Description', 'Generated CLI') }}"""
+    ctx.ensure_object(dict)
+
+    # Enable debug logging if --debug flag is set
+    set_debug(debug)
+
+    # Load profile
+    load_profile(profile)
+
+    ctx.obj["profile"] = profile
+    ctx.obj["debug"] = debug
+    ctx.obj["base_url"] = base_url
+    ctx.obj["no_verify_ssl"] = no_verify_ssl
+    ctx.obj["ca_file"] = ca_file
+
+    # Show help when no subcommand is invoked
+    if ctx.invoked_subcommand is None:
+        click.echo(ctx.get_help())
+
+
+main.add_command(config)
+{% for tag, group in groups.items() %}
+main.add_command({{ group.module_name }})
+{% endfor %}
+
+
+if __name__ == "__main__":
+    main()