name: ci_cd_setup_pipeline
version: "2.0"
type: devops
description: "Intelligent CI/CD pipeline generation with security and quality gates"

metadata:
  category: devops
  sub_category: ci_cd
  supported_platforms: ["github_actions", "gitlab_ci", "jenkins", "circleci", "azure_devops"]
  security_frameworks: ["devsecops", "supply_chain", "compliance"]

inputs:
  project_path:
    type: string
    required: true
    description: "Path to project repository"
  
  ci_platform:
    type: string
    enum: ["github_actions", "gitlab_ci", "jenkins", "circleci", "azure_devops"]
    required: true
  
  project_type:
    type: string
    enum: ["web_app", "api", "library", "mobile", "microservices", "monorepo"]
    required: true
  
  deployment_targets:
    type: array
    items:
      type: object
      properties:
        environment:
          type: string
          enum: ["development", "staging", "production"]
        platform:
          type: string
          enum: ["kubernetes", "ecs", "lambda", "app_service", "heroku", "vercel"]
        region:
          type: string
  
  quality_gates:
    type: object
    properties:
      test_coverage_threshold:
        type: number
        default: 80
      security_scan_required:
        type: boolean
        default: true
      performance_benchmarks:
        type: boolean
        default: false
  
  branching_strategy:
    type: string
    enum: ["gitflow", "github_flow", "gitlab_flow", "trunk_based"]
    default: "github_flow"

steps:
  - name: analyze_project
    type: project_analyzer
    inputs:
      path: "{{ project_path }}"
    config:
      detect:
        - languages
        - frameworks
        - build_tools
        - test_frameworks
        - dependencies
        - existing_ci_config
      analyze_structure:
        - monorepo_detection
        - service_boundaries
        - shared_libraries
    outputs:
      - project_analysis
      - technology_stack
      - project_structure

  - name: design_pipeline_architecture
    type: pipeline_architect
    inputs:
      project: "{{ project_analysis }}"
      platform: "{{ ci_platform }}"
      targets: "{{ deployment_targets }}"
      branching: "{{ branching_strategy }}"
    config:
      design_principles:
        - fail_fast
        - parallel_execution
        - caching_optimization
        - security_first
        - progressive_deployment
      include_stages:
        - build
        - test
        - security_scan
        - quality_check
        - package
        - deploy
        - smoke_test
        - rollback
    outputs:
      - pipeline_design
      - stage_dependencies
      - optimization_points

  - name: generate_build_stage
    type: build_stage_generator
    inputs:
      stack: "{{ technology_stack }}"
      structure: "{{ project_structure }}"
    config:
      optimize_for:
        - build_speed
        - cache_efficiency
        - artifact_size
      include:
        - dependency_caching
        - parallel_builds
        - incremental_compilation
        - multi_stage_docker
    outputs:
      - build_configuration
      - cache_strategy
      - artifact_definitions

  - name: generate_test_stage
    type: test_stage_generator
    inputs:
      test_frameworks: "{{ technology_stack.test_frameworks }}"
      coverage_threshold: "{{ quality_gates.test_coverage_threshold }}"
    config:
      test_types:
        - unit
        - integration
        - e2e
        - performance
        - accessibility
      parallel_execution: true
      test_splitting: true
      retry_flaky_tests: true
      coverage_reporting: true
    outputs:
      - test_configuration
      - parallel_jobs
      - coverage_config

  - name: generate_security_stage
    type: security_stage_generator
    when: "{{ quality_gates.security_scan_required }}"
    inputs:
      stack: "{{ technology_stack }}"
      security_framework: "{{ metadata.security_frameworks[0] }}"
    config:
      scan_types:
        - sast
        - dependency_check
        - container_scan
        - secrets_scan
        - license_compliance
      tools:
        sast:
          - sonarqube
          - semgrep
          - codeql
        dependency:
          - snyk
          - dependabot
          - owasp_dependency_check
        container:
          - trivy
          - grype
          - twistlock
      fail_on_severity: "high"
    outputs:
      - security_configuration
      - scan_policies
      - compliance_checks

  - name: generate_deployment_stage
    type: deployment_stage_generator
    inputs:
      targets: "{{ deployment_targets }}"
      branching: "{{ branching_strategy }}"
    config:
      deployment_strategies:
        production:
          - blue_green
          - canary
          - rolling_update
        staging:
          - direct_deployment
        development:
          - continuous_deployment
      include:
        - health_checks
        - smoke_tests
        - rollback_automation
        - deployment_notifications
    outputs:
      - deployment_configuration
      - environment_configs
      - rollback_procedures

  - name: create_pipeline_config
    type: pipeline_config_generator
    inputs:
      platform: "{{ ci_platform }}"
      design: "{{ pipeline_design }}"
      build: "{{ build_configuration }}"
      test: "{{ test_configuration }}"
      security: "{{ security_configuration | default({}) }}"
      deployment: "{{ deployment_configuration }}"
    config:
      platform_specific:
        github_actions:
          syntax: "yaml"
          file_path: ".github/workflows"
          features:
            - matrix_builds
            - reusable_workflows
            - environments
            - secrets_management
        gitlab_ci:
          syntax: "yaml"
          file_path: ".gitlab-ci.yml"
          features:
            - includes
            - extends
            - rules
            - artifacts
        jenkins:
          syntax: "groovy"
          file_path: "Jenkinsfile"
          features:
            - declarative_pipeline
            - shared_libraries
            - parallel_stages
      optimize:
        - job_parallelization
        - cache_reuse
        - conditional_execution
    outputs:
      - pipeline_config_files
      - environment_variables
      - secrets_requirements

  - name: generate_infrastructure_code
    type: iac_generator
    inputs:
      deployment_targets: "{{ deployment_targets }}"
      pipeline_requirements: "{{ pipeline_design.infrastructure_needs }}"
    config:
      iac_tools:
        - terraform
        - cloudformation
        - pulumi
      resources:
        - ci_runners
        - artifact_storage
        - container_registries
        - deployment_environments
        - monitoring_infrastructure
    outputs:
      - infrastructure_code
      - tfvars_templates
      - deployment_scripts

  - name: create_quality_dashboards
    type: dashboard_generator
    inputs:
      pipeline: "{{ pipeline_design }}"
      metrics: "{{ quality_gates }}"
    config:
      dashboard_types:
        - build_status
        - test_coverage
        - deployment_frequency
        - lead_time
        - mttr
        - security_posture
      integrations:
        - grafana
        - datadog
        - prometheus
    outputs:
      - dashboard_configs
      - metric_queries
      - alert_rules

  - name: generate_documentation
    type: pipeline_doc_generator
    inputs:
      pipeline: "{{ pipeline_config_files }}"
      architecture: "{{ pipeline_design }}"
      infrastructure: "{{ infrastructure_code }}"
    config:
      documentation_sections:
        - architecture_overview
        - setup_instructions
        - branching_workflow
        - deployment_process
        - troubleshooting_guide
        - security_practices
        - monitoring_guide
      include_diagrams: true
      runbook_generation: true
    outputs:
      - pipeline_documentation
      - runbooks
      - architecture_diagrams

outputs:
  ci_cd_package:
    type: complete_ci_cd_setup
    includes:
      - pipeline_configs
      - infrastructure_code
      - documentation
      - dashboard_configs
      - scripts
  
  implementation_guide:
    type: step_by_step_guide
    includes:
      - prerequisites
      - setup_instructions
      - testing_procedures
      - migration_plan
  
  security_report:
    type: security_assessment
    includes:
      - scan_configurations
      - compliance_mappings
      - risk_assessment

name: deployment_pipeline
version: "2.0"
type: devops
description: "Multi-environment deployment with progressive rollout strategies"

metadata:
  category: devops
  sub_category: deployment
  deployment_strategies: ["blue_green", "canary", "rolling", "recreate"]
  platforms: ["kubernetes", "ecs", "lambda", "vm_based"]

inputs:
  application_name:
    type: string
    required: true
  
  artifact_source:
    type: object
    required: true
    properties:
      type:
        type: string
        enum: ["container_registry", "s3", "artifact_registry", "git"]
      location:
        type: string
      version:
        type: string
  
  target_environment:
    type: string
    enum: ["development", "staging", "production"]
    required: true
  
  deployment_strategy:
    type: string
    enum: ["blue_green", "canary", "rolling", "recreate"]
    default: "rolling"
  
  platform_config:
    type: object
    properties:
      type:
        type: string
        enum: ["kubernetes", "ecs", "lambda", "vm_based"]
      cluster:
        type: string
      namespace:
        type: string
      region:
        type: string

steps:
  - name: validate_prerequisites
    type: deployment_validator
    inputs:
      artifact: "{{ artifact_source }}"
      environment: "{{ target_environment }}"
      platform: "{{ platform_config }}"
    config:
      checks:
        - artifact_exists
        - environment_ready
        - permissions_valid
        - resource_quotas
        - dependency_services
        - network_connectivity
    outputs:
      - validation_results
      - environment_state

  - name: prepare_deployment_plan
    type: deployment_planner
    inputs:
      strategy: "{{ deployment_strategy }}"
      current_state: "{{ environment_state }}"
      target_platform: "{{ platform_config }}"
    config:
      calculate:
        - resource_requirements
        - deployment_phases
        - traffic_shifting_plan
        - rollback_points
        - health_check_intervals
      risk_assessment: true
      capacity_planning: true
    outputs:
      - deployment_plan
      - resource_allocation
      - timeline_estimate

  - name: create_deployment_manifests
    type: manifest_generator
    inputs:
      application: "{{ application_name }}"
      artifact: "{{ artifact_source }}"
      platform: "{{ platform_config }}"
      plan: "{{ deployment_plan }}"
    config:
      templates:
        kubernetes:
          - deployment
          - service
          - ingress
          - configmap
          - hpa
          - pdb
        ecs:
          - task_definition
          - service
          - target_group
          - auto_scaling
      include:
        - resource_limits
        - health_checks
        - environment_variables
        - secrets_references
        - labels_and_annotations
    outputs:
      - deployment_manifests
      - configuration_maps
      - secret_references

  - name: setup_monitoring
    type: monitoring_configurator
    inputs:
      application: "{{ application_name }}"
      environment: "{{ target_environment }}"
      platform: "{{ platform_config }}"
    config:
      metrics:
        - application_metrics
        - infrastructure_metrics
        - custom_business_metrics
      monitoring_stack:
        - prometheus
        - grafana
        - alertmanager
        - jaeger
      alerts:
        - error_rate_threshold
        - latency_threshold
        - resource_utilization
        - availability_sla
    outputs:
      - monitoring_config
      - dashboard_urls
      - alert_rules

  - name: execute_deployment
    type: deployment_executor
    inputs:
      manifests: "{{ deployment_manifests }}"
      strategy: "{{ deployment_strategy }}"
      platform: "{{ platform_config }}"
    config:
      execution_mode: "{{ deployment_plan.phases }}"
      health_check_config:
        initial_delay: 30
        interval: 10
        timeout: 5
        success_threshold: 3
        failure_threshold: 3
      traffic_management:
        initial_traffic: 0
        increment: 10
        increment_interval: 300
        success_criteria:
          error_rate: 0.01
          latency_p99: 500
      enable_auto_rollback: true
    outputs:
      - deployment_status
      - instance_details
      - traffic_distribution

  - name: run_smoke_tests
    type: test_executor
    inputs:
      endpoints: "{{ instance_details.endpoints }}"
      test_suite: "smoke_tests"
    config:
      test_types:
        - endpoint_availability
        - basic_functionality
        - integration_points
        - performance_baseline
      parallel_execution: true
      timeout: 300
      retry_failed: 2
    outputs:
      - test_results
      - performance_metrics
      - failure_analysis

  - name: progressive_rollout
    type: traffic_controller
    when: "{{ deployment_strategy in ['canary', 'blue_green'] }}"
    inputs:
      deployment: "{{ deployment_status }}"
      test_results: "{{ test_results }}"
      monitoring_data: "{{ monitoring_config }}"
    config:
      canary_stages:
        - percentage: 5
          duration: 300
          success_criteria:
            error_rate: 0.01
            latency_p99: 500
        - percentage: 25
          duration: 600
          success_criteria:
            error_rate: 0.005
            latency_p99: 400
        - percentage: 50
          duration: 900
        - percentage: 100
          duration: 0
      automated_analysis: true
      manual_approval_points: ["25%", "50%"]
    outputs:
      - rollout_progress
      - traffic_metrics
      - decision_points

  - name: update_load_balancer
    type: load_balancer_configurator
    inputs:
      deployment: "{{ deployment_status }}"
      traffic_plan: "{{ rollout_progress | default(deployment_plan.traffic_shifting_plan) }}"
    config:
      load_balancer_types:
        - application_lb
        - network_lb
        - global_lb
      update_strategies:
        - dns_weighted_routing
        - target_group_shifting
        - header_based_routing
      health_check_grace_period: 60
    outputs:
      - lb_configuration
      - traffic_distribution
      - endpoint_mappings

  - name: finalize_deployment
    type: deployment_finalizer
    inputs:
      deployment: "{{ deployment_status }}"
      test_results: "{{ test_results }}"
      monitoring: "{{ monitoring_config }}"
    config:
      finalization_tasks:
        - cleanup_old_versions
        - update_documentation
        - notify_stakeholders
        - update_cmdb
        - archive_artifacts
        - generate_reports
      retention_policy:
        previous_versions: 3
        logs_retention: 30
        metrics_retention: 90
    outputs:
      - deployment_summary
      - cleanup_report
      - notification_status

outputs:
  deployment_report:
    type: comprehensive_report
    includes:
      - deployment_timeline
      - resource_utilization
      - test_results
      - performance_metrics
      - incident_log
  
  rollback_plan:
    type: emergency_procedures
    includes:
      - rollback_commands
      - state_snapshots
      - contact_information
      - escalation_path
  
  operational_handoff:
    type: operations_package
    includes:
      - monitoring_dashboards
      - alert_configurations
      - runbook_references
      - troubleshooting_guide

name: monitoring_setup_pipeline
version: "2.0"
type: devops
description: "Comprehensive observability stack setup with intelligent alerting"

metadata:
  category: devops
  sub_category: monitoring
  observability_pillars: ["metrics", "logs", "traces", "events"]
  monitoring_stacks: ["prometheus_grafana", "elk", "datadog", "new_relic"]

inputs:
  infrastructure_inventory:
    type: object
    required: true
    properties:
      servers:
        type: array
        items:
          type: object
      containers:
        type: array
        items:
          type: object
      serverless:
        type: array
        items:
          type: object
      databases:
        type: array
        items:
          type: object
  
  monitoring_stack:
    type: string
    enum: ["prometheus_grafana", "elk", "datadog", "new_relic", "custom"]
    required: true
  
  alerting_channels:
    type: array
    items:
      type: object
      properties:
        type:
          type: string
          enum: ["email", "slack", "pagerduty", "webhook", "sms"]
        config:
          type: object
  
  sla_requirements:
    type: object
    properties:
      availability:
        type: number
        default: 99.9
      response_time_p99:
        type: number
        default: 1000
      error_rate:
        type: number
        default: 0.1

steps:
  - name: analyze_infrastructure
    type: infrastructure_analyzer
    inputs:
      inventory: "{{ infrastructure_inventory }}"
    config:
      discover:
        - service_dependencies
        - communication_patterns
        - data_flows
        - critical_paths
        - single_points_of_failure
      classify:
        - tier_1_critical
        - tier_2_important
        - tier_3_standard
    outputs:
      - infrastructure_map
      - service_topology
      - criticality_matrix

  - name: design_monitoring_architecture
    type: monitoring_architect
    inputs:
      infrastructure: "{{ infrastructure_map }}"
      stack: "{{ monitoring_stack }}"
      sla: "{{ sla_requirements }}"
    config:
      design_principles:
        - high_availability
        - scalability
        - data_retention
        - query_performance
        - cost_optimization
      components:
        - collectors
        - aggregators
        - storage
        - visualization
        - alerting
    outputs:
      - monitoring_architecture
      - component_sizing
      - network_topology

  - name: generate_collection_configs
    type: collector_config_generator
    inputs:
      targets: "{{ infrastructure_inventory }}"
      architecture: "{{ monitoring_architecture }}"
    config:
      collectors:
        metrics:
          - prometheus_node_exporter
          - prometheus_blackbox_exporter
          - custom_exporters
        logs:
          - filebeat
          - fluentd
          - vector
        traces:
          - jaeger_agent
          - otel_collector
      collection_intervals:
        high_frequency: 15s
        normal: 60s
        low_frequency: 300s
    outputs:
      - collector_configurations
      - scrape_configs
      - pipeline_definitions

  - name: setup_metric_collection
    type: metric_system_setup
    inputs:
      architecture: "{{ monitoring_architecture }}"
      collectors: "{{ collector_configurations }}"
    config:
      metric_types:
        - system_metrics
        - application_metrics
        - business_metrics
        - custom_metrics
      aggregation_rules:
        - rate_calculations
        - percentile_aggregations
        - moving_averages
        - seasonal_adjustments
      retention_policies:
        raw: "7d"
        5m_aggregates: "30d"
        1h_aggregates: "365d"
    outputs:
      - prometheus_config
      - recording_rules
      - retention_config

  - name: setup_log_aggregation
    type: logging_system_setup
    inputs:
      sources: "{{ infrastructure_inventory }}"
      pipeline: "{{ pipeline_definitions }}"
    config:
      log_processing:
        - parsing_rules
        - enrichment
        - filtering
        - anonymization
      indexing_strategy:
        - time_based_indices
        - data_streams
        - ilm_policies
      search_optimization:
        - field_mappings
        - index_templates
        - search_templates
    outputs:
      - elasticsearch_config
      - logstash_pipelines
      - kibana_config

  - name: configure_distributed_tracing
    type: tracing_setup
    inputs:
      services: "{{ service_topology }}"
      architecture: "{{ monitoring_architecture }}"
    config:
      tracing_strategy:
        - sampling_rates
        - trace_propagation
        - context_injection
        - span_enrichment
      storage_backend:
        - elasticsearch
        - cassandra
        - in_memory
      analysis_features:
        - service_maps
        - latency_analysis
        - error_tracking
        - dependency_graphs
    outputs:
      - tracing_config
      - instrumentation_guide
      - sampling_policies

  - name: create_dashboards
    type: dashboard_generator
    inputs:
      metrics: "{{ prometheus_config }}"
      logs: "{{ kibana_config }}"
      traces: "{{ tracing_config }}"
      sla: "{{ sla_requirements }}"
    config:
      dashboard_types:
        - executive_overview
        - service_health
        - infrastructure_status
        - performance_analytics
        - cost_tracking
        - security_posture
      visualization_types:
        - time_series
        - heatmaps
        - topology_maps
        - tables
        - single_stats
      interactivity:
        - drill_downs
        - variable_templates
        - annotations
        - links
    outputs:
      - grafana_dashboards
      - kibana_dashboards
      - custom_visualizations

  - name: setup_intelligent_alerting
    type: alerting_configurator
    inputs:
      metrics: "{{ recording_rules }}"
      sla: "{{ sla_requirements }}"
      channels: "{{ alerting_channels }}"
      criticality: "{{ criticality_matrix }}"
    config:
      alert_types:
        - threshold_based
        - rate_of_change
        - anomaly_detection
        - prediction_based
        - composite_alerts
      ml_features:
        - baseline_learning
        - seasonality_detection
        - anomaly_scoring
        - forecast_alerts
      alert_routing:
        - severity_based
        - team_based
        - time_based
        - escalation_policies
    outputs:
      - alert_rules
      - ml_models
      - routing_config
      - runbook_links

  - name: implement_slo_monitoring
    type: slo_configurator
    inputs:
      services: "{{ service_topology }}"
      sla: "{{ sla_requirements }}"
      metrics: "{{ prometheus_config }}"
    config:
      slo_types:
        - availability
        - latency
        - error_rate
        - throughput
      error_budget_policies:
        - calculation_method
        - burn_rate_alerts
        - budget_policies
        - freeze_conditions
      reporting:
        - slo_dashboards
        - error_budget_reports
        - trend_analysis
    outputs:
      - slo_definitions
      - error_budgets
      - slo_alerts

  - name: setup_automation
    type: automation_configurator
    inputs:
      alerts: "{{ alert_rules }}"
      infrastructure: "{{ infrastructure_map }}"
    config:
      auto_remediation:
        - restart_services
        - scale_resources
        - clear_disk_space
        - rotate_logs
        - update_configurations
      playbook_triggers:
        - alert_based
        - scheduled
        - event_driven
      safety_controls:
        - approval_required
        - dry_run_mode
        - rollback_capability
        - audit_logging
    outputs:
      - automation_playbooks
      - webhook_configs
      - audit_policies

outputs:
  monitoring_package:
    type: complete_monitoring_setup
    includes:
      - architecture_diagrams
      - configuration_files
      - dashboards
      - alert_rules
      - automation_playbooks
  
  operational_guide:
    type: documentation_package
    includes:
      - setup_instructions
      - dashboard_guide
      - alert_response_procedures
      - troubleshooting_guide
      - maintenance_procedures
  
  compliance_report:
    type: audit_documentation
    includes:
      - data_retention_policies
      - access_controls
      - encryption_status
      - regulatory_mappings

name: infrastructure_pipeline
version: "2.0"
type: devops
description: "IaC generation for cloud-native infrastructure with security best practices"

metadata:
  category: devops
  sub_category: infrastructure
  iac_tools: ["terraform", "cloudformation", "pulumi", "crossplane"]
  cloud_providers: ["aws", "azure", "gcp", "multi_cloud"]

inputs:
  application_requirements:
    type: object
    required: true
    properties:
      compute:
        type: object
        properties:
          type:
            type: string
            enum: ["containers", "vms", "serverless", "hybrid"]
          scaling:
            type: object
          performance:
            type: string
      storage:
        type: object
        properties:
          types:
            type: array
          capacity:
            type: string
          performance:
            type: string
      networking:
        type: object
        properties:
          topology:
            type: string
          security_zones:
            type: array
          external_access:
            type: boolean
  
  cloud_provider:
    type: string
    enum: ["aws", "azure", "gcp", "multi_cloud"]
    required: true
  
  environment_type:
    type: string
    enum: ["development", "staging", "production", "dr"]
    required: true
  
  compliance_requirements:
    type: array
    items:
      type: string
      enum: ["hipaa", "pci_dss", "sox", "gdpr", "fedramp"]
    default: []
  
  budget_constraints:
    type: object
    properties:
      monthly_limit:
        type: number
      optimization_priority:
        type: string
        enum: ["performance", "cost", "balanced"]

steps:
  - name: analyze_requirements
    type: requirements_analyzer
    inputs:
      app_requirements: "{{ application_requirements }}"
      compliance: "{{ compliance_requirements }}"
      budget: "{{ budget_constraints }}"
    config:
      analysis_dimensions:
        - resource_sizing
        - availability_requirements
        - performance_targets
        - security_controls
        - compliance_mappings
        - cost_modeling
    outputs:
      - infrastructure_requirements
      - compliance_controls
      - cost_estimates

  - name: design_architecture
    type: cloud_architect
    inputs:
      requirements: "{{ infrastructure_requirements }}"
      provider: "{{ cloud_provider }}"
      environment: "{{ environment_type }}"
    config:
      architecture_patterns:
        - high_availability
        - disaster_recovery
        - auto_scaling
        - multi_region
        - edge_computing
      security_patterns:
        - zero_trust
        - defense_in_depth
        - encryption_everywhere
        - least_privilege
      include_services:
        - compute_layer
        - data_layer
        - networking_layer
        - security_layer
        - observability_layer
    outputs:
      - architecture_design
      - service_selection
      - network_topology

  - name: generate_network_infrastructure
    type: network_iac_generator
    inputs:
      design: "{{ architecture_design.networking }}"
      provider: "{{ cloud_provider }}"
      security_zones: "{{ application_requirements.networking.security_zones }}"
    config:
      network_components:
        - vpc_or_vnet
        - subnets
        - route_tables
        - nat_gateways
        - load_balancers
        - vpn_connections
        - peering
      security_components:
        - security_groups
        - network_acls
        - waf_rules
        - ddos_protection
      dns_configuration:
        - private_zones
        - public_zones
        - record_sets
    outputs:
      - network_iac
      - security_rules
      - dns_configuration

  - name: generate_compute_infrastructure
    type: compute_iac_generator
    inputs:
      design: "{{ architecture_design.compute }}"
      requirements: "{{ application_requirements.compute }}"
      network: "{{ network_iac }}"
    config:
      compute_types:
        containers:
          - eks_cluster
          - node_groups
          - fargate_profiles
          - service_mesh
        vms:
          - instance_templates
          - auto_scaling_groups
          - placement_groups
          - dedicated_hosts
        serverless:
          - lambda_functions
          - api_gateway
          - step_functions
          - event_bridge
      configuration_management:
        - user_data_scripts
        - cloud_init
        - ansible_playbooks
        - configuration_drift
    outputs:
      - compute_iac
      - scaling_policies
      - placement_strategies

  - name: generate_data_infrastructure
    type: data_iac_generator
    inputs:
      requirements: "{{ application_requirements.storage }}"
      design: "{{ architecture_design.data }}"
      compliance: "{{ compliance_controls }}"
    config:
      storage_types:
        - object_storage
        - block_storage
        - file_storage
        - database_storage
      database_services:
        - rds_instances
        - nosql_databases
        - data_warehouses
        - cache_clusters
      data_protection:
        - encryption_at_rest
        - encryption_in_transit
        - backup_policies
        - snapshot_schedules
        - replication
    outputs:
      - storage_iac
      - database_iac
      - backup_configuration

  - name: generate_security_infrastructure
    type: security_iac_generator
    inputs:
      architecture: "{{ architecture_design }}"
      compliance: "{{ compliance_controls }}"
      services: "{{ service_selection }}"
    config:
      identity_management:
        - iam_roles
        - service_accounts
        - federation
        - mfa_policies
      secrets_management:
        - secret_stores
        - key_rotation
        - certificate_management
      compliance_controls:
        - audit_logging
        - config_rules
        - security_hub
        - compliance_scanning
      threat_protection:
        - ids_ips
        - vulnerability_scanning
        - incident_response
    outputs:
      - security_iac
      - iam_policies
      - compliance_config

  - name: generate_observability_infrastructure
    type: observability_iac_generator
    inputs:
      architecture: "{{ architecture_design }}"
      services: "{{ service_selection }}"
    config:
      monitoring_stack:
        - metrics_collection
        - log_aggregation
        - distributed_tracing
        - synthetic_monitoring
      cost_management:
        - budget_alerts
        - cost_allocation_tags
        - reserved_capacity
        - spot_management
      automation:
        - auto_remediation
        - scaling_automation
        - backup_automation
    outputs:
      - observability_iac
      - tagging_strategy
      - automation_rules

  - name: optimize_for_cost
    type: cost_optimizer
    inputs:
      infrastructure: "{{ [network_iac, compute_iac, storage_iac, database_iac] }}"
      budget: "{{ budget_constraints }}"
      priority: "{{ budget_constraints.optimization_priority }}"
    config:
      optimization_strategies:
        - right_sizing
        - reserved_instances
        - spot_instances
        - auto_scaling
        - scheduled_scaling
        - storage_tiering
      cost_analysis:
        - current_estimate
        - optimization_potential
        - roi_calculation
      recommendations:
        - immediate_savings
        - long_term_savings
        - architecture_changes
    outputs:
      - optimized_iac
      - cost_report
      - savings_recommendations

  - name: validate_infrastructure
    type: iac_validator
    inputs:
      iac_code: "{{ optimized_iac }}"
      requirements: "{{ infrastructure_requirements }}"
      compliance: "{{ compliance_controls }}"
    config:
      validation_types:
        - syntax_check
        - security_scanning
        - compliance_check
        - best_practices
        - cost_validation
      tools:
        - terraform_validate
        - tfsec
        - checkov
        - infracost
        - opa_policies
    outputs:
      - validation_report
      - security_findings
      - compliance_gaps

  - name: generate_deployment_package
    type: deployment_packager
    inputs:
      iac: "{{ optimized_iac }}"
      validation: "{{ validation_report }}"
    config:
      package_contents:
        - terraform_modules
        - variable_files
        - backend_config
        - provider_config
        - makefile
        - documentation
      environments:
        - development
        - staging
        - production
      ci_integration:
        - github_actions
        - gitlab_ci
        - jenkins
    outputs:
      - deployment_package
      - environment_configs
      - ci_templates

outputs:
  infrastructure_package:
    type: complete_iac_package
    includes:
      - terraform_code
      - environment_configurations
      - deployment_scripts
      - documentation
      - architecture_diagrams
  
  cost_analysis:
    type: financial_report
    includes:
      - current_costs
      - projected_costs
      - optimization_opportunities
      - budget_compliance
  
  security_assessment:
    type: security_report
    includes:
      - security_controls
      - compliance_mappings
      - vulnerability_findings
      - remediation_recommendations

component: pipeline_stage_generator
type: ci_cd
description: "Generate CI/CD pipeline stages"

inputs:
  stage_type: string
  technology_stack: object
  quality_requirements: object

config:
  stage_templates:
    - build
    - test
    - security
    - deploy
    - validate

outputs:
  stage_configuration: object
  parallel_jobs: array
  dependencies: array

component: security_scanner
type: devsecops
description: "Integrate security scanning into pipelines"

inputs:
  scan_type: string
  target: string
  severity_threshold: string

config:
  scanners:
    sast:
      - sonarqube
      - semgrep
      - codeql
    dast:
      - zap
      - burp
    container:
      - trivy
      - grype

outputs:
  vulnerabilities: array
  compliance_status: object
  remediation_suggestions: array

component: resource_calculator
type: infrastructure
description: "Calculate optimal resource allocation"

inputs:
  application_profile: object
  performance_requirements: object
  budget_constraints: object

config:
  calculation_factors:
    - peak_load
    - average_load
    - growth_projection
    - redundancy_needs
    - cost_optimization

outputs:
  resource_recommendations: object
  scaling_parameters: object
  cost_estimates: object

component: network_designer
type: infrastructure
description: "Design cloud network topology"

inputs:
  security_zones: array
  connectivity_requirements: object
  compliance_needs: array

config:
  design_patterns:
    - hub_spoke
    - mesh
    - segmented
    - zero_trust

outputs:
  network_topology: object
  security_rules: array
  routing_tables: array

component: threshold_calculator
type: monitoring
description: "Calculate intelligent alert thresholds"

inputs:
  metric_history: array
  sla_requirements: object
  business_cycles: object

config:
  calculation_methods:
    - statistical_analysis
    - ml_prediction
    - business_rules
    - comparative_analysis

outputs:
  thresholds: object
  confidence_scores: object
  adjustment_schedule: object

integration: gitops
platforms:
  - argocd
  - flux
  - jenkins_x

configuration:
  sync_policies:
    - automatic
    - manual_approval
    - staged_rollout
  
  drift_detection: true
  auto_remediation: false
  notification_channels:
    - slack
    - email

integration: cloud_providers
supported:
  - aws
  - azure
  - gcp
  - digitalocean

features:
  - native_service_integration
  - cost_management_apis
  - security_center_integration
  - compliance_reporting

security_measures:
  code_level:
    - signed_commits
    - dependency_scanning
    - secret_scanning
    - license_compliance
  
  runtime_level:
    - least_privilege_access
    - temporary_credentials
    - audit_logging
    - anomaly_detection