devops-project-generator 1.0.0__py3-none-any.whl

cli/__init__.py

@@ -0,0 +1,7 @@
+"""
+CLI module for DevOps Project Generator
+"""
+
+from .cli import app
+
+__all__ = ["app"]

cli/cli.py

@@ -0,0 +1,286 @@
+#!/usr/bin/env python3
+"""
+CLI interface for DevOps Project Generator
+"""
+
+import os
+import sys
+from pathlib import Path
+from typing import Optional, List
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from generator import ProjectConfig, DevOpsProjectGenerator
+
+app = typer.Typer(
+    name="devops-project-generator",
+    help="🚀 DevOps Project Generator - Scaffold production-ready DevOps repositories",
+    no_args_is_help=True,
+)
+
+console = Console()
+
+
+@app.command()
+def init(
+    ci: Optional[str] = typer.Option(
+        None,
+        "--ci",
+        help="CI/CD platform: github-actions, gitlab-ci, jenkins, none",
+        show_choices=True,
+    ),
+    infra: Optional[str] = typer.Option(
+        None,
+        "--infra",
+        help="Infrastructure tool: terraform, cloudformation, none",
+        show_choices=True,
+    ),
+    deploy: Optional[str] = typer.Option(
+        None,
+        "--deploy",
+        help="Deployment method: vm, docker, kubernetes",
+        show_choices=True,
+    ),
+    envs: Optional[str] = typer.Option(
+        None,
+        "--envs",
+        help="Environments: single, dev,stage,prod",
+    ),
+    observability: Optional[str] = typer.Option(
+        None,
+        "--observability",
+        help="Observability level: logs, logs-metrics, full",
+        show_choices=True,
+    ),
+    security: Optional[str] = typer.Option(
+        None,
+        "--security",
+        help="Security level: basic, standard, strict",
+        show_choices=True,
+    ),
+    project_name: Optional[str] = typer.Option(
+        "devops-project",
+        "--name",
+        help="Project name",
+    ),
+    output_dir: Optional[str] = typer.Option(
+        ".",
+        "--output",
+        help="Output directory",
+    ),
+    interactive: bool = typer.Option(
+        True,
+        "--interactive/--no-interactive",
+        help="Interactive mode",
+    ),
+) -> None:
+    """Initialize a new DevOps project"""
+    
+    console.print(Panel.fit(
+        "[bold blue]🚀 DevOps Project Generator[/bold blue]\n"
+        "[dim]Scaffold production-ready DevOps repositories[/dim]",
+        border_style="blue"
+    ))
+    
+    if interactive:
+        config = _interactive_mode()
+    else:
+        config = ProjectConfig(
+            ci=ci,
+            infra=infra,
+            deploy=deploy,
+            envs=envs,
+            observability=observability,
+            security=security,
+            project_name=project_name,
+        )
+    
+    # Validate configuration
+    if not config.validate():
+        console.print("[red]❌ Invalid configuration. Please check your options.[/red]")
+        raise typer.Exit(1)
+    
+    # Generate project
+    generator = DevOpsProjectGenerator(config, output_dir)
+    
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        task = progress.add_task("Generating DevOps project...", total=None)
+        
+        try:
+            generator.generate()
+            progress.update(task, description="✅ Project generated successfully!")
+            
+            console.print("\n[green]✅ DevOps project generated successfully![/green]")
+            console.print(f"\n[bold]Project location:[/bold] {output_dir}/{config.project_name}")
+            console.print("\n[bold]Next steps:[/bold]")
+            console.print(f"  cd {config.project_name}")
+            console.print("  make help")
+            
+        except Exception as e:
+            progress.update(task, description="❌ Generation failed!")
+            console.print(f"\n[red]❌ Error generating project: {str(e)}[/red]")
+            raise typer.Exit(1)
+
+
+def _interactive_mode() -> ProjectConfig:
+    """Interactive configuration mode"""
+    console.print("\n[bold]🔧 Interactive Configuration[/bold]\n")
+    
+    # CI/CD selection
+    ci_table = Table(title="CI/CD Platforms")
+    ci_table.add_column("Option", style="cyan")
+    ci_table.add_column("Description")
+    ci_table.add_row("github-actions", "GitHub Actions workflows")
+    ci_table.add_row("gitlab-ci", "GitLab CI/CD pipelines")
+    ci_table.add_row("jenkins", "Jenkins pipeline files")
+    ci_table.add_row("none", "No CI/CD")
+    console.print(ci_table)
+    
+    ci = typer.prompt("Choose CI/CD platform", type=str)
+    
+    # Infrastructure selection
+    infra_table = Table(title="Infrastructure Tools")
+    infra_table.add_column("Option", style="cyan")
+    infra_table.add_column("Description")
+    infra_table.add_row("terraform", "Terraform IaC")
+    infra_table.add_row("cloudformation", "AWS CloudFormation")
+    infra_table.add_row("none", "No IaC")
+    console.print(infra_table)
+    
+    infra = typer.prompt("Choose infrastructure tool", type=str)
+    
+    # Deployment selection
+    deploy_table = Table(title="Deployment Methods")
+    deploy_table.add_column("Option", style="cyan")
+    deploy_table.add_column("Description")
+    deploy_table.add_row("vm", "Virtual Machine deployment")
+    deploy_table.add_row("docker", "Docker container deployment")
+    deploy_table.add_row("kubernetes", "Kubernetes deployment")
+    console.print(deploy_table)
+    
+    deploy = typer.prompt("Choose deployment method", type=str)
+    
+    # Environments
+    envs = typer.prompt("Choose environments (single, dev,stage,prod)", type=str)
+    
+    # Observability
+    obs_table = Table(title="Observability Levels")
+    obs_table.add_column("Option", style="cyan")
+    obs_table.add_column("Description")
+    obs_table.add_row("logs", "Logs only")
+    obs_table.add_row("logs-metrics", "Logs + Metrics")
+    obs_table.add_row("full", "Logs + Metrics + Alerts")
+    console.print(obs_table)
+    
+    observability = typer.prompt("Choose observability level", type=str)
+    
+    # Security
+    sec_table = Table(title="Security Levels")
+    sec_table.add_column("Option", style="cyan")
+    sec_table.add_column("Description")
+    sec_table.add_row("basic", "Basic security practices")
+    sec_table.add_row("standard", "Standard security measures")
+    sec_table.add_row("strict", "Strict security controls")
+    console.print(sec_table)
+    
+    security = typer.prompt("Choose security level", type=str)
+    
+    project_name = typer.prompt("Project name", default="devops-project")
+    
+    return ProjectConfig(
+        ci=ci,
+        infra=infra,
+        deploy=deploy,
+        envs=envs,
+        observability=observability,
+        security=security,
+        project_name=project_name,
+    )
+
+
+@app.command()
+def list_options() -> None:
+    """List all available options"""
+    console.print(Panel.fit(
+        "[bold blue]📋 Available Options[/bold blue]",
+        border_style="blue"
+    ))
+    
+    # CI/CD Options
+    console.print("\n[bold]🔄 CI/CD Platforms:[/bold]")
+    ci_table = Table()
+    ci_table.add_column("Option", style="cyan")
+    ci_table.add_column("Description")
+    ci_table.add_row("github-actions", "GitHub Actions workflows")
+    ci_table.add_row("gitlab-ci", "GitLab CI/CD pipelines")
+    ci_table.add_row("jenkins", "Jenkins pipeline files")
+    ci_table.add_row("none", "No CI/CD")
+    console.print(ci_table)
+    
+    # Infrastructure Options
+    console.print("\n[bold]🏗️ Infrastructure Tools:[/bold]")
+    infra_table = Table()
+    infra_table.add_column("Option", style="cyan")
+    infra_table.add_column("Description")
+    infra_table.add_row("terraform", "Terraform IaC")
+    infra_table.add_row("cloudformation", "AWS CloudFormation")
+    infra_table.add_row("none", "No IaC")
+    console.print(infra_table)
+    
+    # Deployment Options
+    console.print("\n[bold]🚀 Deployment Methods:[/bold]")
+    deploy_table = Table()
+    deploy_table.add_column("Option", style="cyan")
+    deploy_table.add_column("Description")
+    deploy_table.add_row("vm", "Virtual Machine deployment")
+    deploy_table.add_row("docker", "Docker container deployment")
+    deploy_table.add_row("kubernetes", "Kubernetes deployment")
+    console.print(deploy_table)
+    
+    # Environment Options
+    console.print("\n[bold]🌍 Environment Options:[/bold]")
+    env_table = Table()
+    env_table.add_column("Option", style="cyan")
+    env_table.add_column("Description")
+    env_table.add_row("single", "Single environment")
+    env_table.add_row("dev", "Development environment")
+    env_table.add_row("dev,stage,prod", "Multi-environment setup")
+    console.print(env_table)
+    
+    # Observability Options
+    console.print("\n[bold]📊 Observability Levels:[/bold]")
+    obs_table = Table()
+    obs_table.add_column("Option", style="cyan")
+    obs_table.add_column("Description")
+    obs_table.add_row("logs", "Logs only")
+    obs_table.add_row("logs-metrics", "Logs + Metrics")
+    obs_table.add_row("full", "Logs + Metrics + Alerts")
+    console.print(obs_table)
+    
+    # Security Options
+    console.print("\n[bold]🔒 Security Levels:[/bold]")
+    sec_table = Table()
+    sec_table.add_column("Option", style="cyan")
+    sec_table.add_column("Description")
+    sec_table.add_row("basic", "Basic security practices")
+    sec_table.add_row("standard", "Standard security measures")
+    sec_table.add_row("strict", "Strict security controls")
+    console.print(sec_table)
+
+
+@app.command()
+def version() -> None:
+    """Show version information"""
+    from . import __version__
+    console.print(f"[bold blue]DevOps Project Generator[/bold blue] v{__version__}")
+
+
+if __name__ == "__main__":
+    app()

devops_project_generator-1.0.0.dist-info/METADATA

@@ -0,0 +1,404 @@
+Metadata-Version: 2.4
+Name: devops-project-generator
+Version: 1.0.0
+Summary: A CLI tool that scaffolds production-ready DevOps repositories
+Author-email: NotHarshhaa <devops-project-generator@notHarshhaa.com>
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer[all]>=0.9.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: jinja2>=3.1.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: click>=8.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Dynamic: license-file
+
+# 🚀 DevOps Project Generator
+
+A powerful CLI tool that scaffolds production-ready DevOps repositories based on user-selected options like CI/CD, infrastructure, deployment, environments, observability, and security.
+
+## ✨ Why DevOps Project Generator?
+
+Setting up a real-world DevOps project from scratch is repetitive and error-prone. This tool helps you bootstrap a complete DevOps-ready repository in seconds, following industry best practices.
+
+✔ Opinionated but configurable  
+✔ Beginner-friendly, production-oriented  
+✔ CLI support  
+✔ No tool lock-in  
+
+## 🎯 Who Is This For?
+
+- **DevOps Engineers**
+- **Cloud Engineers** 
+- **Platform Engineers**
+- **SREs**
+- **Students & freshers building real DevOps projects**
+
+## 🧠 What This Generator Creates
+
+A full DevOps project structure covering:
+- CI/CD pipelines
+- Containerization
+- Infrastructure (IaC-ready)
+- Deployment models
+- Environment separation
+- Observability
+- Security basics
+
+All generated based on your selected options.
+
+## ⚙️ Supported Options (v1)
+
+### CI/CD
+- **GitHub Actions**
+- **GitLab CI**
+- **Jenkins**
+- **None**
+
+### Infrastructure
+- **Terraform**
+- **CloudFormation**
+- **None**
+
+### Deployment
+- **VM**
+- **Docker**
+- **Kubernetes**
+
+### Environments
+- **Single**
+- **Dev / Stage / Prod**
+
+### Observability
+- **Logs only**
+- **Logs + Metrics**
+- **Full (Logs + Metrics + Alerts)**
+
+### Security
+- **Basic**
+- **Standard**
+- **Strict**
+
+## 🖥️ Usage
+
+### CLI Usage
+
+```bash
+devops-project-generator init \
+  --ci github-actions \
+  --infra terraform \
+  --deploy kubernetes \
+  --envs dev,stage,prod \
+  --observability full \
+  --security standard
+```
+
+### Interactive Mode
+
+```bash
+devops-project-generator init --interactive
+```
+
+### List Available Options
+
+```bash
+devops-project-generator list-options
+```
+
+## 🏗️ Generated Project Structure (Example)
+
+```
+devops-project/
+├── app/
+│   └── sample-app/
+├── ci/
+│   ├── pipelines/
+│   └── README.md
+├── infra/
+│   ├── terraform/
+│   └── environments/
+├── containers/
+│   ├── Dockerfile
+│   └── docker-compose.yml
+├── k8s/
+│   ├── base/
+│   └── overlays/
+├── monitoring/
+│   ├── logs/
+│   ├── metrics/
+│   └── alerts/
+├── security/
+│   ├── secrets/
+│   └── scanning/
+├── scripts/
+│   └── automation/
+├── Makefile
+└── README.md
+```
+
+## 🛠️ Tech Stack
+
+### Generator Core
+- **Python**
+- **Jinja2**
+- **YAML-based configuration**
+
+### CLI
+- **Typer**
+- **Rich**
+
+## 📦 Installation
+
+### From PyPI
+
+```bash
+pip install devops-project-generator
+```
+
+### From Source
+
+```bash
+git clone https://github.com/NotHarshhaa/devops-project-generator.git
+cd devops-project-generator
+pip install -e .
+```
+
+### Development Setup
+
+```bash
+git clone https://github.com/NotHarshhaa/devops-project-generator.git
+cd devops-project-generator
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+pip install -e ".[dev]"
+```
+
+## 🚀 Quick Start
+
+1. **Generate a new project**
+   ```bash
+   devops-project-generator init --name my-app --ci github-actions --deploy kubernetes
+   ```
+
+2. **Navigate to your project**
+   ```bash
+   cd my-app
+   ```
+
+3. **Setup the environment**
+   ```bash
+   make setup
+   ```
+
+4. **Start the application**
+   ```bash
+   make start
+   ```
+
+5. **Check health**
+   ```bash
+   make health
+   ```
+
+## 📖 Examples
+
+### Basic Web App with Docker
+
+```bash
+devops-project-generator init \
+  --name my-webapp \
+  --ci github-actions \
+  --deploy docker \
+  --envs single \
+  --observability logs \
+  --security basic
+```
+
+### Enterprise Kubernetes App
+
+```bash
+devops-project-generator init \
+  --name enterprise-app \
+  --ci github-actions \
+  --infra terraform \
+  --deploy kubernetes \
+  --envs dev,stage,prod \
+  --observability full \
+  --security strict
+```
+
+### Simple VM Deployment
+
+```bash
+devops-project-generator init \
+  --name simple-app \
+  --ci jenkins \
+  --deploy vm \
+  --envs dev,prod \
+  --observability logs-metrics \
+  --security standard
+```
+
+## 🔧 Configuration
+
+### Global Configuration
+
+You can set default options in `~/.devops-generator/config.yaml`:
+
+```yaml
+defaults:
+  ci: github-actions
+  deploy: kubernetes
+  observability: logs-metrics
+  security: standard
+```
+
+### Project Templates
+
+The generator supports custom templates. Place your templates in:
+
+```
+~/.devops-generator/templates/
+├── ci/
+├── infra/
+├── deploy/
+├── monitoring/
+└── security/
+```
+
+## 🧪 Testing
+
+### Run Tests
+
+```bash
+pytest
+```
+
+### Run Tests with Coverage
+
+```bash
+pytest --cov=devops_project_generator --cov-report=html
+```
+
+### Run Linting
+
+```bash
+flake8 devops_project_generator/
+black devops_project_generator/
+mypy devops_project_generator/
+```
+
+## 🤝 Contributing
+
+We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details.
+
+### Development Workflow
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Add tests for new functionality
+5. Run the test suite
+6. Submit a pull request
+
+### Adding New Features
+
+1. **New CI/CD Platform**: Add templates in `templates/ci/`
+2. **New Infrastructure Tool**: Add templates in `templates/infra/`
+3. **New Deployment Method**: Add templates in `templates/deploy/`
+4. **New Security Level**: Add templates in `templates/security/`
+
+## 📚 Documentation
+
+- [User Guide](docs/user-guide.md)
+- [Developer Guide](docs/developer-guide.md)
+- [Template Reference](docs/template-reference.md)
+- [API Documentation](docs/api.md)
+
+## 🐛 Troubleshooting
+
+### Common Issues
+
+1. **Permission Denied**
+   ```bash
+   chmod +x scripts/setup.sh scripts/deploy.sh
+   ```
+
+2. **Template Not Found**
+   - Check if template files exist in `templates/`
+   - Verify template syntax
+
+3. **Generated Files Not Executable**
+   ```bash
+   find . -name "*.sh" -exec chmod +x {} \;
+   ```
+
+### Getting Help
+
+- **Issues**: [GitHub Issues](https://github.com/NotHarshhaa/devops-project-generator/issues)
+- **Discussions**: [GitHub Discussions](https://github.com/NotHarshhaa/devops-project-generator/discussions)
+- **Documentation**: [Wiki](https://github.com/NotHarshhaa/devops-project-generator/wiki)
+
+## 🗺️ Roadmap
+
+### v1.1
+- [ ] Support for Azure DevOps
+- [ ] Additional cloud providers (GCP, Azure)
+- [ ] More deployment targets (AWS ECS, Fargate)
+- [ ] Advanced monitoring templates
+
+### v1.2
+- [ ] Template marketplace
+- [ ] Plugin system
+- [ ] GUI interface
+- [ ] Integration with popular tools
+
+### v2.0
+- [ ] Multi-language support
+- [ ] Advanced project customization
+- [ ] AI-powered recommendations
+- [ ] Enterprise features
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+- **Typer** - For the amazing CLI framework
+- **Rich** - For beautiful terminal output
+- **Jinja2** - For powerful templating
+- **DevOps Community** - For best practices and inspiration
+
+## 📞 Contact
+
+This project is crafted with 💡 by **[Harshhaa](https://github.com/NotHarshhaa)**.  
+Your feedback is always welcome! Let's build together. 🚀  
+
+📧 **Connect with me:**  
+🔗 **GitHub**: [@NotHarshhaa](https://github.com/NotHarshhaa)  
+🔗 **Portfolio**: [Personal Portfolio](https://notharshhaa.site)  
+🔗 **Links - Portfolio**: [Links](https://link.notharshhaa.site)  
+🔗 **Telegram Community**: [Join Here](https://t.me/prodevopsguy)  
+🔗 **LinkedIn**: [Harshhaa Vardhan Reddy](https://www.linkedin.com/in/NotHarshhaa/)  
+
+---
+
+**Built with ❤️ by the DevOps community**  
+*Making DevOps accessible to everyone*

devops_project_generator-1.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+cli/__init__.py,sha256=w2vLcMzDL8VTCvr4FpIO2huINs7VakcPwwwgET9CZn0,96
+cli/cli.py,sha256=XUXqhsS9rTyeV-K0E6gUsq_KIdGKihfBMqcBpvIiCdk,9833
+devops_project_generator-1.0.0.dist-info/licenses/LICENSE,sha256=_HdG8K47lc8y4-RxCcg8kF9Sky3s9ISv6hq3Htf_4xE,1093
+generator/__init__.py,sha256=ZvV3XJ6NSqJtexzoSuiGO_sunxcJsnh0Y2Ygae28DOI,223
+generator/config.py,sha256=F15LBjUc1jsnpM5TW7jMnpTOdg1io5kG7-pHNXYOvZg,4188
+generator/generator.py,sha256=YtmlJNA5M55R5NioLmzYvHxL4c_s4gyRnYNixasxDxg,9095
+devops_project_generator-1.0.0.dist-info/METADATA,sha256=2IjjmxSqKycWr-dJJ1vUNN0UwBUtell9A_5oCpbnGQ4,9283
+devops_project_generator-1.0.0.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+devops_project_generator-1.0.0.dist-info/entry_points.txt,sha256=rRjyaDvT7HXOGTyTjESukJY6vudqQSaORIDja2ajE_M,53
+devops_project_generator-1.0.0.dist-info/top_level.txt,sha256=wLC3-qeRvJyOHnTMJFtpJQXgQvkzgioPJQix2SQZhFM,14
+devops_project_generator-1.0.0.dist-info/RECORD,,

devops_project_generator-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

devops_project_generator-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+devops-project-generator = cli:app

devops_project_generator-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 H A R S H H A A
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

devops_project_generator-1.0.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+cli
+generator

generator/__init__.py

@@ -0,0 +1,8 @@
+"""
+DevOps Project Generator Core Module
+"""
+
+from .config import ProjectConfig, TemplateConfig
+from .generator import DevOpsProjectGenerator
+
+__all__ = ["ProjectConfig", "TemplateConfig", "DevOpsProjectGenerator"]

generator/config.py

@@ -0,0 +1,117 @@
+"""
+Configuration management for DevOps Project Generator
+"""
+
+from typing import List, Optional, Dict, Any
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class ProjectConfig:
+    """Configuration for DevOps project generation"""
+    
+    ci: Optional[str] = None
+    infra: Optional[str] = None
+    deploy: Optional[str] = None
+    envs: Optional[str] = None
+    observability: Optional[str] = None
+    security: Optional[str] = None
+    project_name: str = "devops-project"
+    
+    # Valid options
+    VALID_CI_OPTIONS = ["github-actions", "gitlab-ci", "jenkins", "none"]
+    VALID_INFRA_OPTIONS = ["terraform", "cloudformation", "none"]
+    VALID_DEPLOY_OPTIONS = ["vm", "docker", "kubernetes"]
+    VALID_OBS_OPTIONS = ["logs", "logs-metrics", "full"]
+    VALID_SEC_OPTIONS = ["basic", "standard", "strict"]
+    
+    def validate(self) -> bool:
+        """Validate configuration options"""
+        if self.ci and self.ci not in self.VALID_CI_OPTIONS:
+            return False
+        if self.infra and self.infra not in self.VALID_INFRA_OPTIONS:
+            return False
+        if self.deploy and self.deploy not in self.VALID_DEPLOY_OPTIONS:
+            return False
+        if self.observability and self.observability not in self.VALID_OBS_OPTIONS:
+            return False
+        if self.security and self.security not in self.VALID_SEC_OPTIONS:
+            return False
+        return True
+    
+    def get_environments(self) -> List[str]:
+        """Parse environments string into list"""
+        if not self.envs:
+            return ["production"]
+        
+        envs = [env.strip() for env in self.envs.split(",")]
+        if self.envs == "single":
+            return ["production"]
+        return envs
+    
+    def has_ci(self) -> bool:
+        """Check if CI/CD is enabled"""
+        return self.ci and self.ci != "none"
+    
+    def has_infra(self) -> bool:
+        """Check if infrastructure is enabled"""
+        return self.infra and self.infra != "none"
+    
+    def has_docker(self) -> bool:
+        """Check if Docker is used"""
+        return self.deploy in ["docker", "kubernetes"]
+    
+    def has_kubernetes(self) -> bool:
+        """Check if Kubernetes is used"""
+        return self.deploy == "kubernetes"
+    
+    def has_metrics(self) -> bool:
+        """Check if metrics are enabled"""
+        return self.observability in ["logs-metrics", "full"]
+    
+    def has_alerts(self) -> bool:
+        """Check if alerts are enabled"""
+        return self.observability == "full"
+    
+    def get_security_level(self) -> str:
+        """Get security level"""
+        return self.security or "basic"
+    
+    def get_template_context(self) -> Dict[str, Any]:
+        """Get template context for Jinja2"""
+        return {
+            "project_name": self.project_name,
+            "ci": self.ci,
+            "infra": self.infra,
+            "deploy": self.deploy,
+            "environments": self.get_environments(),
+            "observability": self.observability,
+            "security": self.get_security_level(),
+            "has_ci": self.has_ci(),
+            "has_infra": self.has_infra(),
+            "has_docker": self.has_docker(),
+            "has_kubernetes": self.has_kubernetes(),
+            "has_metrics": self.has_metrics(),
+            "has_alerts": self.has_alerts(),
+            "is_multi_env": len(self.get_environments()) > 1,
+        }
+
+
+@dataclass
+class TemplateConfig:
+    """Template configuration"""
+    
+    template_dir: Path = field(default_factory=lambda: Path(__file__).parent / "templates")
+    
+    def get_template_path(self, category: str, template_name: str) -> Path:
+        """Get full template path"""
+        return self.template_dir / category / template_name
+    
+    def list_templates(self, category: str) -> List[str]:
+        """List available templates in a category"""
+        category_path = self.template_dir / category
+        if not category_path.exists():
+            return []
+        
+        return [f.name for f in category_path.iterdir() if f.is_file()]

generator/generator.py

@@ -0,0 +1,231 @@
+"""
+Core DevOps project generator
+"""
+
+import os
+import shutil
+from pathlib import Path
+from typing import Dict, Any, List
+from jinja2 import Environment, FileSystemLoader, select_autoescape
+from rich.console import Console
+
+from .config import ProjectConfig, TemplateConfig
+
+console = Console()
+
+
+class DevOpsProjectGenerator:
+    """Main DevOps project generator class"""
+    
+    def __init__(self, config: ProjectConfig, output_dir: str = "."):
+        self.config = config
+        self.output_dir = Path(output_dir)
+        self.template_config = TemplateConfig()
+        self.project_path = self.output_dir / config.project_name
+        
+        # Setup Jinja2 environment
+        template_path = Path("templates")
+        self.jinja_env = Environment(
+            loader=FileSystemLoader(str(template_path)),
+            autoescape=select_autoescape(["html", "xml"]),
+            trim_blocks=True,
+            lstrip_blocks=True,
+        )
+    
+    def generate(self) -> None:
+        """Generate the complete DevOps project"""
+        console.print(f"🏗️  Creating project structure for '{self.config.project_name}'...")
+        
+        # Create project directory
+        self._create_project_structure()
+        
+        # Generate components based on configuration
+        if self.config.has_ci():
+            self._generate_ci_cd()
+        
+        if self.config.has_infra():
+            self._generate_infrastructure()
+        
+        self._generate_deployment()
+        self._generate_monitoring()
+        self._generate_security()
+        self._generate_base_files()
+        
+        console.print("✅ Project generation completed!")
+    
+    def _create_project_structure(self) -> None:
+        """Create base project directory structure"""
+        directories = [
+            "app/sample-app",
+            "ci/pipelines",
+            "infra/environments",
+            "containers",
+            "k8s/base",
+            "k8s/overlays",
+            "monitoring/logs",
+            "monitoring/metrics",
+            "monitoring/alerts",
+            "security/secrets",
+            "security/scanning",
+            "scripts/automation",
+        ]
+        
+        for directory in directories:
+            dir_path = self.project_path / directory
+            dir_path.mkdir(parents=True, exist_ok=True)
+    
+    def _generate_ci_cd(self) -> None:
+        """Generate CI/CD pipeline files"""
+        console.print("🔄 Generating CI/CD pipelines...")
+        
+        ci_templates = {
+            "github-actions": "github-actions.yml.j2",
+            "gitlab-ci": "gitlab-ci.yml.j2",
+            "jenkins": "jenkinsfile.j2",
+        }
+        
+        if self.config.ci in ci_templates:
+            template_name = ci_templates[self.config.ci]
+            self._render_template(
+                f"ci/{template_name}",
+                f"ci/pipelines/{self.config.ci}.yml",
+            )
+        
+        # Generate CI README
+        self._render_template("ci/README.md.j2", "ci/README.md")
+    
+    def _generate_infrastructure(self) -> None:
+        """Generate infrastructure as code files"""
+        console.print("🏗️  Generating infrastructure...")
+        
+        infra_templates = {
+            "terraform": "terraform/main.tf.j2",
+            "cloudformation": "cloudformation/template.yml.j2",
+        }
+        
+        if self.config.infra in infra_templates:
+            template_path = infra_templates[self.config.infra]
+            output_path = f"infra/{self.config.infra}"
+            
+            if self.config.infra == "terraform":
+                self._render_template(template_path, f"{output_path}/main.tf")
+                self._render_template("terraform/variables.tf.j2", f"{output_path}/variables.tf")
+                self._render_template("terraform/outputs.tf.j2", f"{output_path}/outputs.tf")
+            elif self.config.infra == "cloudformation":
+                self._render_template(template_path, f"{output_path}/template.yml")
+        
+        # Generate environment configs
+        for env in self.config.get_environments():
+            self._render_template(
+                f"infra/environment-{self.config.infra}.j2",
+                f"infra/environments/{env}.tf" if self.config.infra == "terraform" else f"infra/environments/{env}.yml",
+                env=env,
+            )
+    
+    def _generate_deployment(self) -> None:
+        """Generate deployment files"""
+        console.print("🚀 Generating deployment files...")
+        
+        if self.config.has_docker():
+            self._render_template("deploy/Dockerfile.j2", "containers/Dockerfile")
+            self._render_template("deploy/docker-compose.yml.j2", "containers/docker-compose.yml")
+        
+        if self.config.has_kubernetes():
+            self._render_template("deploy/k8s-deployment.yml.j2", "k8s/base/deployment.yml")
+            self._render_template("deploy/k8s-service.yml.j2", "k8s/base/service.yml")
+            
+            # Generate environment overlays
+            for env in self.config.get_environments():
+                env_dir = f"k8s/overlays/{env}"
+                (self.project_path / env_dir).mkdir(exist_ok=True)
+                self._render_template(
+                    "deploy/k8s-overlay.yml.j2",
+                    f"{env_dir}/kustomization.yml",
+                    env=env,
+                )
+        
+        if self.config.deploy == "vm":
+            self._render_template("deploy/vm-deploy.sh.j2", "scripts/automation/vm-deploy.sh")
+    
+    def _generate_monitoring(self) -> None:
+        """Generate monitoring and observability files"""
+        console.print("📊 Generating monitoring...")
+        
+        # Always generate logs
+        self._render_template("monitoring/logging.yml.j2", "monitoring/logs/logging.yml")
+        
+        if self.config.has_metrics():
+            self._render_template("monitoring/metrics.yml.j2", "monitoring/metrics/metrics.yml")
+        
+        if self.config.has_alerts():
+            self._render_template("monitoring/alerts.yml.j2", "monitoring/alerts/alerts.yml")
+    
+    def _generate_security(self) -> None:
+        """Generate security files"""
+        console.print("🔒 Generating security...")
+        
+        sec_level = self.config.get_security_level()
+        
+        # Base security files
+        self._render_template(f"security/{sec_level}-secrets.yml.j2", "security/secrets/secrets.yml")
+        self._render_template(f"security/{sec_level}-scan.yml.j2", "security/scanning/scan.yml")
+        
+        if sec_level in ["standard", "strict"]:
+            self._render_template("security/security-policy.yml.j2", "security/security-policy.yml")
+        
+        if sec_level == "strict":
+            self._render_template("security/compliance.yml.j2", "security/compliance.yml")
+    
+    def _generate_base_files(self) -> None:
+        """Generate base project files"""
+        console.print("📄 Generating base files...")
+        
+        # Sample application
+        self._render_template("app/sample-app/main.py.j2", "app/sample-app/main.py")
+        self._render_template("app/sample-app/requirements.txt.j2", "app/sample-app/requirements.txt")
+        
+        # Scripts
+        self._render_template("scripts/setup.sh.j2", "scripts/setup.sh")
+        self._render_template("scripts/deploy.sh.j2", "scripts/deploy.sh")
+        
+        # Makefile
+        self._render_template("Makefile.j2", "Makefile")
+        
+        # README
+        self._render_template("README.md.j2", "README.md")
+        
+        # .gitignore
+        self._render_template("gitignore.j2", ".gitignore")
+        
+        # Make scripts executable
+        script_files = [
+            "scripts/setup.sh",
+            "scripts/deploy.sh",
+            "scripts/automation/vm-deploy.sh",
+        ]
+        
+        for script in script_files:
+            script_path = self.project_path / script
+            if script_path.exists():
+                os.chmod(script_path, 0o755)
+    
+    def _render_template(self, template_path: str, output_path: str, **kwargs) -> None:
+        """Render a template to an output file"""
+        try:
+            template = self.jinja_env.get_template(template_path)
+            
+            # Merge template context with additional kwargs
+            context = self.config.get_template_context()
+            context.update(kwargs)
+            
+            rendered_content = template.render(**context)
+            
+            output_file = self.project_path / output_path
+            output_file.parent.mkdir(parents=True, exist_ok=True)
+            
+            with open(output_file, "w", encoding="utf-8") as f:
+                f.write(rendered_content)
+                
+        except Exception as e:
+            console.print(f"[red]❌ Error rendering template {template_path}: {str(e)}[/red]")
+            raise