Add 10 major utility improvements

1. Real-time deployment status monitoring
2. Security scanning (dependencies, secrets detection)
3. Cost estimation for all platforms
4. Environment variable validation and suggestions
5. Performance optimization analysis
6. CI/CD pipeline generation (GitHub Actions, GitLab CI)
7. Rollback strategies and disaster recovery plans
8. Multi-environment support (dev/staging/prod)
9. Monitoring/observability integration recommendations
10. Deployment tracking and status updates

All utilities integrated into main pipeline with dedicated UI sections

app.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import os
 import tempfile
+import time
 import zipfile
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple
@@ -11,13 +12,29 @@ from typing import Dict, List, Optional, Tuple
 import gradio as gr
 
 from codebase_analyzer import CodebaseAnalyzer
+from cicd_generator import CICDGenerator
+from cost_estimator import CostEstimator
 from deployment_agent import DeploymentAgent
+from env_validator import EnvironmentValidator
 from export_utils import export_json, export_markdown
+from monitoring_integration import MonitoringIntegration
 from orchestrator import ReadinessOrchestrator
+from performance_optimizer import PerformanceOptimizer
+from rollback_manager import RollbackManager
+from security_scanner import SecurityScanner
+from deployment_monitor import DeploymentMonitor
 
 orchestrator = ReadinessOrchestrator()
 analyzer = CodebaseAnalyzer()
 deployment_agent = DeploymentAgent()
+security_scanner = SecurityScanner()
+cost_estimator = CostEstimator()
+env_validator = EnvironmentValidator()
+performance_optimizer = PerformanceOptimizer()
+cicd_generator = CICDGenerator()
+rollback_manager = RollbackManager()
+monitoring_integration = MonitoringIntegration()
+deployment_monitor = DeploymentMonitor()
 
 
 def analyze_input(
@@ -98,17 +115,26 @@ def run_full_pipeline(
     infra_notes: str,
     deployment_platform: str,
     update_readme: bool,
-    stakeholders: str
-) -> Tuple[Dict, str, str, str, str, str, str, str]:
+    stakeholders: str,
+    environment: str
+) -> Tuple[Dict, str, str, str, str, str, str, str, str, str, str, str, str]:
     """Run complete pipeline with analysis, readiness check, and deployment."""
     
     # Step 1: Analyze codebase if folder/repo provided
     analysis_info = ""
+    security_report = ""
+    cost_estimate = ""
+    env_validation = ""
+    performance_analysis = ""
+    cicd_config = ""
+    rollback_plan = ""
+    monitoring_setup = ""
+    
     if upload_folder:
         analysis = analyzer.analyze_folder(upload_folder)
         if "error" not in analysis:
             detected_framework = analysis.get("framework", "")
-            detected_platform = analysis.get("platform", "")
+            detected_platform = analysis.get("platform", "") or deployment_platform
             
             # Update code_summary if empty
             if not code_summary:
@@ -121,6 +147,90 @@ def run_full_pipeline(
                 infra_notes = f"{infra_notes}, {detected_platform}"
             
             analysis_info = f"Framework: {detected_framework}, Platform: {detected_platform}"
+            
+            # Run all utility analyses
+            # Security scan
+            security_scan = security_scanner.scan_codebase(upload_folder)
+            security_report = f"""
+**Security Status**: {security_scan['overall_status']}
+**Total Issues**: {security_scan['total_issues']}
+**Dependency Vulnerabilities**: {security_scan['dependencies']['vulnerabilities_found']}
+**Secrets Found**: {security_scan['secrets']['secrets_found']}
+"""
+            
+            # Cost estimation
+            if deployment_platform and deployment_platform != "None":
+                cost_info = cost_estimator.estimate_platform_cost(
+                    deployment_platform,
+                    detected_framework,
+                    traffic="medium"
+                )
+                cost_val = cost_info['estimated_monthly_cost']
+                cost_str = f"${cost_val}" if isinstance(cost_val, (int, float)) else str(cost_val)
+                cost_estimate = f"""
+**Platform**: {cost_info['platform']}
+**Estimated Monthly Cost**: {cost_str}
+**Cost Range**: {cost_info['cost_range']}
+**Recommendations**: {', '.join(cost_info['recommendations'][:2])}
+"""
+            
+            # Environment validation
+            env_result = env_validator.validate_env_file(upload_folder, detected_framework)
+            env_validation = f"""
+**Status**: {env_result['status']}
+**Variables Found**: {env_result['variables_found']}
+**Missing Required**: {len(env_result['missing_required'])}
+**Issues**: {len(env_result['issues'])}
+**Recommendations**: {', '.join(env_result['recommendations'][:2])}
+"""
+            
+            # Performance analysis
+            perf_result = performance_optimizer.analyze_performance(
+                detected_framework,
+                detected_platform or deployment_platform,
+                analysis
+            )
+            performance_analysis = f"""
+**Performance Score**: {perf_result['performance_score']}/100
+**High Priority Optimizations**: {perf_result['priority_count']['high']}
+**Estimated Improvement**: {perf_result['estimated_improvement']}
+"""
+            
+            # CI/CD generation
+            if deployment_platform and deployment_platform != "None":
+                cicd = cicd_generator.generate_github_actions(
+                    detected_framework,
+                    deployment_platform
+                )
+                cicd_config = f"""
+**Workflow Generated**: {cicd['file']}
+**Framework**: {cicd['framework']}
+**Platform**: {cicd['platform']}
+**Steps**: {', '.join(cicd['steps'])}
+"""
+            
+            # Rollback plan
+            if deployment_platform and deployment_platform != "None":
+                rollback = rollback_manager.generate_rollback_plan(
+                    deployment_platform,
+                    detected_framework
+                )
+                rollback_plan = f"""
+**Strategy**: {rollback['strategy']}
+**Time to Rollback**: {rollback['time_to_rollback']}
+**Data Loss Risk**: {rollback['data_loss_risk']}
+"""
+            
+            # Monitoring setup
+            if detected_framework:
+                monitoring = monitoring_integration.get_monitoring_setup(
+                    detected_framework,
+                    detected_platform or deployment_platform
+                )
+                monitoring_setup = f"""
+**Recommended Tools**: {', '.join(monitoring['recommended_tools'][:3])}
+**Key Metrics**: {', '.join(monitoring['key_metrics'][:3])}
+"""
     
     # Step 2: Run readiness pipeline
     payload = {
@@ -151,6 +261,7 @@ def run_full_pipeline(
     
     # Step 4: Deploy if platform selected
     deployment_status = ""
+    deployment_tracking = ""
     if deployment_platform and deployment_platform != "None":
         try:
             import asyncio
@@ -160,6 +271,15 @@ def run_full_pipeline(
                 analysis = analyzer.analyze_folder(upload_folder)
                 framework = analysis.get("framework")
             
+            # Track deployment
+            deployment_id = f"{project_name}-{int(time.time())}"
+            tracked = deployment_monitor.track_deployment(
+                deployment_id,
+                deployment_platform,
+                os.getenv("GITHUB_REPO", "local"),
+                "initiated"
+            )
+            
             deployment_result = asyncio.run(
                 deployment_agent.execute_deployment({
                     "repo": os.getenv("GITHUB_REPO"),
@@ -169,14 +289,28 @@ def run_full_pipeline(
                     "actions": []
                 })
             )
+            
+            # Update tracking
             if deployment_result.get("success"):
+                deployment_monitor.update_deployment_status(deployment_id, "deploying", "deployment", "Deployment in progress")
                 deployment_status = f"✅ Deployment initiated to {deployment_platform}"
+                deployment_tracking = f"""
+**Deployment ID**: {deployment_id}
+**Status**: Deploying
+**Platform**: {deployment_platform}
+**Framework**: {framework or 'Unknown'}
+**Started**: {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(tracked['started_at']))}
+"""
             else:
+                deployment_monitor.update_deployment_status(deployment_id, "pending", "preparation", deployment_result.get('message', ''))
                 deployment_status = f"⚠️ {deployment_result.get('message', 'Deployment preparation complete. Configure GITHUB_REPO for full deployment')}"
+                deployment_tracking = f"**Status**: Pending - {deployment_result.get('message', '')}"
         except Exception as e:
             deployment_status = f"⚠️ Deployment: {str(e)}"
+            deployment_tracking = f"**Error**: {str(e)}"
     else:
         deployment_status = "ℹ️ Select a deployment platform to deploy"
+        deployment_tracking = "No deployment initiated"
     
     # Extract display information
     progress_text = ""
@@ -235,21 +369,35 @@ def run_full_pipeline(
             action_icon = "🚀" if actionable else "ℹ️"
             deploy_text += f"{action_icon} **{action_type}**: {message}\n"
     
-    # Add deployment status
+    # Add deployment status and tracking
     if deployment_status:
         deploy_text += f"\n\n**Deployment Status**:\n{deployment_status}"
+    if deployment_tracking:
+        deploy_text += f"\n\n**Deployment Tracking**:\n{deployment_tracking}"
     
     # Generate exports
     json_export = export_json(result)
     markdown_export = export_markdown(result)
     
+    # Combine all analysis info
+    full_analysis = analysis_info
+    if progress_text:
+        full_analysis += "\n\n" + progress_text
+    
     return (
         result,
-        analysis_info + "\n\n" + progress_text,
+        full_analysis,
         sponsor_text,
         docs_text,
         deploy_text,
         readme_update_status,
+        security_report or "No security scan performed",
+        cost_estimate or "No cost estimate available",
+        env_validation or "No environment validation performed",
+        performance_analysis or "No performance analysis performed",
+        cicd_config or "No CI/CD config generated",
+        rollback_plan or "No rollback plan generated",
+        monitoring_setup or "No monitoring setup available",
         json_export,
         markdown_export
     )
@@ -331,10 +479,17 @@ def build_interface() -> gr.Blocks:
                 value=True
             )
             
-            stakeholders = gr.Textbox(
-                label="Stakeholders (comma separated)",
-                value="eng, sre"
-            )
+            with gr.Row():
+                stakeholders = gr.Textbox(
+                    label="Stakeholders (comma separated)",
+                    value="eng, sre"
+                )
+                environment = gr.Dropdown(
+                    label="Environment",
+                    choices=["development", "staging", "production"],
+                    value="production",
+                    info="Target deployment environment"
+                )
         
         # Run Pipeline
         run_button = gr.Button("🚀 Run Full Pipeline & Deploy", variant="primary", size="lg")
@@ -361,6 +516,41 @@ def build_interface() -> gr.Blocks:
         
         readme_status = gr.Textbox(label="README Update Status", interactive=False, visible=True)
         
+        # New Utility Sections
+        with gr.Row():
+            gr.Markdown("### 🔒 Security & Performance")
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("#### 🔒 Security Scan")
+                security_output = gr.Textbox(label="Security Report", lines=8, interactive=False)
+            with gr.Column():
+                gr.Markdown("#### ⚡ Performance")
+                performance_output = gr.Textbox(label="Performance Analysis", lines=8, interactive=False)
+        
+        with gr.Row():
+            gr.Markdown("### 💰 Cost & Configuration")
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("#### 💰 Cost Estimation")
+                cost_output = gr.Textbox(label="Platform Cost", lines=6, interactive=False)
+            with gr.Column():
+                gr.Markdown("#### 🔐 Environment Variables")
+                env_output = gr.Textbox(label="Env Validation", lines=6, interactive=False)
+        
+        with gr.Row():
+            gr.Markdown("### 🔄 CI/CD & Operations")
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("#### 🔄 CI/CD Pipeline")
+                cicd_output = gr.Textbox(label="Generated CI/CD", lines=6, interactive=False)
+            with gr.Column():
+                gr.Markdown("#### ⏮️ Rollback Plan")
+                rollback_output = gr.Textbox(label="Rollback Strategy", lines=6, interactive=False)
+        
+        with gr.Row():
+            gr.Markdown("### 📊 Monitoring")
+        monitoring_output = gr.Textbox(label="Monitoring Setup", lines=6, interactive=False)
+        
         # Exports
         with gr.Row():
             gr.Markdown("### 📥 Export Reports")
@@ -386,7 +576,8 @@ def build_interface() -> gr.Blocks:
                 infra_notes,
                 deployment_platform,
                 update_readme,
-                stakeholders
+                stakeholders,
+                environment
             ],
             outputs=[
                 output,
@@ -395,6 +586,13 @@ def build_interface() -> gr.Blocks:
                 docs_output,
                 deploy_output,
                 readme_status,
+                security_output,
+                cost_output,
+                env_output,
+                performance_output,
+                cicd_output,
+                rollback_output,
+                monitoring_output,
                 json_export,
                 markdown_export
             ]

cicd_generator.py

@@ -0,0 +1,147 @@
+"""CI/CD pipeline generation."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+
+class CICDGenerator:
+    """Generates CI/CD pipeline configurations."""
+
+    def generate_github_actions(
+        self,
+        framework: str,
+        platform: str,
+        test_command: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Generate GitHub Actions workflow."""
+        
+        # Framework-specific test commands
+        test_commands = {
+            "next.js": "npm run test",
+            "react": "npm test",
+            "django": "python manage.py test",
+            "fastapi": "pytest",
+            "flask": "pytest",
+            "express": "npm test",
+        }
+        
+        test_cmd = test_command or test_commands.get(framework.lower(), "npm test")
+        
+        # Platform-specific deployment steps
+        deploy_steps = {
+            "vercel": """
+      - name: Deploy to Vercel
+        uses: amondnet/vercel-action@v20
+        with:
+          vercel-token: ${{ secrets.VERCEL_TOKEN }}
+          vercel-org-id: ${{ secrets.ORG_ID }}
+          vercel-project-id: ${{ secrets.PROJECT_ID }}
+""",
+            "netlify": """
+      - name: Deploy to Netlify
+        uses: netlify/actions/cli@master
+        with:
+          args: deploy --prod --dir=build
+        env:
+          NETLIFY_AUTH_TOKEN: ${{ secrets.NETLIFY_AUTH_TOKEN }}
+          NETLIFY_SITE_ID: ${{ secrets.NETLIFY_SITE_ID }}
+""",
+            "aws": """
+      - name: Deploy to AWS
+        run: |
+          aws s3 sync build s3://${{ secrets.S3_BUCKET }}
+          aws cloudfront create-invalidation --distribution-id ${{ secrets.CLOUDFRONT_ID }} --paths "/*"
+        env:
+          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+""",
+        }
+        
+        deploy_step = deploy_steps.get(platform.lower(), """
+      - name: Deploy
+        run: echo "Configure deployment for ${{ secrets.DEPLOY_PLATFORM }}"
+""")
+        
+        workflow = f"""name: CI/CD Pipeline
+
+on:
+  push:
+    branches: [ main, master ]
+  pull_request:
+    branches: [ main, master ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: '18'
+      - name: Install dependencies
+        run: npm install
+      - name: Run tests
+        run: {test_cmd}
+      - name: Build
+        run: npm run build
+
+  deploy:
+    needs: test
+    runs-on: ubuntu-latest
+    if: github.ref == 'refs/heads/main' || github.ref == 'refs/heads/master'
+    steps:
+      - uses: actions/checkout@v3
+      - name: Setup
+        run: npm install
+      - name: Build
+        run: npm run build
+{deploy_step}
+"""
+        
+        return {
+            "workflow": workflow,
+            "file": ".github/workflows/deploy.yml",
+            "framework": framework,
+            "platform": platform,
+            "steps": ["test", "build", "deploy"]
+        }
+
+    def generate_gitlab_ci(self, framework: str, platform: str) -> Dict[str, Any]:
+        """Generate GitLab CI configuration."""
+        config = f""".gitlab-ci.yml:
+  stages:
+    - test
+    - build
+    - deploy
+  
+  test:
+    stage: test
+    script:
+      - npm install
+      - npm test
+  
+  build:
+    stage: build
+    script:
+      - npm install
+      - npm run build
+    artifacts:
+      paths:
+        - build/
+  
+  deploy:
+    stage: deploy
+    script:
+      - echo "Deploy to {platform}"
+    only:
+      - main
+"""
+        return {
+            "config": config,
+            "file": ".gitlab-ci.yml",
+            "framework": framework,
+            "platform": platform
+        }
+

cost_estimator.py

@@ -0,0 +1,167 @@
+"""Cost estimation for different deployment platforms."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+
+class CostEstimator:
+    """Estimates deployment costs for different platforms."""
+
+    def estimate_platform_cost(
+        self,
+        platform: str,
+        framework: Optional[str] = None,
+        traffic: str = "low",
+        storage: str = "small"
+    ) -> Dict[str, Any]:
+        """Estimate monthly cost for a platform."""
+        
+        # Base pricing (simplified estimates)
+        pricing = {
+            "vercel": {
+                "hobby": 0,
+                "pro": 20,
+                "enterprise": "custom",
+                "description": "Free tier: 100GB bandwidth, Pro: $20/month unlimited"
+            },
+            "netlify": {
+                "starter": 0,
+                "pro": 19,
+                "business": 99,
+                "description": "Free tier: 100GB bandwidth, Pro: $19/month"
+            },
+            "aws": {
+                "lambda": 0.20,  # per million requests
+                "ec2_small": 15,
+                "ec2_medium": 30,
+                "description": "Pay-as-you-go, ~$15-50/month for small apps"
+            },
+            "gcp": {
+                "cloud_run": 0.40,  # per million requests
+                "compute_small": 12,
+                "description": "Free tier available, ~$12-40/month"
+            },
+            "azure": {
+                "app_service": 13,
+                "functions": 0.20,
+                "description": "Free tier available, ~$13-50/month"
+            },
+            "railway": {
+                "starter": 5,
+                "pro": 20,
+                "description": "$5/month starter, $20/month pro"
+            },
+            "render": {
+                "free": 0,
+                "starter": 7,
+                "standard": 25,
+                "description": "Free tier available, $7-25/month"
+            },
+            "fly.io": {
+                "starter": 0,
+                "scale": 10,
+                "description": "Free tier: 3 VMs, Scale: $10+/month"
+            },
+            "kubernetes": {
+                "managed": 73,  # GKE, EKS base
+                "self_hosted": 50,
+                "description": "Managed: $73+/month, Self-hosted: $50+/month"
+            },
+            "docker": {
+                "hosting": 5,
+                "description": "Varies by hosting provider, ~$5-20/month"
+            }
+        }
+        
+        platform_lower = platform.lower()
+        cost_info = pricing.get(platform_lower, {
+            "estimated": "Unknown",
+            "description": "Cost estimation not available"
+        })
+        
+        # Adjust based on traffic
+        base_cost = cost_info.get("pro") or cost_info.get("starter") or cost_info.get("estimated", 0)
+        if isinstance(base_cost, (int, float)):
+            if traffic == "high":
+                base_cost *= 2
+            elif traffic == "medium":
+                base_cost *= 1.5
+        
+        return {
+            "platform": platform,
+            "framework": framework,
+            "estimated_monthly_cost": base_cost if isinstance(base_cost, (int, float)) else base_cost,
+            "cost_range": self._get_cost_range(platform_lower, traffic),
+            "description": cost_info.get("description", ""),
+            "traffic_level": traffic,
+            "recommendations": self._get_cost_recommendations(platform_lower, base_cost)
+        }
+
+    def _get_cost_range(self, platform: str, traffic: str) -> str:
+        """Get cost range string."""
+        ranges = {
+            "vercel": "$0-20/month",
+            "netlify": "$0-19/month",
+            "aws": "$15-100/month",
+            "gcp": "$12-80/month",
+            "azure": "$13-100/month",
+            "railway": "$5-20/month",
+            "render": "$0-25/month",
+            "fly.io": "$0-50/month",
+            "kubernetes": "$50-200/month",
+            "docker": "$5-50/month"
+        }
+        return ranges.get(platform, "Varies")
+
+    def _get_cost_recommendations(self, platform: str, cost: Any) -> List[str]:
+        """Get cost optimization recommendations."""
+        recommendations = []
+        
+        if platform in ["vercel", "netlify", "render"]:
+            recommendations.append("Start with free tier for development")
+            recommendations.append("Upgrade to paid tier only when needed")
+        
+        if platform in ["aws", "gcp", "azure"]:
+            recommendations.append("Use reserved instances for 30-50% savings")
+            recommendations.append("Monitor usage to optimize costs")
+        
+        if isinstance(cost, (int, float)) and cost > 50:
+            recommendations.append("Consider serverless options for cost savings")
+            recommendations.append("Review and optimize resource allocation")
+        
+        return recommendations
+
+    def compare_platforms(self, platforms: List[str], framework: Optional[str] = None) -> Dict[str, Any]:
+        """Compare costs across multiple platforms."""
+        comparisons = []
+        for platform in platforms:
+            cost_info = self.estimate_platform_cost(platform, framework)
+            comparisons.append(cost_info)
+        
+        # Sort by cost
+        sorted_platforms = sorted(
+            [c for c in comparisons if isinstance(c["estimated_monthly_cost"], (int, float))],
+            key=lambda x: x["estimated_monthly_cost"]
+        )
+        
+        return {
+            "platforms": comparisons,
+            "cheapest": sorted_platforms[0] if sorted_platforms else None,
+            "recommendation": self._get_best_platform_recommendation(sorted_platforms, framework)
+        }
+
+    def _get_best_platform_recommendation(self, sorted_platforms: List[Dict], framework: Optional[str]) -> str:
+        """Get recommendation for best platform."""
+        if not sorted_platforms:
+            return "Compare platforms based on your specific needs"
+        
+        cheapest = sorted_platforms[0]
+        
+        if framework == "next.js":
+            return f"For Next.js, consider Vercel (optimized) or {cheapest['platform']} (cost-effective)"
+        elif framework in ["django", "flask", "fastapi"]:
+            return f"For Python apps, {cheapest['platform']} offers good value"
+        else:
+            return f"{cheapest['platform']} is the most cost-effective option"
+

deployment_monitor.py

@@ -0,0 +1,96 @@
+"""Real-time deployment status monitoring."""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Dict, List, Optional
+
+
+class DeploymentMonitor:
+    """Monitors deployment status in real-time."""
+
+    def __init__(self):
+        self.deployments: Dict[str, Dict[str, Any]] = {}
+
+    def track_deployment(
+        self,
+        deployment_id: str,
+        platform: str,
+        repo: str,
+        status: str = "initiated"
+    ) -> Dict[str, Any]:
+        """Track a new deployment."""
+        deployment = {
+            "id": deployment_id,
+            "platform": platform,
+            "repo": repo,
+            "status": status,
+            "started_at": time.time(),
+            "updated_at": time.time(),
+            "stages": [],
+            "logs": []
+        }
+        self.deployments[deployment_id] = deployment
+        return deployment
+
+    def update_deployment_status(
+        self,
+        deployment_id: str,
+        status: str,
+        stage: Optional[str] = None,
+        log_message: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Update deployment status."""
+        if deployment_id not in self.deployments:
+            return {"error": "Deployment not found"}
+
+        deployment = self.deployments[deployment_id]
+        deployment["status"] = status
+        deployment["updated_at"] = time.time()
+
+        if stage:
+            deployment["stages"].append({
+                "name": stage,
+                "status": status,
+                "timestamp": time.time()
+            })
+
+        if log_message:
+            deployment["logs"].append({
+                "message": log_message,
+                "timestamp": time.time(),
+                "level": "info" if status == "success" else "warning" if status == "pending" else "error"
+            })
+
+        return deployment
+
+    def get_deployment_status(self, deployment_id: str) -> Dict[str, Any]:
+        """Get current deployment status."""
+        if deployment_id not in self.deployments:
+            return {"error": "Deployment not found"}
+
+        deployment = self.deployments[deployment_id]
+        elapsed = time.time() - deployment["started_at"]
+
+        return {
+            **deployment,
+            "elapsed_time": f"{elapsed:.1f}s",
+            "is_complete": deployment["status"] in ["success", "failed", "cancelled"],
+            "is_running": deployment["status"] in ["initiated", "building", "deploying"]
+        }
+
+    def get_status_summary(self) -> Dict[str, Any]:
+        """Get summary of all deployments."""
+        total = len(self.deployments)
+        running = len([d for d in self.deployments.values() if d["status"] in ["initiated", "building", "deploying"]])
+        successful = len([d for d in self.deployments.values() if d["status"] == "success"])
+        failed = len([d for d in self.deployments.values() if d["status"] == "failed"])
+
+        return {
+            "total_deployments": total,
+            "running": running,
+            "successful": successful,
+            "failed": failed,
+            "success_rate": (successful / total * 100) if total > 0 else 0
+        }
+

env_validator.py

@@ -0,0 +1,158 @@
+"""Environment variable validation and suggestions."""
+
+from __future__ import annotations
+
+import os
+import re
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+class EnvironmentValidator:
+    """Validates and suggests environment variables."""
+
+    def __init__(self):
+        self.common_vars = {
+            "next.js": ["NEXT_PUBLIC_API_URL", "DATABASE_URL", "NEXTAUTH_SECRET", "NEXTAUTH_URL"],
+            "django": ["SECRET_KEY", "DEBUG", "DATABASE_URL", "ALLOWED_HOSTS"],
+            "fastapi": ["DATABASE_URL", "SECRET_KEY", "CORS_ORIGINS", "ENVIRONMENT"],
+            "react": ["REACT_APP_API_URL", "REACT_APP_ENV"],
+            "express": ["PORT", "NODE_ENV", "DATABASE_URL", "JWT_SECRET"],
+            "nestjs": ["PORT", "DATABASE_URL", "JWT_SECRET", "NODE_ENV"],
+        }
+
+    def validate_env_file(self, folder_path: str, framework: Optional[str] = None) -> Dict[str, Any]:
+        """Validate .env files in codebase."""
+        path = Path(folder_path)
+        env_files = list(path.rglob(".env*"))
+        
+        found_vars = []
+        missing_vars = []
+        issues = []
+        
+        # Read all env files
+        for env_file in env_files:
+            if env_file.is_file() and ".git" not in str(env_file):
+                try:
+                    content = env_file.read_text()
+                    # Extract variable names
+                    var_pattern = r'^([A-Z_][A-Z0-9_]*)\s*='
+                    vars_in_file = re.findall(var_pattern, content, re.MULTILINE)
+                    found_vars.extend(vars_in_file)
+                except Exception:
+                    pass
+        
+        # Check for framework-specific requirements
+        if framework:
+            required_vars = self.common_vars.get(framework.lower(), [])
+            for var in required_vars:
+                if var not in found_vars:
+                    missing_vars.append({
+                        "variable": var,
+                        "required": True,
+                        "description": self._get_var_description(var, framework)
+                    })
+        
+        # Check for common issues
+        for env_file in env_files:
+            try:
+                content = env_file.read_text()
+                # Check for hardcoded secrets
+                if re.search(r'(password|secret|key|token)\s*=\s*["\'][^"\']+["\']', content, re.IGNORECASE):
+                    issues.append({
+                        "file": str(env_file.relative_to(path)),
+                        "severity": "high",
+                        "issue": "Hardcoded secrets detected - use environment variables or secrets manager"
+                    })
+                
+                # Check for .env in git
+                gitignore = path / ".gitignore"
+                if gitignore.exists():
+                    gitignore_content = gitignore.read_text()
+                    if ".env" not in gitignore_content:
+                        issues.append({
+                            "file": ".gitignore",
+                            "severity": "medium",
+                            "issue": ".env files should be in .gitignore"
+                        })
+            except Exception:
+                pass
+        
+        return {
+            "env_files_found": len(env_files),
+            "variables_found": len(set(found_vars)),
+            "missing_required": missing_vars,
+            "issues": issues,
+            "status": "valid" if not missing_vars and not issues else "needs_attention",
+            "recommendations": self._get_recommendations(framework, missing_vars, issues)
+        }
+
+    def suggest_env_vars(self, framework: str, platform: str) -> List[Dict[str, str]]:
+        """Suggest environment variables based on framework and platform."""
+        suggestions = []
+        
+        # Framework-specific
+        framework_vars = self.common_vars.get(framework.lower(), [])
+        for var in framework_vars:
+            suggestions.append({
+                "variable": var,
+                "required": True,
+                "description": self._get_var_description(var, framework),
+                "category": "framework"
+            })
+        
+        # Platform-specific
+        platform_vars = {
+            "vercel": ["VERCEL_URL", "VERCEL_ENV"],
+            "netlify": ["NETLIFY", "CONTEXT"],
+            "aws": ["AWS_REGION", "AWS_ACCESS_KEY_ID"],
+            "gcp": ["GOOGLE_CLOUD_PROJECT", "GCP_REGION"],
+            "azure": ["AZURE_REGION", "AZURE_SUBSCRIPTION_ID"],
+        }
+        
+        platform_vars_list = platform_vars.get(platform.lower(), [])
+        for var in platform_vars_list:
+            suggestions.append({
+                "variable": var,
+                "required": False,
+                "description": f"Platform-specific variable for {platform}",
+                "category": "platform"
+            })
+        
+        return suggestions
+
+    def _get_var_description(self, var: str, framework: str) -> str:
+        """Get description for a variable."""
+        descriptions = {
+            "DATABASE_URL": "Database connection string",
+            "SECRET_KEY": "Secret key for encryption/signing",
+            "API_URL": "API endpoint URL",
+            "NODE_ENV": "Node.js environment (development/production)",
+            "PORT": "Application port number",
+            "DEBUG": "Debug mode flag",
+        }
+        return descriptions.get(var, f"Required for {framework}")
+
+    def _get_recommendations(
+        self,
+        framework: Optional[str],
+        missing_vars: List[Dict],
+        issues: List[Dict]
+    ) -> List[str]:
+        """Get recommendations based on validation results."""
+        recommendations = []
+        
+        if missing_vars:
+            recommendations.append(f"Add {len(missing_vars)} missing required environment variables")
+        
+        if issues:
+            recommendations.append("Review security issues in environment files")
+        
+        recommendations.append("Use a secrets manager (AWS Secrets Manager, HashiCorp Vault) for production")
+        recommendations.append("Never commit .env files to version control")
+        
+        if framework:
+            recommendations.append(f"Follow {framework} best practices for environment configuration")
+        
+        return recommendations
+

monitoring_integration.py

@@ -0,0 +1,92 @@
+"""Monitoring and observability integration."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+
+class MonitoringIntegration:
+    """Integrates with monitoring and observability tools."""
+
+    def get_monitoring_setup(
+        self,
+        framework: str,
+        platform: str
+    ) -> Dict[str, Any]:
+        """Get monitoring setup recommendations."""
+        
+        monitoring_tools = {
+            "next.js": {
+                "recommended": ["Vercel Analytics", "Sentry", "LogRocket"],
+                "built_in": "Vercel Analytics (if on Vercel)"
+            },
+            "django": {
+                "recommended": ["Sentry", "New Relic", "Datadog"],
+                "built_in": "Django Debug Toolbar (dev only)"
+            },
+            "fastapi": {
+                "recommended": ["Prometheus", "Grafana", "Sentry"],
+                "built_in": "FastAPI metrics endpoint"
+            },
+            "react": {
+                "recommended": ["Sentry", "LogRocket", "Mixpanel"],
+                "built_in": "React DevTools (dev only)"
+            },
+        }
+        
+        framework_tools = monitoring_tools.get(framework.lower(), {
+            "recommended": ["Sentry", "New Relic", "Datadog"],
+            "built_in": "Application logs"
+        })
+        
+        # Platform-specific monitoring
+        platform_monitoring = {
+            "vercel": "Vercel Analytics and Speed Insights included",
+            "netlify": "Netlify Analytics available",
+            "aws": "CloudWatch monitoring included",
+            "gcp": "Cloud Monitoring and Logging included",
+            "azure": "Azure Monitor included",
+        }
+        
+        return {
+            "framework": framework,
+            "platform": platform,
+            "recommended_tools": framework_tools["recommended"],
+            "built_in_monitoring": framework_tools.get("built_in", ""),
+            "platform_monitoring": platform_monitoring.get(platform.lower(), "Use third-party tools"),
+            "setup_steps": self._get_setup_steps(framework, platform),
+            "key_metrics": self._get_key_metrics(framework)
+        }
+
+    def _get_setup_steps(self, framework: str, platform: str) -> List[str]:
+        """Get setup steps for monitoring."""
+        steps = [
+            f"1. Set up error tracking (Sentry recommended for {framework})",
+            f"2. Configure application performance monitoring",
+            "3. Set up log aggregation",
+            "4. Configure alerting for critical errors",
+            "5. Set up uptime monitoring",
+        ]
+        
+        if platform.lower() in ["aws", "gcp", "azure"]:
+            steps.append(f"6. Enable {platform} native monitoring")
+        
+        return steps
+
+    def _get_key_metrics(self, framework: str) -> List[str]:
+        """Get key metrics to monitor."""
+        base_metrics = [
+            "Response time (p50, p95, p99)",
+            "Error rate",
+            "Request rate",
+            "CPU and memory usage"
+        ]
+        
+        framework_metrics = {
+            "next.js": ["Page load time", "Time to First Byte (TTFB)", "Core Web Vitals"],
+            "django": ["Database query time", "Request processing time"],
+            "fastapi": ["API response time", "Concurrent requests"],
+        }
+        
+        return base_metrics + framework_metrics.get(framework.lower(), [])
+

performance_optimizer.py

@@ -0,0 +1,121 @@
+"""Performance optimization suggestions."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+
+class PerformanceOptimizer:
+    """Provides performance optimization recommendations."""
+
+    def analyze_performance(self, framework: str, platform: str, analysis: Dict[str, Any]) -> Dict[str, Any]:
+        """Analyze and suggest performance optimizations."""
+        optimizations = []
+        score = 100
+        
+        # Framework-specific optimizations
+        if framework.lower() == "next.js":
+            optimizations.extend([
+                {
+                    "category": "build",
+                    "priority": "high",
+                    "suggestion": "Enable static generation for pages where possible",
+                    "impact": "Reduces server load and improves response time"
+                },
+                {
+                    "category": "images",
+                    "priority": "medium",
+                    "suggestion": "Use next/image for automatic image optimization",
+                    "impact": "Reduces image size by 30-50%"
+                },
+                {
+                    "category": "caching",
+                    "priority": "high",
+                    "suggestion": "Implement ISR (Incremental Static Regeneration)",
+                    "impact": "Improves page load time significantly"
+                }
+            ])
+            score -= 10 if not analysis.get("has_docker") else 0
+        
+        elif framework.lower() in ["django", "flask", "fastapi"]:
+            optimizations.extend([
+                {
+                    "category": "database",
+                    "priority": "high",
+                    "suggestion": "Enable database connection pooling",
+                    "impact": "Reduces database connection overhead"
+                },
+                {
+                    "category": "caching",
+                    "priority": "high",
+                    "suggestion": "Implement Redis caching layer",
+                    "impact": "Improves response time by 40-60%"
+                },
+                {
+                    "category": "async",
+                    "priority": "medium",
+                    "suggestion": "Use async/await for I/O operations",
+                    "impact": "Improves concurrency and throughput"
+                }
+            ])
+        
+        # Platform-specific optimizations
+        if platform.lower() == "vercel":
+            optimizations.append({
+                "category": "edge",
+                "priority": "high",
+                "suggestion": "Use Edge Functions for low-latency responses",
+                "impact": "Reduces latency by 50-70%"
+            })
+        
+        if platform.lower() in ["aws", "gcp", "azure"]:
+            optimizations.append({
+                "category": "cdn",
+                "priority": "high",
+                "suggestion": "Enable CDN for static assets",
+                "impact": "Improves global load times"
+            })
+        
+        # General optimizations
+        if not analysis.get("has_docker"):
+            optimizations.append({
+                "category": "containerization",
+                "priority": "medium",
+                "suggestion": "Containerize application for consistent deployments",
+                "impact": "Improves deployment reliability"
+            })
+        
+        if analysis.get("dependencies", []):
+            dep_count = len(analysis.get("dependencies", []))
+            if dep_count > 50:
+                optimizations.append({
+                    "category": "dependencies",
+                    "priority": "medium",
+                    "suggestion": f"Review {dep_count} dependencies - consider removing unused ones",
+                    "impact": "Reduces bundle size and build time"
+                })
+        
+        return {
+            "performance_score": max(0, score),
+            "optimizations": optimizations,
+            "priority_count": {
+                "high": len([o for o in optimizations if o["priority"] == "high"]),
+                "medium": len([o for o in optimizations if o["priority"] == "medium"]),
+                "low": len([o for o in optimizations if o["priority"] == "low"])
+            },
+            "estimated_improvement": self._estimate_improvement(optimizations)
+        }
+
+    def _estimate_improvement(self, optimizations: List[Dict]) -> str:
+        """Estimate performance improvement."""
+        high_priority = len([o for o in optimizations if o["priority"] == "high"])
+        
+        if high_priority >= 3:
+            return "30-50% performance improvement possible"
+        elif high_priority >= 2:
+            return "20-30% performance improvement possible"
+        elif high_priority >= 1:
+            return "10-20% performance improvement possible"
+        else:
+            return "Minor optimizations available"
+

rollback_manager.py

@@ -0,0 +1,131 @@
+"""Rollback strategies and disaster recovery."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+
+class RollbackManager:
+    """Manages rollback strategies and disaster recovery plans."""
+
+    def generate_rollback_plan(
+        self,
+        platform: str,
+        framework: str,
+        deployment_type: str = "blue_green"
+    ) -> Dict[str, Any]:
+        """Generate rollback plan for deployment."""
+        
+        rollback_strategies = {
+            "vercel": {
+                "strategy": "instant_rollback",
+                "steps": [
+                    "1. Go to Vercel dashboard",
+                    "2. Select previous deployment",
+                    "3. Click 'Promote to Production'",
+                    "4. Rollback completes in < 1 minute"
+                ],
+                "time_to_rollback": "< 1 minute",
+                "data_loss_risk": "None"
+            },
+            "netlify": {
+                "strategy": "deploy_rollback",
+                "steps": [
+                    "1. Go to Netlify dashboard",
+                    "2. Navigate to Deploys",
+                    "3. Select previous successful deploy",
+                    "4. Click 'Publish deploy'",
+                    "5. Rollback completes in < 2 minutes"
+                ],
+                "time_to_rollback": "< 2 minutes",
+                "data_loss_risk": "None"
+            },
+            "kubernetes": {
+                "strategy": "blue_green",
+                "steps": [
+                    "1. Keep previous deployment running",
+                    "2. Switch traffic to previous version",
+                    "3. Scale down new deployment",
+                    "4. Rollback completes in < 5 minutes"
+                ],
+                "time_to_rollback": "< 5 minutes",
+                "data_loss_risk": "Low (if database migrations involved)"
+            },
+            "docker": {
+                "strategy": "container_rollback",
+                "steps": [
+                    "1. Stop current container",
+                    "2. Start previous container version",
+                    "3. Update load balancer",
+                    "4. Rollback completes in < 3 minutes"
+                ],
+                "time_to_rollback": "< 3 minutes",
+                "data_loss_risk": "Low"
+            },
+        }
+        
+        strategy = rollback_strategies.get(platform.lower(), {
+            "strategy": "manual_rollback",
+            "steps": [
+                "1. Identify previous stable version",
+                "2. Redeploy previous version",
+                "3. Verify functionality",
+                "4. Monitor for issues"
+            ],
+            "time_to_rollback": "5-10 minutes",
+            "data_loss_risk": "Medium"
+        })
+        
+        return {
+            "platform": platform,
+            "framework": framework,
+            "strategy": strategy["strategy"],
+            "steps": strategy["steps"],
+            "time_to_rollback": strategy["time_to_rollback"],
+            "data_loss_risk": strategy["data_loss_risk"],
+            "pre_rollback_checklist": self._get_pre_rollback_checklist(),
+            "post_rollback_checklist": self._get_post_rollback_checklist()
+        }
+
+    def _get_pre_rollback_checklist(self) -> List[str]:
+        """Get pre-rollback checklist."""
+        return [
+            "Identify the issue causing rollback",
+            "Document current deployment version",
+            "Verify previous stable version is available",
+            "Notify team about rollback",
+            "Backup current database (if applicable)",
+            "Check for database migrations that need reversal"
+        ]
+
+    def _get_post_rollback_checklist(self) -> List[str]:
+        """Get post-rollback checklist."""
+        return [
+            "Verify application is functioning correctly",
+            "Monitor error rates and performance",
+            "Check database integrity",
+            "Notify team of successful rollback",
+            "Document rollback reason and lessons learned",
+            "Plan fix for the issue that caused rollback"
+        ]
+
+    def generate_disaster_recovery_plan(self, platform: str) -> Dict[str, Any]:
+        """Generate disaster recovery plan."""
+        return {
+            "platform": platform,
+            "recovery_time_objective": "15-30 minutes",
+            "recovery_point_objective": "Last successful deployment",
+            "backup_strategy": "Automated backups before each deployment",
+            "monitoring": "Set up alerts for critical failures",
+            "communication_plan": "Notify stakeholders within 5 minutes of incident",
+            "steps": [
+                "1. Assess the severity of the incident",
+                "2. Execute rollback plan",
+                "3. Verify system stability",
+                "4. Investigate root cause",
+                "5. Implement fix",
+                "6. Re-deploy with fix",
+                "7. Document incident and improvements"
+            ]
+        }
+

security_scanner.py

@@ -0,0 +1,101 @@
+"""Security scanning for dependencies and secrets."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any, Dict, List
+
+from codebase_analyzer import CodebaseAnalyzer
+
+
+class SecurityScanner:
+    """Scans codebase for security issues."""
+
+    def __init__(self):
+        self.analyzer = CodebaseAnalyzer()
+
+    def scan_dependencies(self, folder_path: str) -> Dict[str, Any]:
+        """Scan dependencies for known vulnerabilities."""
+        analysis = self.analyzer.analyze_folder(folder_path)
+        dependencies = analysis.get("dependencies", [])
+        
+        # Known vulnerable packages (simplified - would use real vulnerability DB)
+        vulnerable_packages = {
+            "lodash": "< 4.17.21",
+            "axios": "< 0.21.1",
+            "express": "< 4.17.1",
+        }
+        
+        issues = []
+        for dep in dependencies[:20]:  # Check first 20
+            dep_name = dep.lower() if isinstance(dep, str) else dep.get("name", "").lower()
+            if dep_name in vulnerable_packages:
+                issues.append({
+                    "package": dep_name,
+                    "severity": "high",
+                    "issue": f"Known vulnerability, update to {vulnerable_packages[dep_name]}",
+                    "type": "dependency_vulnerability"
+                })
+        
+        return {
+            "total_dependencies": len(dependencies),
+            "scanned": min(20, len(dependencies)),
+            "vulnerabilities_found": len(issues),
+            "issues": issues,
+            "status": "safe" if not issues else "vulnerabilities_detected"
+        }
+
+    def scan_secrets(self, folder_path: str) -> Dict[str, Any]:
+        """Scan for exposed secrets and API keys."""
+        path = Path(folder_path)
+        secrets_found = []
+        
+        # Patterns for common secrets
+        secret_patterns = {
+            "api_key": r'(?i)(api[_-]?key|apikey)\s*[:=]\s*["\']?([a-zA-Z0-9_\-]{20,})["\']?',
+            "secret": r'(?i)(secret|password|pwd)\s*[:=]\s*["\']?([a-zA-Z0-9_\-]{10,})["\']?',
+            "token": r'(?i)(token|bearer)\s*[:=]\s*["\']?([a-zA-Z0-9_\-]{20,})["\']?',
+            "aws_key": r'AKIA[0-9A-Z]{16}',
+            "private_key": r'-----BEGIN\s+(RSA\s+)?PRIVATE\s+KEY-----',
+        }
+        
+        # Scan common config files
+        config_files = ["*.env", "*.env.*", "*.config.js", "*.config.ts", "*.json"]
+        
+        for pattern in config_files:
+            for file_path in path.rglob(pattern):
+                if file_path.is_file() and ".git" not in str(file_path):
+                    try:
+                        content = file_path.read_text()
+                        for secret_type, regex in secret_patterns.items():
+                            matches = re.findall(regex, content)
+                            if matches:
+                                secrets_found.append({
+                                    "file": str(file_path.relative_to(path)),
+                                    "type": secret_type,
+                                    "severity": "critical",
+                                    "issue": f"Potential {secret_type} exposed in {file_path.name}"
+                                })
+                    except Exception:
+                        pass
+        
+        return {
+            "secrets_found": len(secrets_found),
+            "issues": secrets_found[:10],  # Limit to 10
+            "status": "safe" if not secrets_found else "secrets_detected",
+            "recommendation": "Use environment variables and secrets management"
+        }
+
+    def scan_codebase(self, folder_path: str) -> Dict[str, Any]:
+        """Complete security scan."""
+        deps_scan = self.scan_dependencies(folder_path)
+        secrets_scan = self.scan_secrets(folder_path)
+        
+        return {
+            "dependencies": deps_scan,
+            "secrets": secrets_scan,
+            "overall_status": "safe" if deps_scan["status"] == "safe" and secrets_scan["status"] == "safe" else "issues_found",
+            "total_issues": deps_scan["vulnerabilities_found"] + secrets_scan["secrets_found"]
+        }
+