@el-j/magic-helix-core 4.0.0-beta.2 → 4.0.0-beta.4

package/dist/default_templates/ci/gitlab-ci.md

@@ -1,330 +0,0 @@
-# GitLab CI/CD Templates
-
-## Node.js/TypeScript Pipeline
-```yaml
-image: node:20-alpine
-
-stages:
-  - build
-  - test
-  - docker
-  - deploy
-
-cache:
-  key:
-    files:
-      - package-lock.json
-  paths:
-    - node_modules/
-    - .npm/
-
-variables:
-  npm_config_cache: "$CI_PROJECT_DIR/.npm"
-
-build:
-  stage: build
-  script:
-    - npm ci
-    - npm run build
-  artifacts:
-    paths:
-      - dist/
-    expire_in: 1 hour
-
-test:
-  stage: test
-  coverage: '/Lines\s*:\s*(\d+\.\d+)%/'
-  script:
-    - npm ci
-    - npm test -- --coverage
-  artifacts:
-    reports:
-      coverage_report:
-        coverage_format: cobertura
-        path: coverage/cobertura-coverage.xml
-      junit: junit.xml
-
-lint:
-  stage: test
-  script:
-    - npm ci
-    - npm run lint
-
-docker-build:
-  stage: docker
-  image: docker:latest
-  services:
-    - docker:dind
-  before_script:
-    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
-  script:
-    - docker build -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA .
-    - docker tag $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA $CI_REGISTRY_IMAGE:latest
-    - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA
-    - docker push $CI_REGISTRY_IMAGE:latest
-  only:
-    - main
-
-deploy-production:
-  stage: deploy
-  image: alpine/kubectl:latest
-  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
-    - kubectl set image deployment/app app=$CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA -n production
-  environment:
-    name: production
-    url: https://app.example.com
-  only:
-    - main
-```
-
-## Python Pipeline
-```yaml
-image: python:3.12-slim
-
-stages:
-  - test
-  - build
-  - deploy
-
-variables:
-  PIP_CACHE_DIR: "$CI_PROJECT_DIR/.cache/pip"
-
-cache:
-  paths:
-    - .cache/pip
-    - .venv/
-
-before_script:
-  - pip install poetry
-  - poetry config virtualenvs.in-project true
-  - poetry install
-
-test:
-  stage: test
-  script:
-    - poetry run pytest --cov --cov-report=xml --cov-report=term
-    - poetry run ruff check .
-    - poetry run mypy .
-  coverage: '/(?i)total.*? (100(?:\.0+)?\%|[1-9]?\d(?:\.\d+)?\%)$/'
-  artifacts:
-    reports:
-      coverage_report:
-        coverage_format: cobertura
-        path: coverage.xml
-
-docker:
-  stage: build
-  image: docker:latest
-  services:
-    - docker:dind
-  script:
-    - docker build -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA .
-    - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA
-  only:
-    - main
-```
-
-## Go Pipeline
-```yaml
-image: golang:1.21
-
-stages:
-  - test
-  - build
-
-variables:
-  GOPATH: $CI_PROJECT_DIR/.go
-
-cache:
-  paths:
-    - .go/pkg/mod/
-
-before_script:
-  - mkdir -p .go
-  - go mod download
-
-test:
-  stage: test
-  script:
-    - go fmt $(go list ./... | grep -v /vendor/)
-    - go vet $(go list ./... | grep -v /vendor/)
-    - go test -race -coverprofile=coverage.txt -covermode=atomic ./...
-  coverage: '/coverage: \d+\.\d+% of statements/'
-  artifacts:
-    reports:
-      coverage_report:
-        coverage_format: cobertura
-        path: coverage.xml
-
-build:
-  stage: build
-  script:
-    - CGO_ENABLED=0 go build -ldflags="-s -w" -o app
-  artifacts:
-    paths:
-      - app
-```
-
-## Rust Pipeline
-```yaml
-image: rust:1.75
-
-stages:
-  - test
-  - build
-
-variables:
-  CARGO_HOME: $CI_PROJECT_DIR/.cargo
-
-cache:
-  paths:
-    - .cargo/
-    - target/
-
-test:
-  stage: test
-  script:
-    - rustc --version && cargo --version
-    - cargo fmt -- --check
-    - cargo clippy -- -D warnings
-    - cargo test --verbose
-
-build:
-  stage: build
-  script:
-    - cargo build --release
-  artifacts:
-    paths:
-      - target/release/app
-```
-
-## Java/Maven Pipeline
-```yaml
-image: maven:3.9-eclipse-temurin-21
-
-stages:
-  - build
-  - test
-  - package
-
-variables:
-  MAVEN_OPTS: "-Dmaven.repo.local=$CI_PROJECT_DIR/.m2/repository"
-
-cache:
-  paths:
-    - .m2/repository
-
-build:
-  stage: build
-  script:
-    - mvn compile
-
-test:
-  stage: test
-  script:
-    - mvn test
-    - mvn jacoco:report
-  coverage: '/Total.*?([0-9]{1,3})%/'
-  artifacts:
-    reports:
-      junit: target/surefire-reports/TEST-*.xml
-
-package:
-  stage: package
-  script:
-    - mvn package -DskipTests
-  artifacts:
-    paths:
-      - target/*.jar
-```
-
-## Multi-Stage with Environments
-```yaml
-stages:
-  - build
-  - test
-  - staging
-  - production
-
-build:
-  stage: build
-  script:
-    - npm ci
-    - npm run build
-  artifacts:
-    paths:
-      - dist/
-
-test:
-  stage: test
-  script:
-    - npm test
-
-deploy-staging:
-  stage: staging
-  script:
-    - echo "Deploying to staging"
-    - kubectl set image deployment/app app=$CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA -n staging
-  environment:
-    name: staging
-    url: https://staging.example.com
-  only:
-    - develop
-
-deploy-production:
-  stage: production
-  script:
-    - echo "Deploying to production"
-    - kubectl set image deployment/app app=$CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA -n production
-  environment:
-    name: production
-    url: https://app.example.com
-  when: manual
-  only:
-    - main
-```
-
-## Docker with Buildx (Multi-arch)
-```yaml
-docker-multiarch:
-  stage: build
-  image: docker:latest
-  services:
-    - docker:dind
-  before_script:
-    - docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
-    - docker buildx create --use --name multiarch
-    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
-  script:
-    - docker buildx build --platform linux/amd64,linux/arm64 -t $CI_REGISTRY_IMAGE:latest --push .
-```
-
-## Security Scanning
-```yaml
-include:
-  - template: Security/SAST.gitlab-ci.yml
-  - template: Security/Dependency-Scanning.gitlab-ci.yml
-  - template: Security/Container-Scanning.gitlab-ci.yml
-
-container_scanning:
-  variables:
-    DOCKER_IMAGE: $CI_REGISTRY_IMAGE:$CI_COMMIT_SHORT_SHA
-  dependencies:
-    - docker-build
-```
-
-## Best Practices
-1. **Caching**: Cache dependencies (`node_modules/`, `.m2/`, `.cargo/`)
-2. **Artifacts**: Pass build outputs between stages
-3. **Environments**: Use GitLab environments for deployment tracking
-4. **Manual Gates**: Use `when: manual` for production deployments
-5. **Templates**: Use `include:` to reuse common configurations
-6. **Variables**: Store secrets in GitLab CI/CD Variables (masked & protected)
-7. **Docker Layer Caching**: Use `DOCKER_BUILDKIT=1` for faster builds
-8. **Coverage**: Use `coverage:` regex to display coverage in merge requests
-9. **Resource Groups**: Prevent concurrent deployments to the same environment
-10. **Rules**: Use `rules:` instead of `only:`/`except:` for modern syntax

package/dist/default_templates/containers/docker-multistage.md

@@ -1,120 +0,0 @@
-# Docker Multi-Stage Build Best Practices
-
-## Overview
-Multi-stage builds reduce image size and improve security by separating build-time and runtime dependencies.
-
-## Basic Pattern
-```dockerfile
-# Stage 1: Build
-FROM builder-image AS builder
-WORKDIR /build
-COPY source files
-RUN build commands
-
-# Stage 2: Runtime
-FROM runtime-image
-WORKDIR /app
-COPY --from=builder /build/artifacts .
-CMD ["run", "app"]
-```
-
-## Language-Specific Optimizations
-
-### Go
-```dockerfile
-FROM golang:1.21-alpine AS builder
-WORKDIR /build
-COPY go.mod go.sum ./
-RUN go mod download
-COPY . .
-RUN CGO_ENABLED=0 go build -ldflags="-s -w" -o app
-
-FROM scratch
-COPY --from=builder /build/app /app
-ENTRYPOINT ["/app"]
-```
-
-### Rust
-```dockerfile
-FROM rust:1.75-alpine AS builder
-WORKDIR /build
-RUN apk add --no-cache musl-dev
-COPY Cargo.toml Cargo.lock ./
-RUN mkdir src && echo "fn main() {}" > src/main.rs && cargo build --release && rm -rf src
-COPY src ./src
-RUN touch src/main.rs && cargo build --release
-
-FROM alpine:latest
-RUN apk add --no-cache ca-certificates
-COPY --from=builder /build/target/release/app /app
-CMD ["/app"]
-```
-
-### Node.js
-```dockerfile
-FROM node:20-alpine AS builder
-WORKDIR /build
-COPY package*.json ./
-RUN npm ci --only=production
-
-FROM node:20-alpine
-WORKDIR /app
-COPY --from=builder /build/node_modules ./node_modules
-COPY . .
-CMD ["node", "index.js"]
-```
-
-### Java/Spring Boot
-```dockerfile
-FROM maven:3.9-eclipse-temurin-21 AS builder
-WORKDIR /build
-COPY pom.xml .
-RUN mvn dependency:go-offline
-COPY src ./src
-RUN mvn package -DskipTests
-
-FROM eclipse-temurin:21-jre-alpine
-WORKDIR /app
-COPY --from=builder /build/target/*.jar app.jar
-ENTRYPOINT ["java", "-jar", "app.jar"]
-```
-
-### Python
-```dockerfile
-FROM python:3.12-slim AS builder
-WORKDIR /build
-RUN pip install --no-cache-dir poetry
-COPY pyproject.toml poetry.lock ./
-RUN poetry export -f requirements.txt -o requirements.txt --without-hashes
-RUN pip wheel --no-cache-dir --wheel-dir /wheels -r requirements.txt
-
-FROM python:3.12-slim
-WORKDIR /app
-COPY --from=builder /wheels /wheels
-RUN pip install --no-cache-dir /wheels/*
-COPY . .
-CMD ["python", "main.py"]
-```
-
-## Security Hardening
-- Use specific image tags, not `latest`
-- Run as non-root user: `USER 1000:1000`
-- Scan images: `docker scout cves image:tag`
-- Use distroless or alpine base images
-- Multi-platform builds: `docker buildx build --platform linux/amd64,linux/arm64`
-
-## .dockerignore Template
-```
-node_modules
-.git
-.env
-*.log
-dist
-coverage
-.vscode
-```
-
-## Build Optimization
-- Layer caching: COPY dependency files before source code
-- Parallel builds: `RUN cmd1 & cmd2 & wait`
-- Build contexts: Use `.dockerignore` to exclude unnecessary files

package/dist/default_templates/containers/kubernetes-deploy.md

@@ -1,210 +0,0 @@
-# Kubernetes Deployment Guide
-
-## Basic Deployment Structure
-
-### Deployment Manifest
-```yaml
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: app-deployment
-  labels:
-    app: myapp
-spec:
-  replicas: 3
-  selector:
-    matchLabels:
-      app: myapp
-  template:
-    metadata:
-      labels:
-        app: myapp
-    spec:
-      containers:
-      - name: app
-        image: myregistry/myapp:1.0.0
-        ports:
-        - containerPort: 8080
-        resources:
-          requests:
-            memory: "128Mi"
-            cpu: "100m"
-          limits:
-            memory: "512Mi"
-            cpu: "500m"
-        livenessProbe:
-          httpGet:
-            path: /health
-            port: 8080
-          initialDelaySeconds: 30
-          periodSeconds: 10
-        readinessProbe:
-          httpGet:
-            path: /ready
-            port: 8080
-          initialDelaySeconds: 10
-          periodSeconds: 5
-        env:
-        - name: DATABASE_URL
-          valueFrom:
-            secretKeyRef:
-              name: app-secrets
-              key: db-url
-```
-
-### Service Manifest
-```yaml
-apiVersion: v1
-kind: Service
-metadata:
-  name: app-service
-spec:
-  selector:
-    app: myapp
-  ports:
-  - protocol: TCP
-    port: 80
-    targetPort: 8080
-  type: LoadBalancer
-```
-
-### ConfigMap
-```yaml
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: app-config
-data:
-  LOG_LEVEL: "info"
-  API_TIMEOUT: "30s"
-```
-
-### Secret
-```yaml
-apiVersion: v1
-kind: Secret
-metadata:
-  name: app-secrets
-type: Opaque
-data:
-  db-url: cG9zdGdyZXM6Ly9leGFtcGxl  # base64 encoded
-```
-
-## Ingress Configuration
-```yaml
-apiVersion: networking.k8s.io/v1
-kind: Ingress
-metadata:
-  name: app-ingress
-  annotations:
-    cert-manager.io/cluster-issuer: letsencrypt-prod
-spec:
-  ingressClassName: nginx
-  tls:
-  - hosts:
-    - myapp.example.com
-    secretName: app-tls
-  rules:
-  - host: myapp.example.com
-    http:
-      paths:
-      - path: /
-        pathType: Prefix
-        backend:
-          service:
-            name: app-service
-            port:
-              number: 80
-```
-
-## Horizontal Pod Autoscaler
-```yaml
-apiVersion: autoscaling/v2
-kind: HorizontalPodAutoscaler
-metadata:
-  name: app-hpa
-spec:
-  scaleTargetRef:
-    apiVersion: apps/v1
-    kind: Deployment
-    name: app-deployment
-  minReplicas: 2
-  maxReplicas: 10
-  metrics:
-  - type: Resource
-    resource:
-      name: cpu
-      target:
-        type: Utilization
-        averageUtilization: 70
-```
-
-## StatefulSet (for databases)
-```yaml
-apiVersion: apps/v1
-kind: StatefulSet
-metadata:
-  name: postgres
-spec:
-  serviceName: postgres
-  replicas: 3
-  selector:
-    matchLabels:
-      app: postgres
-  template:
-    metadata:
-      labels:
-        app: postgres
-    spec:
-      containers:
-      - name: postgres
-        image: postgres:16-alpine
-        ports:
-        - containerPort: 5432
-        volumeMounts:
-        - name: data
-          mountPath: /var/lib/postgresql/data
-  volumeClaimTemplates:
-  - metadata:
-      name: data
-    spec:
-      accessModes: ["ReadWriteOnce"]
-      resources:
-        requests:
-          storage: 10Gi
-```
-
-## Best Practices
-1. **Resource Limits**: Always set CPU/memory requests and limits
-2. **Health Checks**: Implement liveness and readiness probes
-3. **Rolling Updates**: Use `RollingUpdate` strategy with `maxSurge` and `maxUnavailable`
-4. **Pod Disruption Budgets**: Ensure availability during node maintenance
-5. **Network Policies**: Restrict pod-to-pod communication
-6. **RBAC**: Use ServiceAccounts with minimal permissions
-7. **Secrets Management**: Use external secret managers (Vault, AWS Secrets Manager)
-8. **Monitoring**: Deploy Prometheus/Grafana stack
-9. **Logging**: Use Fluentd/Fluent Bit for log aggregation
-10. **GitOps**: Manage deployments with ArgoCD or Flux
-
-## Common Commands
-```bash
-# Apply manifests
-kubectl apply -f deployment.yaml
-
-# Check status
-kubectl get pods -l app=myapp
-kubectl describe pod <pod-name>
-kubectl logs <pod-name> -f
-
-# Scale deployment
-kubectl scale deployment app-deployment --replicas=5
-
-# Update image
-kubectl set image deployment/app-deployment app=myregistry/myapp:2.0.0
-
-# Rollback
-kubectl rollout undo deployment/app-deployment
-
-# Port forwarding
-kubectl port-forward svc/app-service 8080:80
-```