cli-wizard 1.0.0__py3-none-any.whl

cli_wizard/__init__.py

@@ -0,0 +1,4 @@
+# Copyright (c) 2026, Giacomo Marciani
+# Licensed under the MIT License
+
+"""CLI Wizard - Build modern CLI from OpenAPI"""

cli_wizard/cli.py

@@ -0,0 +1,37 @@
+# Copyright (c) 2026, Giacomo Marciani
+# Licensed under the MIT License
+
+"""Main CLI module for CLI Wizard."""
+
+import click
+import logging
+from cli_wizard.constants import __version__
+from cli_wizard.commands.config import config
+from cli_wizard.commands.generate import generate
+
+
+@click.group()
+@click.version_option(version=__version__, prog_name="cli-wizard")
+@click.option("--debug", "-d", is_flag=True, help="Enable debug output")
+@click.pass_context
+def main(ctx: click.Context, debug: bool) -> None:
+    """CLI Wizard - Generate modern CLI from OpenAPI."""
+    ctx.ensure_object(dict)
+    ctx.obj["debug"] = debug
+
+    # Configure logging
+    level = logging.DEBUG if debug else logging.INFO
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s %(levelname)s: %(message)s",
+        datefmt="%Y-%m-%dT%H:%M:%SZ",
+    )
+    logging.Formatter.converter = lambda *args: __import__("time").gmtime()
+
+
+main.add_command(config)
+main.add_command(generate)
+
+
+if __name__ == "__main__":
+    main()

cli_wizard/commands/__init__.py

@@ -0,0 +1,4 @@
+# Copyright (c) 2026, Giacomo Marciani
+# Licensed under the MIT License
+
+"""Commands package for CLI Wizard."""

cli_wizard/commands/common.py

@@ -0,0 +1,36 @@
+# Copyright (c) 2026, Giacomo Marciani
+# Licensed under the MIT License
+
+"""Common utilities for CLI Wizard commands."""
+
+import click
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def configure_logging(debug: bool = False) -> None:
+    """Configure logging with UTC timestamps.
+
+    Args:
+        debug: Whether to enable debug level logging
+    """
+    import time
+
+    for handler in logging.root.handlers[:]:
+        logging.root.removeHandler(handler)
+    level = logging.DEBUG if debug else logging.INFO
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s %(levelname)s: %(message)s",
+        datefmt="%Y-%m-%dT%H:%M:%SZ",
+    )
+    logging.Formatter.converter = time.gmtime
+
+
+debug_option = click.option(
+    "--debug",
+    "-d",
+    is_flag=True,
+    help="Enable debug output",
+)

cli_wizard/commands/config.py

@@ -0,0 +1,82 @@
+# Copyright (c) 2026, Giacomo Marciani
+# Licensed under the MIT License
+
+"""Configuration commands for CLI Wizard."""
+
+import click
+import logging
+import json
+from cli_wizard.config.configuration import (
+    load_config,
+    save_config,
+    get_config_path,
+)
+
+logger = logging.getLogger(__name__)
+
+
+@click.group()
+def config() -> None:
+    """Manage configurations."""
+
+
+@config.command()
+@click.argument("key")
+@click.argument("value")
+def set(key: str, value: str) -> None:
+    """Set a configuration value."""
+    cfg = load_config()
+    old_value = cfg.get(key)
+    cfg[key] = value
+    save_config(cfg)
+
+    result = {"key": key, "value": value, "oldValue": old_value}
+    print(json.dumps(result, indent=2))
+
+
+@config.command()
+@click.argument("key")
+def get(key: str) -> None:
+    """Get a configuration value."""
+    cfg = load_config()
+    if key not in cfg:
+        logger.error(f"Unknown configuration key '{key}'")
+        return
+
+    result = {"key": key, "value": cfg[key]}
+    print(json.dumps(result, indent=2))
+
+
+@config.command()
+@click.argument("key")
+def unset(key: str) -> None:
+    """Unset a configuration value (set to None)."""
+    cfg = load_config()
+    if key not in cfg:
+        logger.error(f"Unknown configuration key '{key}'")
+        return
+
+    old_value = cfg.get(key)
+    cfg[key] = None
+    save_config(cfg)
+
+    result = {"key": key, "value": None, "oldValue": old_value}
+    print(json.dumps(result, indent=2))
+
+
+@config.command()
+def show() -> None:
+    """Show all configuration values as JSON."""
+    cfg = load_config()
+    print(json.dumps(cfg, indent=2))
+
+
+@config.command()
+def reset() -> None:
+    """Reset configuration to defaults and delete local config file."""
+    cfg = load_config()
+    print(json.dumps(cfg, indent=2))
+
+    config_path = get_config_path()
+    if config_path.exists():
+        config_path.unlink()

cli_wizard/commands/generate.py

@@ -0,0 +1,231 @@
+# Copyright (c) 2026, Giacomo Marciani
+# Licensed under the MIT License
+
+"""Generate command for CLI Wizard."""
+
+import re
+from typing import Any
+
+import click
+import logging
+import shutil
+from pathlib import Path
+
+import yaml
+from pydantic import ValidationError
+
+from cli_wizard.config.configuration import load_default_config
+from cli_wizard.config.schema import Config
+from cli_wizard.generator import OpenApiParser, CliGenerator
+
+logger = logging.getLogger(__name__)
+
+# Load defaults from config
+_defaults = load_default_config()
+_default_openapi = _defaults.get("OpenApiFileName", "openapi.yaml")
+_default_config = _defaults.get("ConfigFileName", "config.yaml")
+_default_output = _defaults.get("OutputDir", "cli")
+
+
+@click.command()
+@click.option(
+    "--working-dir",
+    "-w",
+    type=click.Path(exists=True, file_okay=False, resolve_path=True),
+    default=None,
+    help="Working directory for resolving relative paths",
+)
+@click.option(
+    "--openapi",
+    "-o",
+    type=click.Path(dir_okay=False),
+    default=_default_openapi,
+    help=f"Path to OpenAPI spec file in YAML or JSON format (default: {_default_openapi})",
+)
+@click.option(
+    "--config",
+    "-c",
+    type=click.Path(dir_okay=False),
+    default=_default_config,
+    help=f"Path to config YAML file (default: {_default_config})",
+)
+@click.option(
+    "--output",
+    "-d",
+    type=click.Path(file_okay=False),
+    default=_default_output,
+    help=f"Output directory for generated CLI (default: {_default_output})",
+)
+@click.pass_context
+def generate(
+    ctx: click.Context,
+    working_dir: str | None,
+    openapi: str,
+    config: str,
+    output: str,
+) -> None:
+    """Generate a CLI from an OpenAPI spec and config file."""
+    debug = ctx.obj.get("debug", False) if ctx.obj else False
+
+    # Resolve paths relative to working directory
+    base_dir = Path(working_dir) if working_dir else Path.cwd()
+    openapi_path = (
+        base_dir / openapi if not Path(openapi).is_absolute() else Path(openapi)
+    )
+    config_path = base_dir / config if not Path(config).is_absolute() else Path(config)
+
+    if debug:
+        logger.debug(f"Working directory: {base_dir}")
+        logger.debug(f"OpenAPI spec: {openapi_path}")
+        logger.debug(f"Config file: {config_path}")
+
+    # Validate input files exist
+    if not openapi_path.exists():
+        click.secho(
+            f"✗ OpenAPI spec file not found: {openapi_path}", fg="red", err=True
+        )
+        raise SystemExit(1)
+    if not config_path.exists():
+        click.secho(f"✗ Config file not found: {config_path}", fg="red", err=True)
+        raise SystemExit(1)
+
+    # Load and validate configuration
+    cli_config = _load_cli_config(config_path)
+
+    # Resolve output path (CLI option > config > default)
+    output_dir: str = output
+    if output == _default_output:
+        config_output = cli_config.get("OutputDir")
+        if config_output is not None:
+            output_dir = str(config_output)
+    output_path = (
+        base_dir / output_dir
+        if not Path(output_dir).is_absolute()
+        else Path(output_dir)
+    )
+
+    if debug:
+        logger.debug(f"Output directory: {output_path}")
+
+    # Get CLI name and package name from config
+    cli_name = cli_config["PackageName"]
+    # Convert hyphens to underscores for Python package compatibility
+    package_name = cli_name.replace("-", "_")
+
+    # Parse OpenAPI spec
+    click.secho("📄 Parsing OpenAPI spec: ", fg="cyan", nl=False)
+    click.echo(openapi_path)
+    parser = OpenApiParser(str(openapi_path))
+
+    groups = parser.parse(
+        exclude_tags=cli_config.get("ExcludeTags", []),
+        include_tags=cli_config.get("IncludeTags", []),
+        tag_mapping=cli_config.get("TagMapping", {}),
+    )
+
+    if not groups:
+        click.secho("✗ No operations found in OpenAPI spec", fg="red", err=True)
+        raise SystemExit(1)
+
+    # Clean up output directory before generating
+    if output_path.exists():
+        # Check if we're inside the output directory
+        try:
+            cwd = Path.cwd()
+            if output_path in cwd.parents or output_path == cwd:
+                click.secho(
+                    f"✗ Cannot clean output directory while inside it. "
+                    f"Please run from a different directory.",
+                    fg="red",
+                    err=True,
+                )
+                raise SystemExit(1)
+        except OSError:
+            # Current directory may already be deleted
+            pass
+        click.secho("🧹 Cleaning output directory: ", fg="cyan", nl=False)
+        click.echo(output_path)
+        shutil.rmtree(output_path)
+
+    # Generate CLI project
+    click.secho("⚙️  Generating CLI project: ", fg="cyan", nl=False)
+    click.echo(output_path)
+    generator = CliGenerator(config=cli_config, config_dir=config_path.parent)
+    generator.generate(groups, output_path, cli_name, package_name)
+
+    # Summary
+    click.secho(f"\n✓ Generated CLI '{cli_name}'", fg="green", bold=True)
+    click.secho("  📁 Location: ", fg="white", nl=False)
+    click.echo(output_path)
+    click.secho("  📦 Package: ", fg="white", nl=False)
+    click.echo(package_name)
+    click.secho("  🔧 Commands: ", fg="white", nl=False)
+    click.echo(f"{len(groups)} groups")
+    for tag, group in groups.items():
+        click.secho(f"     • {group.cli_name}", fg="yellow", nl=False)
+        click.echo(f" ({len(group.operations)} commands)")
+
+    click.echo()
+    click.secho("📋 Next steps:", fg="cyan", bold=True)
+    click.echo(f"   pip install -e {output_path}")
+    click.echo(f"   {cli_name} --help")
+
+
+def _load_cli_config(config_path: Path) -> dict:
+    """Load and validate CLI generator configuration from YAML file."""
+    try:
+        with open(config_path) as f:
+            raw_config = yaml.safe_load(f) or {}
+    except (yaml.YAMLError, IOError) as e:
+        click.secho(f"✗ Could not load config file: {e}", fg="red", err=True)
+        raise SystemExit(1)
+
+    # Validate with Pydantic schema
+    try:
+        validated = Config(**raw_config)
+        config = validated.model_dump()
+    except ValidationError as e:
+        click.secho("✗ Invalid configuration:", fg="red", err=True)
+        for error in e.errors():
+            field = ".".join(str(loc) for loc in error["loc"])
+            click.secho(f"  • {field}: {error['msg']}", fg="red", err=True)
+        raise SystemExit(1)
+
+    # Expand #[Param] references
+    return _expand_config_references(config)
+
+
+def _expand_config_references(config: dict[str, Any]) -> dict[str, Any]:
+    """Expand #[Param] references in config values recursively.
+
+    Supports referencing other config parameters using #[ParamName] syntax.
+    Environment variables using ${VAR} syntax are left as-is for runtime expansion.
+    Recursively expands until no more references remain.
+    """
+
+    def expand_value(value: Any, config: dict[str, Any]) -> Any:
+        if isinstance(value, str):
+            # Keep expanding until no more #[Param] references
+            pattern = r"#\[(\w+)\]"
+            prev_value: str | None = None
+            while prev_value != value:
+                prev_value = value
+                matches = re.findall(pattern, value)
+                for param_name in matches:
+                    if param_name in config:
+                        replacement = config[param_name]
+                        if isinstance(replacement, str):
+                            value = value.replace(f"#[{param_name}]", replacement)
+            return value
+        elif isinstance(value, dict):
+            return {k: expand_value(v, config) for k, v in value.items()}
+        elif isinstance(value, list):
+            return [expand_value(item, config) for item in value]
+        return value
+
+    # First pass: expand all values
+    expanded: dict[str, Any] = expand_value(config, config)
+
+    # Second pass: re-expand with updated config to handle nested references
+    result: dict[str, Any] = expand_value(expanded, expanded)
+    return result

cli_wizard/config/configuration.py

@@ -0,0 +1,53 @@
+# Copyright (c) 2026, Giacomo Marciani
+# Licensed under the MIT License
+
+"""Configuration utilities for CLI Wizard."""
+
+import yaml
+from pathlib import Path
+from typing import Dict, Any
+import importlib.resources
+
+
+def get_config_path() -> Path:
+    """Get the configuration file path."""
+    config_dir = Path.home() / ".cli_wizard"
+    config_dir.mkdir(exist_ok=True)
+    return config_dir / "config.yaml"
+
+
+def load_default_config() -> Dict[str, Any]:
+    """Load default configuration from packaged default_config.yaml."""
+    try:
+        with importlib.resources.open_text(
+            "cli_wizard.config", "default_config.yaml"
+        ) as f:
+            data = yaml.safe_load(f)
+            return data if isinstance(data, dict) else {}
+    except (yaml.YAMLError, IOError, FileNotFoundError):
+        return {}
+
+
+def load_config() -> Dict[str, Any]:
+    """Load configuration from file, merging with defaults."""
+    default_config = load_default_config()
+    config_path = get_config_path()
+
+    if not config_path.exists():
+        return default_config
+
+    try:
+        with open(config_path, "r") as f:
+            user_config = yaml.safe_load(f)
+            if isinstance(user_config, dict):
+                default_config.update(user_config)
+            return default_config
+    except (yaml.YAMLError, IOError):
+        return default_config
+
+
+def save_config(config: Dict[str, Any]) -> None:
+    """Save configuration to file."""
+    config_path = get_config_path()
+    with open(config_path, "w") as f:
+        yaml.safe_dump(config, f, indent=2)

cli_wizard/config/default_config.yaml

@@ -0,0 +1,7 @@
+ConfigFileName: config.yaml
+OpenApiFileName: openapi.json
+OutputDir: cli
+# PackageName sets the Python package name for the generated CLI.
+# Hyphens are automatically converted to underscores for Python compatibility.
+# Example: "my-cli" becomes "my_cli" for the package folder.
+PackageName: my-cli

cli_wizard/config/schema.py

@@ -0,0 +1,182 @@
+# Copyright (c) 2026, Giacomo Marciani
+# Licensed under the MIT License
+
+"""Configuration schema for CLI Wizard."""
+
+import re
+from typing import Literal
+
+from pydantic import BaseModel, Field, field_validator
+
+
+class Config(BaseModel):
+    """CLI Wizard configuration schema."""
+
+    # Required parameters
+    PackageName: str = Field(
+        ..., description="Python package name for the generated CLI"
+    )
+    DefaultBaseUrl: str = Field(..., description="Default API base URL")
+
+    # Output settings
+    OutputDir: str = Field(
+        default="#[PackageName]",
+        description="Output directory for the generated CLI project",
+    )
+    MainDir: str = Field(
+        default="${HOME}/.#[PackageName]",
+        description="Main directory for CLI data (config, cache, logging, etc.)",
+    )
+    ProfileFile: str = Field(
+        default="#[MainDir]/profiles.yaml",
+        description="Path to profiles YAML file",
+    )
+
+    # OpenAPI settings
+    OpenapiSpec: str = Field(
+        default="openapi.json",
+        description="Path to OpenAPI spec (relative to config file or absolute)",
+    )
+    ExcludeTags: list[str] = Field(
+        default_factory=list,
+        description="Tags to exclude from generation",
+    )
+    IncludeTags: list[str] = Field(
+        default_factory=list,
+        description="Tags to include (if empty, all non-excluded tags are included)",
+    )
+    TagMapping: dict[str, str] = Field(
+        default_factory=dict,
+        description="Map OpenAPI tags to CLI command group names",
+    )
+    CommandMapping: dict[str, str] = Field(
+        default_factory=dict,
+        description="Customize command names (operationId -> command name)",
+    )
+
+    # Output formatting
+    OutputFormat: Literal["json", "table", "yaml"] = Field(
+        default="json",
+        description="Default output format",
+    )
+    OutputColors: bool = Field(
+        default=True,
+        description="Enable colored output",
+    )
+    JsonIndent: int = Field(
+        default=2,
+        ge=0,
+        description="JSON indentation",
+    )
+    TableStyle: Literal["ascii", "rounded", "minimal", "markdown"] = Field(
+        default="rounded",
+        description="Table style",
+    )
+
+    # Splash screen
+    SplashFile: str | None = Field(
+        default=None,
+        description="Path to splash text file (relative to config or absolute)",
+    )
+    SplashColor: str = Field(
+        default="#FFFFFF",
+        description="Color for splash text (hex code)",
+    )
+
+    # Logging
+    LogLevel: Literal["DEBUG", "INFO", "WARNING", "ERROR"] = Field(
+        default="INFO",
+        description="Default log level",
+    )
+    LogFormat: str = Field(
+        default="[%(levelname)s] %(asctime)s %(message)s",
+        description="Log message format (Python logging format)",
+    )
+    LogTimestampFormat: str = Field(
+        default="%Y-%m-%dT%H:%M:%S",
+        description="Timestamp format for log messages (strftime format)",
+    )
+    LogTimezone: Literal["UTC", "Local"] = Field(
+        default="UTC",
+        description="Timezone for log timestamps",
+    )
+    LogColorStyle: Literal["full", "level"] = Field(
+        default="level",
+        description="Log color style: 'full' colors entire line, 'level' colors only the level prefix",
+    )
+    LogColorDebug: str = Field(
+        default="#808080",
+        description="Color for DEBUG log level (hex code)",
+    )
+    LogColorInfo: str = Field(
+        default="#00FF00",
+        description="Color for INFO log level (hex code)",
+    )
+    LogColorWarning: str = Field(
+        default="#FFFF00",
+        description="Color for WARNING log level (hex code)",
+    )
+    LogColorError: str = Field(
+        default="#FF0000",
+        description="Color for ERROR log level (hex code)",
+    )
+    LogFile: str | None = Field(
+        default=None,
+        description="Path to log file (None means no file logging)",
+    )
+    LogRotationType: Literal["size", "days"] = Field(
+        default="days",
+        description="Log rotation type: 'size' for file size, 'days' for time-based",
+    )
+    LogRotationSize: int = Field(
+        default=10,
+        ge=1,
+        description="Log rotation size in MB (when LogRotationType is 'size')",
+    )
+    LogRotationDays: int = Field(
+        default=30,
+        ge=1,
+        description="Log rotation interval in days (when LogRotationType is 'days')",
+    )
+    LogRotationBackupCount: int = Field(
+        default=5,
+        ge=0,
+        description="Number of backup log files to keep",
+    )
+
+    # API client settings
+    Timeout: int = Field(
+        default=30,
+        ge=1,
+        description="Request timeout in seconds",
+    )
+    CaFile: str | None = Field(
+        default=None,
+        description="CA certificate file for SSL verification (relative to config or absolute)",
+    )
+    RetryMaxAttempts: int = Field(
+        default=3,
+        ge=0,
+        description="Retry max attempts",
+    )
+    RetryBackoffFactor: float = Field(
+        default=0.5,
+        ge=0,
+        description="Retry backoff factor",
+    )
+
+    @field_validator(
+        "SplashColor",
+        "LogColorDebug",
+        "LogColorInfo",
+        "LogColorWarning",
+        "LogColorError",
+    )
+    @classmethod
+    def validate_hex_color(cls, v: str) -> str:
+        """Validate that color is a valid hex color code."""
+        if not re.match(r"^#[0-9A-Fa-f]{6}$", v):
+            raise ValueError(f"Invalid hex color code: {v}. Must be in format #RRGGBB")
+        return v.upper()
+
+    model_config = {"extra": "forbid"}

cli_wizard/constants.py

@@ -0,0 +1,11 @@
+# Copyright (c) 2026, Giacomo Marciani
+# Licensed under the MIT License
+
+"""Constants for CLI Wizard."""
+
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("cli-wizard")
+except PackageNotFoundError:
+    __version__ = "0.0.0"

cli_wizard/generator/__init__.py

@@ -0,0 +1,22 @@
+# Copyright (c) 2026, Giacomo Marciani
+# Licensed under the MIT License
+
+"""Generator package for CLI Wizard."""
+
+from cli_wizard.generator.parser import OpenApiParser
+from cli_wizard.generator.generator import CliGenerator
+from cli_wizard.generator.models import (
+    Parameter,
+    RequestBodyProperty,
+    Operation,
+    CommandGroup,
+)
+
+__all__ = [
+    "OpenApiParser",
+    "CliGenerator",
+    "Parameter",
+    "RequestBodyProperty",
+    "Operation",
+    "CommandGroup",
+]