aegis-stack 0.2.0rc2__py3-none-any.whl

aegis/commands/init.py

@@ -0,0 +1,370 @@
+"""
+Init command implementation.
+"""
+
+from pathlib import Path
+from typing import cast
+
+import typer
+
+from ..cli.callbacks import (
+    validate_and_resolve_components,
+    validate_and_resolve_services,
+)
+from ..cli.interactive import interactive_project_selection
+from ..cli.utils import detect_scheduler_backend
+from ..cli.validators import validate_project_name
+from ..core.component_utils import (
+    clean_component_names,
+    extract_base_component_name,
+    restore_engine_info,
+)
+from ..core.components import (
+    COMPONENTS,
+    CORE_COMPONENTS,
+    ComponentType,
+    SchedulerBackend,
+)
+from ..core.dependency_resolver import DependencyResolver
+from ..core.service_resolver import ServiceResolver
+from ..core.template_generator import TemplateGenerator
+
+
+def init_command(
+    project_name: str = typer.Argument(
+        ..., help="Name of the new Aegis Stack project to create"
+    ),
+    components: str | None = typer.Option(
+        None,
+        "--components",
+        "-c",
+        callback=validate_and_resolve_components,
+        help="Comma-separated list of components (redis,worker,scheduler,database)",
+    ),
+    services: str | None = typer.Option(
+        None,
+        "--services",
+        "-s",
+        callback=validate_and_resolve_services,
+        help="Comma-separated list of services (auth). Use 'aegis services' for full list.",
+    ),
+    interactive: bool = typer.Option(
+        True,
+        "--interactive/--no-interactive",
+        "-i/-ni",
+        help="Use interactive component selection",
+    ),
+    force: bool = typer.Option(
+        False, "--force", "-f", help="Overwrite existing directory if it exists"
+    ),
+    output_dir: str | None = typer.Option(
+        None,
+        "--output-dir",
+        "-o",
+        help="Directory to create the project in (default: current directory)",
+    ),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompt"),
+    engine: str = typer.Option(
+        "copier",
+        "--engine",
+        hidden=True,  # Internal testing flag, not shown in --help
+        help="Template engine (cookiecutter or copier) - for internal testing",
+    ),
+) -> None:
+    """
+    Initialize a new Aegis Stack project with battle-tested component combinations.
+
+    This command creates a complete project structure with your chosen components,
+    ensuring all dependencies and configurations are compatible and tested.
+
+    Examples:\\n
+        - aegis init my-app\\n
+        - aegis init my-app --components redis,worker\\n
+        - aegis init my-app --components redis,worker,scheduler,database --no-interactive\\n
+        - aegis init my-app --services auth --no-interactive\\n
+    """  # noqa
+
+    # Validate project name first
+    validate_project_name(project_name)
+
+    # Validate engine parameter
+    valid_engines = ["cookiecutter", "copier"]
+    if engine not in valid_engines:
+        typer.echo(
+            f"❌ Invalid engine '{engine}'. Must be one of: {', '.join(valid_engines)}",
+            err=True,
+        )
+        raise typer.Exit(1)
+
+    typer.echo("🛡️  Aegis Stack Project Initialization")
+    typer.echo("=" * 50)
+
+    # Determine output directory
+    base_output_dir = Path(output_dir) if output_dir else Path.cwd()
+    project_path = base_output_dir / project_name
+
+    typer.echo(f"📁 Project will be created in: {project_path.resolve()}")
+
+    # Check if directory already exists
+    if project_path.exists():
+        if not force:
+            typer.echo(f"❌ Directory '{project_path}' already exists", err=True)
+            typer.echo(
+                "   Use --force to overwrite or choose a different name", err=True
+            )
+            raise typer.Exit(1)
+        else:
+            typer.echo(f"⚠️  Overwriting existing directory: {project_path}")
+
+    # Interactive component selection
+    # Note: components is list[str] after callback, despite str annotation
+    selected_components = cast(list[str], components) if components else []
+    selected_services = cast(list[str], services) if services else []
+    scheduler_backend = SchedulerBackend.MEMORY.value  # Default to in-memory scheduler
+
+    # Resolve services to components if services were provided (non-interactive mode only)
+    if selected_services and not interactive:
+        # Check if --components was explicitly provided
+        components_explicitly_provided = components is not None
+
+        if components_explicitly_provided:
+            # In non-interactive mode with explicit --components, validate compatibility
+            # Include core components (always present) for validation
+            components_for_validation = list(set(selected_components + CORE_COMPONENTS))
+            errors = ServiceResolver.validate_service_component_compatibility(
+                selected_services, components_for_validation
+            )
+            if errors:
+                typer.echo("❌ Service-component compatibility errors:", err=True)
+                for error in errors:
+                    typer.echo(f"   • {error}", err=True)
+
+                # Show suggestion
+                missing_components = (
+                    ServiceResolver.get_missing_components_for_services(
+                        selected_services, components_for_validation
+                    )
+                )
+                if missing_components:
+                    typer.echo(
+                        f"💡 Suggestion: Add missing components --components {','.join(sorted(set(selected_components + missing_components)))}",
+                        err=True,
+                    )
+                    typer.echo(
+                        "   Or remove --components to let services auto-add dependencies.",
+                        err=True,
+                    )
+                typer.echo(
+                    "   Alternatively, use interactive mode to auto-add service dependencies.",
+                    err=True,
+                )
+                raise typer.Exit(1)
+        else:
+            # No --components provided, auto-add required components for services
+            service_components, _ = ServiceResolver.resolve_service_dependencies(
+                selected_services
+            )
+            if service_components:
+                typer.echo(
+                    f"📦 Services require components: {', '.join(sorted(service_components))}"
+                )
+            selected_components = service_components
+
+        # Resolve service dependencies and merge with any explicitly selected components
+        service_components, _ = ServiceResolver.resolve_service_dependencies(
+            selected_services
+        )
+        # Merge service-required components with explicitly selected components
+        all_components = list(set(selected_components + service_components))
+        selected_components = all_components
+
+    # Auto-detect scheduler backend when components are specified
+    if selected_components:
+        scheduler_backend = detect_scheduler_backend(selected_components)
+        if scheduler_backend != SchedulerBackend.MEMORY.value:
+            typer.echo(
+                f"📊 Auto-detected: Scheduler with {scheduler_backend} persistence"
+            )
+
+    if interactive and not components and not services:
+        selected_components, scheduler_backend, interactive_services = (
+            interactive_project_selection()
+        )
+
+        # Resolve dependencies for interactively selected components
+        if selected_components:
+            # Clean component names for dependency resolution (remove engine info)
+            # Save original with engine info
+            original_selected = list(selected_components)
+            clean_components = clean_component_names(selected_components)
+
+            resolved_clean = DependencyResolver.resolve_dependencies(clean_components)
+
+            # Restore engine info for display components
+            selected_components = restore_engine_info(resolved_clean, original_selected)
+
+            # Calculate auto-added components using clean names
+            clean_selected_only = clean_component_names(
+                [c for c in selected_components if c not in CORE_COMPONENTS]
+            )
+            auto_added = DependencyResolver.get_missing_dependencies(
+                clean_selected_only
+            )
+            if auto_added:
+                typer.echo(f"\n📦 Auto-added dependencies: {', '.join(auto_added)}")
+
+        # Merge interactively selected services with any already selected services
+        selected_services = list(set(selected_services + interactive_services))
+
+        # Handle service dependencies for interactively selected services
+        if interactive_services:
+            # Track originally selected components before service resolution
+            originally_selected_components = selected_components.copy()
+
+            service_components, _ = ServiceResolver.resolve_service_dependencies(
+                interactive_services
+            )
+            # Merge service-required components with selected components
+            all_components = list(set(selected_components + service_components))
+            selected_components = all_components
+
+            # Show which components were auto-added by services
+            service_added_components = [
+                comp
+                for comp in service_components
+                if comp not in originally_selected_components
+                and comp not in CORE_COMPONENTS
+            ]
+            if service_added_components:
+                # Create a mapping of which services require which components
+                service_component_map = {}
+                for service_name in interactive_services:
+                    service_deps = ServiceResolver.resolve_service_dependencies(
+                        [service_name]
+                    )[0]
+                    for comp in service_deps:
+                        if comp in service_added_components:
+                            if comp not in service_component_map:
+                                service_component_map[comp] = []
+                            service_component_map[comp].append(service_name)
+
+                typer.echo("\n📦 Auto-added by services:")
+                for comp, requiring_services in service_component_map.items():
+                    services_str = ", ".join(requiring_services)
+                    typer.echo(f"   • {comp} (required by {services_str})")
+
+    # Create template generator with scheduler backend context
+    template_gen = TemplateGenerator(
+        project_name, list(selected_components), scheduler_backend, selected_services
+    )
+
+    # Show selected configuration
+    typer.echo()
+    typer.echo(f"📁 Project Name: {project_name}")
+    typer.echo("🏗️  Project Structure:")
+    typer.echo(f"   ✅ Core: {', '.join(CORE_COMPONENTS)}")
+
+    # Show infrastructure components
+    infra_components = []
+    for name in selected_components:
+        # Handle database[engine] format
+        base_name = extract_base_component_name(name)
+        if (
+            base_name in COMPONENTS
+            and COMPONENTS[base_name].type == ComponentType.INFRASTRUCTURE
+        ):
+            infra_components.append(name)
+
+    if infra_components:
+        typer.echo(f"   📦 Infrastructure: {', '.join(infra_components)}")
+
+    # Show selected services
+    if selected_services:
+        typer.echo(f"   🔧 Services: {', '.join(selected_services)}")
+
+    # Show template files that will be generated
+    template_files = template_gen.get_template_files()
+    if template_files:
+        typer.echo("\n📄 Component Files:")
+        for file_path in template_files:
+            typer.echo(f"   • {file_path}")
+
+    # Show entrypoints that will be created
+    entrypoints = template_gen.get_entrypoints()
+    if entrypoints:
+        typer.echo("\n🚀 Entrypoints:")
+        for entrypoint in entrypoints:
+            typer.echo(f"   • {entrypoint}")
+
+    # Show worker queues that will be created
+    worker_queues = template_gen.get_worker_queues()
+    if worker_queues:
+        typer.echo("\n👷 Worker Queues:")
+        for queue in worker_queues:
+            typer.echo(f"   • {queue}")
+
+    # Show dependency information using template generator
+    deps = template_gen._get_pyproject_deps()
+    if deps:
+        typer.echo("\n📦 Dependencies to be installed:")
+        for dep in deps:
+            typer.echo(f"   • {dep}")
+
+    # Confirm before proceeding
+    typer.echo()
+    if not yes and not typer.confirm("🚀 Create this project?"):
+        typer.echo("❌ Project creation cancelled")
+        raise typer.Exit(0)
+
+    # Handle force overwrite by completely removing existing directory
+    project_path = base_output_dir / project_name
+    if force and project_path.exists():
+        typer.echo(f"🗑️  Removing existing directory: {project_path}")
+        import shutil
+
+        shutil.rmtree(project_path)
+
+    # Create project using selected template engine
+    typer.echo()
+    typer.echo(f"🔧 Creating project: {project_name}")
+
+    try:
+        if engine == "copier":
+            # Use Copier template engine
+            from ..core.copier_manager import generate_with_copier
+
+            generate_with_copier(template_gen, base_output_dir)
+
+        else:
+            # Use Cookiecutter template engine (fallback option)
+            from cookiecutter.main import cookiecutter
+
+            # Get the template path
+            template_path = (
+                Path(__file__).parent.parent
+                / "templates"
+                / "cookiecutter-aegis-project"
+            )
+
+            # Use template generator for context
+            extra_context = template_gen.get_template_context()
+
+            # Generate project with cookiecutter
+            cookiecutter(
+                str(template_path),
+                extra_context=extra_context,
+                output_dir=str(base_output_dir),
+                no_input=True,  # Don't prompt user, use our context
+                overwrite_if_exists=False,  # No longer needed since we remove directory first
+            )
+
+        # Note: Comprehensive setup output is now handled by the post-generation hook
+        # which provides better status reporting and automated setup
+
+    except ImportError as e:
+        typer.echo(f"❌ Error: {e}", err=True)
+        typer.echo("   Required template engine not installed", err=True)
+        raise typer.Exit(1)
+    except Exception as e:
+        typer.echo(f"❌ Error creating project: {e}", err=True)
+        raise typer.Exit(1)

aegis/commands/remove.py

@@ -0,0 +1,227 @@
+"""
+Remove command implementation.
+
+Removes components from an existing Aegis Stack project using manual file deletion.
+"""
+
+from pathlib import Path
+
+import typer
+
+from ..core.components import COMPONENTS, CORE_COMPONENTS, SchedulerBackend
+from ..core.copier_manager import (
+    is_copier_project,
+    load_copier_answers,
+)
+from ..core.dependency_resolver import DependencyResolver
+from ..core.manual_updater import ManualUpdater
+from ..core.version_compatibility import validate_version_compatibility
+
+
+def remove_command(
+    components: str | None = typer.Argument(
+        None,
+        help="Comma-separated list of components to remove (scheduler,worker,database)",
+    ),
+    interactive: bool = typer.Option(
+        False,
+        "--interactive",
+        "-i",
+        help="Use interactive component selection",
+    ),
+    project_path: str = typer.Option(
+        ".",
+        "--project-path",
+        "-p",
+        help="Path to the Aegis Stack project (default: current directory)",
+    ),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompt"),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        "-f",
+        help="Force through version mismatch warnings",
+    ),
+) -> None:
+    """
+    Remove components from an existing Aegis Stack project.
+
+    This command removes component files and updates project configuration.
+    WARNING: This operation deletes files and cannot be easily undone!
+
+    Examples:\\\\n
+        - aegis remove scheduler\\\\n
+        - aegis remove worker,database\\\\n
+        - aegis remove scheduler --project-path ../my-project\\\\n
+
+    Note: Core components (backend, frontend) cannot be removed.
+    """
+
+    typer.echo("🛡️  Aegis Stack - Remove Components")
+    typer.echo("=" * 50)
+
+    # Resolve project path
+    target_path = Path(project_path).resolve()
+
+    # Validate it's a Copier project
+    if not is_copier_project(target_path):
+        typer.echo(
+            f"❌ Project at {target_path} was not generated with Copier.", err=True
+        )
+        typer.echo(
+            "   The 'aegis remove' command only works with Copier-generated projects.",
+            err=True,
+        )
+        raise typer.Exit(1)
+
+    typer.echo(f"📁 Project: {target_path}")
+
+    # Check version compatibility between CLI and project template
+    validate_version_compatibility(target_path, command_name="remove", force=force)
+
+    # Validate components argument or interactive mode
+    if not interactive and not components:
+        typer.echo(
+            "❌ Error: components argument is required (or use --interactive)", err=True
+        )
+        typer.echo("   Usage: aegis remove scheduler,worker", err=True)
+        typer.echo("   Or: aegis remove --interactive", err=True)
+        raise typer.Exit(1)
+
+    # Interactive mode
+    if interactive:
+        if components:
+            typer.echo(
+                "⚠️  Warning: --interactive flag ignores component arguments",
+                err=False,
+            )
+
+        from ..cli.interactive import interactive_component_remove_selection
+
+        selected_components = interactive_component_remove_selection(target_path)
+
+        if not selected_components:
+            typer.echo("\n✅ No components selected for removal")
+            raise typer.Exit(0)
+
+        # Convert to comma-separated string for existing logic
+        components = ",".join(selected_components)
+
+        # Auto-confirm in interactive mode (user already confirmed during selection)
+        yes = True
+
+    # Parse and validate components
+    assert components is not None  # Already validated by check above
+    components_raw = [c.strip() for c in components.split(",")]
+
+    # Check for empty components
+    if any(not c for c in components_raw):
+        typer.echo("❌ Empty component name is not allowed", err=True)
+        raise typer.Exit(1)
+
+    selected_components = [c for c in components_raw if c]
+
+    # Validate components exist
+    try:
+        # Use the same validation logic as init command
+        errors = DependencyResolver.validate_components(selected_components)
+        if errors:
+            for error in errors:
+                typer.echo(f"❌ {error}", err=True)
+            raise typer.Exit(1)
+
+    except Exception as e:
+        typer.echo(f"❌ Component validation failed: {e}", err=True)
+        raise typer.Exit(1)
+
+    # Load existing project configuration
+    try:
+        existing_answers = load_copier_answers(target_path)
+    except Exception as e:
+        typer.echo(f"❌ Failed to load project configuration: {e}", err=True)
+        raise typer.Exit(1)
+
+    # Check which components are currently enabled
+    not_enabled = []
+    components_to_remove = []
+
+    for component in selected_components:
+        # Check if component is core (cannot be removed)
+        if component in CORE_COMPONENTS:
+            typer.echo(f"⚠️  Cannot remove core component: {component}", err=False)
+            continue
+
+        # Check if component is enabled
+        include_key = f"include_{component}"
+        if not existing_answers.get(include_key):
+            not_enabled.append(component)
+        else:
+            components_to_remove.append(component)
+
+    if not_enabled:
+        typer.echo(f"ℹ️  Not enabled: {', '.join(not_enabled)}", err=False)
+
+    if not components_to_remove:
+        typer.echo("✅ No components to remove!")
+        raise typer.Exit(0)
+
+    # Check for scheduler with sqlite backend - warn about persistence
+    if "scheduler" in components_to_remove:
+        scheduler_backend = existing_answers.get("scheduler_backend")
+        if scheduler_backend == SchedulerBackend.SQLITE.value:
+            typer.echo("\n⚠️  IMPORTANT: Scheduler Persistence Warning")
+            typer.echo("   Your scheduler uses SQLite for job persistence.")
+            typer.echo("   The database file at data/scheduler.db will remain.")
+            typer.echo()
+            typer.echo("   💡 To keep your job history: Leave the database component")
+            typer.echo("   💡 To remove all data: Also remove the database component")
+            typer.echo()
+
+    # Show what will be removed
+    typer.echo("\n⚠️  Components to remove:")
+    for component in components_to_remove:
+        if component in COMPONENTS:
+            desc = COMPONENTS[component].description
+            typer.echo(f"   • {component}: {desc}")
+
+    # Confirm before proceeding
+    typer.echo()
+    typer.echo("⚠️  WARNING: This will DELETE component files from your project!")
+    typer.echo("   Make sure you have committed your changes to git.")
+    typer.echo()
+
+    if not yes and not typer.confirm("🗑️  Remove these components?"):
+        typer.echo("❌ Operation cancelled")
+        raise typer.Exit(0)
+
+    # Run manual removal for each component
+    typer.echo("\n🔄 Removing components...")
+    try:
+        updater = ManualUpdater(target_path)
+
+        # Remove each component sequentially
+        for component in components_to_remove:
+            typer.echo(f"\n📦 Removing {component}...")
+
+            # Remove the component
+            result = updater.remove_component(component)
+
+            if not result.success:
+                typer.echo(
+                    f"❌ Failed to remove {component}: {result.error_message}", err=True
+                )
+                raise typer.Exit(1)
+
+            # Show results
+            if result.files_deleted:
+                typer.echo(f"   ✅ Removed {len(result.files_deleted)} files")
+
+        typer.echo("\n✅ Components removed successfully!")
+        typer.echo("\n📝 Next steps:")
+        typer.echo("   1. Run 'make check' to verify the changes")
+        typer.echo("   2. Test your application")
+        typer.echo("   3. Commit the changes to git")
+
+    except Exception as e:
+        typer.echo(f"\n❌ Failed to remove components: {e}", err=True)
+        raise typer.Exit(1)

aegis/commands/services.py

@@ -0,0 +1,52 @@
+"""
+Services command implementation.
+"""
+
+import typer
+
+from ..core.services import ServiceType, get_services_by_type
+
+
+def services_command() -> None:
+    """List available services and their dependencies."""
+
+    typer.echo("\n🔧 AVAILABLE SERVICES")
+    typer.echo("=" * 40)
+
+    # Group services by type
+    service_types = [
+        (ServiceType.AUTH, "🔐 Authentication Services"),
+        (ServiceType.PAYMENT, "💰 Payment Services"),
+        (ServiceType.AI, "🤖 AI & Machine Learning Services"),
+        (ServiceType.NOTIFICATION, "📧 Notification Services"),
+        (ServiceType.ANALYTICS, "📊 Analytics Services"),
+        (ServiceType.STORAGE, "💾 Storage Services"),
+    ]
+
+    services_found = False
+    for service_type, header in service_types:
+        type_services = get_services_by_type(service_type)
+        if type_services:
+            services_found = True
+            typer.echo(f"\n{header}")
+            typer.echo("-" * 40)
+
+            for name, spec in type_services.items():
+                typer.echo(f"  {name:12} - {spec.description}")
+                if spec.required_components:
+                    typer.echo(
+                        f"               Requires components: {', '.join(spec.required_components)}"
+                    )
+                if spec.recommended_components:
+                    typer.echo(
+                        f"               Recommends components: {', '.join(spec.recommended_components)}"
+                    )
+                if spec.required_services:
+                    typer.echo(
+                        f"               Requires services: {', '.join(spec.required_services)}"
+                    )
+
+    if not services_found:
+        typer.echo("  No services available yet.")
+
+    typer.echo("\n💡 Use 'aegis init PROJECT_NAME --services auth' to add services")