gkt-node 3.3.0

package/assets/.agent/skills/gitlab-ci-patterns/SKILL.md

@@ -0,0 +1,283 @@
+---
+name: gitlab-ci-patterns
+description: Build GitLab CI/CD pipelines with multi-stage workflows, caching, and distributed runners for scalable automation. Use when implementing GitLab CI/CD, optimizing pipeline performance, or setting up automated testing and deployment.
+---
+
+# GitLab CI Patterns
+
+Comprehensive GitLab CI/CD pipeline patterns for automated testing, building, and deployment.
+
+## Do not use this skill when
+
+- The task is unrelated to gitlab ci patterns
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
+
+## Purpose
+
+Create efficient GitLab CI pipelines with proper stage organization, caching, and deployment strategies.
+
+## Use this skill when
+
+- Automate GitLab-based CI/CD
+- Implement multi-stage pipelines
+- Configure GitLab Runners
+- Deploy to Kubernetes from GitLab
+- Implement GitOps workflows
+
+## Basic Pipeline Structure
+
+```yaml
+stages:
+  - build
+  - test
+  - deploy
+
+variables:
+  DOCKER_DRIVER: overlay2
+  DOCKER_TLS_CERTDIR: "/certs"
+
+build:
+  stage: build
+  image: node:20
+  script:
+    - npm ci
+    - npm run build
+  artifacts:
+    paths:
+      - dist/
+    expire_in: 1 hour
+  cache:
+    key: ${CI_COMMIT_REF_SLUG}
+    paths:
+      - node_modules/
+
+test:
+  stage: test
+  image: node:20
+  script:
+    - npm ci
+    - npm run lint
+    - npm test
+  coverage: '/Lines\s*:\s*(\d+\.\d+)%/'
+  artifacts:
+    reports:
+      coverage_report:
+        coverage_format: cobertura
+        path: coverage/cobertura-coverage.xml
+
+deploy:
+  stage: deploy
+  image: bitnami/kubectl:latest
+  script:
+    - kubectl apply -f k8s/
+    - kubectl rollout status deployment/my-app
+  only:
+    - main
+  environment:
+    name: production
+    url: https://app.example.com
+```
+
+## Docker Build and Push
+
+```yaml
+build-docker:
+  stage: build
+  image: docker:24
+  services:
+    - docker:24-dind
+  before_script:
+    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
+  script:
+    - docker build -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA .
+    - docker build -t $CI_REGISTRY_IMAGE:latest .
+    - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
+    - docker push $CI_REGISTRY_IMAGE:latest
+  only:
+    - main
+    - tags
+```
+
+## Multi-Environment Deployment
+
+```yaml
+.deploy_template: &deploy_template
+  image: bitnami/kubectl:latest
+  before_script:
+    - kubectl config set-cluster k8s --server="$KUBE_URL" --insecure-skip-tls-verify=true
+    - kubectl config set-credentials admin --token="$KUBE_TOKEN"
+    - kubectl config set-context default --cluster=k8s --user=admin
+    - kubectl config use-context default
+
+deploy:staging:
+  <<: *deploy_template
+  stage: deploy
+  script:
+    - kubectl apply -f k8s/ -n staging
+    - kubectl rollout status deployment/my-app -n staging
+  environment:
+    name: staging
+    url: https://staging.example.com
+  only:
+    - develop
+
+deploy:production:
+  <<: *deploy_template
+  stage: deploy
+  script:
+    - kubectl apply -f k8s/ -n production
+    - kubectl rollout status deployment/my-app -n production
+  environment:
+    name: production
+    url: https://app.example.com
+  when: manual
+  only:
+    - main
+```
+
+## Terraform Pipeline
+
+```yaml
+stages:
+  - validate
+  - plan
+  - apply
+
+variables:
+  TF_ROOT: ${CI_PROJECT_DIR}/terraform
+  TF_VERSION: "1.6.0"
+
+before_script:
+  - cd ${TF_ROOT}
+  - terraform --version
+
+validate:
+  stage: validate
+  image: hashicorp/terraform:${TF_VERSION}
+  script:
+    - terraform init -backend=false
+    - terraform validate
+    - terraform fmt -check
+
+plan:
+  stage: plan
+  image: hashicorp/terraform:${TF_VERSION}
+  script:
+    - terraform init
+    - terraform plan -out=tfplan
+  artifacts:
+    paths:
+      - ${TF_ROOT}/tfplan
+    expire_in: 1 day
+
+apply:
+  stage: apply
+  image: hashicorp/terraform:${TF_VERSION}
+  script:
+    - terraform init
+    - terraform apply -auto-approve tfplan
+  dependencies:
+    - plan
+  when: manual
+  only:
+    - main
+```
+
+## Security Scanning
+
+```yaml
+include:
+  - template: Security/SAST.gitlab-ci.yml
+  - template: Security/Dependency-Scanning.gitlab-ci.yml
+  - template: Security/Container-Scanning.gitlab-ci.yml
+
+trivy-scan:
+  stage: test
+  image: aquasec/trivy:latest
+  script:
+    - trivy image --exit-code 1 --severity HIGH,CRITICAL $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
+  allow_failure: true
+```
+
+## Caching Strategies
+
+```yaml
+# Cache node_modules
+build:
+  cache:
+    key: ${CI_COMMIT_REF_SLUG}
+    paths:
+      - node_modules/
+    policy: pull-push
+
+# Global cache
+cache:
+  key: ${CI_COMMIT_REF_SLUG}
+  paths:
+    - .cache/
+    - vendor/
+
+# Separate cache per job
+job1:
+  cache:
+    key: job1-cache
+    paths:
+      - build/
+
+job2:
+  cache:
+    key: job2-cache
+    paths:
+      - dist/
+```
+
+## Dynamic Child Pipelines
+
+```yaml
+generate-pipeline:
+  stage: build
+  script:
+    - python generate_pipeline.py > child-pipeline.yml
+  artifacts:
+    paths:
+      - child-pipeline.yml
+
+trigger-child:
+  stage: deploy
+  trigger:
+    include:
+      - artifact: child-pipeline.yml
+        job: generate-pipeline
+    strategy: depend
+```
+
+## Reference Files
+
+- `assets/gitlab-ci.yml.template` - Complete pipeline template
+- `references/pipeline-stages.md` - Stage organization patterns
+
+## Best Practices
+
+1. **Use specific image tags** (node:20, not node:latest)
+2. **Cache dependencies** appropriately
+3. **Use artifacts** for build outputs
+4. **Implement manual gates** for production
+5. **Use environments** for deployment tracking
+6. **Enable merge request pipelines**
+7. **Use pipeline schedules** for recurring jobs
+8. **Implement security scanning**
+9. **Use CI/CD variables** for secrets
+10. **Monitor pipeline performance**
+
+## Related Skills
+
+- `github-actions-templates` - For GitHub Actions
+- `deployment-pipeline-design` - For architecture
+- `secrets-management` - For secrets handling

package/assets/.agent/skills/gitops-workflow/SKILL.md

@@ -0,0 +1,303 @@
+---
+name: gitops-workflow
+description: Implement GitOps workflows with ArgoCD and Flux for automated, declarative Kubernetes deployments with continuous reconciliation. Use when implementing GitOps practices, automating Kubernetes deployments, or setting up declarative infrastructure management.
+---
+
+# GitOps Workflow
+
+Complete guide to implementing GitOps workflows with ArgoCD and Flux for automated Kubernetes deployments.
+
+## Purpose
+
+Implement declarative, Git-based continuous delivery for Kubernetes using ArgoCD or Flux CD, following OpenGitOps principles.
+
+## Use this skill when
+
+- Set up GitOps for Kubernetes clusters
+- Automate application deployments from Git
+- Implement progressive delivery strategies
+- Manage multi-cluster deployments
+- Configure automated sync policies
+- Set up secret management in GitOps
+
+## Do not use this skill when
+
+- You need a one-off manual deployment
+- You cannot manage cluster access or repo permissions
+- You are not deploying to Kubernetes
+
+## Instructions
+
+1. Define repo layout and desired-state conventions.
+2. Install ArgoCD or Flux and connect clusters.
+3. Configure sync policies, environments, and promotion flow.
+4. Validate rollbacks and secret handling.
+
+## Safety
+
+- Avoid auto-sync to production without approvals.
+- Keep secrets out of Git and use sealed or external secret managers.
+
+## OpenGitOps Principles
+
+1. **Declarative** - Entire system described declaratively
+2. **Versioned and Immutable** - Desired state stored in Git
+3. **Pulled Automatically** - Software agents pull desired state
+4. **Continuously Reconciled** - Agents reconcile actual vs desired state
+
+## ArgoCD Setup
+
+### 1. Installation
+
+```bash
+# Create namespace
+kubectl create namespace argocd
+
+# Install ArgoCD
+kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml
+
+# Get admin password
+kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 -d
+```
+
+**Reference:** See `references/argocd-setup.md` for detailed setup
+
+### 2. Repository Structure
+
+```
+gitops-repo/
+├── apps/
+│   ├── production/
+│   │   ├── app1/
+│   │   │   ├── kustomization.yaml
+│   │   │   └── deployment.yaml
+│   │   └── app2/
+│   └── staging/
+├── infrastructure/
+│   ├── ingress-nginx/
+│   ├── cert-manager/
+│   └── monitoring/
+└── argocd/
+    ├── applications/
+    └── projects/
+```
+
+### 3. Create Application
+
+```yaml
+# argocd/applications/my-app.yaml
+apiVersion: argoproj.io/v1alpha1
+kind: Application
+metadata:
+  name: my-app
+  namespace: argocd
+spec:
+  project: default
+  source:
+    repoURL: https://github.com/org/gitops-repo
+    targetRevision: main
+    path: apps/production/my-app
+  destination:
+    server: https://kubernetes.default.svc
+    namespace: production
+  syncPolicy:
+    automated:
+      prune: true
+      selfHeal: true
+    syncOptions:
+    - CreateNamespace=true
+```
+
+### 4. App of Apps Pattern
+
+```yaml
+apiVersion: argoproj.io/v1alpha1
+kind: Application
+metadata:
+  name: applications
+  namespace: argocd
+spec:
+  project: default
+  source:
+    repoURL: https://github.com/org/gitops-repo
+    targetRevision: main
+    path: argocd/applications
+  destination:
+    server: https://kubernetes.default.svc
+    namespace: argocd
+  syncPolicy:
+    automated: {}
+```
+
+## Flux CD Setup
+
+### 1. Installation
+
+```bash
+# Install Flux CLI
+curl -s https://fluxcd.io/install.sh | sudo bash
+
+# Bootstrap Flux
+flux bootstrap github \
+  --owner=org \
+  --repository=gitops-repo \
+  --branch=main \
+  --path=clusters/production \
+  --personal
+```
+
+### 2. Create GitRepository
+
+```yaml
+apiVersion: source.toolkit.fluxcd.io/v1
+kind: GitRepository
+metadata:
+  name: my-app
+  namespace: flux-system
+spec:
+  interval: 1m
+  url: https://github.com/org/my-app
+  ref:
+    branch: main
+```
+
+### 3. Create Kustomization
+
+```yaml
+apiVersion: kustomize.toolkit.fluxcd.io/v1
+kind: Kustomization
+metadata:
+  name: my-app
+  namespace: flux-system
+spec:
+  interval: 5m
+  path: ./deploy
+  prune: true
+  sourceRef:
+    kind: GitRepository
+    name: my-app
+```
+
+## Sync Policies
+
+### Auto-Sync Configuration
+
+**ArgoCD:**
+```yaml
+syncPolicy:
+  automated:
+    prune: true      # Delete resources not in Git
+    selfHeal: true   # Reconcile manual changes
+    allowEmpty: false
+  retry:
+    limit: 5
+    backoff:
+      duration: 5s
+      factor: 2
+      maxDuration: 3m
+```
+
+**Flux:**
+```yaml
+spec:
+  interval: 1m
+  prune: true
+  wait: true
+  timeout: 5m
+```
+
+**Reference:** See `references/sync-policies.md`
+
+## Progressive Delivery
+
+### Canary Deployment with ArgoCD Rollouts
+
+```yaml
+apiVersion: argoproj.io/v1alpha1
+kind: Rollout
+metadata:
+  name: my-app
+spec:
+  replicas: 5
+  strategy:
+    canary:
+      steps:
+      - setWeight: 20
+      - pause: {duration: 1m}
+      - setWeight: 50
+      - pause: {duration: 2m}
+      - setWeight: 100
+```
+
+### Blue-Green Deployment
+
+```yaml
+strategy:
+  blueGreen:
+    activeService: my-app
+    previewService: my-app-preview
+    autoPromotionEnabled: false
+```
+
+## Secret Management
+
+### External Secrets Operator
+
+```yaml
+apiVersion: external-secrets.io/v1beta1
+kind: ExternalSecret
+metadata:
+  name: db-credentials
+spec:
+  refreshInterval: 1h
+  secretStoreRef:
+    name: aws-secrets-manager
+    kind: SecretStore
+  target:
+    name: db-credentials
+  data:
+  - secretKey: password
+    remoteRef:
+      key: prod/db/password
+```
+
+### Sealed Secrets
+
+```bash
+# Encrypt secret
+kubeseal --format yaml < secret.yaml > sealed-secret.yaml
+
+# Commit sealed-secret.yaml to Git
+```
+
+## Best Practices
+
+1. **Use separate repos or branches** for different environments
+2. **Implement RBAC** for Git repositories
+3. **Enable notifications** for sync failures
+4. **Use health checks** for custom resources
+5. **Implement approval gates** for production
+6. **Keep secrets out of Git** (use External Secrets)
+7. **Use App of Apps pattern** for organization
+8. **Tag releases** for easy rollback
+9. **Monitor sync status** with alerts
+10. **Test changes** in staging first
+
+## Troubleshooting
+
+**Sync failures:**
+```bash
+argocd app get my-app
+argocd app sync my-app --prune
+```
+
+**Out of sync status:**
+```bash
+argocd app diff my-app
+argocd app sync my-app --force
+```
+
+## Related Skills
+
+- `k8s-manifest-generator` - For creating manifests
+- `helm-chart-scaffolding` - For packaging applications

package/assets/.agent/skills/gitops-workflow/references/argocd-setup.md

@@ -0,0 +1,134 @@
+# ArgoCD Setup and Configuration
+
+## Installation Methods
+
+### 1. Standard Installation
+```bash
+kubectl create namespace argocd
+kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml
+```
+
+### 2. High Availability Installation
+```bash
+kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/ha/install.yaml
+```
+
+### 3. Helm Installation
+```bash
+helm repo add argo https://argoproj.github.io/argo-helm
+helm install argocd argo/argo-cd -n argocd --create-namespace
+```
+
+## Initial Configuration
+
+### Access ArgoCD UI
+```bash
+# Port forward
+kubectl port-forward svc/argocd-server -n argocd 8080:443
+
+# Get initial admin password
+argocd admin initial-password -n argocd
+```
+
+### Configure Ingress
+```yaml
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: argocd-server-ingress
+  namespace: argocd
+  annotations:
+    cert-manager.io/cluster-issuer: letsencrypt-prod
+    nginx.ingress.kubernetes.io/ssl-passthrough: "true"
+    nginx.ingress.kubernetes.io/backend-protocol: "HTTPS"
+spec:
+  ingressClassName: nginx
+  rules:
+  - host: argocd.example.com
+    http:
+      paths:
+      - path: /
+        pathType: Prefix
+        backend:
+          service:
+            name: argocd-server
+            port:
+              number: 443
+  tls:
+  - hosts:
+    - argocd.example.com
+    secretName: argocd-secret
+```
+
+## CLI Configuration
+
+### Login
+```bash
+argocd login argocd.example.com --username admin
+```
+
+### Add Repository
+```bash
+argocd repo add https://github.com/org/repo --username user --password token
+```
+
+### Create Application
+```bash
+argocd app create my-app \
+  --repo https://github.com/org/repo \
+  --path apps/my-app \
+  --dest-server https://kubernetes.default.svc \
+  --dest-namespace production
+```
+
+## SSO Configuration
+
+### GitHub OAuth
+```yaml
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: argocd-cm
+  namespace: argocd
+data:
+  url: https://argocd.example.com
+  dex.config: |
+    connectors:
+      - type: github
+        id: github
+        name: GitHub
+        config:
+          clientID: $GITHUB_CLIENT_ID
+          clientSecret: $GITHUB_CLIENT_SECRET
+          orgs:
+          - name: my-org
+```
+
+## RBAC Configuration
+```yaml
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: argocd-rbac-cm
+  namespace: argocd
+data:
+  policy.default: role:readonly
+  policy.csv: |
+    p, role:developers, applications, *, */dev, allow
+    p, role:operators, applications, *, */*, allow
+    g, my-org:devs, role:developers
+    g, my-org:ops, role:operators
+```
+
+## Best Practices
+
+1. Enable SSO for production
+2. Implement RBAC policies
+3. Use separate projects for teams
+4. Enable audit logging
+5. Configure notifications
+6. Use ApplicationSets for multi-cluster
+7. Implement resource hooks
+8. Configure health checks
+9. Use sync windows for maintenance
+10. Monitor with Prometheus metrics