mcp-souschef 3.0.0__py3-none-any.whl → 3.5.1__py3-none-any.whl

souschef/ci/common.py

@@ -54,7 +54,7 @@ def _parse_kitchen_configuration(kitchen_file: Path) -> tuple[list[str], list[st
     kitchen_platforms: list[str] = []
 
     try:
-        with kitchen_file.open() as file_handle:
+        with kitchen_file.open() as file_handle:  # nosonar
             kitchen_config = yaml.safe_load(file_handle)
             if not kitchen_config:
                 return kitchen_suites, kitchen_platforms

souschef/cli.py

@@ -7,12 +7,13 @@ Provides easy access to Chef cookbook parsing and conversion tools.
 import json
 import sys
 from pathlib import Path
-from typing import NoReturn
+from typing import NoReturn, TypedDict
 
 import click
 
 from souschef import __version__
 from souschef.converters.playbook import generate_playbook_from_recipe
+from souschef.core.logging import configure_logging
 from souschef.core.path_utils import _normalize_path
 from souschef.profiling import (
     generate_cookbook_performance_report,
@@ -36,11 +37,25 @@ from souschef.server import (
     read_file,
 )
 
+
+class ConversionResults(TypedDict):
+    """Type definition for cookbook conversion results."""
+
+    cookbook_name: str
+    recipes: dict[str, str]
+    templates: dict[str, str]
+    attributes: dict[str, str]
+    metadata: dict[str, str] | str
+
+
 # CI/CD job description constants
 CI_JOB_LINT = "  • Lint (cookstyle/foodcritic)"
 CI_JOB_UNIT_TESTS = "  • Unit Tests (ChefSpec)"
 CI_JOB_INTEGRATION_TESTS = "  • Integration Tests (Test Kitchen)"
 
+# File name constants
+METADATA_FILENAME = "metadata.rb"
+
 
 def _resolve_output_path(output: str | None, default_path: Path) -> Path:
     """Normalise and validate output paths for generated files."""
@@ -54,6 +69,33 @@ def _resolve_output_path(output: str | None, default_path: Path) -> Path:
     return resolved_path
 
 
+def _safe_write_file(content: str, output: str | None, default_path: Path) -> Path:
+    """
+    Safely write content to a validated file path.
+
+    Args:
+        content: Content to write to file.
+        output: Optional user-specified output path.
+        default_path: Default path if output not specified.
+
+    Returns:
+        The path where content was written.
+
+    Raises:
+        click.Abort: If path validation or write fails.
+
+    """
+    validated_path = _resolve_output_path(output, default_path)
+    try:
+        # Separate validation from write to satisfy SonarQube path construction rules
+        with validated_path.open("w", encoding="utf-8") as f:
+            f.write(content)
+    except OSError as e:
+        click.echo(f"Error writing file: {e}", err=True)
+        raise click.Abort() from e
+    return validated_path
+
+
 @click.group()
 @click.version_option(version=__version__, prog_name="souschef")
 def cli() -> None:
@@ -308,7 +350,7 @@ def cookbook(cookbook_path: str, output: str | None, dry_run: bool) -> None:
     click.echo("=" * 50)
 
     # Parse metadata
-    metadata_file = cookbook_dir / "metadata.rb"
+    metadata_file = cookbook_dir / METADATA_FILENAME
     if metadata_file.exists():
         click.echo("\n📋 Metadata:")
         click.echo("-" * 50)
@@ -345,9 +387,124 @@ def cookbook(cookbook_path: str, output: str | None, dry_run: bool) -> None:
         for template_file in templates_dir.glob("*.erb"):
             _display_template_summary(template_file)
 
+    # Convert and save if output directory specified
     if output and not dry_run:
+        _save_cookbook_conversion(cookbook_dir, output)
+    elif output and dry_run:
         click.echo(f"\n💾 Would save results to: {output}")
-        click.echo("(Full conversion not yet implemented)")
+        click.echo("(Dry run - no files will be written)")
+
+
+def _save_cookbook_conversion(cookbook_dir: Path, output_path: str) -> None:
+    """
+    Convert and save cookbook to Ansible format.
+
+    Args:
+        cookbook_dir: Path to Chef cookbook directory
+        output_path: Path to output directory for Ansible files
+
+    """
+    output_dir = Path(output_path)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    click.echo(f"\n💾 Saving conversion to: {output_dir}")
+    click.echo("=" * 50)
+
+    results: ConversionResults = {
+        "cookbook_name": cookbook_dir.name,
+        "recipes": {},
+        "templates": {},
+        "attributes": {},
+        "metadata": {},
+    }
+
+    # Convert metadata
+    metadata_file = cookbook_dir / METADATA_FILENAME
+    if metadata_file.exists():
+        click.echo("Converting metadata...")
+        metadata_result = read_cookbook_metadata(str(metadata_file))
+        results["metadata"] = metadata_result
+
+        # Save metadata as README
+        readme_path = output_dir / "README.md"
+        with readme_path.open("w") as f:
+            f.write(f"# {cookbook_dir.name} - Converted from Chef\n\n")
+            f.write("## Metadata\n\n")
+            f.write(metadata_result)
+        click.echo(f"  ✓ Saved metadata to {readme_path}")
+
+    # Convert recipes to playbooks
+    recipes_dir = cookbook_dir / "recipes"
+    playbooks_dir = output_dir / "playbooks"
+    if recipes_dir.exists():
+        playbooks_dir.mkdir(parents=True, exist_ok=True)
+        click.echo("\nConverting recipes to playbooks...")
+
+        for recipe_file in recipes_dir.glob("*.rb"):
+            playbook_name = recipe_file.stem
+            playbook_content = generate_playbook_from_recipe(str(recipe_file))
+
+            playbook_path = playbooks_dir / f"{playbook_name}.yml"
+            with playbook_path.open("w") as f:
+                f.write(playbook_content)
+
+            results["recipes"][playbook_name] = str(playbook_path)
+            click.echo(f"  ✓ Converted {recipe_file.name} → {playbook_path}")
+
+    # Convert templates
+    templates_dir = cookbook_dir / "templates" / "default"
+    output_templates_dir = output_dir / "templates"
+    if templates_dir.exists():
+        from souschef.converters.template import convert_template_file
+
+        output_templates_dir.mkdir(parents=True, exist_ok=True)
+        click.echo("\nConverting ERB templates to Jinja2...")
+
+        for template_file in templates_dir.glob("*.erb"):
+            template_result = convert_template_file(str(template_file))
+
+            if template_result.get("success"):
+                jinja_name = template_file.stem + ".j2"
+                jinja_path = output_templates_dir / jinja_name
+
+                with jinja_path.open("w") as f:
+                    f.write(template_result.get("jinja2_template", ""))
+
+                results["templates"][template_file.name] = str(jinja_path)
+                click.echo(f"  ✓ Converted {template_file.name} → {jinja_path}")
+            else:
+                click.echo(f"  ✗ Failed to convert {template_file.name}")
+
+    # Parse and save attributes
+    attributes_dir = cookbook_dir / "attributes"
+    if attributes_dir.exists():
+        vars_dir = output_dir / "vars"
+        vars_dir.mkdir(parents=True, exist_ok=True)
+        click.echo("\nExtracting attributes...")
+
+        for attr_file in attributes_dir.glob("*.rb"):
+            attr_result = parse_attributes(str(attr_file))
+
+            # Save as YAML vars file
+            vars_name = attr_file.stem + ".yml"
+            vars_path = vars_dir / vars_name
+
+            with vars_path.open("w") as f:
+                f.write("# Converted from Chef attributes\n")
+                f.write(f"# Source: {attr_file.name}\n\n")
+                f.write(attr_result)
+
+            results["attributes"][attr_file.name] = str(vars_path)
+            click.echo(f"  ✓ Extracted {attr_file.name} → {vars_path}")
+
+    # Save conversion summary
+    summary_path = output_dir / "conversion_summary.json"
+    with summary_path.open("w") as f:
+        json.dump(results, f, indent=2)
+
+    click.echo("\n✅ Conversion complete!")
+    click.echo(f"📁 Output directory: {output_dir}")
+    click.echo(f"📄 Summary: {summary_path}")
 
 
 @cli.command()
@@ -455,13 +612,13 @@ def generate_jenkinsfile(
         )
 
         # Determine output path
-        output_path = _resolve_output_path(
-            output, default_path=Path.cwd() / "Jenkinsfile"
-        )
+        _resolve_output_path(output, default_path=Path.cwd() / "Jenkinsfile")
 
-        # Write Jenkinsfile
-        output_path.write_text(result)
-        click.echo(f"✓ Generated {pipeline_type} Jenkinsfile: {output_path}")
+        # Write Jenkinsfile using safe write helper
+        written_path = _safe_write_file(
+            result, output, default_path=Path.cwd() / "Jenkinsfile"
+        )
+        click.echo(f"✓ Generated {pipeline_type} Jenkinsfile: {written_path}")
 
         # Show summary
         click.echo("\nGenerated Pipeline Stages:")
@@ -534,14 +691,11 @@ def generate_gitlab_ci(
             enable_artifacts="yes" if artifacts else "no",
         )
 
-        # Determine output path
-        output_path = _resolve_output_path(
-            output, default_path=Path.cwd() / ".gitlab-ci.yml"
+        # Write GitLab CI config using safe write helper
+        written_path = _safe_write_file(
+            result, output, default_path=Path.cwd() / ".gitlab-ci.yml"
         )
-
-        # Write GitLab CI config
-        output_path.write_text(result)
-        click.echo(f"✓ Generated GitLab CI configuration: {output_path}")
+        click.echo(f"✓ Generated GitLab CI configuration: {written_path}")
 
         # Show summary
         click.echo("\nGenerated CI Jobs:")
@@ -1195,10 +1349,9 @@ def ui(port: int) -> None:
     Opens a web-based interface for interactive Chef to Ansible migration planning,
     cookbook analysis, and visualization.
     """
-    try:
-        import subprocess
-        import sys
+    import subprocess
 
+    try:
         # Launch Streamlit app
         cmd = [
             sys.executable,
@@ -1224,8 +1377,138 @@ def ui(port: int) -> None:
         sys.exit(1)
 
 
+@cli.command("validate-chef-server")
+@click.option("--server-url", prompt="Chef Server URL", help="Chef Server base URL")
+@click.option("--node-name", default="admin", help="Chef node name for authentication")
+def validate_chef_server(server_url: str, node_name: str) -> None:
+    """
+    Validate Chef Server connectivity and configuration.
+
+    Tests the connection to the Chef Server REST API to ensure it's
+    reachable and properly configured.
+    """
+    click.echo("🔍 Validating Chef Server connection...")
+    from souschef.ui.pages.chef_server_settings import _validate_chef_server_connection
+
+    success, message = _validate_chef_server_connection(server_url, node_name)
+
+    if success:
+        click.echo(f"✅ {message}")
+    else:
+        click.echo(f"❌ {message}", err=True)
+        sys.exit(1)
+
+
+def _display_node_text(node: dict) -> None:
+    """Display a single node's information in text format."""
+    click.echo(f"\n  📍 {node.get('name', 'unknown')}")
+    click.echo(f"     Environment: {node.get('environment', '_default')}")
+    click.echo(f"     Platform: {node.get('platform', 'unknown')}")
+    if node.get("ipaddress"):
+        click.echo(f"     IP: {node['ipaddress']}")
+    if node.get("fqdn"):
+        click.echo(f"     FQDN: {node['fqdn']}")
+    if node.get("roles"):
+        click.echo(f"     Roles: {', '.join(node['roles'])}")
+
+
+def _output_chef_nodes(nodes: list, output_json: bool) -> None:
+    """Output nodes in requested format."""
+    if output_json:
+        click.echo(json.dumps(nodes, indent=2))
+    else:
+        for node in nodes:
+            _display_node_text(node)
+
+
+@cli.command("query-chef-nodes")
+@click.option("--search-query", default="*:*", help="Chef search query for nodes")
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON")
+def query_chef_nodes(search_query: str, output_json: bool) -> None:
+    """
+    Query Chef Server for nodes matching search criteria.
+
+    Retrieves nodes from Chef Server that match the provided search query,
+    extracting role assignments, environment, platform, and IP address
+    information for dynamic inventory generation.
+    """
+    import os
+
+    if not os.environ.get("CHEF_SERVER_URL"):
+        click.echo("❌ CHEF_SERVER_URL not set", err=True)
+        sys.exit(1)
+
+    click.echo(f"🔎 Querying Chef Server for nodes matching: {search_query}")
+
+    from souschef.converters.playbook import get_chef_nodes
+
+    try:
+        nodes = get_chef_nodes(search_query)
+
+        if not nodes:
+            click.echo("ℹ️  No nodes found matching the search query")
+            return
+
+        click.echo(f"Found {len(nodes)} nodes:")
+        _output_chef_nodes(nodes, output_json)
+    except Exception as e:
+        click.echo(f"❌ Error querying Chef Server: {e}", err=True)
+        sys.exit(1)
+
+
+@cli.command("convert-template-ai")
+@click.argument("erb_path", type=click.Path(exists=True))
+@click.option("--ai/--no-ai", default=True, help="Use AI enhancement")
+@click.option("--output", type=click.Path(), help="Output path for template")
+def convert_template_ai(erb_path: str, ai: bool, output: str | None) -> None:
+    """
+    Convert an ERB template to Jinja2 with optional AI assistance.
+
+    Converts Chef ERB templates to Ansible Jinja2 format with optional
+    AI-based validation and improvement for complex Ruby logic.
+    """
+    click.echo(f"🔄 Converting template: {erb_path}")
+    if ai:
+        click.echo("✨ Using AI enhancement for complex conversions")
+    else:
+        click.echo("📝 Using rule-based conversion only")
+
+    from souschef.converters.template import convert_template_with_ai
+
+    try:
+        result = convert_template_with_ai(erb_path, ai_service=None)
+
+        if result.get("success"):
+            method = result.get("conversion_method", "unknown")
+            click.echo(f"✅ Conversion successful ({method})")
+
+            if output:
+                output_path = Path(output)
+                output_path.parent.mkdir(parents=True, exist_ok=True)
+                output_path.write_text(result.get("jinja2_output", ""))
+                click.echo(f"💾 Converted template saved to: {output}")
+            else:
+                click.echo("\nConverted Template:")
+                click.echo("-" * 50)
+                click.echo(result.get("jinja2_output", ""))
+                click.echo("-" * 50)
+
+            if result.get("warnings"):
+                click.echo("\n⚠️  Warnings:")
+                for warning in result["warnings"]:
+                    click.echo(f"  - {warning}")
+        else:
+            error_msg = result.get("error", "Unknown error")
+            click.echo(f"❌ Conversion failed: {error_msg}", err=True)
+            sys.exit(1)
+    except Exception as e:
+        click.echo(f"❌ Error converting template: {e}", err=True)
+        sys.exit(1)
+
+
 def main() -> NoReturn:
     """Run the CLI."""
+    configure_logging()
     cli()
     sys.exit(0)