cli-wizard 2.0.0__tar.gz → 2.1.0__tar.gz

{cli_wizard-2.0.0/src/cli_wizard.egg-info → cli_wizard-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cli-wizard
-Version: 2.0.0
+Version: 2.1.0
 Summary: Generate modern CLIs from OpenAPI specifications
 Author-email: Giacomo Marciani <giacomo.marciani@gmail.com>
 License: MIT
@@ -17,24 +17,22 @@ Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: click~=8.3.1
-Requires-Dist: Jinja2~=3.1.6
-Requires-Dist: pydantic~=2.12.5
-Requires-Dist: PyYAML~=6.0.3
-Requires-Dist: requests~=2.32.5
+Requires-Dist: click~=8.4
+Requires-Dist: Jinja2~=3.1
+Requires-Dist: pydantic~=2.13
+Requires-Dist: PyYAML~=6.0
+Requires-Dist: requests~=2.34
+Requires-Dist: ruff~=0.16.2
 Provides-Extra: dev
-Requires-Dist: autoflake~=2.3; extra == "dev"
-Requires-Dist: black~=26.1; extra == "dev"
-Requires-Dist: build~=1.4; extra == "dev"
-Requires-Dist: flake8~=7.3; extra == "dev"
-Requires-Dist: mypy~=1.19; extra == "dev"
-Requires-Dist: pre-commit~=4.5; extra == "dev"
-Requires-Dist: pytest~=9.0; extra == "dev"
-Requires-Dist: pytest-cov~=7.0; extra == "dev"
-Requires-Dist: tox~=4.34; extra == "dev"
-Requires-Dist: twine~=6.2; extra == "dev"
+Requires-Dist: build~=1.5; extra == "dev"
+Requires-Dist: mypy~=2.3; extra == "dev"
+Requires-Dist: pre-commit~=4.6; extra == "dev"
+Requires-Dist: pytest~=9.1; extra == "dev"
+Requires-Dist: pytest-cov~=7.1; extra == "dev"
+Requires-Dist: tox~=4.58; extra == "dev"
+Requires-Dist: twine<8.0,>=6.2; extra == "dev"
 Requires-Dist: types-PyYAML~=6.0; extra == "dev"
-Requires-Dist: types-requests~=2.32; extra == "dev"
+Requires-Dist: types-requests~=2.33; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: sphinx~=9.1; extra == "docs"
 Requires-Dist: sphinx-click~=6.2; extra == "docs"
@@ -54,7 +52,7 @@ Dynamic: license-file
 [![Build status](https://img.shields.io/github/actions/workflow/status/gmarciani/cli-wizard/test.yaml?branch=main)](https://github.com/gmarciani/cli-wizard/actions)
 [![Tests](https://img.shields.io/github/actions/workflow/status/gmarciani/cli-wizard/test.yaml?branch=main&label=tests)](https://github.com/gmarciani/cli-wizard/actions)
 [![Coverage](https://img.shields.io/codecov/c/github/gmarciani/cli-wizard)](https://codecov.io/gh/gmarciani/cli-wizard)
-[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Code style: ruff](https://img.shields.io/badge/code%20style-ruff-261230.svg)](https://github.com/astral-sh/ruff)
 [![Downloads](https://img.shields.io/pypi/dm/cli-wizard.svg)](https://pypi.org/project/cli-wizard)
 
 </div>

{cli_wizard-2.0.0 → cli_wizard-2.1.0}/README.md

@@ -9,7 +9,7 @@
 [![Build status](https://img.shields.io/github/actions/workflow/status/gmarciani/cli-wizard/test.yaml?branch=main)](https://github.com/gmarciani/cli-wizard/actions)
 [![Tests](https://img.shields.io/github/actions/workflow/status/gmarciani/cli-wizard/test.yaml?branch=main&label=tests)](https://github.com/gmarciani/cli-wizard/actions)
 [![Coverage](https://img.shields.io/codecov/c/github/gmarciani/cli-wizard)](https://codecov.io/gh/gmarciani/cli-wizard)
-[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Code style: ruff](https://img.shields.io/badge/code%20style-ruff-261230.svg)](https://github.com/astral-sh/ruff)
 [![Downloads](https://img.shields.io/pypi/dm/cli-wizard.svg)](https://pypi.org/project/cli-wizard)
 
 </div>

cli_wizard-2.1.0/VERSION

@@ -0,0 +1 @@
+2.1.0

{cli_wizard-2.0.0 → cli_wizard-2.1.0}/pyproject.toml

@@ -22,27 +22,25 @@ classifiers = [
 ]
 requires-python = ">=3.12"
 dependencies = [
-    "click~=8.3.1",
-    "Jinja2~=3.1.6",
-    "pydantic~=2.12.5",
-    "PyYAML~=6.0.3",
-    "requests~=2.32.5",
+    "click~=8.4",
+    "Jinja2~=3.1",
+    "pydantic~=2.13",
+    "PyYAML~=6.0",
+    "requests~=2.34",
+    "ruff~=0.16.2",
 ]
 
 [project.optional-dependencies]
 dev = [
-    "autoflake~=2.3",
-    "black~=26.1",
-    "build~=1.4",
-    "flake8~=7.3",
-    "mypy~=1.19",
-    "pre-commit~=4.5",
-    "pytest~=9.0",
-    "pytest-cov~=7.0",
-    "tox~=4.34",
-    "twine~=6.2",
+    "build~=1.5",
+    "mypy~=2.3",
+    "pre-commit~=4.6",
+    "pytest~=9.1",
+    "pytest-cov~=7.1",
+    "tox~=4.58",
+    "twine>=6.2,<8.0",
     "types-PyYAML~=6.0",
-    "types-requests~=2.32",
+    "types-requests~=2.33",
 ]
 docs = [
     "sphinx~=9.1",
@@ -76,9 +74,12 @@ cli_wizard = [
 [tool.setuptools.dynamic]
 version = {file = "VERSION"}
 
-[tool.black]
+[tool.ruff]
 line-length = 88
-target-version = ['py312']
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I"]
 
 [tool.mypy]
 python_version = "3.12"

{cli_wizard-2.0.0 → cli_wizard-2.1.0}/src/cli_wizard/cli.py

@@ -3,12 +3,14 @@
 
 """Main CLI module for CLI Wizard."""
 
-import click
 import logging
-from cli_wizard.constants import __version__
+
+import click
+
 from cli_wizard.commands.bootstrap import bootstrap
 from cli_wizard.commands.config import config
 from cli_wizard.commands.generate import generate
+from cli_wizard.constants import __version__
 
 
 @click.group(help="CLI Wizard - Generate modern CLI from OpenAPI.")

{cli_wizard-2.0.0 → cli_wizard-2.1.0}/src/cli_wizard/commands/bootstrap.py

@@ -6,8 +6,8 @@
 import getpass
 import logging
 import re
-from pathlib import Path
 from datetime import date
+from pathlib import Path
 from typing import Any
 
 import click
@@ -22,6 +22,10 @@ from cli_wizard.generator import CliGenerator
 logger = logging.getLogger(__name__)
 
 
+# Width beyond which PyYAML would wrap a scalar onto a second line
+YAML_NO_WRAP_WIDTH = 2**31 - 1
+
+
 # Parameters prompted during bootstrap (in order)
 BOOTSTRAP_PARAMS: list[str] = [
     "CommandName",
@@ -115,7 +119,8 @@ You will be guided through a step by step procedure to generate
 a basic CLI and an extensible configuration file to evolve it.
 No OpenAPI file is required.
 
-PATH is the directory where the project will be created. It can be a relative or absolute path."""
+PATH is the directory where the project will be created.
+It can be a relative or absolute path."""
 )
 @click.argument(
     "path",
@@ -253,13 +258,17 @@ def _yaml_value(value: Any) -> str:
     elif isinstance(value, bool):
         return "true" if value else "false"
     elif isinstance(value, str):
-        # Quote strings that might be ambiguous
-        if value == "" or value in ("true", "false", "null", "yes", "no"):
-            return f'"{value}"'
-        # Quote strings with special characters
-        if any(c in value for c in ":#{}[]&*!|>'\"%@`"):
-            return f'"{value}"'
-        return f'"{value}"'
+        # Always double-quoted, and escaped by PyYAML rather than by hand, so
+        # that quotes, backslashes and control characters survive the round
+        # trip through the file. The template writes one value per line, so
+        # line wrapping is disabled.
+        return yaml.safe_dump(
+            value,
+            default_style='"',
+            default_flow_style=True,
+            allow_unicode=True,
+            width=YAML_NO_WRAP_WIDTH,
+        ).strip()
     elif isinstance(value, (int, float)):
         return str(value)
     elif isinstance(value, list):
@@ -321,32 +330,54 @@ def _load_cli_config(config_path: Path) -> dict:
         raise SystemExit(1)
 
     # Expand #[Param] references
-    return _expand_config_references(config)
+    try:
+        return _expand_config_references(config)
+    except ValueError as e:
+        click.secho("✗ Invalid configuration:", fg="red", err=True)
+        click.secho(f"  • {e}", fg="red", err=True)
+        raise SystemExit(1)
 
 
 def _expand_config_references(config: dict[str, Any]) -> dict[str, Any]:
-    """Expand #[Param] references in config values recursively."""
+    """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.
+    References to unknown or non-string parameters are left as-is. A parameter
+    that references itself, directly or through other parameters, raises a
+    ValueError rather than expanding forever.
+    """
+    pattern = re.compile(r"#\[(\w+)\]")
+    resolved: dict[str, str] = {}
+
+    def resolve(name: str, chain: tuple[str, ...]) -> str:
+        """Resolve a top-level parameter, refusing to expand it into itself."""
+        if name in chain:
+            path = " -> ".join(chain + (name,))
+            raise ValueError(
+                f"Circular #[Param] reference in configuration: {path} "
+                f'(value of {name!r}: "{config[name]}")'
+            )
+        if name not in resolved:
+            resolved[name] = substitute(config[name], chain + (name,))
+        return resolved[name]
+
+    def substitute(value: str, chain: tuple[str, ...]) -> str:
+        def replace(match: re.Match[str]) -> str:
+            param_name = match.group(1)
+            if isinstance(config.get(param_name), str):
+                return resolve(param_name, chain)
+            return match.group(0)
+
+        return pattern.sub(replace, value)
 
-    def expand_value(value: Any, cfg: dict[str, Any]) -> Any:
+    def expand_value(value: Any) -> Any:
         if isinstance(value, str):
-            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 cfg:
-                        replacement = cfg[param_name]
-                        if isinstance(replacement, str):
-                            value = value.replace(f"#[{param_name}]", replacement)
-            return value
+            return substitute(value, ())
         elif isinstance(value, dict):
-            return {k: expand_value(v, cfg) for k, v in value.items()}
+            return {k: expand_value(v) for k, v in value.items()}
         elif isinstance(value, list):
-            return [expand_value(item, cfg) for item in value]
+            return [expand_value(item) for item in value]
         return value
 
-    expanded = expand_value(config, config)
-    result = expand_value(expanded, expanded)
-    # expand_value always returns a dict when given a dict
-    return dict(result) if isinstance(result, dict) else config
+    return {key: expand_value(value) for key, value in config.items()}

{cli_wizard-2.0.0 → cli_wizard-2.1.0}/src/cli_wizard/commands/common.py

@@ -3,9 +3,10 @@
 
 """Common utilities for CLI Wizard commands."""
 
-import click
 import logging
 
+import click
+
 logger = logging.getLogger(__name__)
 
 

cli_wizard-2.1.0/src/cli_wizard/commands/config.py

@@ -0,0 +1,106 @@
+# Copyright (c) 2026, Giacomo Marciani
+# Licensed under the MIT License
+
+"""Configuration commands for CLI Wizard."""
+
+import json
+import logging
+
+import click
+from pydantic import ValidationError
+
+from cli_wizard.config.configuration import (
+    get_config_path,
+    load_config,
+    load_stored_config,
+    save_config,
+)
+from cli_wizard.config.schema import Config
+
+logger = logging.getLogger(__name__)
+
+
+def _check_known_key(key: str) -> None:
+    """Abort if the key is not a configuration field."""
+    if key not in Config.model_fields:
+        raise click.ClickException(f"Unknown configuration key '{key}'")
+
+
+@click.group(help="Manage configurations.")
+def config() -> None:
+    """Config command group implementation."""
+
+
+@config.command(help="Set a configuration value.")
+@click.argument("key")
+@click.argument("value")
+def set(key: str, value: str) -> None:
+    """Set command implementation."""
+    _check_known_key(key)
+
+    stored = load_stored_config()
+    old_value = load_config().get(key)
+
+    try:
+        stored[key] = Config.parse_cli_value(key, value)
+        save_config(stored)
+    except ValidationError as e:
+        detail = "; ".join(item["msg"] for item in e.errors())
+        raise click.ClickException(f"Invalid value for '{key}': {detail}") from e
+    except ValueError as e:
+        raise click.ClickException(f"Invalid value for '{key}': {e}") from e
+
+    result = {"key": key, "value": load_config()[key], "oldValue": old_value}
+    print(json.dumps(result, indent=2))
+
+
+@config.command(help="Get a configuration value.")
+@click.argument("key")
+def get(key: str) -> None:
+    """Get command implementation."""
+    _check_known_key(key)
+
+    result = {"key": key, "value": load_config()[key]}
+    print(json.dumps(result, indent=2))
+
+
+@config.command(help="Unset a configuration value, reverting it to the default.")
+@click.argument("key")
+def unset(key: str) -> None:
+    """Unset command implementation.
+
+    Removes the key so the schema default applies again. Every field has a
+    default, so this cannot leave a config the schema rejects.
+    """
+    _check_known_key(key)
+
+    stored = load_stored_config()
+    if key in stored:
+        old_value = stored.pop(key)
+        save_config(stored)
+    else:
+        logger.info(f"'{key}' is not set; it already uses the schema default.")
+        old_value = None
+
+    result = {"key": key, "value": load_config()[key], "oldValue": old_value}
+    print(json.dumps(result, indent=2))
+
+
+@config.command(help="Show all configuration values as JSON.")
+def show() -> None:
+    """Show command implementation."""
+    print(json.dumps(load_config(), indent=2))
+
+
+@config.command(help="Reset configuration to defaults and delete local config file.")
+def reset() -> None:
+    """Reset command implementation.
+
+    Deletes before reading: this is the way back from a config file the schema
+    rejects, so it must not depend on that file being loadable.
+    """
+    config_path = get_config_path()
+    if config_path.exists():
+        config_path.unlink()
+
+    print(json.dumps(Config().model_dump(), indent=2))

{cli_wizard-2.0.0 → cli_wizard-2.1.0}/src/cli_wizard/commands/generate.py

@@ -3,31 +3,33 @@
 
 """Generate command for CLI Wizard."""
 
-import re
-from typing import Any
-
-import click
 import logging
+import re
 import shutil
 from pathlib import Path
+from typing import Any
 
+import click
 import yaml
 from pydantic import ValidationError
 
 from cli_wizard.config.schema import Config
 from cli_wizard.constants import CONFIG_FILE_NAME
-from cli_wizard.generator import OpenApiParser, CliGenerator
+from cli_wizard.generator import CliGenerator, OpenApiParser
+from cli_wizard.generator.generator import RuffNotFoundError, resolve_ruff
 
 logger = logging.getLogger(__name__)
 
 
-@click.command(help="""Generate the CLI from config and OpenAPI spec.
+@click.command(
+    help="""Generate the CLI from config and OpenAPI spec.
 
 PATH is the output directory where the CLI project will be generated.
 It can be a relative or absolute path.
 
 If --api is provided, API commands will be generated from the OpenAPI spec.
-Otherwise, a functional CLI is generated without API commands.""")
+Otherwise, a functional CLI is generated without API commands."""
+)
 @click.argument(
     "path",
     type=click.Path(file_okay=False, resolve_path=True),
@@ -47,12 +49,19 @@ Otherwise, a functional CLI is generated without API commands.""")
     default=None,
     help="Path to OpenAPI spec file in YAML or JSON format (optional)",
 )
+@click.option(
+    "--force",
+    "-f",
+    is_flag=True,
+    help="Skip confirmation prompt if output directory exists and is not empty",
+)
 @click.pass_context
 def generate(
     ctx: click.Context,
     path: str,
     configuration: str,
     api: str | None,
+    force: bool,
 ) -> None:
     """Generate command implementation."""
     debug = ctx.obj.get("debug", False) if ctx.obj else False
@@ -116,6 +125,13 @@ def generate(
             fg="cyan",
         )
 
+    # Verify the formatter before deleting the previous output
+    try:
+        resolve_ruff()
+    except RuffNotFoundError as e:
+        click.secho(f"✗ {e}", 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
@@ -132,6 +148,15 @@ def generate(
         except OSError:
             # Current directory may already be deleted
             pass
+
+        # Confirm before destroying a directory that holds work
+        if not force and any(output_path.iterdir()):
+            click.confirm(
+                f"⚠️  Output directory '{output_path}' is not empty. "
+                "Its entire contents will be deleted. Continue?",
+                abort=True,
+            )
+
         click.secho("🧹 Cleaning output directory: ", fg="cyan", nl=False)
         click.echo(output_path)
         shutil.rmtree(output_path)
@@ -185,7 +210,12 @@ def _load_cli_config(config_path: Path) -> dict:
         raise SystemExit(1)
 
     # Expand #[Param] references
-    return _expand_config_references(config)
+    try:
+        return _expand_config_references(config)
+    except ValueError as e:
+        click.secho("✗ Invalid configuration:", fg="red", err=True)
+        click.secho(f"  • {e}", fg="red", err=True)
+        raise SystemExit(1)
 
 
 def _expand_config_references(config: dict[str, Any]) -> dict[str, Any]:
@@ -193,32 +223,41 @@ def _expand_config_references(config: dict[str, Any]) -> dict[str, Any]:
 
     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.
+    References to unknown or non-string parameters are left as-is. A parameter
+    that references itself, directly or through other parameters, raises a
+    ValueError rather than expanding forever.
     """
+    pattern = re.compile(r"#\[(\w+)\]")
+    resolved: dict[str, str] = {}
+
+    def resolve(name: str, chain: tuple[str, ...]) -> str:
+        """Resolve a top-level parameter, refusing to expand it into itself."""
+        if name in chain:
+            path = " -> ".join(chain + (name,))
+            raise ValueError(
+                f"Circular #[Param] reference in configuration: {path} "
+                f'(value of {name!r}: "{config[name]}")'
+            )
+        if name not in resolved:
+            resolved[name] = substitute(config[name], chain + (name,))
+        return resolved[name]
+
+    def substitute(value: str, chain: tuple[str, ...]) -> str:
+        def replace(match: re.Match[str]) -> str:
+            param_name = match.group(1)
+            if isinstance(config.get(param_name), str):
+                return resolve(param_name, chain)
+            return match.group(0)
 
-    def expand_value(value: Any, config: dict[str, Any]) -> Any:
+        return pattern.sub(replace, value)
+
+    def expand_value(value: 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
+            return substitute(value, ())
         elif isinstance(value, dict):
-            return {k: expand_value(v, config) for k, v in value.items()}
+            return {k: expand_value(v) for k, v in value.items()}
         elif isinstance(value, list):
-            return [expand_value(item, config) for item in value]
+            return [expand_value(item) 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
+    return {key: expand_value(value) for key, value in config.items()}

cli_wizard-2.1.0/src/cli_wizard/config/configuration.py

@@ -0,0 +1,77 @@
+# Copyright (c) 2026, Giacomo Marciani
+# Licensed under the MIT License
+
+"""Configuration utilities for CLI Wizard.
+
+``load_stored_config`` returns only the keys the user explicitly set, and that
+is what gets persisted. ``load_config`` returns those merged over the schema
+defaults with derivations applied, and that is what consumers read. Keeping
+them apart is what lets a later ``ProjectName`` change re-derive
+``CommandName`` instead of being pinned by a value that was only ever a
+default.
+"""
+
+import logging
+from pathlib import Path
+from typing import Any, Dict
+
+import yaml
+
+from cli_wizard.config.schema import Config
+from cli_wizard.constants import CONFIG_FILE_NAME
+
+logger = logging.getLogger(__name__)
+
+
+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_FILE_NAME
+
+
+def load_stored_config() -> Dict[str, Any]:
+    """Load only the values explicitly stored in the config file.
+
+    A file that cannot be read, parsed or validated degrades to an empty
+    config with a warning, so it can never lock the user out of the commands
+    that would repair it.
+    """
+    config_path = get_config_path()
+
+    if not config_path.exists():
+        return {}
+
+    try:
+        with open(config_path, "r") as f:
+            stored = yaml.safe_load(f)
+        if not isinstance(stored, dict):
+            raise ValueError("file does not contain a mapping")
+        Config(**stored)  # Validate only; load_config() builds the merged view.
+        return stored
+    except (yaml.YAMLError, IOError, ValueError) as e:
+        # Pydantic's ValidationError is a ValueError.
+        logger.warning(
+            f"Ignoring invalid configuration file '{config_path}' ({e}). "
+            "Run 'cli-wizard config reset' to recreate it."
+        )
+        return {}
+
+
+def load_config() -> Dict[str, Any]:
+    """Load configuration from file, using schema defaults for missing values."""
+    return Config(**load_stored_config()).model_dump()
+
+
+def save_config(config: Dict[str, Any]) -> None:
+    """Save configuration to file, validating and coercing it first.
+
+    Only the keys present in ``config`` are persisted: writing back the full
+    merged dump would freeze derived values such as ``CommandName``.
+    """
+    validated = Config(**config)
+    stored = {key: getattr(validated, key) for key in config}
+
+    config_path = get_config_path()
+    with open(config_path, "w") as f:
+        yaml.safe_dump(stored, f, indent=2)