proagents 1.0.0

package/proagents/cicd/gitlab-ci.md

@@ -0,0 +1,278 @@
+# GitLab CI Templates
+
+Ready-to-use GitLab CI/CD pipeline configurations.
+
+---
+
+## Complete Pipeline
+
+```yaml
+# .gitlab-ci.yml
+stages:
+  - validate
+  - test
+  - security
+  - build
+  - deploy
+
+variables:
+  NODE_VERSION: "20"
+  npm_config_cache: "$CI_PROJECT_DIR/.npm"
+
+# Cache configuration
+.node_cache: &node_cache
+  cache:
+    key:
+      files:
+        - package-lock.json
+    paths:
+      - .npm/
+      - node_modules/
+    policy: pull-push
+
+# Base template
+.node_template: &node_template
+  image: node:${NODE_VERSION}
+  <<: *node_cache
+  before_script:
+    - npm ci --cache .npm --prefer-offline
+
+# ============ VALIDATE STAGE ============
+lint:
+  stage: validate
+  <<: *node_template
+  script:
+    - npm run lint
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
+
+typecheck:
+  stage: validate
+  <<: *node_template
+  script:
+    - npm run type-check
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
+
+# ============ TEST STAGE ============
+unit_tests:
+  stage: test
+  <<: *node_template
+  script:
+    - npm run test:unit -- --coverage
+  coverage: '/Lines\s*:\s*(\d+\.?\d*)%/'
+  artifacts:
+    reports:
+      coverage_report:
+        coverage_format: cobertura
+        path: coverage/cobertura-coverage.xml
+      junit: junit.xml
+    paths:
+      - coverage/
+    expire_in: 1 week
+
+integration_tests:
+  stage: test
+  <<: *node_template
+  services:
+    - postgres:15
+    - redis:7
+  variables:
+    POSTGRES_DB: test_db
+    POSTGRES_USER: test
+    POSTGRES_PASSWORD: test
+    DATABASE_URL: "postgresql://test:test@postgres:5432/test_db"
+    REDIS_URL: "redis://redis:6379"
+  script:
+    - npm run test:integration
+
+# ============ SECURITY STAGE ============
+dependency_scan:
+  stage: security
+  <<: *node_template
+  script:
+    - npm audit --audit-level=high
+  allow_failure: true
+
+sast:
+  stage: security
+  image:
+    name: "semgrep/semgrep"
+    entrypoint: [""]
+  script:
+    - semgrep --config auto --json -o semgrep-report.json .
+  artifacts:
+    reports:
+      sast: semgrep-report.json
+
+secret_detection:
+  stage: security
+  image: trufflesecurity/trufflehog:latest
+  script:
+    - trufflehog git file://. --only-verified
+
+# ============ BUILD STAGE ============
+build:
+  stage: build
+  <<: *node_template
+  script:
+    - npm run build
+  artifacts:
+    paths:
+      - dist/
+    expire_in: 1 week
+  rules:
+    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+
+docker_build:
+  stage: build
+  image: docker:24
+  services:
+    - docker:24-dind
+  variables:
+    DOCKER_TLS_CERTDIR: "/certs"
+  script:
+    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
+    - docker build -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA .
+    - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
+  rules:
+    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
+
+# ============ DEPLOY STAGE ============
+deploy_staging:
+  stage: deploy
+  image: alpine:latest
+  environment:
+    name: staging
+    url: https://staging.example.com
+  script:
+    - apk add --no-cache curl
+    - curl -X POST $DEPLOY_WEBHOOK_STAGING
+  rules:
+    - if: $CI_COMMIT_BRANCH == "develop"
+
+deploy_production:
+  stage: deploy
+  image: alpine:latest
+  environment:
+    name: production
+    url: https://example.com
+  script:
+    - apk add --no-cache curl
+    - curl -X POST $DEPLOY_WEBHOOK_PRODUCTION
+  rules:
+    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
+      when: manual
+  needs:
+    - build
+    - unit_tests
+    - integration_tests
+```
+
+---
+
+## Merge Request Pipeline
+
+```yaml
+# Optimized for merge requests
+workflow:
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
+
+mr_checks:
+  stage: validate
+  script:
+    - |
+      # Check MR title format
+      if [[ ! "$CI_MERGE_REQUEST_TITLE" =~ ^(feat|fix|docs|style|refactor|test|chore)\(.+\):.+ ]]; then
+        echo "MR title must follow conventional commits format"
+        exit 1
+      fi
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+```
+
+---
+
+## Environment-Specific Variables
+
+```yaml
+# Per-environment configuration
+.staging_vars: &staging_vars
+  variables:
+    ENVIRONMENT: staging
+    API_URL: https://api-staging.example.com
+
+.production_vars: &production_vars
+  variables:
+    ENVIRONMENT: production
+    API_URL: https://api.example.com
+
+deploy_staging:
+  <<: *staging_vars
+  # ... rest of config
+
+deploy_production:
+  <<: *production_vars
+  # ... rest of config
+```
+
+---
+
+## Scheduled Pipelines
+
+```yaml
+# Scheduled jobs
+dependency_update:
+  stage: validate
+  script:
+    - npx proagents deps check --ci
+    - npx proagents deps update --create-mr
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "schedule"
+      variables:
+        SCHEDULE_TYPE: "dependency_update"
+
+nightly_security_scan:
+  stage: security
+  script:
+    - npm audit
+    - npx snyk test
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "schedule"
+      variables:
+        SCHEDULE_TYPE: "security_scan"
+```
+
+---
+
+## Include External Templates
+
+```yaml
+include:
+  # GitLab templates
+  - template: Security/SAST.gitlab-ci.yml
+  - template: Security/Dependency-Scanning.gitlab-ci.yml
+
+  # Local templates
+  - local: .gitlab/ci/test.yml
+  - local: .gitlab/ci/deploy.yml
+
+  # Remote templates
+  - remote: https://example.com/ci-templates/node.yml
+```
+
+---
+
+## Best Practices
+
+1. **Use Caching**: Cache npm dependencies
+2. **Parallel Jobs**: Run independent jobs in parallel
+3. **Use Artifacts**: Pass data between stages
+4. **Environment Protection**: Use protected environments
+5. **Include Templates**: DRY with includes
+6. **Rules Over Only/Except**: Use `rules:` for conditional jobs

package/proagents/cicd/jenkins.md

@@ -0,0 +1,317 @@
+# Jenkins Pipeline Templates
+
+Declarative Jenkins pipeline configurations.
+
+---
+
+## Complete Jenkinsfile
+
+```groovy
+// Jenkinsfile
+pipeline {
+    agent any
+
+    environment {
+        NODE_VERSION = '20'
+        NPM_CONFIG_CACHE = "${WORKSPACE}/.npm"
+    }
+
+    options {
+        buildDiscarder(logRotator(numToKeepStr: '10'))
+        timeout(time: 30, unit: 'MINUTES')
+        disableConcurrentBuilds()
+    }
+
+    tools {
+        nodejs 'NodeJS-20'
+    }
+
+    stages {
+        stage('Install') {
+            steps {
+                sh 'npm ci'
+            }
+        }
+
+        stage('Validate') {
+            parallel {
+                stage('Lint') {
+                    steps {
+                        sh 'npm run lint'
+                    }
+                }
+                stage('Type Check') {
+                    steps {
+                        sh 'npm run type-check'
+                    }
+                }
+            }
+        }
+
+        stage('Test') {
+            parallel {
+                stage('Unit Tests') {
+                    steps {
+                        sh 'npm run test:unit -- --coverage'
+                    }
+                    post {
+                        always {
+                            junit 'junit.xml'
+                            publishCoverage adapters: [
+                                coberturaAdapter('coverage/cobertura-coverage.xml')
+                            ]
+                        }
+                    }
+                }
+                stage('Integration Tests') {
+                    steps {
+                        sh 'npm run test:integration'
+                    }
+                }
+            }
+        }
+
+        stage('Security Scan') {
+            steps {
+                sh 'npm audit --audit-level=high'
+            }
+        }
+
+        stage('Build') {
+            steps {
+                sh 'npm run build'
+            }
+            post {
+                success {
+                    archiveArtifacts artifacts: 'dist/**/*', fingerprint: true
+                }
+            }
+        }
+
+        stage('Deploy to Staging') {
+            when {
+                branch 'develop'
+            }
+            steps {
+                script {
+                    deployToEnvironment('staging')
+                }
+            }
+        }
+
+        stage('Deploy to Production') {
+            when {
+                branch 'main'
+            }
+            input {
+                message "Deploy to production?"
+                ok "Deploy"
+                submitter "admin,deploy-team"
+            }
+            steps {
+                script {
+                    deployToEnvironment('production')
+                }
+            }
+        }
+    }
+
+    post {
+        always {
+            cleanWs()
+        }
+        success {
+            slackSend(
+                color: 'good',
+                message: "Build succeeded: ${env.JOB_NAME} #${env.BUILD_NUMBER}"
+            )
+        }
+        failure {
+            slackSend(
+                color: 'danger',
+                message: "Build failed: ${env.JOB_NAME} #${env.BUILD_NUMBER}"
+            )
+        }
+    }
+}
+
+def deployToEnvironment(String environment) {
+    withCredentials([string(credentialsId: "${environment}-deploy-token", variable: 'DEPLOY_TOKEN')]) {
+        sh "npx proagents deploy --env ${environment}"
+    }
+}
+```
+
+---
+
+## Multibranch Pipeline
+
+```groovy
+// Jenkinsfile for multibranch
+pipeline {
+    agent any
+
+    stages {
+        stage('Build & Test') {
+            steps {
+                sh 'npm ci'
+                sh 'npm test'
+                sh 'npm run build'
+            }
+        }
+
+        stage('Deploy') {
+            when {
+                anyOf {
+                    branch 'main'
+                    branch 'develop'
+                }
+            }
+            steps {
+                script {
+                    def environment = env.BRANCH_NAME == 'main' ? 'production' : 'staging'
+                    deployToEnvironment(environment)
+                }
+            }
+        }
+    }
+}
+```
+
+---
+
+## Shared Library
+
+```groovy
+// vars/nodePipeline.groovy
+def call(Map config = [:]) {
+    pipeline {
+        agent any
+
+        tools {
+            nodejs config.nodeVersion ?: 'NodeJS-20'
+        }
+
+        stages {
+            stage('Install') {
+                steps {
+                    sh 'npm ci'
+                }
+            }
+
+            stage('Test') {
+                steps {
+                    sh 'npm test'
+                }
+            }
+
+            stage('Build') {
+                steps {
+                    sh 'npm run build'
+                }
+            }
+
+            stage('Deploy') {
+                when {
+                    expression { config.deploy == true }
+                }
+                steps {
+                    sh "npx proagents deploy --env ${config.environment}"
+                }
+            }
+        }
+    }
+}
+
+// Usage in Jenkinsfile
+@Library('my-shared-lib') _
+
+nodePipeline(
+    nodeVersion: 'NodeJS-20',
+    deploy: true,
+    environment: 'staging'
+)
+```
+
+---
+
+## Docker Agent
+
+```groovy
+pipeline {
+    agent {
+        docker {
+            image 'node:20'
+            args '-v $HOME/.npm:/root/.npm'
+        }
+    }
+
+    stages {
+        stage('Build') {
+            steps {
+                sh 'npm ci'
+                sh 'npm run build'
+            }
+        }
+    }
+}
+```
+
+---
+
+## Kubernetes Agent
+
+```groovy
+pipeline {
+    agent {
+        kubernetes {
+            yaml '''
+apiVersion: v1
+kind: Pod
+spec:
+  containers:
+  - name: node
+    image: node:20
+    command:
+    - sleep
+    args:
+    - infinity
+  - name: docker
+    image: docker:dind
+    securityContext:
+      privileged: true
+'''
+        }
+    }
+
+    stages {
+        stage('Build') {
+            steps {
+                container('node') {
+                    sh 'npm ci'
+                    sh 'npm run build'
+                }
+            }
+        }
+
+        stage('Docker Build') {
+            steps {
+                container('docker') {
+                    sh 'docker build -t myapp:latest .'
+                }
+            }
+        }
+    }
+}
+```
+
+---
+
+## Best Practices
+
+1. **Use Declarative Pipelines**: Easier to read and maintain
+2. **Shared Libraries**: DRY with shared pipeline code
+3. **Parallel Stages**: Run independent stages in parallel
+4. **Input Gates**: Require approval for production
+5. **Clean Workspace**: Always clean up after builds
+6. **Credentials Management**: Use Jenkins credentials store