Integrating Kiro with CI/CD Pipelines

# .github/workflows/kiro-ci.yml
name: Intelligent Kiro CI/CD

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

env:
  KIRO_API_KEY: ${{ secrets.KIRO_API_KEY }}
  KIRO_PROJECT_ID: ${{ secrets.KIRO_PROJECT_ID }}

jobs:
  analyze-changes:
    runs-on: ubuntu-latest
    outputs:
      impact-analysis: ${{ steps.kiro-analysis.outputs.impact }}
      test-strategy: ${{ steps.kiro-analysis.outputs.test-strategy }}
      deployment-strategy: ${{ steps.kiro-analysis.outputs.deployment-strategy }}
      
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0  # Full history for better analysis
          
      - name: Setup Kiro CLI
        uses: aws-kiro/setup-kiro@v1
        with:
          version: 'latest'
          
      - name: Analyze Change Impact
        id: kiro-analysis
        run: |
          # Analyze changes and generate intelligent pipeline configuration
          kiro analyze changes \
            --from-ref ${{ github.event.before }} \
            --to-ref ${{ github.sha }} \
            --output-format json \
            --include-impact-analysis \
            --include-test-strategy \
            --include-deployment-strategy > analysis.json
            
          # Export analysis results for downstream jobs
          echo "impact=$(cat analysis.json | jq -c .impact)" >> $GITHUB_OUTPUT
          echo "test-strategy=$(cat analysis.json | jq -c .testStrategy)" >> $GITHUB_OUTPUT
          echo "deployment-strategy=$(cat analysis.json | jq -c .deploymentStrategy)" >> $GITHUB_OUTPUT
          
      - name: Upload Analysis Results
        uses: actions/upload-artifact@v4
        with:
          name: kiro-analysis
          path: analysis.json

  intelligent-build:
    needs: analyze-changes
    runs-on: ubuntu-latest
    strategy:
      matrix:
        # Dynamic matrix based on Kiro analysis
        component: ${{ fromJson(needs.analyze-changes.outputs.impact-analysis).affectedComponents }}
        
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '18'
          cache: 'npm'
          
      - name: Install Dependencies
        run: |
          # Intelligent dependency installation based on changes
          if [[ "${{ matrix.component }}" == "frontend" ]]; then
            npm ci --prefix frontend
          elif [[ "${{ matrix.component }}" == "backend" ]]; then
            npm ci --prefix backend
          else
            npm ci  # Full install for cross-cutting changes
          fi
          
      - name: Kiro-Optimized Build
        run: |
          # Use Kiro to optimize build process
          kiro build optimize \
            --component ${{ matrix.component }} \
            --parallel-jobs auto \
            --cache-strategy intelligent \
            --output-analysis build-analysis.json
            
      - name: Upload Build Artifacts
        uses: actions/upload-artifact@v4
        with:
          name: build-${{ matrix.component }}
          path: |
            dist/
            build-analysis.json

  intelligent-testing:
    needs: [analyze-changes, intelligent-build]
    runs-on: ubuntu-latest
    strategy:
      matrix:
        test-suite: ${{ fromJson(needs.analyze-changes.outputs.test-strategy).testSuites }}
        
    steps:
      - uses: actions/checkout@v4
      
      - name: Download Build Artifacts
        uses: actions/download-artifact@v4
        with:
          pattern: build-*
          merge-multiple: true
          
      - name: Setup Test Environment
        run: |
          # Configure test environment based on test suite requirements
          kiro test setup \
            --suite ${{ matrix.test-suite.name }} \
            --environment ${{ matrix.test-suite.environment }} \
            --data-strategy ${{ matrix.test-suite.dataStrategy }}
            
      - name: Execute Intelligent Tests
        run: |
          # Run tests with Kiro optimization
          kiro test run \
            --suite ${{ matrix.test-suite.name }} \
            --parallel-workers ${{ matrix.test-suite.parallelWorkers }} \
            --retry-strategy intelligent \
            --coverage-analysis \
            --performance-baseline \
            --output-format junit,json
            
      - name: Analyze Test Results
        if: always()
        run: |
          # Intelligent test result analysis
          kiro test analyze \
            --results test-results.json \
            --identify-flaky-tests \
            --suggest-optimizations \
            --update-baselines
            
      - name: Upload Test Results
        uses: actions/upload-artifact@v4
        if: always()
        with:
          name: test-results-${{ matrix.test-suite.name }}
          path: |
            test-results.*
            coverage/

  quality-gates:
    needs: [analyze-changes, intelligent-testing]
    runs-on: ubuntu-latest
    outputs:
      deployment-approved: ${{ steps.quality-check.outputs.approved }}
      confidence-score: ${{ steps.quality-check.outputs.confidence }}
      
    steps:
      - uses: actions/checkout@v4
      
      - name: Download Test Results
        uses: actions/download-artifact@v4
        with:
          pattern: test-results-*
          merge-multiple: true
          
      - name: Intelligent Quality Assessment
        id: quality-check
        run: |
          # Kiro's AI-powered quality gates
          quality_result=$(kiro quality assess \
            --test-results . \
            --change-impact "${{ needs.analyze-changes.outputs.impact-analysis }}" \
            --quality-standards production \
            --risk-tolerance medium \
            --output-format json)
            
          echo "approved=$(echo $quality_result | jq -r .approved)" >> $GITHUB_OUTPUT
          echo "confidence=$(echo $quality_result | jq -r .confidenceScore)" >> $GITHUB_OUTPUT
          
          # Set job status based on quality assessment
          if [[ "$(echo $quality_result | jq -r .approved)" == "true" ]]; then
            echo "✅ Quality gates passed with confidence score: $(echo $quality_result | jq -r .confidenceScore)"
          else
            echo "❌ Quality gates failed: $(echo $quality_result | jq -r .reason)"
            exit 1
          fi

  intelligent-deployment:
    needs: [analyze-changes, quality-gates]
    if: needs.quality-gates.outputs.deployment-approved == 'true'
    runs-on: ubuntu-latest
    environment: 
      name: ${{ fromJson(needs.analyze-changes.outputs.deployment-strategy).targetEnvironment }}
      
    steps:
      - uses: actions/checkout@v4
      
      - name: Configure Deployment Strategy
        run: |
          # Use Kiro to determine optimal deployment approach
          kiro deploy configure \
            --strategy "${{ fromJson(needs.analyze-changes.outputs.deployment-strategy).strategy }}" \
            --confidence-score ${{ needs.quality-gates.outputs.confidence-score }} \
            --rollback-plan automatic \
            --monitoring-enhanced
            
      - name: Execute Intelligent Deployment
        run: |
          # Deploy with Kiro intelligence
          kiro deploy execute \
            --environment ${{ fromJson(needs.analyze-changes.outputs.deployment-strategy).targetEnvironment }} \
            --health-checks automatic \
            --traffic-shifting gradual \
            --rollback-triggers intelligent
            
      - name: Post-Deployment Monitoring
        run: |
          # Activate intelligent monitoring
          kiro monitor activate \
            --deployment-id ${{ github.sha }} \
            --alert-strategy context-aware \
            --optimization continuous

# .gitlab-ci.yml
stages:
  - analyze
  - build
  - test
  - quality
  - deploy
  - monitor

variables:
  KIRO_API_ENDPOINT: "https://api.kiro.aws.amazon.com"
  KIRO_PROJECT_ID: $CI_PROJECT_ID

# Change Impact Analysis
kiro-analysis:
  stage: analyze
  image: aws-kiro/cli:latest
  script:
    - kiro auth login --token $KIRO_API_TOKEN
    - |
      kiro analyze pipeline-optimization \
        --commit-range $CI_MERGE_REQUEST_TARGET_BRANCH_SHA..$CI_COMMIT_SHA \
        --project-context .kiro/ \
        --output-file kiro-analysis.json \
        --generate-pipeline-config
  artifacts:
    reports:
      kiro_analysis: kiro-analysis.json
    paths:
      - kiro-analysis.json
      - dynamic-pipeline.yml
    expire_in: 1 hour
  rules:
    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH

# Dynamic Build Jobs
.build_template: &build_template
  stage: build
  before_script:
    - export BUILD_CONFIG=$(cat kiro-analysis.json | jq -r ".buildStrategy.${BUILD_COMPONENT}")
    - kiro build configure --config "$BUILD_CONFIG"
  script:
    - kiro build execute --component $BUILD_COMPONENT --optimization-level auto
  artifacts:
    paths:
      - dist/
      - build-metrics.json
    expire_in: 1 day
  needs:
    - job: kiro-analysis
      artifacts: true

build-frontend:
  <<: *build_template
  variables:
    BUILD_COMPONENT: "frontend"
  rules:
    - if: '$KIRO_BUILD_FRONTEND == "true"'

build-backend:
  <<: *build_template
  variables:
    BUILD_COMPONENT: "backend"
  rules:
    - if: '$KIRO_BUILD_BACKEND == "true"'

build-services:
  <<: *build_template
  variables:
    BUILD_COMPONENT: "services"
  parallel:
    matrix:
      - SERVICE: [auth, api, worker, scheduler]
  rules:
    - if: '$KIRO_BUILD_SERVICES == "true"'

# Intelligent Test Execution
.test_template: &test_template
  stage: test
  before_script:
    - export TEST_CONFIG=$(cat kiro-analysis.json | jq -r ".testStrategy.${TEST_TYPE}")
    - kiro test environment-setup --config "$TEST_CONFIG"
  script:
    - |
      kiro test execute \
        --type $TEST_TYPE \
        --parallel-workers auto \
        --coverage-threshold auto \
        --performance-baseline \
        --ai-generated-tests \
        --output-format junit,coverage,performance
  after_script:
    - kiro test analyze --results test-results/ --update-benchmarks
  artifacts:
    reports:
      junit: test-results/junit.xml
      coverage_report:
        coverage_format: cobertura
        path: test-results/coverage.xml
    paths:
      - test-results/
    expire_in: 1 week
  coverage: '/Coverage: \d+\.\d+%/'

unit-tests:
  <<: *test_template
  variables:
    TEST_TYPE: "unit"
  parallel: 3
  needs:
    - job: kiro-analysis
      artifacts: true

integration-tests:
  <<: *test_template
  variables:
    TEST_TYPE: "integration"
  services:
    - postgres:13
    - redis:6
  needs:
    - job: build-backend
      artifacts: true

e2e-tests:
  <<: *test_template
  variables:
    TEST_TYPE: "e2e"
  services:
    - selenium/standalone-chrome:latest
  needs:
    - job: build-frontend
      artifacts: true
    - job: build-backend
      artifacts: true

# AI-Powered Quality Gates
quality-assessment:
  stage: quality
  image: aws-kiro/cli:latest
  script:
    - |
      quality_result=$(kiro quality comprehensive-assessment \
        --test-results test-results/ \
        --build-metrics build-metrics.json \
        --change-analysis kiro-analysis.json \
        --quality-profile production \
        --ai-confidence-threshold 0.85)
    - echo $quality_result | jq .
    - |
      if [[ $(echo $quality_result | jq -r .approved) == "true" ]]; then
        echo "DEPLOYMENT_APPROVED=true" > deploy.env
        echo "CONFIDENCE_SCORE=$(echo $quality_result | jq -r .confidenceScore)" >> deploy.env
      else
        echo "Quality gates failed: $(echo $quality_result | jq -r .reason)"
        exit 1
      fi
  artifacts:
    reports:
      dotenv: deploy.env
  needs:
    - job: unit-tests
      artifacts: true
    - job: integration-tests
      artifacts: true
    - job: e2e-tests
      artifacts: true

# Intelligent Deployment
deploy-staging:
  stage: deploy
  environment:
    name: staging
    url: https://staging.example.com
  script:
    - |
      kiro deploy execute \
        --environment staging \
        --strategy blue-green \
        --health-checks comprehensive \
        --rollback-policy automatic \
        --monitoring enhanced \
        --confidence-score $CONFIDENCE_SCORE
  rules:
    - if: $DEPLOYMENT_APPROVED == "true" && $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
  needs:
    - job: quality-assessment
      artifacts: true

deploy-production:
  stage: deploy
  environment:
    name: production
    url: https://production.example.com
  when: manual
  script:
    - |
      # Enhanced production deployment with extra safeguards
      kiro deploy execute \
        --environment production \
        --strategy canary \
        --canary-percentage 5 \
        --promotion-criteria ai-determined \
        --monitoring comprehensive \
        --incident-response automatic
  rules:
    - if: $DEPLOYMENT_APPROVED == "true" && $CONFIDENCE_SCORE > "0.9"
  needs:
    - job: deploy-staging

# Continuous Monitoring and Optimization
post-deployment-monitoring:
  stage: monitor
  script:
    - |
      kiro monitor deployment \
        --deployment-id $CI_COMMIT_SHA \
        --duration 24h \
        --metrics comprehensive \
        --alerting intelligent \
        --optimization continuous
  rules:
    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
  needs:
    - job: deploy-production
      optional: true

// Jenkinsfile
pipeline {
    agent any
    
    environment {
        KIRO_API_TOKEN = credentials('kiro-api-token')
        KIRO_PROJECT_ID = "${env.JOB_NAME}"
    }
    
    stages {
        stage('Kiro Analysis') {
            steps {
                script {
                    // Perform intelligent change analysis
                    def analysisResult = sh(
                        script: """
                            kiro analyze commit-impact \
                                --from-commit ${env.GIT_PREVIOUS_COMMIT ?: 'HEAD~1'} \
                                --to-commit ${env.GIT_COMMIT} \
                                --output-format json \
                                --include-pipeline-recommendations
                        """,
                        returnStdout: true
                    ).trim()
                    
                    env.KIRO_ANALYSIS = analysisResult
                    def analysis = readJSON text: analysisResult
                    
                    // Set dynamic pipeline variables based on analysis
                    env.SHOULD_RUN_FULL_TESTS = analysis.testStrategy.fullSuite.toString()
                    env.SHOULD_DEPLOY_STAGING = analysis.deploymentStrategy.staging.recommended.toString()
                    env.BUILD_PARALLELISM = analysis.buildStrategy.parallelism.toString()
                    
                    // Store analysis for later stages
                    writeFile file: 'kiro-analysis.json', text: analysisResult
                    archiveArtifacts artifacts: 'kiro-analysis.json'
                }
            }
        }
        
        stage('Intelligent Build') {
            parallel {
                stage('Frontend Build') {
                    when {
                        expression { 
                            def analysis = readJSON file: 'kiro-analysis.json'
                            return analysis.affectedComponents.contains('frontend')
                        }
                    }
                    steps {
                        script {
                            kiroIntelligentBuild('frontend')
                        }
                    }
                }
                
                stage('Backend Build') {
                    when {
                        expression {
                            def analysis = readJSON file: 'kiro-analysis.json'
                            return analysis.affectedComponents.contains('backend')
                        }
                    }
                    steps {
                        script {
                            kiroIntelligentBuild('backend')
                        }
                    }
                }
                
                stage('Services Build') {
                    when {
                        expression {
                            def analysis = readJSON file: 'kiro-analysis.json'
                            return analysis.affectedComponents.contains('services')
                        }
                    }
                    steps {
                        script {
                            def analysis = readJSON file: 'kiro-analysis.json'
                            def services = analysis.affectedServices
                            
                            // Build affected services in parallel
                            def parallelBuilds = [:]
                            services.each { service ->
                                parallelBuilds[service] = {
                                    kiroIntelligentBuild('services', service)
                                }
                            }
                            parallel parallelBuilds
                        }
                    }
                }
            }
        }
        
        stage('AI-Optimized Testing') {
            parallel {
                stage('Unit Tests') {
                    steps {
                        script {
                            kiroIntelligentTest('unit')
                        }
                    }
                    post {
                        always {
                            publishTestResults testResultsPattern: 'test-results/unit/junit.xml'
                            publishCoverage adapters: [
                                cobertura('test-results/unit/coverage.xml')
                            ]
                        }
                    }
                }
                
                stage('Integration Tests') {
                    when {
                        expression { env.SHOULD_RUN_FULL_TESTS == 'true' }
                    }
                    steps {
                        script {
                            kiroIntelligentTest('integration')
                        }
                    }
                    post {
                        always {
                            publishTestResults testResultsPattern: 'test-results/integration/junit.xml'
                        }
                    }
                }
                
                stage('Performance Tests') {
                    when {
                        expression {
                            def analysis = readJSON file: 'kiro-analysis.json'
                            return analysis.performanceImpact.significant
                        }
                    }
                    steps {
                        script {
                            kiroIntelligentTest('performance')
                        }
                    }
                    post {
                        always {
                            publishPerformanceReport(
                                sourceDataFiles: 'test-results/performance/results.xml'
                            )
                        }
                    }
                }
            }
        }
        
        stage('Quality Gates') {
            steps {
                script {
                    // AI-powered quality assessment
                    def qualityResult = sh(
                        script: """
                            kiro quality assess \
                                --test-results test-results/ \
                                --build-artifacts dist/ \
                                --change-analysis kiro-analysis.json \
                                --quality-profile enterprise \
                                --output-format json
                        """,
                        returnStdout: true
                    ).trim()
                    
                    def quality = readJSON text: qualityResult
                    
                    if (!quality.approved) {
                        error("Quality gates failed: ${quality.reason}")
                    }
                    
                    env.QUALITY_CONFIDENCE = quality.confidenceScore.toString()
                    env.DEPLOYMENT_STRATEGY = quality.recommendedDeploymentStrategy
                }
            }
        }
        
        stage('Intelligent Deployment') {
            when {
                allOf {
                    branch 'main'
                    expression { env.SHOULD_DEPLOY_STAGING == 'true' }
                }
            }
            stages {
                stage('Deploy to Staging') {
                    steps {
                        script {
                            kiroIntelligentDeploy('staging')
                        }
                    }
                }
                
                stage('Staging Validation') {
                    steps {
                        script {
                            // Intelligent post-deployment validation
                            sh """
                                kiro validate deployment \
                                    --environment staging \
                                    --deployment-id ${env.BUILD_ID} \
                                    --validation-suite comprehensive \
                                    --ai-powered-checks
                            """
                        }
                    }
                }
                
                stage('Deploy to Production') {
                    when {
                        expression { 
                            return env.QUALITY_CONFIDENCE.toFloat() > 0.9 
                        }
                    }
                    input {
                        message "Deploy to production?"
                        ok "Deploy"
                        parameters {
                            choice(
                                name: 'DEPLOYMENT_STRATEGY',
                                choices: ['blue-green', 'canary', 'rolling'],
                                description: 'Deployment strategy (AI recommended: ' + env.DEPLOYMENT_STRATEGY + ')'
                            )
                        }
                    }
                    steps {
                        script {
                            kiroIntelligentDeploy('production', params.DEPLOYMENT_STRATEGY)
                        }
                    }
                }
            }
        }
        
        stage('Continuous Monitoring') {
            when {
                branch 'main'
            }
            steps {
                script {
                    // Activate intelligent monitoring
                    sh """
                        kiro monitor activate \
                            --deployment-id ${env.BUILD_ID} \
                            --environment production \
                            --alert-strategy adaptive \
                            --optimization continuous \
                            --duration 48h
                    """
                }
            }
        }
    }
    
    post {
        always {
            script {
                // Kiro pipeline analytics and optimization
                sh """
                    kiro pipeline analyze \
                        --pipeline-id ${env.BUILD_ID} \
                        --duration ${currentBuild.duration} \
                        --result ${currentBuild.result} \
                        --suggest-optimizations
                """
            }
        }
        failure {
            script {
                // Intelligent failure analysis
                sh """
                    kiro failure analyze \
                        --pipeline-id ${env.BUILD_ID} \
                        --logs ${env.BUILD_URL}consoleText \
                        --suggest-fixes \
                        --create-incident-report
                """
            }
        }
    }
}

// Helper functions for Kiro integration
def kiroIntelligentBuild(component, service = null) {
    def buildCmd = "kiro build execute --component ${component}"
    if (service) {
        buildCmd += " --service ${service}"
    }
    buildCmd += " --optimization auto --cache intelligent --metrics detailed"
    
    sh buildCmd
}

def kiroIntelligentTest(testType) {
    sh """
        kiro test execute \
            --type ${testType} \
            --parallel auto \
            --selection intelligent \
            --retry-strategy adaptive \
            --coverage-analysis \
            --performance-baseline
    """
}

def kiroIntelligentDeploy(environment, strategy = null) {
    def deployCmd = "kiro deploy execute --environment ${environment}"
    if (strategy) {
        deployCmd += " --strategy ${strategy}"
    } else {
        deployCmd += " --strategy auto"
    }
    deployCmd += " --health-checks comprehensive --rollback automatic --monitoring enhanced"
    
    sh deployCmd
}

# cloudformation-pipeline.yml
AWSTemplateFormatVersion: '2010-09-09'
Description: 'Intelligent CI/CD Pipeline with Kiro Integration'

Parameters:
  KiroApiToken:
    Type: String
    NoEcho: true
    Description: Kiro API Token for authentication
    
  GitHubRepo:
    Type: String
    Description: GitHub repository name
    
  GitHubOwner:
    Type: String
    Description: GitHub repository owner

Resources:
  # S3 Bucket for Pipeline Artifacts
  ArtifactStore:
    Type: AWS::S3::Bucket
    Properties:
      VersioningConfiguration:
        Status: Enabled
      PublicAccessBlockConfiguration:
        BlockPublicAcls: true
        BlockPublicPolicy: true
        IgnorePublicAcls: true
        RestrictPublicBuckets: true

  # IAM Role for CodePipeline
  CodePipelineRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service: codepipeline.amazonaws.com
            Action: sts:AssumeRole
      Policies:
        - PolicyName: KiroIntegrationPolicy
          PolicyDocument:
            Version: '2012-10-17'
            Statement:
              - Effect: Allow
                Action:
                  - s3:GetObject
                  - s3:PutObject
                  - codebuild:BatchGetBuilds
                  - codebuild:StartBuild
                  - lambda:InvokeFunction
                Resource: '*'

  # Kiro Analysis Lambda Function
  KiroAnalysisFunction:
    Type: AWS::Lambda::Function
    Properties:
      Runtime: python3.9
      Handler: index.handler
      Code:
        ZipFile: |
          import json
          import boto3
          import subprocess
          import os
          
          def handler(event, context):
              # Extract CodePipeline job data
              job_id = event['CodePipeline.job']['id']
              input_artifacts = event['CodePipeline.job']['data']['inputArtifacts']
              
              try:
                  # Download source artifacts
                  s3 = boto3.client('s3')
                  
                  # Perform Kiro analysis
                  analysis_result = subprocess.run([
                      'kiro', 'analyze', 'pipeline-optimization',
                      '--source-location', '/tmp/source',
                      '--output-format', 'json'
                  ], capture_output=True, text=True)
                  
                  if analysis_result.returncode != 0:
                      raise Exception(f"Kiro analysis failed: {analysis_result.stderr}")
                  
                  analysis = json.loads(analysis_result.stdout)
                  
                  # Store analysis results for subsequent stages
                  s3.put_object(
                      Bucket=os.environ['ARTIFACT_BUCKET'],
                      Key=f"kiro-analysis/{job_id}/analysis.json",
                      Body=json.dumps(analysis)
                  )
                  
                  # Report success to CodePipeline
                  codepipeline = boto3.client('codepipeline')
                  codepipeline.put_job_success_result(jobId=job_id)
                  
              except Exception as e:
                  codepipeline = boto3.client('codepipeline')
                  codepipeline.put_job_failure_result(
                      jobId=job_id,
                      failureDetails={'message': str(e)}
                  )
      Environment:
        Variables:
          KIRO_API_TOKEN: !Ref KiroApiToken
          ARTIFACT_BUCKET: !Ref ArtifactStore
      Role: !GetAtt LambdaExecutionRole.Arn

  # CodeBuild Project for Intelligent Build
  IntelligentBuildProject:
    Type: AWS::CodeBuild::Project
    Properties:
      ServiceRole: !GetAtt CodeBuildRole.Arn
      Artifacts:
        Type: CODEPIPELINE
      Environment:
        Type: LINUX_CONTAINER
        ComputeType: BUILD_GENERAL1_MEDIUM
        Image: aws/codebuild/standard:5.0
        EnvironmentVariables:
          - Name: KIRO_API_TOKEN
            Value: !Ref KiroApiToken
          - Name: ARTIFACT_BUCKET
            Value: !Ref ArtifactStore
      Source:
        Type: CODEPIPELINE
        BuildSpec: |
          version: 0.2
          phases:
            install:
              runtime-versions:
                nodejs: 14
              commands:
                - curl -fsSL https://kiro.aws.amazon.com/install.sh | sh
                - export PATH=$PATH:/usr/local/bin/kiro
            pre_build:
              commands:
                - echo "Retrieving Kiro analysis..."
                - aws s3 cp s3://$ARTIFACT_BUCKET/kiro-analysis/$CODEBUILD_BUILD_ID/analysis.json .
                - export KIRO_ANALYSIS=$(cat analysis.json)
            build:
              commands:
                - echo "Executing intelligent build..."
                - |
                  kiro build execute \
                    --analysis-file analysis.json \
                    --optimization-level auto \
                    --parallel-jobs auto \
                    --cache-strategy intelligent \
                    --metrics-output build-metrics.json
            post_build:
              commands:
                - echo "Build completed"
                - kiro build analyze --metrics build-metrics.json
          artifacts:
            files:
              - '**/*'
            secondary-artifacts:
              BuildMetrics:
                files:
                  - build-metrics.json

  # Main Pipeline
  IntelligentPipeline:
    Type: AWS::CodePipeline::Pipeline
    Properties:
      RoleArn: !GetAtt CodePipelineRole.Arn
      ArtifactStore:
        Type: S3
        Location: !Ref ArtifactStore
      Stages:
        - Name: Source
          Actions:
            - Name: SourceAction
              ActionTypeId:
                Category: Source
                Owner: ThirdParty
                Provider: GitHub
                Version: 1
              Configuration:
                Owner: !Ref GitHubOwner
                Repo: !Ref GitHubRepo
                Branch: main
                OAuthToken: !Ref GitHubToken
              OutputArtifacts:
                - Name: SourceOutput

        - Name: KiroAnalysis
          Actions:
            - Name: AnalyzeChanges
              ActionTypeId:
                Category: Invoke
                Owner: AWS
                Provider: Lambda
                Version: 1
              Configuration:
                FunctionName: !Ref KiroAnalysisFunction
              InputArtifacts:
                - Name: SourceOutput
              OutputArtifacts:
                - Name: AnalysisOutput

        - Name: IntelligentBuild
          Actions:
            - Name: BuildApplication
              ActionTypeId:
                Category: Build
                Owner: AWS
                Provider: CodeBuild
                Version: 1
              Configuration:
                ProjectName: !Ref IntelligentBuildProject
              InputArtifacts:
                - Name: SourceOutput
                - Name: AnalysisOutput
              OutputArtifacts:
                - Name: BuildOutput

        - Name: IntelligentTest
          Actions:
            - Name: RunTests
              ActionTypeId:
                Category: Build
                Owner: AWS
                Provider: CodeBuild
                Version: 1
              Configuration:
                ProjectName: !Ref IntelligentTestProject
              InputArtifacts:
                - Name: BuildOutput
                - Name: AnalysisOutput
              OutputArtifacts:
                - Name: TestOutput

        - Name: QualityGates
          Actions:
            - Name: AssessQuality
              ActionTypeId:
                Category: Invoke
                Owner: AWS
                Provider: Lambda
                Version: 1
              Configuration:
                FunctionName: !Ref QualityGatesFunction
              InputArtifacts:
                - Name: TestOutput
                - Name: AnalysisOutput

        - Name: IntelligentDeploy
          Actions:
            - Name: DeployToStaging
              ActionTypeId:
                Category: Deploy
                Owner: AWS
                Provider: CloudFormation
                Version: 1
              Configuration:
                ActionMode: CREATE_UPDATE
                StackName: staging-stack
                TemplatePath: BuildOutput::infrastructure/staging.yml
                Capabilities: CAPABILITY_IAM
                RoleArn: !GetAtt CloudFormationRole.Arn
              InputArtifacts:
                - Name: BuildOutput
              Region: !Ref AWS::Region

Outputs:
  PipelineName:
    Description: Name of the created pipeline
    Value: !Ref IntelligentPipeline
    
  ArtifactBucket:
    Description: S3 bucket for pipeline artifacts
    Value: !Ref ArtifactStore