refactor #112: reorganize config CLI and fix help-mode crash

Signed-off-by: sushant-suse <[email protected]>

Author: sushant-suse

src/docbuild/cli/cmd_cli.py

@@ -219,7 +219,13 @@ def cli(
     context = ctx.obj
     context.verbose, context.dry_run, context.debug = verbose, dry_run, debug
 
-    # State tracking for centralized error handling
+    # --- THE TRUE LAZY FIX ---
+    # If the user is just asking for help, STOP HERE.
+    # Click will handle the help display for the subcommands automatically.
+    if ctx.resilient_parsing or "--help" in sys.argv or "-h" in sys.argv:
+        return
+
+    # 2. Only load config if we aren't displaying help
     current_model: type[BaseModel] = AppConfig
     current_files: Sequence[Path] | None = None
 
@@ -229,11 +235,12 @@ def cli(
         current_files = (app_config,) if app_config else None
         load_app_config(ctx, app_config, max_workers)
 
-        # Setup logging
-        logging_config = context.appconfig.logging.model_dump(
-            by_alias=True, exclude_none=True
-        )
-        setup_logging(cliverbosity=verbose, user_config={"logging": logging_config})
+        # Access logging safely
+        if context.appconfig and context.appconfig.logging:
+            logging_config = context.appconfig.logging.model_dump(
+                by_alias=True, exclude_none=True
+            )
+            setup_logging(cliverbosity=verbose, user_config={"logging": logging_config})
 
         # --- PHASE 2: Load Environment Config ---
         current_model = EnvConfig

src/docbuild/cli/cmd_config/__init__.py

@@ -1,21 +1,21 @@
-"""CLI interface to shows config files how docbuild sees it."""
+"""CLI interface for docbuild configuration management."""
 
 import click
 
-from .application import app
-from .environment import env
+from .list import list_config
+from .validate import validate_config
 
 
 @click.group(
     name="config",
-    help=__doc__,
+    help="CLI interface to manage and verify configuration files.",
 )
 @click.pass_context
 def config(ctx: click.Context) -> None:
-    """Subcommand to show the configuration files and their content."""
+    """Subcommand to manage docbuild configuration (TOML and XML)."""
     pass
 
 
-# Register the subcommands for the config group
-config.add_command(env)
-config.add_command(app)
+# Register the task-oriented subcommands
+config.add_command(list_config)
+config.add_command(validate_config)

src/docbuild/cli/cmd_config/application.py

@@ -0,0 +1,62 @@
+"""CLI interface to list the configuration."""
+
+from typing import Any
+
+import click
+from rich import print_json
+from rich.console import Console
+
+console = Console()
+
+def flatten_dict(d: dict[str, Any], prefix: str = "") -> dict[str, Any]:
+    """Flatten a nested dictionary into dotted keys (e.g., app.logging.level)."""
+    items: list[tuple[str, Any]] = []
+    for k, v in d.items():
+        new_key = f"{prefix}.{k}" if prefix else k
+        if isinstance(v, dict):
+            items.extend(flatten_dict(v, new_key).items())
+        else:
+            items.append((new_key, v))
+    return dict(items)
+
+def _print_section(title: str, data: dict[str, Any], prefix: str, flat: bool, color: str) -> None:
+    """Print the Application and Environment configuration sections."""
+    if flat:
+        for k, v in flatten_dict(data, prefix).items():
+            console.print(f"[bold {color}]{k}[/bold {color}] = [green]{v}[/green]")
+    else:
+        console.print(f"\n# {title}", style="blue")
+        print_json(data=data)
+
+def _print_portal(doctypes: list[Any], flat: bool) -> None:
+    """Print the Portal and Doctype metadata section."""
+    if not flat:
+        console.print("\n# Portal/Doctype Metadata", style="blue")
+
+    for doctype in doctypes:
+        name = getattr(doctype, "name", "Unknown")
+        path = str(getattr(doctype, "path", "N/A"))
+        if flat:
+            console.print(f"[bold magenta]portal.{name}[/bold magenta] = [green]{path}[/green]")
+        else:
+            console.print(f"  - [bold]{name}[/bold]: {path}")
+
+@click.command(name="list")
+@click.option("--app", is_flag=True, help="Show only application configuration")
+@click.option("--env", is_flag=True, help="Show only environment configuration")
+@click.option("--portal", is_flag=True, help="Show only portal/doctype metadata")
+@click.option("--flat", is_flag=True, help="Output in flat dotted format (git-style)")
+@click.pass_context
+def list_config(ctx: click.Context, app: bool, env: bool, portal: bool, flat: bool) -> None:
+    """List the configuration as JSON or flat text."""
+    context = ctx.obj
+    show_all = not (app or env or portal)
+
+    if (app or show_all) and context.appconfig:
+        _print_section("Application Configuration", context.appconfig.model_dump(), "app", flat, "cyan")
+
+    if (env or show_all) and context.envconfig:
+        _print_section("Environment Configuration", context.envconfig.model_dump(), "env", flat, "yellow")
+
+    if (portal or show_all) and context.doctypes:
+        _print_portal(context.doctypes, flat)

src/docbuild/cli/cmd_config/environment.py

@@ -0,0 +1,57 @@
+"""CLI interface to validate the configuration files."""
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+
+
+@click.command(name="validate")
+@click.pass_context
+def validate_config(ctx: click.Context) -> None:
+    """Validate all configuration files (TOML and XML).
+
+    This command performs a full check of the application settings,
+    environment overrides, and portal doctypes.
+    """
+    context = ctx.obj
+    console = Console()
+
+    # Since this command is reached only if the main CLI loader
+    # didn't exit with an error, we know the TOML files are
+    # syntactically correct and match the Pydantic models.
+
+    console.print("[bold blue]Running Configuration Validation...[/bold blue]\n")
+
+    # 1. App Config Status
+    if context.appconfig:
+        console.print("✅ [bold]Application Configuration:[/bold] Valid")
+        if context.appconfigfiles:
+            for f in context.appconfigfiles:
+                console.print(f"   [dim]- {f}[/dim]")
+
+    # 2. Env Config Status
+    if context.envconfig:
+        console.print("\n✅ [bold]Environment Configuration:[/bold] Valid")
+        if context.envconfigfiles:
+            for f in context.envconfigfiles:
+                console.print(f"   [dim]- {f}[/dim]")
+        elif context.envconfig_from_defaults:
+            console.print("   [dim]- Using internal defaults[/dim]")
+
+    # 3. Portal/Doctype Status
+    if context.doctypes:
+        console.print(f"\n✅ [bold]Portals/Doctypes:[/bold] {len(context.doctypes)} discovered")
+        for doctype in context.doctypes:
+            name = getattr(doctype, "name", "Unknown")
+            console.print(f"   [dim]- {name}[/dim]")
+    else:
+        console.print("\n⚠️ [bold yellow]Portals/Doctypes:[/bold yellow] None discovered")
+
+    console.print(
+        Panel(
+            "[bold green]Configuration is valid![/bold green]\n"
+            "All TOML files match the required schema and portals are reachable.",
+            border_style="green",
+            expand=False
+        )
+    )

src/docbuild/cli/cmd_config/list.py

@@ -0,0 +1,40 @@
+from pathlib import Path
+from unittest.mock import Mock
+
+import pytest
+
+from docbuild.cli.cmd_cli import cli
+from docbuild.models.config.app import AppConfig
+from docbuild.models.config.env import EnvConfig
+
+
+@pytest.fixture
+def mock_models(monkeypatch):
+    """Local fixture to mock config models for list command tests."""
+    mock_app = Mock(spec=AppConfig)
+    # 1. Provide the logging attribute the CLI expects
+    mock_app.logging = Mock()
+    mock_app.logging.model_dump.return_value = {"version": 1}
+    # 2. Provide the data for our 'list' command
+    mock_app.model_dump.return_value = {"key": "value", "logging": {"level": "info"}}
+
+    mock_env = Mock(spec=EnvConfig)
+    mock_env.model_dump.return_value = {"env_key": "env_val"}
+
+    monkeypatch.setattr(AppConfig, "from_dict", Mock(return_value=mock_app))
+    monkeypatch.setattr(EnvConfig, "from_dict", Mock(return_value=mock_env))
+    return mock_app
+
+def test_config_list_json(runner, mock_models, fake_handle_config):
+    """Test that config list shows the expected JSON output."""
+    fake_handle_config(lambda *a, **k: ((Path("test.toml"),), {"key": "value"}, False))
+    result = runner.invoke(cli, ["config", "list"])
+    assert result.exit_code == 0
+    assert '"key": "value"' in result.output
+
+def test_config_list_flat(runner, mock_models, fake_handle_config):
+    """Test that config list with --flat shows flattened keys."""
+    fake_handle_config(lambda *a, **k: ((Path("test.toml"),), {"logging": {"level": "info"}}, False))
+    result = runner.invoke(cli, ["config", "list", "--flat"])
+    assert result.exit_code == 0
+    assert "app.logging.level = info" in result.output

src/docbuild/cli/cmd_config/validate.py

@@ -0,0 +1,44 @@
+from pathlib import Path
+from unittest.mock import MagicMock, Mock
+
+import pytest
+
+from docbuild.cli.cmd_cli import cli
+from docbuild.cli.context import DocBuildContext
+from docbuild.models.config.app import AppConfig
+from docbuild.models.config.env import EnvConfig
+
+
+@pytest.fixture
+def mock_models(monkeypatch):
+    """Local fixture to mock config models for validate command tests."""
+    mock_app = Mock(spec=AppConfig)
+    mock_app.logging = Mock()
+    mock_app.logging.model_dump.return_value = {"version": 1}
+
+    mock_env = Mock(spec=EnvConfig)
+
+    monkeypatch.setattr(AppConfig, "from_dict", Mock(return_value=mock_app))
+    monkeypatch.setattr(EnvConfig, "from_dict", Mock(return_value=mock_env))
+    return mock_app
+
+def test_config_validate_success(runner, mock_models, fake_handle_config):
+    """Test that config validate succeeds with valid configuration."""
+    # Setup context attributes so they don't default to Mocks
+    # Manually create the context with real lists/tuples to avoid Mock iteration errors
+    ctx_obj = DocBuildContext()
+    ctx_obj.appconfig = mock_models
+    ctx_obj.appconfigfiles = (Path("app.toml"),)
+    ctx_obj.envconfig = MagicMock() # Mock for EnvConfig
+    ctx_obj.envconfigfiles = (Path("env.toml"),)
+    ctx_obj.doctypes = [] # Explicitly empty list
+
+    fake_handle_config(lambda *a, **k: ((Path("app.toml"),), {"key": "val"}, False))
+
+    # We use 'standalone_mode=False' so we can see the actual error if it crashes
+    result = runner.invoke(cli, ["config", "validate"], obj=ctx_obj)
+
+    assert result.exit_code == 0
+    # Use 'in' to check for text without worrying about exact formatting/colors
+    assert "Configuration is valid" in result.output
+    assert "Application Configuration" in result.output