@patricio0312rev/skillset 0.1.0

package/templates/ci-cd/github-actions-pipeline-creator/ SKILL.md

@@ -0,0 +1,348 @@
+---
+name: github-actions-pipeline-creator
+description: Creates comprehensive GitHub Actions CI/CD workflows for linting, testing, building, and deploying. Includes caching strategies, matrix builds, artifact handling, and failure diagnostics. Use for "GitHub Actions", "CI pipeline", "workflow automation", or "continuous integration".
+---
+
+# GitHub Actions Pipeline Creator
+
+Build production-ready GitHub Actions workflows with best practices.
+
+## Basic CI Workflow
+
+```yaml
+# .github/workflows/ci.yml
+name: CI
+
+on:
+  push:
+    branches: [main, develop]
+  pull_request:
+    branches: [main]
+
+# Cancel in-progress runs for same workflow
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  lint:
+    name: Lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+          cache: "npm"
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run ESLint
+        run: npm run lint
+
+      - name: Run Prettier
+        run: npm run format:check
+
+      - name: Run TypeScript
+        run: npm run type-check
+
+  test:
+    name: Test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+          cache: "npm"
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run tests
+        run: npm test -- --coverage
+
+      - name: Upload coverage
+        uses: codecov/codecov-action@v3
+        with:
+          files: ./coverage/coverage-final.json
+          flags: unittests
+          fail_ci_if_error: true
+
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    needs: [lint, test]
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+          cache: "npm"
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Build
+        run: npm run build
+        env:
+          NODE_ENV: production
+
+      - name: Upload build artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+          retention-days: 7
+```
+
+## Matrix Strategy
+
+```yaml
+test:
+  name: Test
+  runs-on: ${{ matrix.os }}
+  strategy:
+    matrix:
+      os: [ubuntu-latest, macos-latest, windows-latest]
+      node-version: [18, 20, 21]
+      exclude:
+        # Skip Windows + Node 18 (slow)
+        - os: windows-latest
+          node-version: 18
+    fail-fast: false
+
+  steps:
+    - uses: actions/checkout@v4
+
+    - name: Setup Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v4
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: "npm"
+
+    - run: npm ci
+    - run: npm test
+```
+
+## Advanced Caching
+
+```yaml
+- name: Cache dependencies
+  uses: actions/cache@v3
+  with:
+    path: |
+      ~/.npm
+      node_modules
+      .next/cache
+    key: ${{ runner.os }}-npm-${{ hashFiles('**/package-lock.json') }}
+    restore-keys: |
+      ${{ runner.os }}-npm-
+
+- name: Cache build
+  uses: actions/cache@v3
+  with:
+    path: |
+      dist
+      .cache
+    key: build-${{ github.sha }}
+    restore-keys: |
+      build-
+```
+
+## Docker Build & Push
+
+```yaml
+docker:
+  name: Build & Push Docker
+  runs-on: ubuntu-latest
+  steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
+
+    - name: Login to Docker Hub
+      uses: docker/login-action@v3
+      with:
+        username: ${{ secrets.DOCKER_USERNAME }}
+        password: ${{ secrets.DOCKER_PASSWORD }}
+
+    - name: Extract metadata
+      id: meta
+      uses: docker/metadata-action@v5
+      with:
+        images: mycompany/myapp
+        tags: |
+          type=ref,event=branch
+          type=ref,event=pr
+          type=semver,pattern={{version}}
+          type=sha
+
+    - name: Build and push
+      uses: docker/build-push-action@v5
+      with:
+        context: .
+        push: true
+        tags: ${{ steps.meta.outputs.tags }}
+        labels: ${{ steps.meta.outputs.labels }}
+        cache-from: type=registry,ref=mycompany/myapp:buildcache
+        cache-to: type=registry,ref=mycompany/myapp:buildcache,mode=max
+```
+
+## Deployment Workflow
+
+```yaml
+# .github/workflows/deploy.yml
+name: Deploy
+
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+    inputs:
+      environment:
+        description: "Environment to deploy to"
+        required: true
+        type: choice
+        options:
+          - staging
+          - production
+
+jobs:
+  deploy:
+    name: Deploy to ${{ github.event.inputs.environment || 'staging' }}
+    runs-on: ubuntu-latest
+    environment:
+      name: ${{ github.event.inputs.environment || 'staging' }}
+      url: https://${{ steps.deploy.outputs.url }}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Download artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+      - name: Deploy to Vercel
+        id: deploy
+        uses: amondnet/vercel-action@v25
+        with:
+          vercel-token: ${{ secrets.VERCEL_TOKEN }}
+          vercel-org-id: ${{ secrets.VERCEL_ORG_ID }}
+          vercel-project-id: ${{ secrets.VERCEL_PROJECT_ID }}
+          vercel-args: ${{ github.event.inputs.environment == 'production' && '--prod' || '' }}
+```
+
+## Failure Diagnostics
+
+```yaml
+- name: Run tests
+  id: test
+  run: npm test
+  continue-on-error: true
+
+- name: Upload test results
+  if: always()
+  uses: actions/upload-artifact@v4
+  with:
+    name: test-results
+    path: |
+      test-results/
+      coverage/
+
+- name: Comment PR with results
+  if: failure() && github.event_name == 'pull_request'
+  uses: actions/github-script@v7
+  with:
+    script: |
+      github.rest.issues.createComment({
+        issue_number: context.issue.number,
+        owner: context.repo.owner,
+        repo: context.repo.repo,
+        body: '❌ Tests failed. Check the [test results](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }})'
+      })
+
+- name: Fail if tests failed
+  if: steps.test.outcome == 'failure'
+  run: exit 1
+```
+
+## Composite Actions
+
+```yaml
+# .github/actions/setup-node/action.yml
+name: "Setup Node.js with Cache"
+description: "Setup Node.js and restore cache"
+
+inputs:
+  node-version:
+    description: "Node.js version"
+    required: false
+    default: "20"
+
+runs:
+  using: "composite"
+  steps:
+    - name: Setup Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: ${{ inputs.node-version }}
+        cache: "npm"
+
+    - name: Install dependencies
+      shell: bash
+      run: npm ci
+# Usage in workflow:
+# - uses: ./.github/actions/setup-node
+#   with:
+#     node-version: '20'
+```
+
+## Conditional Jobs
+
+```yaml
+lint:
+  if: github.event_name == 'pull_request'
+  runs-on: ubuntu-latest
+  steps: [...]
+
+deploy:
+  if: github.ref == 'refs/heads/main' && github.event_name == 'push'
+  needs: [build, test]
+  runs-on: ubuntu-latest
+  steps: [...]
+```
+
+## Best Practices
+
+1. **Cache dependencies**: Speeds up 3-5x
+2. **Parallel jobs**: Run lint/test/build concurrently
+3. **Matrix strategy**: Test multiple versions/platforms
+4. **Fail fast**: Stop on first failure (or not)
+5. **Upload artifacts**: Debug failures
+6. **Concurrency control**: Cancel outdated runs
+7. **Secrets management**: Never log secrets
+8. **Status checks**: Require passing CI
+
+## Output Checklist
+
+- [ ] Lint job configured
+- [ ] Test job with coverage
+- [ ] Build job with artifacts
+- [ ] Deploy job with environments
+- [ ] Caching strategy implemented
+- [ ] Matrix builds (if needed)
+- [ ] Failure diagnostics
+- [ ] PR comments on failure
+- [ ] Docker build (if needed)
+- [ ] Status badges in README

package/templates/ci-cd/monorepo-ci-optimizer/ SKILL.md

@@ -0,0 +1,298 @@
+---
+name: monorepo-ci-optimizer
+description: Optimizes CI pipelines for monorepos by detecting affected packages/apps and running only necessary builds and tests. Includes Turborepo/Nx strategies, caching, and parallel execution. Use for "monorepo CI", "affected detection", "incremental builds", or "workspace optimization".
+---
+
+# Monorepo CI Optimizer
+
+Run only affected builds and tests in monorepos for faster CI.
+
+## Affected Detection Strategy
+
+### Using Turborepo
+
+```yaml
+# .github/workflows/ci.yml
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0 # Need full history for affected detection
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+          cache: "pnpm"
+
+      - run: pnpm install
+
+      - name: Build affected
+        run: |
+          pnpm turbo run build --filter='...[origin/main]'
+
+      - name: Test affected
+        run: |
+          pnpm turbo run test --filter='...[origin/main]'
+
+      - name: Lint affected
+        run: |
+          pnpm turbo run lint --filter='...[origin/main]'
+```
+
+### Using Nx
+
+```yaml
+build:
+  runs-on: ubuntu-latest
+  steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+
+    - uses: nrwl/nx-set-shas@v4
+
+    - uses: actions/setup-node@v4
+      with:
+        node-version: "20"
+        cache: "npm"
+
+    - run: npm ci
+
+    - name: Build affected projects
+      run: npx nx affected:build --base=$NX_BASE --head=$NX_HEAD
+
+    - name: Test affected projects
+      run: npx nx affected:test --base=$NX_BASE --head=$NX_HEAD --parallel=3
+
+    - name: Lint affected projects
+      run: npx nx affected:lint --base=$NX_BASE --head=$NX_HEAD
+```
+
+## Remote Caching (Turborepo)
+
+```yaml
+- name: Setup Turborepo cache
+  uses: actions/cache@v3
+  with:
+    path: .turbo
+    key: ${{ runner.os }}-turbo-${{ github.sha }}
+    restore-keys: |
+      ${{ runner.os }}-turbo-
+
+- name: Build with remote cache
+  run: pnpm turbo run build
+  env:
+    TURBO_TOKEN: ${{ secrets.TURBO_TOKEN }}
+    TURBO_TEAM: ${{ secrets.TURBO_TEAM }}
+```
+
+## Nx Cloud Integration
+
+```yaml
+- name: Setup Nx Cloud
+  run: |
+    npx nx-cloud start-ci-run --distribute-on="3 linux-medium-js"
+  env:
+    NX_CLOUD_ACCESS_TOKEN: ${{ secrets.NX_CLOUD_ACCESS_TOKEN }}
+
+- name: Run affected
+  run: |
+    npx nx affected --target=build --parallel=3
+    npx nx affected --target=test --parallel=3
+    npx nx affected --target=lint --parallel=3
+```
+
+## Manual Affected Detection
+
+```typescript
+// scripts/get-affected.ts
+import * as path from "path";
+import { execSync } from "child_process";
+import * as fs from "fs";
+
+interface Package {
+  name: string;
+  path: string;
+  dependencies: string[];
+}
+
+function getChangedFiles(base: string = "origin/main"): string[] {
+  const output = execSync(`git diff --name-only ${base}...HEAD`, {
+    encoding: "utf-8",
+  });
+  return output.split("\n").filter(Boolean);
+}
+
+function getPackages(): Package[] {
+  const packagesDir = path.join(process.cwd(), "packages");
+  return fs.readdirSync(packagesDir).map((name) => {
+    const packageJson = JSON.parse(
+      fs.readFileSync(path.join(packagesDir, name, "package.json"), "utf-8")
+    );
+    return {
+      name: packageJson.name,
+      path: `packages/${name}`,
+      dependencies: [
+        ...Object.keys(packageJson.dependencies || {}),
+        ...Object.keys(packageJson.devDependencies || {}),
+      ],
+    };
+  });
+}
+
+function getAffectedPackages(): string[] {
+  const changedFiles = getChangedFiles();
+  const packages = getPackages();
+  const affected = new Set<string>();
+
+  // Direct changes
+  changedFiles.forEach((file) => {
+    packages.forEach((pkg) => {
+      if (file.startsWith(pkg.path)) {
+        affected.add(pkg.name);
+      }
+    });
+  });
+
+  // Dependent packages
+  let changed = true;
+  while (changed) {
+    changed = false;
+    packages.forEach((pkg) => {
+      if (!affected.has(pkg.name)) {
+        const hasAffectedDep = pkg.dependencies.some((dep) =>
+          affected.has(dep)
+        );
+        if (hasAffectedDep) {
+          affected.add(pkg.name);
+          changed = true;
+        }
+      }
+    });
+  }
+
+  return Array.from(affected);
+}
+
+// Output for GitHub Actions
+const affected = getAffectedPackages();
+console.log(`::set-output name=packages::${affected.join(",")}`);
+console.log(`Affected packages: ${affected.join(", ")}`);
+```
+
+## Matrix Strategy for Affected Packages
+
+```yaml
+detect-affected:
+  runs-on: ubuntu-latest
+  outputs:
+    packages: ${{ steps.affected.outputs.packages }}
+  steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+
+    - id: affected
+      run: |
+        PACKAGES=$(node scripts/get-affected.ts)
+        echo "packages=$PACKAGES" >> $GITHUB_OUTPUT
+
+test-affected:
+  needs: detect-affected
+  if: needs.detect-affected.outputs.packages != ''
+  runs-on: ubuntu-latest
+  strategy:
+    matrix:
+      package: ${{ fromJSON(needs.detect-affected.outputs.packages) }}
+  steps:
+    - uses: actions/checkout@v4
+
+    - uses: actions/setup-node@v4
+      with:
+        node-version: "20"
+        cache: "pnpm"
+
+    - run: pnpm install
+
+    - name: Test ${{ matrix.package }}
+      run: pnpm --filter ${{ matrix.package }} test
+```
+
+## Workspace-aware Caching
+
+```yaml
+- name: Cache workspace builds
+  uses: actions/cache@v3
+  with:
+    path: |
+      packages/*/dist
+      packages/*/node_modules/.cache
+    key: ${{ runner.os }}-workspace-${{ hashFiles('**/pnpm-lock.yaml') }}-${{ hashFiles('packages/**/*.ts') }}
+    restore-keys: |
+      ${{ runner.os }}-workspace-${{ hashFiles('**/pnpm-lock.yaml') }}-
+      ${{ runner.os }}-workspace-
+```
+
+## Parallel Execution
+
+```yaml
+- name: Build all packages in parallel
+  run: pnpm turbo run build --parallel
+
+- name: Test with controlled parallelism
+  run: pnpm turbo run test --concurrency=3
+```
+
+## Optimization Metrics
+
+```markdown
+## Before Optimization
+
+- Full build: 25 minutes
+- All tests: 15 minutes
+- Total: 40 minutes
+- Runs on every PR
+
+## After Affected Detection
+
+- Affected build: 5 minutes (80% reduction)
+- Affected tests: 3 minutes (80% reduction)
+- Total: 8 minutes (80% reduction)
+- Only runs necessary checks
+
+## With Remote Caching
+
+- Cache hit build: 30 seconds (98% reduction)
+- Cache hit tests: 1 minute (93% reduction)
+- Total: 1.5 minutes (96% reduction)
+```
+
+## Best Practices
+
+1. **Fetch full history**: `fetch-depth: 0` for accurate diffs
+2. **Topological order**: Build dependencies first
+3. **Remote caching**: Share cache across CI runs
+4. **Parallel execution**: Run independent tasks concurrently
+5. **Incremental builds**: Only rebuild what changed
+6. **Dependency graph**: Track package relationships
+7. **Force full build**: On main branch merges
+
+## Output Checklist
+
+- [ ] Affected detection implemented
+- [ ] Turborepo or Nx configured
+- [ ] Remote caching enabled
+- [ ] Parallel execution optimized
+- [ ] Matrix strategy for packages
+- [ ] Workspace-aware caching
+- [ ] Dependency graph documented
+- [ ] Before/after metrics tracked