Integracja GitHub Actions

Claude Code może być zintegrowany z przepływami pracy GitHub Actions w celu automatyzacji przeglądów kodu, generowania dokumentacji, przeprowadzania audytów bezpieczeństwa i wzbogacania potoku CI/CD o możliwości wspomagane przez AI.

Pierwsze kroki

Podstawowa konfiguracja

Dodaj klucz API do GitHub Secrets

# W ustawieniach repozytorium:
# Settings → Secrets and variables → Actions
# Dodaj nowy sekret repozytorium: ANTHROPIC_API_KEY

Utwórz podstawowy przepływ pracy

name: Claude Code Analysis

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  code-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0  # Pełna historia dla lepszego kontekstu

      - name: Install Claude Code
        run: |
          # Zainstaluj CLI Claude Code
          npm install -g @anthropic-ai/claude-code

          # Zweryfikuj instalację
          claude --version

      - name: Run Code Review
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          claude review \
            --base origin/${{ github.base_ref }} \
            --head ${{ github.sha }} \
            --output review-report.md

      - name: Comment PR
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const review = fs.readFileSync('review-report.md', 'utf8');
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: review
            });

Przetestuj przepływ pracy

# Utwórz testowy PR aby uruchomić przepływ pracy
git checkout -b test-claude-code
echo "# Test" > test.md
git add test.md
git commit -m "Test Claude Code integration"
git push origin test-claude-code

Zaawansowane przepływy pracy

Automatyczny przegląd kodu

Kompleksowy przegląd PR

name: AI Code Review

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  ai-review:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write
      issues: write

    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Get Changed Files
        id: changed-files
        run: |
          # Pobierz listę zmienionych plików
          CHANGED_FILES=$(git diff --name-only origin/${{ github.base_ref }}...${{ github.sha }})
          echo "files<<EOF" >> $GITHUB_OUTPUT
          echo "$CHANGED_FILES" >> $GITHUB_OUTPUT
          echo "EOF" >> $GITHUB_OUTPUT

      - name: Claude Code Review
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          # Utwórz prompt przeglądu
          cat > review-prompt.txt << 'EOF'
          Przejrzyj ten pull request skupiając się na:
          1. Jakości kodu i najlepszych praktykach
          2. Potencjalnych błędach lub problemach
          3. Lukach bezpieczeństwa
          4. Implikacjach wydajnościowych
          5. Sugestiach ulepszeń

          Zmienione pliki:
          ${{ steps.changed-files.outputs.files }}

          Podaj konkretną, wykonalną opinię z przykładami kodu gdzie to ma zastosowanie.
          Formatuj jako GitHub Flavored Markdown.
          EOF

          # Uruchom przegląd
          claude review \
            --prompt-file review-prompt.txt \
            --base origin/${{ github.base_ref }} \
            --format markdown \
            > review.md

      - name: Post Review Comments
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const review = fs.readFileSync('review.md', 'utf8');

            // Sprawdź czy przegląd jest merytoryczny
            if (review.length > 100) {
              // Utwórz komentarz przeglądu
              await github.rest.pulls.createReview({
                owner: context.repo.owner,
                repo: context.repo.repo,
                pull_number: context.issue.number,
                body: review,
                event: 'COMMENT'
              });
            }

name: Generate API Documentation

on:
  push:
    branches: [main]
    paths:
      - 'src/api/**'
      - 'openapi.yaml'

jobs:
  generate-docs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Generate API Docs
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          claude "Przeanalizuj kod API w src/api i:
          1. Wygeneruj kompleksową dokumentację API
          2. Uwzględnij przykłady request/response
          3. Udokumentuj kody błędów i ich obsługę
          4. Utwórz przykłady użycia w wielu językach
          5. Wygeneruj aktualizacje specyfikacji OpenAPI
          Wynik w formacie Markdown" \
          --output docs/api-reference.md

      - name: Generate SDK Examples
        run: |
          claude "Na podstawie API w src/api, wygeneruj:
          1. Przykłady użycia SDK Python
          2. Przykłady JavaScript/TypeScript
          3. Przykłady klienta Go
          4. Przykłady poleceń cURL
          5. Kolekcję Postman
          Zapisz każdy w odpowiednim katalogu" \
          --output-dir examples/

      - name: Commit Documentation
        run: |
          git config --local user.email "action@github.com"
          git config --local user.name "GitHub Action"
          git add docs/ examples/
          git diff --staged --quiet || git commit -m "chore: Update API documentation [skip ci]"
          git push

name: Update README

on:
  push:
    branches: [main]
    paths:
      - 'src/**'
      - 'package.json'

jobs:
  update-readme:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Analyze Project
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          claude "Przeanalizuj ten projekt i zaktualizuj README.md:
          1. Zaktualizuj listę funkcji na podstawie aktualnego kodu
          2. Odśwież instrukcje instalacji
          3. Zaktualizuj przykłady użycia
          4. Upewnij się, że wszystkie znaczniki są aktualne
          5. Dodaj nowe opcje konfiguracji
          Zachowaj istniejącą strukturę i styl" \
          --edit README.md

      - name: Create PR
        uses: peter-evans/create-pull-request@v5
        with:
          commit-message: 'docs: Update README.md'
          title: 'docs: Automatyczna aktualizacja README'
          body: |
            Ten PR aktualizuje README.md na podstawie ostatnich zmian w kodzie.

            Wygenerowane przez analizę Claude Code.
          branch: update-readme

Skanowanie bezpieczeństwa

Potok audytu bezpieczeństwa

name: Security Audit

on:
  push:
    branches: [main]
  pull_request:
  schedule:
    - cron: '0 2 * * 1'  # Tygodniowo w poniedziałek

jobs:
  security-scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Dependency Audit
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          # Tradycyjne skanowanie
          npm audit --json > npm-audit.json

          # Analiza Claude Code
          claude "Przeanalizuj npm-audit.json i:
          1. Ustaw priorytety luk według ważności i możliwości eksploitacji
          2. Zasugeruj konkretne kroki naprawcze
          3. Zidentyfikuj fałszywe alarmy
          4. Polec alternatywne pakiety jeśli potrzeba
          5. Utwórz gotowe do PR polecenia naprawcze" \
          --input npm-audit.json \
          --output security-report.md

      - name: Code Security Review
        run: |
          claude "Przeprowadź przegląd bezpieczeństwa bazy kodu:
          1. Sprawdź zakodowane sekrety lub klucze API
          2. Zidentyfikuj luki SQL injection
          3. Znajdź luki XSS
          4. Sprawdź problemy authentication/authorization
          5. Przejrzyj implementacje kryptograficzne
          6. Zidentyfikuj problemy OWASP Top 10
          Skup się na katalogu src/" \
          --output code-security-report.md

      - name: Infrastructure Security
        run: |
          claude "Przejrzyj konfiguracje infrastruktury:
          1. Sprawdź Dockerfile pod kątem problemów bezpieczeństwa
          2. Przejrzyj manifesty k8s pod kątem błędnych konfiguracji
          3. Przeanalizuj GitHub Actions pod kątem problemów bezpieczeństwa
          4. Sprawdź ujawnione wrażliwe dane
          5. Przejrzyj polityki CORS i CSP" \
          --output infra-security-report.md

      - name: Upload Reports
        uses: actions/upload-artifact@v4
        with:
          name: security-reports
          path: |
            *-report.md
            npm-audit.json

Generowanie testów

Generowanie testów jednostkowych

- name: Generate Missing Tests
  env:
    ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
  run: |
    # Znajdź pliki z niskim pokryciem
    UNCOVERED=$(find src -name "*.js" -o -name "*.ts" | \
      xargs -I {} sh -c 'test -f "$(echo {} | \
      sed "s/src/test/;s/\.[jt]s$/.test.&/")" || echo {}')

    # Wygeneruj testy dla niepokrytych plików
    for file in $UNCOVERED; do
      claude "Wygeneruj kompleksowe testy jednostkowe dla $file:
      1. Testuj wszystkie eksportowane funkcje
      2. Uwzględnij przypadki skrajne
      3. Mockuj zewnętrzne zależności
      4. Użyj składni Jest/Vitest
      5. Cel 90%+ pokrycia" \
      --output "${file/src/test}.test.js"
    done

Generowanie testów integracyjnych

- name: Generate Integration Tests
  run: |
    claude "Przeanalizuj endpointy API i wygeneruj:
    1. Testy integracyjne dla wszystkich endpointów
    2. Testuj przepływy uwierzytelniania
    3. Testuj scenariusze błędów
    4. Testuj ograniczenia szybkości
    5. Testuj walidację danych
    Użyj składni Supertest" \
    --output test/integration/api.test.js

Generowanie testów E2E

- name: Generate E2E Tests
  run: |
    claude "Utwórz testy E2E Playwright:
    1. Testuj krytyczne ścieżki użytkownika
    2. Testuj przesyłanie formularzy
    3. Testuj obsługę błędów
    4. Testuj responsywny design
    5. Uwzględnij testy dostępności" \
    --output test/e2e/

Optymalizacja wydajności

Optymalizacja buildu

Analiza zależności

- name: Optimize Dependencies
  env:
    ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
  run: |
    claude "Przeanalizuj package.json i:
    1. Zidentyfikuj nieużywane zależności
    2. Znajdź duplikaty zależności
    3. Zasugeruj łżejsze alternatywy
    4. Zidentyfikuj problemy bezpieczeństwa
    5. Polec aktualizacje wersji
    Wygeneruj polecenia naprawcze" \
    --output dependency-optimization.sh

    # Wykonaj rekomendacje
    chmod +x dependency-optimization.sh
    ./dependency-optimization.sh

Analiza bundla

- name: Analyze Bundle Size
  run: |
    # Wygeneruj statystyki bundla
    npm run build -- --stats

    claude "Przeanalizuj webpack-stats.json:
    1. Zidentyfikuj duże moduły
    2. Znajdź zduplikowany kod
    3. Zasugeruj punkty podziału kodu
    4. Polec lazy loading
    5. Zidentyfikuj możliwości tree-shaking" \
    --output bundle-optimization.md

Zarządzanie wydaniami

Automatyczne wydania

Inteligentne notatki wydania

name: Create Release

on:
  push:
    tags:
      - 'v*'

jobs:
  release:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Generate Release Notes
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          # Pobierz commity od ostatniego tagu
          LAST_TAG=$(git describe --tags --abbrev=0 HEAD^)
          COMMITS=$(git log $LAST_TAG..HEAD --pretty=format:"%h %s")

          claude "Wygeneruj notatki wydania z tych commitów:
          $COMMITS

          Formatuj jako:
          1. Zmiany łamiące wsteczną kompatybilność (jeśli są)
          2. Nowe funkcje
          3. Naprawy błędów
          4. Usprawnienia wydajności
          5. Aktualizacje dokumentacji

          Spraw by było przyjazne użytkownikowi i ekscytujące!" \
          --output release-notes.md

      - name: Create GitHub Release
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const notes = fs.readFileSync('release-notes.md', 'utf8');

            await github.rest.repos.createRelease({
              owner: context.repo.owner,
              repo: context.repo.repo,
              tag_name: context.ref.replace('refs/tags/', ''),
              name: `Release ${context.ref.replace('refs/tags/', '')}`,
              body: notes,
              draft: false,
              prerelease: false
            });

Zarządzanie kosztami

Monitorowanie użycia tokenów

Śledź użycie na przepływ pracy

- name: Log Token Usage
  if: always()
  env:
    ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
  run: |
    # Pobierz użycie tokenów z Claude Code
    TOKEN_USAGE=$(claude usage --format json)

    # Zaloguj do GitHub
    echo "::notice title=Token Usage::$TOKEN_USAGE"

    # Przechowaj do analizy
    echo "$TOKEN_USAGE" >> .github/token-usage.log

    # Ostrzeż jeśli użycie jest wysokie
    TOKENS=$(echo $TOKEN_USAGE | jq '.total_tokens')
    if [ $TOKENS -gt 10000 ]; then
      echo "::warning title=High Token Usage::Used $TOKENS tokens"
    fi

Utwórz dashboard użycia

- name: Update Usage Dashboard
  run: |
    claude "Przeanalizuj .github/token-usage.log i:
    1. Utwórz wykres trendów użycia
    2. Zidentyfikuj przepływy pracy o wysokim użyciu
    3. Zasugeruj optymalizacje
    4. Oblicz miesięczne koszty
    5. Wygeneruj raport markdown" \
    --output .github/usage-report.md

Najlepsze praktyki

Względy bezpieczeństwa

Szablony przepływów pracy

Szablon automatyzacji PR

Kompletny przepływ pracy PR

name: PR Automation

on:
  pull_request:
    types: [opened, synchronize, reopened]

concurrency:
  group: pr-${{ github.event.number }}
  cancel-in-progress: true

jobs:
  setup:
    runs-on: ubuntu-latest
    outputs:
      cache-key: ${{ steps.cache.outputs.key }}
    steps:
      - uses: actions/checkout@v4
      - id: cache
        run: echo "key=${{ runner.os }}-${{ hashFiles('**/package-lock.json') }}"

  code-quality:
    needs: setup
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/cache@v3
        with:
          path: ~/.npm
          key: ${{ needs.setup.outputs.cache-key }}

      - name: Install Dependencies
        run: npm ci

      - name: Lint Code
        run: npm run lint

      - name: Claude Code Review
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          claude review \
            --focus "jakość kodu, najlepsze praktyki, wydajność" \
            --severity "error,warning" \
            --output review.md

  security:
    needs: setup
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Security Scan
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          claude security-scan \
            --include-dependencies \
            --check-secrets \
            --output security.md

  tests:
    needs: setup
    runs-on: ubuntu-latest
    strategy:
      matrix:
        node: [18, 20]
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node }}

      - name: Run Tests
        run: |
          npm ci
          npm test

      - name: Generate Missing Tests
        if: failure()
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          claude generate-tests \
            --failed-only \
            --output test/generated/

  summarize:
    needs: [code-quality, security, tests]
    if: always()
    runs-on: ubuntu-latest
    steps:
      - name: Summarize Results
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          claude "Podsumuj kontrole PR:
          - Jakość kodu: ${{ needs.code-quality.result }}
          - Bezpieczeństwo: ${{ needs.security.result }}
          - Testy: ${{ needs.tests.result }}

          Podaj wykonalne następne kroki" \
          --output summary.md

Rozwiązywanie problemów

Typowe problemy

# Debug problemy z kluczem API
- name: Debug API Key
  run: |
    # Sprawdź czy klucz jest ustawiony
    if [ -z "$ANTHROPIC_API_KEY" ]; then
      echo "::error::ANTHROPIC_API_KEY nie jest ustawiony"
      exit 1
    fi

    # Testuj poprawność klucza
    claude "Hello" --max-tokens 10 || {
      echo "::error::Walidacja klucza API nie powiodła się"
      exit 1
    }

# Obsługa ograniczeń szybkości
- name: Run with Retry
  uses: nick-fields/retry@v2
  with:
    timeout_minutes: 10
    max_attempts: 3
    retry_wait_seconds: 60
    command: |
      claude review --output review.md

# Obsługa dużych baz kodu
- name: Process Large Files
  run: |
    # Podziel przegląd na kawałki
    find src -name "*.js" | \
      xargs -n 10 -P 4 -I {} \
      claude review --files {} \
        --output reviews/{}.md

    # Połącz wyniki
    cat reviews/*.md > combined-review.md

Następne kroki

Wzbogać swój potok CI/CD o:

Integrację przedsiębiorstwa dla narzędzi korporacyjnych
Kontrolę kosztów dla zarządzania budżetem
Monitorowanie kosztów dla śledzenia użycia

Pamiętaj: Zacznij od prostych przepływów pracy i stopniowo dodawaj złożoność. Monitoruj koszty uważnie i optymalizuj użycie tokenów poprzez cachowanie wyników i uruchamianie tylko przy istotnych zmianach.