Jenkinsfile Generator

rendered/
output/

# Test artifacts
generated/

// Declarative Pipeline Template
// Replace [PLACEHOLDER] values with your configuration
// Generated by Jenkinsfile Generator

pipeline {
    // Agent Configuration
    // Options: any, none, label, docker, dockerfile, kubernetes
    agent [AGENT_TYPE]

    // Environment Variables (optional)
    environment {
        // Static variables
        BUILD_ENV = '[ENVIRONMENT]'
        VERSION = '[VERSION]'

        // Credential bindings
        // DOCKER_CREDENTIALS = credentials('[CREDENTIALS_ID]')
    }

    // Pipeline Parameters (optional)
    parameters {
        string(name: 'BRANCH', defaultValue: 'main', description: 'Branch to build')
        choice(name: 'ENVIRONMENT', choices: ['dev', 'staging', 'production'], description: 'Target environment')
        booleanParam(name: 'SKIP_TESTS', defaultValue: false, description: 'Skip tests')
    }

    // Pipeline Options
    options {
        buildDiscarder(logRotator(numToKeepStr: '10'))
        timestamps()
        timeout(time: 1, unit: 'HOURS')
        disableConcurrentBuilds()
    }

    // Build Triggers (optional)
    // triggers {
    //     cron('H */4 * * 1-5')
    //     pollSCM('H/15 * * * *')
    // }

    // Tool Configuration (optional)
    // tools {
    //     maven 'Maven-3.9.9'
    //     jdk 'JDK-21'
    // }

    stages {
        stage('Checkout') {
            steps {
                checkout scm
                // Or explicit checkout:
                // git branch: 'main', url: '[REPOSITORY_URL]'
            }
        }

        stage('Build') {
            steps {
                sh '[BUILD_COMMAND]'
                // Examples:
                // sh 'mvn clean compile'
                // sh 'npm install && npm run build'
                // sh 'go build ./...'
            }
        }

        stage('Test') {
            when {
                not {
                    expression { params.SKIP_TESTS }
                }
            }
            steps {
                sh '[TEST_COMMAND]'
                // Examples:
                // sh 'mvn test'
                // sh 'npm test'
                // sh 'pytest'
            }
            post {
                always {
                    junit '[TEST_RESULTS_PATH]'
                    // Examples:
                    // junit '**/target/surefire-reports/*.xml'
                    // junit '**/test-results/*.xml'
                }
            }
        }

        stage('Package') {
            steps {
                sh '[PACKAGE_COMMAND]'
                // Examples:
                // sh 'mvn package -DskipTests'
                // sh 'npm run build:prod'
            }
        }

        // Optional: Docker Build Stage
        // stage('Docker Build') {
        //     steps {
        //         script {
        //             docker.build("[IMAGE_NAME]:${BUILD_NUMBER}")
        //         }
        //     }
        // }

        // Optional: Deploy Stage with Approval
        stage('Deploy') {
            when {
                branch 'main'
            }
            input {
                message 'Deploy to [ENVIRONMENT]?'
                ok 'Deploy'
                submitter '[APPROVERS]'
            }
            steps {
                sh '[DEPLOY_COMMAND]'
                // Examples:
                // sh './deploy.sh production'
                // sh 'kubectl apply -f k8s/'
            }
        }
    }

    post {
        always {
            // Always cleanup workspace
            cleanWs()
        }
        success {
            // Archive artifacts on success
            archiveArtifacts artifacts: '[ARTIFACT_PATTERN]', fingerprint: true
            // Examples:
            // archiveArtifacts artifacts: '**/target/*.jar', fingerprint: true

            // Optional: Slack notification
            // slackSend color: 'good', message: "Build ${env.BUILD_NUMBER} succeeded"
        }
        failure {
            // Notify on failure
            echo 'Pipeline failed!'

            // Optional: Email notification
            // emailext(
            //     subject: "Build Failed: ${env.JOB_NAME} #${env.BUILD_NUMBER}",
            //     body: "Check ${env.BUILD_URL}",
            //     to: '[EMAIL_RECIPIENTS]'
            // )
        }
    }
}

// Scripted Pipeline Template
// Replace [PLACEHOLDER] values with your configuration
// Generated by Jenkinsfile Generator

// Optional: Load shared library
// @Library('my-shared-library') _

// Node selection (optional: specify label)
node('[AGENT_LABEL]') {
    // Environment setup
    def buildVersion = "${env.BUILD_NUMBER}"
    def artifactName = "[ARTIFACT_NAME]"

    try {
        stage('Checkout') {
            checkout scm
            // Or explicit checkout:
            // git branch: 'main', url: '[REPOSITORY_URL]'
        }

        stage('Build') {
            // Optional: Run inside Docker container
            // docker.image('[DOCKER_IMAGE]').inside {
            //     sh '[BUILD_COMMAND]'
            // }

            sh '[BUILD_COMMAND]'
            // Examples:
            // sh 'mvn clean compile'
            // sh 'npm install && npm run build'
            // sh 'go build ./...'
        }

        stage('Test') {
            sh '[TEST_COMMAND]'
            // Examples:
            // sh 'mvn test'
            // sh 'npm test'
            // sh 'pytest --junitxml=test-results.xml'

            // Publish test results
            junit '[TEST_RESULTS_PATH]'
            // Examples:
            // junit '**/target/surefire-reports/*.xml'
            // junit '**/test-results.xml'
        }

        stage('Package') {
            sh '[PACKAGE_COMMAND]'
            // Examples:
            // sh 'mvn package -DskipTests'
            // sh 'npm run build:prod'
        }

        // Optional: Docker Build and Push
        // stage('Docker Build') {
        //     def image = docker.build("[IMAGE_NAME]:${buildVersion}")
        //
        //     stage('Docker Push') {
        //         docker.withRegistry('[REGISTRY_URL]', '[REGISTRY_CREDENTIALS]') {
        //             image.push()
        //             image.push('latest')
        //         }
        //     }
        // }

        // Optional: Parallel Testing
        // stage('Parallel Tests') {
        //     parallel(
        //         'Unit Tests': {
        //             node {
        //                 sh 'npm run test:unit'
        //             }
        //         },
        //         'Integration Tests': {
        //             node {
        //                 sh 'npm run test:integration'
        //             }
        //         }
        //     )
        // }

        // Conditional deployment based on branch
        if (env.BRANCH_NAME == 'main') {
            stage('Deploy to Production') {
                // Wait for approval
                input message: 'Deploy to production?', submitter: '[APPROVERS]'

                sh '[DEPLOY_COMMAND]'
                // Examples:
                // sh './deploy.sh production'
                // sh 'kubectl apply -f k8s/'
            }
        } else if (env.BRANCH_NAME == 'develop') {
            stage('Deploy to Staging') {
                sh '[DEPLOY_STAGING_COMMAND]'
            }
        }

        // Archive artifacts on success
        if (currentBuild.result == null || currentBuild.result == 'SUCCESS') {
            archiveArtifacts artifacts: '[ARTIFACT_PATTERN]', fingerprint: true
            // Examples:
            // archiveArtifacts artifacts: '**/target/*.jar', fingerprint: true
        }

    } catch (Exception e) {
        currentBuild.result = 'FAILURE'
        echo "Pipeline failed: ${e.message}"

        // Optional: Send failure notification
        // emailext(
        //     subject: "Build Failed: ${env.JOB_NAME} #${env.BUILD_NUMBER}",
        //     body: "Error: ${e.message}\nCheck ${env.BUILD_URL}",
        //     to: '[EMAIL_RECIPIENTS]'
        // )

        // Optional: Slack notification
        // slackSend color: 'danger', message: "Build ${env.BUILD_NUMBER} failed"

        throw e
    } finally {
        // Always cleanup workspace
        deleteDir()
    }
}

// Declarative Pipeline - Basic CI Example
// Generated by Jenkinsfile Generator
// Date: 2025-01-18

pipeline {
    agent any

    tools {
        maven 'Maven-3.9.9'
        jdk 'JDK-21'
    }

    options {
        buildDiscarder(logRotator(numToKeepStr: '10'))
        timestamps()
    }

    stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }

        stage('Build') {
            steps {
                sh 'mvn clean compile'
            }
        }

        stage('Test') {
            steps {
                sh 'mvn test'
            }
            post {
                always {
                    junit '**/target/surefire-reports/*.xml'
                }
            }
        }

        stage('Package') {
            steps {
                sh 'mvn package'
            }
        }
    }

    post {
        success {
            archiveArtifacts artifacts: '**/target/*.jar', fingerprint: true
        }
        always {
            deleteDir()
        }
        failure {
            echo 'Pipeline failed!'
        }
    }
}

// Declarative Pipeline - Docker Build and Push
// Generated by Jenkinsfile Generator
// Date: 2025-01-18

pipeline {
    agent any

    environment {
        DOCKER_IMAGE = "${JOB_NAME}"
        DOCKER_REGISTRY = 'registry.example.com'
    }

    options {
        buildDiscarder(logRotator(numToKeepStr: '10'))
        disableConcurrentBuilds()
    }

    stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }

        stage('Build Application') {
            agent {
                docker {
                    image 'maven:3.9.9-eclipse-temurin-21'
                    args '-v $HOME/.m2:/root/.m2'
                }
            }
            steps {
                sh 'mvn clean package'
            }
        }

        stage('Build Docker Image') {
            steps {
                script {
                    // Build once and store reference - avoid rebuilding for each tag
                    def customImage = docker.build("${DOCKER_IMAGE}:${BUILD_NUMBER}")
                    // Tag with 'latest' using the same built image
                    customImage.tag('latest')
                }
            }
        }

        stage('Push to Registry') {
            steps {
                script {
                    docker.withRegistry("https://${DOCKER_REGISTRY}", 'docker-registry-credentials') {
                        def customImage = docker.image("${DOCKER_IMAGE}:${BUILD_NUMBER}")
                        // Push both tags - build number and latest
                        customImage.push()
                        customImage.push('latest')
                    }
                }
            }
        }
    }

    post {
        success {
            echo "Successfully built and pushed ${DOCKER_IMAGE}:${BUILD_NUMBER}"
        }
        always {
            deleteDir()
        }
    }
}

// Declarative Pipeline - Kubernetes Agent with Multi-Container Build
// Generated by Jenkinsfile Generator
// Date: 2025-01-18
// Updated: Using modern YAML syntax (recommended approach)

pipeline {
    agent {
        kubernetes {
            // Modern YAML syntax - recommended for Kubernetes plugin
            yaml '''
apiVersion: v1
kind: Pod
metadata:
  labels:
    jenkins-build: true
spec:
  containers:
  - name: maven
    image: maven:3.9.9-eclipse-temurin-21
    command:
    - sleep
    args:
    - 99d
    resources:
      requests:
        memory: "1Gi"
        cpu: "500m"
      limits:
        memory: "2Gi"
        cpu: "1000m"
  - name: kubectl
    image: bitnami/kubectl:latest
    command:
    - sleep
    args:
    - 99d
    resources:
      requests:
        memory: "256Mi"
        cpu: "100m"
      limits:
        memory: "512Mi"
        cpu: "200m"
'''
        }
    }

    environment {
        DEPLOYMENT_NAME = 'myapp'
        NAMESPACE = 'production'
    }

    options {
        timeout(time: 1, unit: 'HOURS')
        timestamps()
        buildDiscarder(logRotator(numToKeepStr: '10'))
    }

    stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }

        stage('Build') {
            steps {
                container('maven') {
                    sh 'mvn clean package -DskipTests'
                }
            }
        }

        stage('Test') {
            steps {
                container('maven') {
                    sh 'mvn test'
                }
            }
            post {
                always {
                    junit '**/target/surefire-reports/*.xml'
                }
            }
        }

        stage('Deploy to Kubernetes') {
            when {
                branch 'main'
                beforeAgent true
            }
            steps {
                container('kubectl') {
                    sh "kubectl apply -f k8s/deployment.yaml -n ${NAMESPACE}"
                    sh "kubectl set image deployment/${DEPLOYMENT_NAME} app=\${DOCKER_IMAGE}:\${BUILD_NUMBER} -n ${NAMESPACE}"
                    sh "kubectl rollout status deployment/${DEPLOYMENT_NAME} -n ${NAMESPACE} --timeout=300s"
                }
            }
        }
    }

    post {
        success {
            echo "Successfully deployed to Kubernetes namespace: ${NAMESPACE}"
        }
        failure {
            echo "Pipeline failed - check logs for details"
        }
        always {
            cleanWs()
        }
    }
}

// Declarative Pipeline - Matrix Build Example
// Generated by Jenkinsfile Generator
// Demonstrates multi-dimensional matrix builds across platforms and browsers

pipeline {
    agent none

    parameters {
        choice(
            name: 'PLATFORM_FILTER',
            choices: ['all', 'linux', 'windows', 'mac'],
            description: 'Run on specific platform only'
        )
    }

    options {
        buildDiscarder(logRotator(numToKeepStr: '10'))
        timestamps()
        timeout(time: 2, unit: 'HOURS')
    }

    stages {
        stage('Checkout') {
            agent any
            steps {
                checkout scm
                stash name: 'source', includes: '**/*'
            }
        }

        stage('Build and Test Matrix') {
            matrix {
                agent {
                    label "${PLATFORM}-agent"
                }

                // Only run cells matching the platform filter parameter
                when {
                    anyOf {
                        expression { params.PLATFORM_FILTER == 'all' }
                        expression { params.PLATFORM_FILTER == env.PLATFORM }
                    }
                }

                // Define the matrix axes
                axes {
                    axis {
                        name 'PLATFORM'
                        values 'linux', 'windows', 'mac'
                    }
                    axis {
                        name 'BROWSER'
                        values 'chrome', 'firefox', 'safari', 'edge'
                    }
                    axis {
                        name 'NODE_VERSION'
                        values '20', '22', '24'
                    }
                }

                // Exclude invalid combinations
                excludes {
                    // Safari is not available on Linux
                    exclude {
                        axis {
                            name 'PLATFORM'
                            values 'linux'
                        }
                        axis {
                            name 'BROWSER'
                            values 'safari'
                        }
                    }
                    // Edge is only available on Windows
                    exclude {
                        axis {
                            name 'PLATFORM'
                            notValues 'windows'
                        }
                        axis {
                            name 'BROWSER'
                            values 'edge'
                        }
                    }
                    // Safari is not available on Windows
                    exclude {
                        axis {
                            name 'PLATFORM'
                            values 'windows'
                        }
                        axis {
                            name 'BROWSER'
                            values 'safari'
                        }
                    }
                }

                stages {
                    stage('Setup') {
                        steps {
                            unstash 'source'
                            echo "Setting up Node ${NODE_VERSION} on ${PLATFORM}"
                            // Platform-specific setup
                            script {
                                if (env.PLATFORM == 'windows') {
                                    bat "echo Setting up Node ${NODE_VERSION}"
                                } else {
                                    sh "echo Setting up Node ${NODE_VERSION}"
                                }
                            }
                        }
                    }

                    stage('Install Dependencies') {
                        steps {
                            script {
                                if (env.PLATFORM == 'windows') {
                                    bat 'npm ci'
                                } else {
                                    sh 'npm ci'
                                }
                            }
                        }
                    }

                    stage('Build') {
                        steps {
                            echo "Building for ${PLATFORM} with Node ${NODE_VERSION}"
                            script {
                                if (env.PLATFORM == 'windows') {
                                    bat 'npm run build'
                                } else {
                                    sh 'npm run build'
                                }
                            }
                        }
                    }

                    stage('Test') {
                        steps {
                            echo "Testing on ${PLATFORM} with ${BROWSER} using Node ${NODE_VERSION}"
                            script {
                                if (env.PLATFORM == 'windows') {
                                    bat "npm run test:e2e -- --browser ${BROWSER}"
                                } else {
                                    sh "npm run test:e2e -- --browser ${BROWSER}"
                                }
                            }
                        }
                        post {
                            always {
                                junit "**/test-results/${PLATFORM}-${BROWSER}-${NODE_VERSION}/*.xml"
                            }
                        }
                    }
                }
            }
        }

        stage('Aggregate Results') {
            agent any
            steps {
                echo 'Aggregating test results from all matrix cells...'
            }
            post {
                always {
                    // Archive all test results
                    archiveArtifacts artifacts: '**/test-results/**/*.xml', allowEmptyArchive: true
                }
            }
        }
    }

    post {
        success {
            echo 'All matrix builds completed successfully!'
        }
        failure {
            echo 'One or more matrix cells failed!'
        }
    }
}

// Declarative Pipeline - Parallel Test Execution
// Generated by Jenkinsfile Generator
// Demonstrates native parallel execution in Declarative Pipeline

pipeline {
    agent none

    options {
        buildDiscarder(logRotator(numToKeepStr: '10'))
        timestamps()
        // Abort all parallel stages if one fails
        parallelsAlwaysFailFast()
    }

    stages {
        stage('Checkout') {
            agent any
            steps {
                checkout scm
                stash name: 'source', includes: '**/*'
            }
        }

        stage('Build') {
            agent {
                docker {
                    image 'node:20-alpine'
                }
            }
            steps {
                unstash 'source'
                sh 'npm ci'
                sh 'npm run build'
                stash name: 'build-artifacts', includes: 'dist/**/*'
            }
        }

        stage('Parallel Tests') {
            // Native parallel execution in Declarative Pipeline
            // All stages inside parallel {} run concurrently
            parallel {
                stage('Unit Tests') {
                    agent {
                        docker {
                            image 'node:20-alpine'
                        }
                    }
                    steps {
                        unstash 'source'
                        sh 'npm ci'
                        sh 'npm run test:unit'
                    }
                    post {
                        always {
                            junit '**/test-results/unit/*.xml'
                        }
                    }
                }

                stage('Integration Tests') {
                    agent {
                        docker {
                            image 'node:20-alpine'
                        }
                    }
                    steps {
                        unstash 'source'
                        sh 'npm ci'
                        sh 'npm run test:integration'
                    }
                    post {
                        always {
                            junit '**/test-results/integration/*.xml'
                        }
                    }
                }

                stage('E2E Tests') {
                    agent {
                        docker {
                            image 'cypress/included:13.6.0'
                        }
                    }
                    steps {
                        unstash 'source'
                        unstash 'build-artifacts'
                        sh 'npm ci'
                        sh 'npm run test:e2e'
                    }
                    post {
                        always {
                            junit '**/test-results/e2e/*.xml'
                        }
                        failure {
                            archiveArtifacts artifacts: 'cypress/screenshots/**/*', allowEmptyArchive: true
                            archiveArtifacts artifacts: 'cypress/videos/**/*', allowEmptyArchive: true
                        }
                    }
                }

                stage('Security Scan') {
                    agent any
                    steps {
                        unstash 'source'
                        sh 'npm audit --audit-level=high || true'
                    }
                }
            }
        }

        stage('Code Coverage Report') {
            agent any
            steps {
                unstash 'source'
                echo 'Aggregating test coverage reports...'
            }
            post {
                always {
                    publishHTML([
                        allowMissing: true,
                        alwaysLinkToLastBuild: true,
                        keepAll: true,
                        reportDir: 'coverage',
                        reportFiles: 'index.html',
                        reportName: 'Coverage Report'
                    ])
                }
            }
        }
    }

    post {
        success {
            echo 'All parallel tests passed!'
        }
        failure {
            echo 'One or more parallel tests failed!'
        }
    }
}

// Declarative Pipeline - DevSecOps Security Scanning
// Generated by Jenkinsfile Generator
// Integrates SonarQube, OWASP Dependency-Check, and Trivy for comprehensive security scanning

pipeline {
    agent any

    environment {
        DOCKER_IMAGE = "${JOB_NAME}"
        DOCKER_REGISTRY = 'registry.example.com'
        SONARQUBE_SERVER = 'sonarqube-server'
    }

    options {
        buildDiscarder(logRotator(numToKeepStr: '10'))
        timestamps()
        timeout(time: 1, unit: 'HOURS')
    }

    tools {
        maven 'Maven-3.9.9'
        jdk 'JDK-21'
    }

    stages {
        stage('Checkout') {
            steps {
                checkout scm
            }
        }

        stage('Build') {
            steps {
                sh 'mvn clean compile -DskipTests'
            }
        }

        stage('Security Scans') {
            parallel {
                stage('SonarQube Analysis') {
                    steps {
                        withSonarQubeEnv("${SONARQUBE_SERVER}") {
                            sh '''
                                mvn sonar:sonar \
                                    -Dsonar.projectKey=${JOB_NAME} \
                                    -Dsonar.projectName="${JOB_NAME}" \
                                    -Dsonar.java.binaries=target/classes
                            '''
                        }
                    }
                }

                stage('OWASP Dependency Check') {
                    steps {
                        // Using OWASP Dependency-Check Plugin
                        dependencyCheck(
                            additionalArguments: '''
                                --scan .
                                --format HTML
                                --format XML
                                --format JSON
                                --out dependency-check-report
                                --suppression suppression.xml
                                --failOnCVSS 7
                            ''',
                            odcInstallation: 'OWASP-Dependency-Check'
                        )
                    }
                    post {
                        always {
                            dependencyCheckPublisher(
                                pattern: 'dependency-check-report/dependency-check-report.xml',
                                failedTotalCritical: 0,
                                failedTotalHigh: 5,
                                unstableTotalCritical: 0,
                                unstableTotalHigh: 3
                            )
                        }
                    }
                }

                stage('Secret Detection') {
                    steps {
                        sh '''
                            # Using gitleaks for secret detection
                            docker run --rm -v "$(pwd):/repo" \
                                zricethezav/gitleaks:latest \
                                detect --source="/repo" \
                                --report-path="/repo/gitleaks-report.json" \
                                --report-format json \
                                --exit-code 1 || true
                        '''
                    }
                    post {
                        always {
                            archiveArtifacts artifacts: 'gitleaks-report.json', allowEmptyArchive: true
                        }
                    }
                }
            }
        }

        stage('SonarQube Quality Gate') {
            steps {
                timeout(time: 5, unit: 'MINUTES') {
                    waitForQualityGate abortPipeline: true
                }
            }
        }

        stage('Unit Tests') {
            steps {
                sh 'mvn test'
            }
            post {
                always {
                    junit '**/target/surefire-reports/*.xml'
                    jacoco(
                        execPattern: '**/target/jacoco.exec',
                        classPattern: '**/target/classes',
                        sourcePattern: '**/src/main/java',
                        exclusionPattern: '**/test/**'
                    )
                }
            }
        }

        stage('Package') {
            steps {
                sh 'mvn package -DskipTests'
            }
        }

        stage('Build Docker Image') {
            steps {
                script {
                    def customImage = docker.build("${DOCKER_IMAGE}:${BUILD_NUMBER}")
                    customImage.tag('latest')
                }
            }
        }

        stage('Trivy Container Scan') {
            steps {
                sh '''
                    # Trivy container image vulnerability scan
                    docker run --rm \
                        -v /var/run/docker.sock:/var/run/docker.sock \
                        -v ${WORKSPACE}/trivy-cache:/root/.cache/ \
                        aquasec/trivy:latest image \
                        --severity CRITICAL,HIGH \
                        --exit-code 1 \
                        --ignore-unfixed \
                        --format table \
                        --output trivy-report.txt \
                        ${DOCKER_IMAGE}:${BUILD_NUMBER} || true

                    # Generate JSON report for archiving
                    docker run --rm \
                        -v /var/run/docker.sock:/var/run/docker.sock \
                        -v ${WORKSPACE}/trivy-cache:/root/.cache/ \
                        aquasec/trivy:latest image \
                        --severity CRITICAL,HIGH,MEDIUM \
                        --format json \
                        --output trivy-report.json \
                        ${DOCKER_IMAGE}:${BUILD_NUMBER} || true
                '''
            }
            post {
                always {
                    archiveArtifacts artifacts: 'trivy-report.*', allowEmptyArchive: true
                }
            }
        }

        stage('Trivy Filesystem Scan') {
            steps {
                sh '''
                    # Trivy filesystem scan for IaC misconfigurations
                    docker run --rm \
                        -v ${WORKSPACE}:/workspace \
                        aquasec/trivy:latest fs \
                        --severity CRITICAL,HIGH \
                        --format table \
                        --scanners vuln,secret,misconfig \
                        /workspace
                '''
            }
        }

        stage('Push to Registry') {
            when {
                allOf {
                    branch 'main'
                    // Only push if all security scans passed
                    expression { currentBuild.result == null || currentBuild.result == 'SUCCESS' }
                }
            }
            steps {
                script {
                    docker.withRegistry("https://${DOCKER_REGISTRY}", 'docker-registry-credentials') {
                        def customImage = docker.image("${DOCKER_IMAGE}:${BUILD_NUMBER}")
                        customImage.push()
                        customImage.push('latest')
                    }
                }
            }
        }
    }

    post {
        always {
            // Archive all security reports
            archiveArtifacts artifacts: '**/dependency-check-report/**/*', allowEmptyArchive: true

            // Clean workspace
            deleteDir()
        }
        success {
            echo 'All security scans passed! Pipeline completed successfully.'
        }
        failure {
            echo 'Security vulnerabilities detected or pipeline failed!'
            // Send notification on security failures
            // emailext(
            //     subject: "Security Scan Failed: ${env.JOB_NAME} #${env.BUILD_NUMBER}",
            //     body: "Security vulnerabilities were detected. Check ${env.BUILD_URL} for details.",
            //     to: 'security-team@example.com'
            // )
        }
        unstable {
            echo 'Security scan found warnings. Review the reports.'
        }
    }
}

// Declarative Pipeline - Using Shared Library
// Generated by Jenkinsfile Generator
// Demonstrates shared library usage patterns

@Library('my-jenkins-library') _
import org.example.Utils
import org.example.Docker
import org.example.Notifications

pipeline {
    agent any

    environment {
        DOCKER_REGISTRY = 'registry.example.com'
        DOCKER_IMAGE = 'myapp'
    }

    options {
        buildDiscarder(logRotator(numToKeepStr: '10'))
        timestamps()
        timeout(time: 30, unit: 'MINUTES')
    }

    stages {
        stage('Checkout') {
            steps {
                checkout scm
                script {
                    // Using shared library utility class
                    env.GIT_BRANCH = Utils.getBranchName(this)
                    env.GIT_COMMIT_SHORT = Utils.getShortCommitSha(this)
                    log.info "Building branch: ${env.GIT_BRANCH} at commit: ${env.GIT_COMMIT_SHORT}"
                }
            }
        }

        stage('Validate Environment') {
            steps {
                script {
                    // Validate required environment variables using shared library
                    Utils.validateEnvVars(this, ['DOCKER_REGISTRY', 'DOCKER_IMAGE'])
                    log.success 'Environment validation passed'
                }
            }
        }

        stage('Build') {
            steps {
                script {
                    log.info 'Starting build process...'
                    sh 'mvn clean package -DskipTests'
                    log.success 'Build completed'
                }
            }
        }

        stage('Test') {
            steps {
                script {
                    log.info 'Running tests...'
                    sh 'mvn test'
                    log.success 'Tests passed'
                }
            }
            post {
                always {
                    junit '**/target/surefire-reports/*.xml'
                }
            }
        }

        stage('Security Scan') {
            steps {
                script {
                    // Using shared library security scanning function
                    securityScan(
                        sonarqube: true,
                        sonarqubeServer: 'sonarqube-server',
                        owaspDependencyCheck: true,
                        failOnCritical: true
                    )
                }
            }
        }

        stage('Docker Build') {
            steps {
                script {
                    // Using shared library Docker class
                    def dockerUtil = new Docker(
                        this,
                        env.DOCKER_REGISTRY,
                        'docker-registry-credentials'
                    )

                    // Build with commit SHA tag
                    def image = dockerUtil.build(
                        env.DOCKER_IMAGE,
                        env.GIT_COMMIT_SHORT
                    )

                    // Store image reference for later stages
                    env.DOCKER_IMAGE_TAG = "${env.DOCKER_REGISTRY}/${env.DOCKER_IMAGE}:${env.GIT_COMMIT_SHORT}"
                    log.success "Docker image built: ${env.DOCKER_IMAGE_TAG}"
                }
            }
        }

        stage('Container Security Scan') {
            steps {
                script {
                    // Scan the built container image
                    securityScan(
                        trivy: true,
                        trivyImage: env.DOCKER_IMAGE_TAG,
                        failOnCritical: true
                    )
                }
            }
        }

        stage('Push to Registry') {
            when {
                anyOf {
                    branch 'main'
                    branch 'develop'
                }
            }
            steps {
                script {
                    // Using shared library Docker build/push function
                    dockerBuild(
                        imageName: env.DOCKER_IMAGE,
                        registry: env.DOCKER_REGISTRY,
                        credentialsId: 'docker-registry-credentials',
                        tags: [env.GIT_COMMIT_SHORT, env.GIT_BRANCH, 'latest'],
                        push: true
                    )
                    log.success 'Docker image pushed to registry'
                }
            }
        }

        stage('Deploy to Staging') {
            when {
                branch 'develop'
            }
            steps {
                script {
                    // Using shared library deployment function
                    deployApp(
                        environment: 'staging',
                        kubeConfig: 'kubeconfig-staging',
                        namespace: 'myapp-staging',
                        manifests: 'k8s/staging/',
                        approval: false
                    )
                }
            }
        }

        stage('Deploy to Production') {
            when {
                branch 'main'
            }
            steps {
                script {
                    // Deployment with approval gate
                    deployApp(
                        environment: 'production',
                        kubeConfig: 'kubeconfig-production',
                        namespace: 'myapp-production',
                        manifests: 'k8s/production/',
                        approval: true
                    )
                }
            }
        }
    }

    post {
        always {
            script {
                // Using shared library notification class
                def notify = new Notifications(this)
                notify.buildStatus('#builds', 'devops-team@example.com')
            }
            cleanWs()
        }
        success {
            script {
                log.success "Pipeline completed successfully for ${env.GIT_BRANCH}"
            }
        }
        failure {
            script {
                log.error "Pipeline failed for ${env.GIT_BRANCH}"
            }
        }
    }
}

// Scripted Pipeline - Basic CI Example
// Generated by Jenkinsfile Generator
// Date: 2025-01-18

node {
    try {
        stage('Checkout') {
            checkout scm
        }

        stage('Build') {
            sh 'mvn clean compile'
        }

        stage('Test') {
            sh 'mvn test'
            junit '**/target/surefire-reports/*.xml'
        }

        stage('Package') {
            sh 'mvn package'
        }

        if (currentBuild.result == null || currentBuild.result == 'SUCCESS') {
            archiveArtifacts artifacts: '**/target/*.jar', fingerprint: true
        }
    } catch (Exception e) {
        currentBuild.result = 'FAILURE'
        echo "Pipeline failed: ${e.message}"
        throw e
    } finally {
        deleteDir()
    }
}

// Scripted Pipeline - Conditional Deployment
// Generated by Jenkinsfile Generator
// Date: 2025-01-18

node {
    try {
        stage('Checkout') {
            checkout scm
        }

        stage('Build') {
            sh 'npm install'
            sh 'npm run build'
        }

        stage('Test') {
            sh 'npm test'
            junit '**/test-results/*.xml'
        }

        // Conditional deployment based on branch
        if (env.BRANCH_NAME == 'main') {
            stage('Deploy to Production') {
                input message: 'Deploy to production?', submitter: 'admin,ops-team'
                sh './deploy.sh production'
                echo 'Deployed to production'
            }
        } else if (env.BRANCH_NAME ==~ /release\/.*/) {
            stage('Deploy to Staging') {
                sh './deploy.sh staging'
                echo 'Deployed to staging'
            }
        } else if (env.BRANCH_NAME ==~ /feature\/.*/) {
            stage('Deploy to Dev') {
                sh './deploy.sh dev'
                echo 'Deployed to dev environment'
            }
        } else {
            echo "Branch ${env.BRANCH_NAME} - no deployment"
        }

    } catch (Exception e) {
        currentBuild.result = 'FAILURE'
        emailext(
            subject: "Build Failed: ${env.JOB_NAME} #${env.BUILD_NUMBER}",
            body: "Error: ${e.message}\nCheck console output at ${env.BUILD_URL}",
            to: 'team@example.com'
        )
        throw e
    } finally {
        deleteDir()
    }
}

// Scripted Pipeline - Docker Build with Sidecar
// Generated by Jenkinsfile Generator
// Date: 2025-01-18

node {
    try {
        stage('Checkout') {
            checkout scm
        }

        stage('Build') {
            docker.image('maven:3.9.9-eclipse-temurin-21').inside('-v $HOME/.m2:/root/.m2') {
                sh 'mvn clean package'
            }
        }

        stage('Integration Tests with Database') {
            docker.image('mysql:8-oracle').withRun('-e "MYSQL_ROOT_PASSWORD=test123" -p 3306:3306') { db ->
                // Wait for MySQL to be ready
                sh 'while ! mysqladmin ping -h0.0.0.0 --silent; do sleep 1; done'

                // Run tests
                docker.image('maven:3.9.9-eclipse-temurin-21').inside("--link ${db.id}:mysql") {
                    sh 'mvn verify -Dspring.datasource.url=jdbc:mysql://mysql:3306/test'
                }
            }
        }

        stage('Build Docker Image') {
            def customImage = docker.build("myapp:${env.BUILD_NUMBER}")

            stage('Test Docker Image') {
                customImage.inside {
                    sh 'node --version'
                }
            }

            stage('Push Docker Image') {
                docker.withRegistry('https://registry.example.com', 'docker-credentials') {
                    customImage.push()
                    customImage.push('latest')
                }
            }
        }
    } catch (Exception e) {
        currentBuild.result = 'FAILURE'
        throw e
    } finally {
        deleteDir()
    }
}

#!/usr/bin/env python3
"""
Generate Declarative Jenkins Pipeline

This script generates a Declarative Jenkinsfile with specified configuration.
"""

import argparse
import re
import sys
from pathlib import Path

# Add lib to path
sys.path.insert(0, str(Path(__file__).parent / 'lib'))

from common_patterns import PipelinePatterns, StageTemplates, PostConditions, EnvironmentTemplates
from syntax_helpers import DeclarativeSyntax, FormattingHelpers, GroovySyntax, ValidationHelpers


_INLINE_YAML_KEY_PATTERN = re.compile(r'^\s*[\w.\-"\']+\s*:\s*.*$')


def _looks_like_inline_yaml(value):
    """Return True if the input resembles inline YAML content."""
    stripped = value.strip()
    if not stripped:
        return False
    if '\n' in value:
        return True
    if stripped.startswith(('---', '{', '[')):
        return True
    return bool(_INLINE_YAML_KEY_PATTERN.match(stripped))


def resolve_k8s_yaml(k8s_yaml_value):
    """Resolve --k8s-yaml as either inline YAML or a path to an existing file."""
    if not k8s_yaml_value:
        return ''

    candidate_path = Path(k8s_yaml_value).expanduser()
    if candidate_path.is_file():
        return candidate_path.read_text(encoding='utf-8')

    if _looks_like_inline_yaml(k8s_yaml_value):
        return k8s_yaml_value

    raise ValueError(
        f"--k8s-yaml must be inline YAML content or an existing file path: {k8s_yaml_value}"
    )


class DeclarativePipelineGenerator:
    """Generator for Declarative Jenkins Pipelines"""

    def __init__(self, config):
        self.config = config
        self.pipeline_parts = []

    def generate(self):
        """Generate complete declarative pipeline"""
        # Start pipeline block
        self.pipeline_parts.append("pipeline {")

        # Add agent
        self._add_agent()

        # Add environment (if specified)
        self._add_environment()

        # Add parameters (if specified)
        self._add_parameters()

        # Add options (if specified)
        self._add_options()

        # Add triggers (if specified)
        self._add_triggers()

        # Add tools (if specified)
        self._add_tools()

        # Add stages
        self._add_stages()

        # Add post conditions
        self._add_post()

        # Close pipeline block
        self.pipeline_parts.append("}")

        # Format and return
        content = '\n'.join(self.pipeline_parts)
        return FormattingHelpers.format_jenkinsfile(
            FormattingHelpers.add_header_comment(
                content,
                f"Declarative Pipeline - {self.config.get('name', 'Generated Pipeline')}"
            )
        )

    def _add_agent(self):
        """Add agent configuration"""
        agent_type = self.config.get('agent', 'any')

        if agent_type == 'docker':
            agent_block = DeclarativeSyntax.agent_block(
                'docker',
                image=self.config.get('docker_image', 'ubuntu:latest'),
                args=self.config.get('docker_args', ''),
                reuseNode=self.config.get('docker_reuse_node', False)
            )
        elif agent_type == 'dockerfile':
            agent_block = DeclarativeSyntax.agent_block(
                'dockerfile',
                filename=self.config.get('dockerfile', 'Dockerfile'),
                dir=self.config.get('dockerfile_dir', '.'),
                additionalBuildArgs=self.config.get('dockerfile_build_args', '')
            )
        elif agent_type == 'kubernetes':
            agent_block = DeclarativeSyntax.agent_block(
                'kubernetes',
                yaml=self.config.get('k8s_yaml', ''),
                inheritFrom=self.config.get('k8s_inherit_from', '')
            )
        elif agent_type == 'label':
            agent_block = DeclarativeSyntax.agent_block(
                'label',
                label=self.config.get('agent_label', 'linux')
            )
        elif agent_type == 'none':
            agent_block = DeclarativeSyntax.agent_block('none')
        else:
            agent_block = DeclarativeSyntax.agent_block('any')

        self.pipeline_parts.append(agent_block)

    def _add_environment(self):
        """Add environment variables"""
        env_vars = self.config.get('environment', {})
        credentials = self.config.get('credentials', {})

        if env_vars or credentials:
            env_block = DeclarativeSyntax.environment_block(env_vars, credentials)
            if env_block:
                self.pipeline_parts.append("")
                self.pipeline_parts.append(env_block)

    def _add_parameters(self):
        """Add parameters"""
        parameters = self.config.get('parameters', [])

        if parameters:
            param_block = DeclarativeSyntax.parameters_block(parameters)
            if param_block:
                self.pipeline_parts.append("")
                self.pipeline_parts.append(param_block)

    def _add_options(self):
        """Add options"""
        options = self.config.get('options', {})

        if options:
            options_block = DeclarativeSyntax.options_block(options)
            if options_block:
                self.pipeline_parts.append("")
                self.pipeline_parts.append(options_block)

    def _add_triggers(self):
        """Add triggers"""
        triggers = self.config.get('triggers', {})

        if triggers:
            triggers_block = DeclarativeSyntax.triggers_block(triggers)
            if triggers_block:
                self.pipeline_parts.append("")
                self.pipeline_parts.append(triggers_block)

    def _add_tools(self):
        """Add tools"""
        tools = self.config.get('tools', {})

        if tools:
            tools_block = DeclarativeSyntax.tools_block(tools)
            if tools_block:
                self.pipeline_parts.append("")
                self.pipeline_parts.append(tools_block)

    def _add_stages(self):
        """Add stages based on configuration"""
        self.pipeline_parts.append("")
        self.pipeline_parts.append("    stages {")

        # Get stage list from config or use default
        stages = self.config.get('stages', ['build', 'test'])

        # Get build tool pattern if specified
        build_tool = self.config.get('build_tool', 'maven')
        pattern = PipelinePatterns.ci_pattern(build_tool)

        # Generate stages based on type
        for stage in stages:
            if stage == 'checkout':
                self.pipeline_parts.append(StageTemplates.checkout_stage(
                    scm_url=self.config.get('scm_url'),
                    branch=self.config.get('branch', 'main'),
                    credentials=self.config.get('scm_credentials')
                ))
            elif stage == 'build':
                build_cmd = self.config.get('build_cmd', pattern['build_cmd'])
                self.pipeline_parts.append(StageTemplates.build_stage(build_cmd))
            elif stage == 'test':
                test_cmd = self.config.get('test_cmd', pattern['test_cmd'])
                test_results = self.config.get('test_results', pattern['test_results'])
                self.pipeline_parts.append(StageTemplates.test_stage(test_cmd, test_results))
            elif stage == 'deploy':
                deploy_cmd = self.config.get('deploy_cmd', './deploy.sh')
                environment = self.config.get('deploy_env', 'production')
                approval = self.config.get('deploy_approval', True)
                approvers = self.config.get('deploy_approvers', 'admin')
                self.pipeline_parts.append(StageTemplates.deploy_stage(
                    environment, deploy_cmd, approval, approvers
                ))
            elif stage == 'docker-build':
                image_name = self.config.get('docker_image_name', 'myapp')
                dockerfile = self.config.get('dockerfile', 'Dockerfile')
                self.pipeline_parts.append(StageTemplates.docker_build_stage(image_name, dockerfile))
            elif stage == 'docker-push':
                image_name = self.config.get('docker_image_name', 'myapp')
                registry = self.config.get('docker_registry')
                registry_creds = self.config.get('docker_registry_credentials')
                self.pipeline_parts.append(StageTemplates.docker_push_stage(
                    image_name, registry, registry_creds
                ))
            elif stage == 'parallel-tests':
                test_types = self.config.get('test_types', ['unit', 'integration'])
                # Avoid redundant failFast true at stage level when
                # parallelsAlwaysFailFast() is already set globally in options
                has_global_fail_fast = self.config.get('options', {}).get('parallelsAlwaysFailFast', False)
                stage_fail_fast = self.config.get('parallel_fail_fast', True) and not has_global_fail_fast
                self.pipeline_parts.append(StageTemplates.parallel_test_stage(
                    test_types,
                    fail_fast=stage_fail_fast,
                ))
            else:
                # Custom stage
                stage_name = ValidationHelpers.normalize_stage_name(
                    stage.replace('-', ' ').replace('_', ' ').title()
                )
                stage_name_literal = GroovySyntax.single_quoted_literal(stage_name)
                custom_cmd = self.config.get(f'{stage}_cmd', f'echo "Running {stage_name}"')
                custom_cmd_literal = GroovySyntax.single_quoted_literal(custom_cmd)
                self.pipeline_parts.append(f"""
        stage({stage_name_literal}) {{
            steps {{
                sh {custom_cmd_literal}
            }}
        }}""")

        self.pipeline_parts.append("    }")

    def _add_post(self):
        """Add post conditions"""
        artifacts = self.config.get('archive_artifacts')
        cleanup = self.config.get('cleanup', True)
        email = self.config.get('notification_email')
        slack = self.config.get('notification_slack')

        if email or slack:
            post_block = PostConditions.notification_post(
                email,
                slack,
                archive_artifacts=artifacts,
                cleanup=cleanup,
            )
        else:
            post_block = PostConditions.standard_post(artifacts, cleanup)

        if post_block:
            self.pipeline_parts.append("")
            self.pipeline_parts.append(post_block)


def parse_args():
    """Parse command line arguments"""
    parser = argparse.ArgumentParser(
        description='Generate Declarative Jenkins Pipeline',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog='''
Examples:
  # Basic CI pipeline
  %(prog)s --output Jenkinsfile --stages build,test --build-tool maven

  # Docker-based pipeline
  %(prog)s --output Jenkinsfile --agent docker --docker-image maven:3.9.9-eclipse-temurin-21

  # Full CD pipeline with deployment
  %(prog)s --output Jenkinsfile --stages checkout,build,test,deploy --deploy-env production

  # Kubernetes agent pipeline
  %(prog)s --output Jenkinsfile --agent kubernetes --k8s-yaml pod.yaml
        '''
    )

    # Required arguments
    parser.add_argument('--output', '-o', required=True,
                        help='Output Jenkinsfile path')

    # Pipeline configuration
    parser.add_argument('--name', default='Generated Pipeline',
                        help='Pipeline name (for header comment)')
    parser.add_argument('--stages', default='build,test',
                        help='Comma-separated list of stages (build,test,deploy,etc.)')

    # Agent configuration
    parser.add_argument('--agent', default='any',
                        choices=['any', 'none', 'label', 'docker', 'dockerfile', 'kubernetes'],
                        help='Agent type')
    parser.add_argument('--agent-label', default='linux',
                        help='Agent label (for --agent label)')
    parser.add_argument('--docker-image', default='ubuntu:latest',
                        help='Docker image (for --agent docker)')
    parser.add_argument('--docker-args', default='',
                        help='Docker arguments (for --agent docker)')
    parser.add_argument('--dockerfile', default='Dockerfile',
                        help='Dockerfile name (for --agent dockerfile)')
    parser.add_argument('--k8s-yaml', default='',
                        help='Kubernetes YAML (inline) or path to an existing file')

    # Build configuration
    parser.add_argument('--build-tool', default='maven',
                        choices=['maven', 'gradle', 'npm', 'python', 'go'],
                        help='Build tool (determines default commands)')
    parser.add_argument('--build-cmd', help='Custom build command')
    parser.add_argument('--test-cmd', help='Custom test command')
    parser.add_argument('--deploy-cmd', default='./deploy.sh',
                        help='Deploy command')

    # SCM configuration
    parser.add_argument('--scm-url', help='Git repository URL')
    parser.add_argument('--branch', default='main', help='Git branch')
    parser.add_argument('--scm-credentials', help='SCM credentials ID')

    # Options
    parser.add_argument('--timeout', type=int, help='Pipeline timeout in hours')
    parser.add_argument('--build-discarder', type=int, default=10,
                        help='Number of builds to keep')
    parser.add_argument('--disable-concurrent', action='store_true',
                        help='Disable concurrent builds')
    parser.add_argument('--timestamps', action='store_true',
                        help='Add timestamps to console output')
    parser.add_argument('--preserve-stashes', type=int, metavar='N',
                        help='Preserve stashes for N builds (for stage restarting)')
    parser.add_argument('--durability-hint',
                        choices=['PERFORMANCE_OPTIMIZED', 'SURVIVABLE_NONATOMIC', 'MAX_SURVIVABILITY'],
                        help='Pipeline durability hint (trade performance for durability)')
    parser.add_argument('--quiet-period', type=int,
                        help='Override global quiet period in seconds')
    parser.add_argument('--skip-stages-after-unstable', action='store_true',
                        help='Skip remaining stages if build becomes unstable')
    parser.add_argument('--disable-resume', action='store_true',
                        help='Do not allow pipeline to resume if controller restarts')
    parallel_fail_fast_group = parser.add_mutually_exclusive_group()
    parallel_fail_fast_group.add_argument('--parallels-fail-fast', dest='parallels_fail_fast',
                                          action='store_true',
                                          help='Abort all parallel stages when one fails (default)')
    parallel_fail_fast_group.add_argument('--no-parallels-fail-fast', dest='parallels_fail_fast',
                                          action='store_false',
                                          help='Allow parallel branches to continue after a failure')
    parser.set_defaults(parallels_fail_fast=True)

    # Deployment
    parser.add_argument('--deploy-env', default='production',
                        help='Deployment environment name')
    parser.add_argument('--no-deploy-approval', action='store_true',
                        help='Skip deployment approval')
    parser.add_argument('--deploy-approvers', default='admin',
                        help='Comma-separated list of deployment approvers')

    # Notifications
    parser.add_argument('--notification-email', help='Email for notifications')
    parser.add_argument('--notification-slack', help='Slack channel for notifications')

    # Docker
    parser.add_argument('--docker-image-name', default='myapp',
                        help='Docker image name for docker-build/push stages')
    parser.add_argument('--docker-registry', help='Docker registry URL')
    parser.add_argument('--docker-registry-credentials', help='Docker registry credentials ID')

    # Post-build
    parser.add_argument('--archive-artifacts', help='Artifacts pattern to archive')
    parser.add_argument('--no-cleanup', action='store_true',
                        help='Disable workspace cleanup')

    return parser.parse_args()


def main():
    """Main entry point"""
    args = parse_args()
    try:
        stages = ValidationHelpers.parse_stage_list(args.stages)
        k8s_yaml = resolve_k8s_yaml(args.k8s_yaml)
    except ValueError as exc:
        print(f"ERROR: {exc}", file=sys.stderr)
        return 2

    # Build configuration from args
    config = {
        'name': args.name,
        'stages': stages,
        'agent': args.agent,
        'agent_label': args.agent_label,
        'docker_image': args.docker_image,
        'docker_args': args.docker_args,
        'dockerfile': args.dockerfile,
        'k8s_yaml': k8s_yaml,
        'build_tool': args.build_tool,
        'scm_url': args.scm_url,
        'branch': args.branch,
        'scm_credentials': args.scm_credentials,
        'deploy_cmd': args.deploy_cmd,
        'deploy_env': args.deploy_env,
        'deploy_approval': not args.no_deploy_approval,
        'deploy_approvers': args.deploy_approvers,
        'notification_email': args.notification_email,
        'notification_slack': args.notification_slack,
        'docker_image_name': args.docker_image_name,
        'docker_registry': args.docker_registry,
        'docker_registry_credentials': args.docker_registry_credentials,
        'archive_artifacts': args.archive_artifacts,
        'cleanup': not args.no_cleanup,
        'parallel_fail_fast': args.parallels_fail_fast,
    }

    # Add custom commands if specified
    if args.build_cmd:
        config['build_cmd'] = args.build_cmd
    if args.test_cmd:
        config['test_cmd'] = args.test_cmd

    # Add options
    options = {}
    if args.timeout:
        options['timeout'] = {'time': args.timeout, 'unit': 'HOURS'}
    if args.build_discarder:
        options['buildDiscarder'] = {'numToKeepStr': str(args.build_discarder)}
    if args.disable_concurrent:
        options['disableConcurrentBuilds'] = True
    if args.timestamps:
        options['timestamps'] = True
    if args.preserve_stashes:
        options['preserveStashes'] = {'buildCount': args.preserve_stashes}
    if args.durability_hint:
        options['durabilityHint'] = args.durability_hint
    if args.quiet_period:
        options['quietPeriod'] = args.quiet_period
    if args.skip_stages_after_unstable:
        options['skipStagesAfterUnstable'] = True
    if args.disable_resume:
        options['disableResume'] = True
    if args.parallels_fail_fast and 'parallel-tests' in stages:
        options['parallelsAlwaysFailFast'] = True
    if options:
        config['options'] = options

    # Generate pipeline
    generator = DeclarativePipelineGenerator(config)
    jenkinsfile_content = generator.generate()

    # Write output
    output_path = Path(args.output)
    output_path.parent.mkdir(parents=True, exist_ok=True)
    output_path.write_text(jenkinsfile_content)

    print(f"✓ Generated Declarative Jenkinsfile: {args.output}")
    print(f"  Pipeline: {args.name}")
    print(f"  Stages: {', '.join(config['stages'])}")
    print(f"  Agent: {args.agent}")
    print("\n" + "="*60)
    print("NEXT STEP: Validate using jenkinsfile-validator skill")
    print(f"  bash devops-skills-plugin/skills/jenkinsfile-validator/scripts/validate_jenkinsfile.sh {args.output}")
    print("="*60)

    return 0


if __name__ == '__main__':
    sys.exit(main())

#!/usr/bin/env python3
"""
Generate Scripted Jenkins Pipeline

This script generates a Scripted Jenkinsfile with specified configuration.
"""

import argparse
import sys
import os
from pathlib import Path

# Add lib to path
sys.path.insert(0, str(Path(__file__).parent / 'lib'))

from common_patterns import PipelinePatterns
from syntax_helpers import ScriptedSyntax, FormattingHelpers, ValidationHelpers


class ScriptedPipelineGenerator:
    """Generator for Scripted Jenkins Pipelines"""

    def __init__(self, config):
        self.config = config
        self.pipeline_parts = []

    def generate(self):
        """Generate complete scripted pipeline"""
        # Get agent/node configuration
        node_label = self.config.get('agent_label')

        # Build node content
        node_content = self._build_node_content()

        # Create node block
        if node_label:
            pipeline = ScriptedSyntax.node_block(node_label, node_content)
        else:
            pipeline = ScriptedSyntax.node_block(content=node_content)

        # Format and return
        return FormattingHelpers.format_jenkinsfile(
            FormattingHelpers.add_header_comment(
                pipeline,
                f"Scripted Pipeline - {self.config.get('name', 'Generated Pipeline')}"
            )
        )

    @staticmethod
    def _indent_lines(text, spaces=4):
        """Indent all non-empty lines by the given number of spaces."""
        prefix = ' ' * spaces
        return '\n'.join(
            prefix + line if line.strip() else line
            for line in text.split('\n')
        )

    def _build_node_content(self):
        """Build content inside node block"""
        parts = []

        # Get stages
        stages = self.config.get('stages', ['build', 'test'])
        build_tool = self.config.get('build_tool', 'maven')
        pattern = PipelinePatterns.ci_pattern(build_tool)

        # Determine if we need try-catch-finally
        use_error_handling = self.config.get('error_handling', True)

        if use_error_handling:
            # Build try block content.
            # Re-indent by 4 extra spaces so stages sit inside try {} correctly.
            raw_try_content = self._build_stages_content(stages, pattern)
            try_content = self._indent_lines(raw_try_content, 4)

            # Build catch block
            catch_content = """        currentBuild.result = 'FAILURE'
        echo "Pipeline failed: ${e.message}"
        throw e"""

            # Build finally block (cleanup)
            finally_content = ""
            if self.config.get('cleanup', True):
                finally_content = "        deleteDir()"

            # Add notification in catch if configured
            if self.config.get('notification_email'):
                catch_content = f"""        currentBuild.result = 'FAILURE'
        emailext(
            subject: "Build Failed: ${{env.JOB_NAME}} #${{env.BUILD_NUMBER}}",
            body: "Error: ${{e.message}}\\nCheck console output at ${{env.BUILD_URL}}",
            to: '{self.config.get('notification_email')}'
        )
        throw e"""

            node_content = ScriptedSyntax.try_catch_finally(
                try_content, catch_content, finally_content
            )
        else:
            # Simple stages without error handling
            node_content = self._build_stages_content(stages, pattern)
            if self.config.get('cleanup', True):
                node_content += "\n\n    deleteDir()"

        return node_content

    def _build_stages_content(self, stages, pattern):
        """Build stages content"""
        stage_blocks = []

        for stage in stages:
            if stage == 'checkout':
                stage_content = self._generate_checkout_stage()
            elif stage == 'build':
                stage_content = self._generate_build_stage(pattern)
            elif stage == 'test':
                stage_content = self._generate_test_stage(pattern)
            elif stage == 'deploy':
                stage_content = self._generate_deploy_stage()
            elif stage == 'docker-build':
                stage_content = self._generate_docker_build_stage()
            elif stage == 'docker-push':
                stage_content = self._generate_docker_push_stage()
            elif stage == 'parallel-tests':
                stage_content = self._generate_parallel_tests_stage()
            else:
                # Custom stage
                custom_cmd = self.config.get(f'{stage}_cmd', f'echo "Running {stage}"')
                stage_content = f"""        sh '{custom_cmd}'"""

            stage_display_name = stage.replace('-', ' ').replace('_', ' ').title()
            stage_block = ScriptedSyntax.stage_block(
                stage_display_name,
                stage_content
            )
            stage_blocks.append(stage_block)

        return '\n\n'.join(stage_blocks)

    def _generate_checkout_stage(self):
        """Generate checkout stage"""
        scm_url = self.config.get('scm_url')
        branch = self.config.get('branch', 'main')
        credentials = self.config.get('scm_credentials')

        if scm_url:
            if credentials:
                return f"""        checkout scmGit(
            branches: [[name: '*/{branch}']],
            userRemoteConfigs: [[
                url: '{scm_url}',
                credentialsId: '{credentials}'
            ]]
        )"""
            else:
                return f"""        git branch: '{branch}', url: '{scm_url}'"""
        else:
            return """        checkout scm"""

    def _generate_build_stage(self, pattern):
        """Generate build stage"""
        build_cmd = self.config.get('build_cmd', pattern['build_cmd'])

        # Check if using Docker
        if self.config.get('docker_image'):
            docker_image = self.config.get('docker_image')
            docker_args = self.config.get('docker_args', '')
            content = f"""            sh '{build_cmd}'"""

            return ScriptedSyntax.docker_inside_block(docker_image, content, docker_args)
        else:
            return f"""        sh '{build_cmd}'"""

    def _generate_test_stage(self, pattern):
        """Generate test stage"""
        test_cmd = self.config.get('test_cmd', pattern['test_cmd'])
        test_results = self.config.get('test_results', pattern['test_results'])

        content = f"""        sh '{test_cmd}'
        junit '{test_results}'"""

        # Check if using Docker
        if self.config.get('docker_image'):
            docker_image = self.config.get('docker_image')
            docker_args = self.config.get('docker_args', '')
            return ScriptedSyntax.docker_inside_block(docker_image, content, docker_args)
        else:
            return content

    def _generate_deploy_stage(self):
        """Generate deploy stage"""
        deploy_cmd = self.config.get('deploy_cmd', './deploy.sh')
        deploy_env = self.config.get('deploy_env', 'production')
        approval = self.config.get('deploy_approval', True)
        approvers = self.config.get('deploy_approvers', 'admin')

        if approval:
            return f"""        input message: 'Deploy to {deploy_env}?', submitter: '{approvers}'
        sh '{deploy_cmd}'"""
        else:
            return f"""        sh '{deploy_cmd}'"""

    def _generate_docker_build_stage(self):
        """Generate Docker build stage"""
        image_name = self.config.get('docker_image_name', 'myapp')
        dockerfile = self.config.get('dockerfile', 'Dockerfile')

        return f"""        def customImage = docker.build('{image_name}:${{BUILD_NUMBER}}', '-f {dockerfile} .')"""

    def _generate_docker_push_stage(self):
        """Generate Docker push stage"""
        image_name = self.config.get('docker_image_name', 'myapp')
        registry = self.config.get('docker_registry')
        registry_creds = self.config.get('docker_registry_credentials')

        if registry and registry_creds:
            return f"""        docker.withRegistry('{registry}', '{registry_creds}') {{
            docker.image('{image_name}:${{BUILD_NUMBER}}').push()
            docker.image('{image_name}:${{BUILD_NUMBER}}').push('latest')
        }}"""
        else:
            return f"""        docker.image('{image_name}:${{BUILD_NUMBER}}').push()
        docker.image('{image_name}:${{BUILD_NUMBER}}').push('latest')"""

    def _generate_parallel_tests_stage(self):
        """Generate parallel test stages"""
        test_types = self.config.get('test_types', ['unit', 'integration'])

        parallel_stages = {}
        for test_type in test_types:
            parallel_stages[f'{test_type.capitalize()} Tests'] = f"""            sh 'npm run test:{test_type}'"""

        # Return just the content without the stage wrapper
        # because ScriptedSyntax.parallel_block will be wrapped in a stage
        parallel_content = []
        for name, content in parallel_stages.items():
            parallel_content.append(f"""        '{name}': {{
            node {{
{content}
            }}
        }}""")

        return f"""        parallel(
{','.join(parallel_content)}
        )"""


def parse_args():
    """Parse command line arguments"""
    parser = argparse.ArgumentParser(
        description='Generate Scripted Jenkins Pipeline',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog='''
Examples:
  # Basic CI pipeline
  %(prog)s --output Jenkinsfile --stages build,test --build-tool maven

  # Docker-based pipeline
  %(prog)s --output Jenkinsfile --docker-image maven:3.9.9-eclipse-temurin-21

  # Full CD pipeline with deployment
  %(prog)s --output Jenkinsfile --stages checkout,build,test,deploy --deploy-env production

  # Pipeline with specific node label
  %(prog)s --output Jenkinsfile --agent-label linux-docker --stages build,test
        '''
    )

    # Required arguments
    parser.add_argument('--output', '-o', required=True,
                        help='Output Jenkinsfile path')

    # Pipeline configuration
    parser.add_argument('--name', default='Generated Pipeline',
                        help='Pipeline name (for header comment)')
    parser.add_argument('--stages', default='build,test',
                        help='Comma-separated list of stages (build,test,deploy,etc.)')

    # Agent configuration
    parser.add_argument('--agent-label', help='Node label for agent selection')

    # Build configuration
    parser.add_argument('--build-tool', default='maven',
                        choices=['maven', 'gradle', 'npm', 'python', 'go'],
                        help='Build tool (determines default commands)')
    parser.add_argument('--build-cmd', help='Custom build command')
    parser.add_argument('--test-cmd', help='Custom test command')
    parser.add_argument('--deploy-cmd', default='./deploy.sh',
                        help='Deploy command')

    # Docker configuration
    parser.add_argument('--docker-image', help='Docker image to use for build')
    parser.add_argument('--docker-args', default='',
                        help='Docker run arguments')
    parser.add_argument('--docker-image-name', default='myapp',
                        help='Docker image name for docker-build/push stages')
    parser.add_argument('--docker-registry', help='Docker registry URL')
    parser.add_argument('--docker-registry-credentials', help='Docker registry credentials ID')
    parser.add_argument('--dockerfile', default='Dockerfile',
                        help='Dockerfile name')

    # SCM configuration
    parser.add_argument('--scm-url', help='Git repository URL')
    parser.add_argument('--branch', default='main', help='Git branch')
    parser.add_argument('--scm-credentials', help='SCM credentials ID')

    # Deployment
    parser.add_argument('--deploy-env', default='production',
                        help='Deployment environment name')
    parser.add_argument('--no-deploy-approval', action='store_true',
                        help='Skip deployment approval')
    parser.add_argument('--deploy-approvers', default='admin',
                        help='Comma-separated list of deployment approvers')

    # Error handling and cleanup
    parser.add_argument('--no-error-handling', action='store_true',
                        help='Disable try-catch-finally error handling')
    parser.add_argument('--no-cleanup', action='store_true',
                        help='Disable workspace cleanup')

    # Notifications
    parser.add_argument('--notification-email', help='Email for notifications')

    # Test configuration
    parser.add_argument('--test-types', default='unit,integration',
                        help='Comma-separated test types for parallel-tests stage')

    return parser.parse_args()


def main():
    """Main entry point"""
    args = parse_args()

    try:
        stages = ValidationHelpers.parse_stage_list(args.stages)
    except ValueError as exc:
        print(f"ERROR: {exc}", file=sys.stderr)
        return 2

    # Build configuration from args
    config = {
        'name': args.name,
        'stages': stages,
        'agent_label': args.agent_label,
        'build_tool': args.build_tool,
        'docker_image': args.docker_image,
        'docker_args': args.docker_args,
        'docker_image_name': args.docker_image_name,
        'docker_registry': args.docker_registry,
        'docker_registry_credentials': args.docker_registry_credentials,
        'dockerfile': args.dockerfile,
        'scm_url': args.scm_url,
        'branch': args.branch,
        'scm_credentials': args.scm_credentials,
        'deploy_cmd': args.deploy_cmd,
        'deploy_env': args.deploy_env,
        'deploy_approval': not args.no_deploy_approval,
        'deploy_approvers': args.deploy_approvers,
        'error_handling': not args.no_error_handling,
        'cleanup': not args.no_cleanup,
        'notification_email': args.notification_email,
        'test_types': args.test_types.split(','),
    }

    # Add custom commands if specified
    if args.build_cmd:
        config['build_cmd'] = args.build_cmd
    if args.test_cmd:
        config['test_cmd'] = args.test_cmd

    # Determine test results pattern
    pattern = PipelinePatterns.ci_pattern(args.build_tool)
    config['test_results'] = pattern['test_results']

    # Generate pipeline
    generator = ScriptedPipelineGenerator(config)
    jenkinsfile_content = generator.generate()

    # Write output
    output_path = Path(args.output)
    output_path.parent.mkdir(parents=True, exist_ok=True)
    output_path.write_text(jenkinsfile_content)

    print(f"✓ Generated Scripted Jenkinsfile: {args.output}")
    print(f"  Pipeline: {args.name}")
    print(f"  Stages: {', '.join(config['stages'])}")
    if args.agent_label:
        print(f"  Agent Label: {args.agent_label}")
    print("\n" + "="*60)
    print("NEXT STEP: Validate the generated Jenkinsfile")
    print("  Use: jenkinsfile-validator skill")
    print("="*60)

    return 0


if __name__ == '__main__':
    sys.exit(main())

"""
Shared utilities for Jenkinsfile generation
"""

from .common_patterns import (
    PipelinePatterns,
    StageTemplates,
    PostConditions,
    EnvironmentTemplates,
)

from .syntax_helpers import (
    GroovySyntax,
    DeclarativeSyntax,
    ScriptedSyntax,
    ValidationHelpers,
    FormattingHelpers,
)

__all__ = [
    # Common patterns
    'PipelinePatterns',
    'StageTemplates',
    'PostConditions',
    'EnvironmentTemplates',
    # Syntax helpers
    'GroovySyntax',
    'DeclarativeSyntax',
    'ScriptedSyntax',
    'ValidationHelpers',
    'FormattingHelpers',
]

#!/usr/bin/env python3
"""Regression tests for generate_declarative.py behavior."""

from pathlib import Path
import sys
import tempfile
import unittest


SCRIPT_DIR = Path(__file__).resolve().parent
sys.path.insert(0, str(SCRIPT_DIR))
sys.path.insert(0, str(SCRIPT_DIR / "lib"))

from generate_declarative import DeclarativePipelineGenerator, resolve_k8s_yaml  # noqa: E402
from syntax_helpers import ValidationHelpers  # noqa: E402


class ResolveK8sYamlRegressionTests(unittest.TestCase):
    """Cover path-vs-inline resolution behavior for --k8s-yaml."""

    def test_reads_existing_file_without_extension(self):
        with tempfile.TemporaryDirectory() as temp_dir:
            yaml_path = Path(temp_dir) / "pod-template"
            yaml_content = "apiVersion: v1\nkind: Pod\nmetadata:\n  name: demo\n"
            yaml_path.write_text(yaml_content, encoding="utf-8")

            self.assertEqual(resolve_k8s_yaml(str(yaml_path)), yaml_content)

    def test_missing_non_inline_value_raises_error(self):
        with tempfile.TemporaryDirectory() as temp_dir:
            missing_path = Path(temp_dir) / "does-not-exist"
            with self.assertRaisesRegex(
                ValueError,
                "--k8s-yaml must be inline YAML content or an existing file path",
            ):
                resolve_k8s_yaml(str(missing_path))

    def test_missing_single_token_value_raises_error(self):
        with self.assertRaisesRegex(
            ValueError,
            "--k8s-yaml must be inline YAML content or an existing file path",
        ):
            resolve_k8s_yaml("definitely-missing-k8s-yaml-token")

    def test_inline_yaml_is_preserved(self):
        inline_yaml = "apiVersion: v1\nkind: Pod\nmetadata:\n  name: inline"
        self.assertEqual(resolve_k8s_yaml(inline_yaml), inline_yaml)


class StageListParsingRegressionTests(unittest.TestCase):
    """Lock stage key normalization and validation rules."""

    def test_parse_stage_list_normalizes_case_and_spacing(self):
        stages = ValidationHelpers.parse_stage_list(" Build,TEST,parallel-tests,custom_stage ")
        self.assertEqual(stages, ["build", "test", "parallel-tests", "custom_stage"])

    def test_parse_stage_list_rejects_invalid_keys(self):
        with self.assertRaisesRegex(ValueError, "Invalid stage key"):
            ValidationHelpers.parse_stage_list("build,Security Scan")

    def test_parse_stage_list_requires_at_least_one_stage(self):
        with self.assertRaisesRegex(ValueError, "At least one stage must be provided"):
            ValidationHelpers.parse_stage_list(" , , ")


class ParallelFailFastRegressionTests(unittest.TestCase):
    """Verify parallel fail-fast rendering combinations."""

    @staticmethod
    def _render_pipeline(options=None, parallel_fail_fast=True):
        config = {
            "name": "Parallel Fail Fast Regression",
            "stages": ["parallel-tests"],
            "parallel_fail_fast": parallel_fail_fast,
        }
        if options is not None:
            config["options"] = options
        return DeclarativePipelineGenerator(config).generate()

    def test_parallel_stage_includes_fail_fast_by_default(self):
        output = self._render_pipeline()
        self.assertIn("failFast true", output)

    def test_global_fail_fast_option_omits_redundant_stage_flag(self):
        output = self._render_pipeline(options={"parallelsAlwaysFailFast": True})
        self.assertIn("parallelsAlwaysFailFast()", output)
        self.assertNotIn("failFast true", output)

    def test_parallel_stage_can_disable_fail_fast(self):
        output = self._render_pipeline(parallel_fail_fast=False)
        self.assertNotIn("failFast true", output)
        self.assertNotIn("parallelsAlwaysFailFast()", output)


if __name__ == "__main__":
    unittest.main()