Przepływy automatyzacji: potoki rozwoju oparte na AI

Możliwości AI Cursor wykraczają daleko poza interaktywne kodowanie. Ten przewodnik pokazuje, jak budować zaawansowane przepływy automatyzacji wykorzystujące AI do ciągłego rozwoju, testowania i konserwacji.

Architektura automatyzacji

graph TB subgraph "Wyzwalacze" Git[Haki Git] Schedule[Zadania Cron] Watch[Obserwatory plików] API[Webhooki API] end subgraph "Automatyzacja Cursor" Agent[Agent w tle] CLI[Cursor CLI] SDK[Cursor SDK] MCP[Serwery MCP] end subgraph "Akcje" Code[Generowanie kodu] Test[Tworzenie testów] Review[Przegląd kodu] Fix[Naprawy błędów] Docs[Dokumentacja] end Git --> Agent Schedule --> CLI Watch --> SDK API --> MCP Agent --> Code Agent --> Test CLI --> Review SDK --> Fix MCP --> Docs style Agent fill:#f9f,stroke:#333,stroke-width:2px style MCP fill:#bbf,stroke:#333,stroke-width:2px

Serwery MCP do automatyzacji

Dostępne serwery MCP do automatyzacji

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "your-github-token"
      }
    },
    "gitlab": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-gitlab"],
      "env": {
        "GITLAB_TOKEN": "your-gitlab-token",
        "GITLAB_URL": "https://gitlab.com"
      }
    },
    "jenkins": {
      "command": "npx",
      "args": ["-y", "jenkins-mcp-server"],
      "env": {
        "JENKINS_URL": "https://jenkins.company.com",
        "JENKINS_USER": "your-username",
        "JENKINS_TOKEN": "your-api-token"
      }
    },
    "terraform": {
      "command": "npx",
      "args": ["-y", "terraform-mcp"],
      "env": {
        "TF_WORKSPACE": "production"
      }
    },
    "kubernetes": {
      "command": "npx",
      "args": ["-y", "@kubernetes/mcp-server"],
      "env": {
        "KUBECONFIG": "~/.kube/config"
      }
    }
  }
}

Automatyzacja CI/CD z MCP

"Używając GitHub MCP, zautomatyzuj nasze CI/CD:
1. Uzyskaj status uruchomienia przepływu pracy dla głównej gałęzi
2. Wyzwól przepływ pracy wdrożenia, jeśli testy przeszły
3. Stwórz wydanie z dziennikiem zmian
4. Zaktualizuj problem śledzenia wdrożenia"

// Zaawansowana orkiestracja przepływu pracy
"Używając GitHub MCP:
- Sprawdź, czy kontrole PR #123 przeszły
- Jeśli tak, automatycznie połącz ze squash
- Wyzwól wdrożenie produkcyjne
- Monitoruj status wdrożenia
- Cofnij, jeśli kontrole zdrowia nie powiodą się"

"Używając Jenkins MCP:
- Wyzwól zadanie 'build-and-test'
- Poczekaj na ukończenie
- Jeśli pomyślne, wyzwól 'deploy-staging'
- Uruchom testy integracyjne
- Promuj do produkcji, jeśli wszystko przejdzie"

// Monitorowanie potoku
"Monitoruj potok Jenkins:
- Uzyskaj obecny status budowy
- Pokaż szczegóły nieudanych testów
- Wylistuj blokujące problemy
- Zaproponuj naprawy na podstawie logów"

"Używając GitLab MCP:
- Stwórz żądanie połączenia z gałęzi funkcji
- Uruchom potok CI
- Automatycznie przypisz recenzentów na podstawie CODEOWNERS
- Zaplanuj wdrożenie na staging
- Stwórz notatki wdrożenia"

Automatyzacja infrastruktury

// Orkiestracja Terraform + Kubernetes
"Koordynuj wdrożenie infrastruktury:
1. Używając Terraform MCP:
   - Zaplanuj zmiany infrastruktury
   - Pokaż mi, co zostanie utworzone/zmodyfikowane
   - Zastosuj zmiany po zatwierdzeniu

2. Używając Kubernetes MCP:
   - Wdróż nową wersję aplikacji
   - Monitoruj zdrowie podów
   - Skaluj na podstawie obciążenia
   - Zaktualizuj reguły ingress"

// Kompletny przykład automatyzacji
"Zautomatyzuj pełne wdrożenie:
1. GitHub MCP: Uzyskaj najnowszy tag wydania
2. Jenkins MCP: Zbuduj obraz Docker
3. Terraform MCP: Zaktualizuj infrastrukturę
4. Kubernetes MCP: Wdróż nową wersję
5. Slack MCP: Powiadom zespół o wdrożeniu"

Wzorce automatyzacji zadań

// Automatyczne zarządzanie problemami
"Używając Linear MCP i GitHub MCP razem:
- Gdy PR zostanie połączone z main
- Znajdź powiązane problemy Linear
- Przenieś problemy do statusu 'Done'
- Dodaj datę wdrożenia
- Połącz z URL produkcyjnym"

// Automatyzacja bezpieczeństwa
"Automatyzacja skanowania bezpieczeństwa:
1. GitHub MCP: Uzyskaj zmienione pliki
2. Uruchom skanowanie bezpieczeństwa na zmianach
3. Jeśli znaleziono luki:
   - Stwórz problem GitHub
   - Przypisz do zespołu bezpieczeństwa
   - Zablokuj wdrożenie
   - Zaproponuj naprawy"

Automatyzacja agenta w tle

Konfiguracja agentów w tle

Skonfiguruj środowisko agenta

{
  "backgroundAgent": {
    "enabled": true,
    "maxConcurrentTasks": 3,
    "taskTimeout": 300000,
    "retryAttempts": 2,
    "logLevel": "info",
    "webhookUrl": "${AGENT_WEBHOOK_URL}"
  },
  "automations": {
    "codeGeneration": true,
    "testCreation": true,
    "bugFixing": true,
    "codeReview": true,
    "documentation": true
  }
}

Stwórz przepływ pracy generowania testów

Przepływ pracy agenta Cursor do generowania testów:

#!/bin/bash
# Znajdź pliki bez testów
FILES_WITHOUT_TESTS=$(find src -name "*.ts" -o -name "*.js" |
  while read file; do
    test_file="${file%.ts}.test.ts"
    [ ! -f "$test_file" ] && echo "$file"
  done)

# Otwórz każdy plik w Cursor do generowania testów
for file in $FILES_WITHOUT_TESTS; do
  echo "Generowanie testów dla: $file"
  cursor "$file"

  # Użyj tego promptu w trybie Agent (Ctrl+I):
  # "Wygeneruj kompleksowe testy Jest dla @Files używając stylu BDD.
  # Skup się na testowaniu wszystkich publicznych funkcji i przypadków brzegowych.
  # Użyj @Code, aby zrozumieć szczegóły implementacji."
done

Zaplanuj automatyzację

name: Automatyzacja w tle Cursor

on:
  schedule:
    - cron: '0 */4 * * *' # Co 4 godziny
  push:
    branches: [main, develop]

jobs:
  automation:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Uruchom agenta Cursor
        env:
          CURSOR_API_KEY: ${{ secrets.CURSOR_API_KEY }}
        run: |
          cursor agent run \
            --config .cursor/agent-config.json \
            --tasks "test-generation,doc-update,code-review"

Zaawansowane wzorce agenta

// Inteligentny orkiestrator zadań
class TaskOrchestrator {
  private queue: TaskQueue;
  private agents: Map<string, BackgroundAgent>;

  async orchestrate(trigger: Trigger) {
    // Przeanalizuj wyzwalacz i określ zadania
    const tasks = await this.analyzeTrigger(trigger);

    // Ustal priorytety zadań
    const prioritized = this.prioritizeTasks(tasks);

    // Rozdziel między agentów
    for (const task of prioritized) {
      const agent = this.selectOptimalAgent(task);
      await this.queueTask(agent, task);
    }

    // Monitoruj wykonanie
    return this.monitorExecution();
  }

  private selectOptimalAgent(task: Task): BackgroundAgent {
    // Rozważ możliwości agenta, obciążenie i specjalizację
    const agents = Array.from(this.agents.values());

    return agents.reduce((best, agent) => {
      const score = this.calculateAgentScore(agent, task);
      return score > this.calculateAgentScore(best, task) ? agent : best;
    });
  }
}

Integracja haków Git

Automatyczne kontrole przed zatwierdzeniem

#!/bin/bash
echo "Uruchamiam kontrole przed zatwierdzeniem Cursor AI..."

# 1. Kontrola jakości kodu
cursor lint --ai-enhanced --fix

# 2. Skanowanie bezpieczeństwa
cursor security scan --staged

# 3. Generuj brakujące testy
cursor agent run --task generate-tests --target staged

# 4. Zaktualizuj dokumentację
cursor docs update --auto

# 5. Sprawdź zapachy kodu
cursor analyze --smells --complexity

if [ $? -ne 0 ]; then
  echo "Kontrole przed zatwierdzeniem nie powiodły się. Proszę przejrzeć i naprawić problemy."
  exit 1
fi

echo "Kontrole przed zatwierdzeniem zakończone sukcesem!"

Automatyzacja po połączeniu

#!/bin/bash
# post-merge-automation.sh

# Uzyskaj listę połączonych plików
MERGED_FILES=$(git diff --name-only HEAD~1 HEAD)

# 1. Zaktualizuj dokumentację
echo "Aktualizuję dokumentację..."
cursor README.md docs/
# W trybie Agent (Ctrl+I), użyj:
# "Zaktualizuj całą dokumentację na podstawie @Git zmian w ostatnim połączeniu"
# "Uwzględnij diagramy architektury, jeśli wprowadzono zmiany strukturalne"

# 2. Sprawdź zmiany API i wygeneruj testy
if echo "$MERGED_FILES" | grep -q "api/"; then
  echo "Wykryto zmiany API, generuję testy integracyjne..."
  cursor tests/integration/
  # Prompt agenta: "Wygeneruj testy integracyjne dla punktów końcowych API zmodyfikowanych w @Recent Changes"
fi

# 3. Zaktualizuj dokumentację zależności
cursor package.json docs/dependencies.md
# Prompt agenta: "Zaktualizuj dokumentację grafu zależności na podstawie zmian @Files package.json"

# 4. Wygeneruj podsumowanie i powiadom
echo "Automatyzacja po połączeniu ukończona"
# Użyj agenta do stworzenia podsumowania: "Podsumuj wpływ @Recent Changes dla zespołu"

Integracja potoku CI/CD

Automatyczny przegląd kodu

name: Przegląd kodu AI

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  ai-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
        with:
          fetch-depth: 0

      - name: Przegląd Cursor AI
        id: review
        run: |
          cursor review \
            --base ${{ github.base_ref }} \
            --head ${{ github.head_ref }} \
            --output review.md

      - name: Opublikuj komentarz przeglądu
        uses: actions/github-script@v6
        with:
          script: |
            const review = fs.readFileSync('review.md', 'utf8');
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: review
            });

Ciągłe generowanie testów

class ContinuousTestGenerator {
  async generateTestsForChanges(changes: FileChange[]) {
    const testPlan = await this.createTestPlan(changes);

    for (const item of testPlan) {
      switch (item.type) {
        case 'unit':
          await this.generateUnitTests(item);
          break;

        case 'integration':
          await this.generateIntegrationTests(item);
          break;

        case 'e2e':
          await this.generateE2ETests(item);
          break;
      }
    }

    // Uruchom wygenerowane testy
    const results = await this.runGeneratedTests();

    // Dopracuj na podstawie rezultatów
    if (results.failures.length > 0) {
      await this.refineFailingTests(results.failures);
    }
  }

  # Generuj testy jednostkowe używając agenta Cursor
  generateUnitTests() {
    local TARGET_FILE=$1

    # Otwórz plik w Cursor
    cursor "$TARGET_FILE"

    # Użyj trybu Agent (Ctrl+I) z tym kompleksowym promptem:
    cat << 'EOF'
    Wygeneruj kompleksowe testy jednostkowe Jest dla @Files zgodnie ze wzorcem AAA:
    - Struktura Arrange-Act-Assert
    - Cel pokrycia 90% instrukcji
    - Uwzględnij przypadki brzegowe i scenariusze błędów
    - Odpowiednio mockuj zewnętrzne zależności
    - Używaj opisowych nazw testów
    - Grupuj powiązane testy w blokach describe

    Odwołaj się do @Code, aby zrozumieć wszystkie funkcje i ich parametry.
    Sprawdź @Definitions dla informacji o typach.
    EOF
  }
}

Zaplanowana konserwacja

Automatyczna refaktoryzacja

export class ScheduledRefactoring {
  async performWeeklyMaintenance() {
    const tasks = [
      this.removeDeadCode(),
      this.updateDeprecatedPatterns(),
      this.optimizeImports(),
      this.consolidateDuplicates(),
      this.improveNaming()
    ];

    const results = await Promise.allSettled(tasks);

    // Stwórz PR podsumowania
    if (this.hasChanges(results)) {
      await this.createMaintenancePR(results);
    }
  }

  # Usuń martwy kod używając Cursor
  removeDeadCode() {
    echo "Analizuję bazę kodu pod kątem martwego kodu..."

    # Użyj agenta Cursor do znalezienia martwego kodu
    cursor .

    # Prompty agenta do wykrywania martwego kodu:
    # "Znajdź nieużywane funkcje w @Codebase"
    # "Zidentyfikuj nieosiągalny kod w @Files"
    # "Szukaj nieużywanych importów w całym projekcie"

    # Dla każdego zidentyfikowanego martwego kodu:
    # 1. Przejrzyj z: "Sprawdź, czy ten kod jest rzeczywiście nieużywany, sprawdzając referencje @Code"
    # 2. Usuń z: "Usuń ten nieużywany kod i zaktualizuj wszystkie powiązane testy"
  }

  # Zaktualizuj przestarzałe wzorce
  updateDeprecatedPatterns() {
    # Stwórz plik wzorców
    cat > .cursor/deprecated-patterns.md << 'EOF'
    # Przestarzałe wzorce do aktualizacji

    1. Stare: `findOne()` → Nowe: `findFirst()`
    2. Stare: `wzorzec callback` → Nowe: `async/await`
    3. Stare: `require()` → Nowe: `import`
    EOF

    # Otwórz w Cursor do aktualizacji wzorców
    cursor .cursor/deprecated-patterns.md

    # Użyj agenta z promptami jak:
    # "Znajdź wszystkie wystąpienia findOne() w @Codebase i zaproponuj aktualizacje do findFirst()"
    # "Zaktualizuj wzorce callback do async/await w @Files"
    # "Zmodernizuj instrukcje require do importów ES6 w całym projekcie"
  }
}

Automatyzacja dokumentacji

class AutoDocumentation {
  async generateComprehensiveDocs() {
    // Dokumentacja API
    await this.generateApiDocs();

    // Diagramy architektury
    await this.generateArchitectureDiagrams();

    // Przewodniki konfiguracji
    await this.updateSetupGuides();

    // Przykłady kodu
    await this.generateCodeExamples();
  }

  # Generuj dokumentację API używając Cursor
  generateApiDocs() {
    # Znajdź wszystkie punkty końcowe API
    API_FILES=$(find . -path "*/api/*" -name "*.ts" -o -name "*.js")

    for endpoint_file in $API_FILES; do
      cursor "$endpoint_file"

      # Użyj trybu Agent (Ctrl+I) z tymi promptami:
      # "Wygeneruj dokumentację OpenAPI dla punktów końcowych w @Files"
      # "Uwzględnij przykłady żądań/odpowiedzi i kody błędów"
      # "Dodaj wymagania uwierzytelniania i informacje o ograniczaniu liczby żądań"
      # "Stwórz kolekcję Postman z tych punktów końcowych"
    done
  }

  # Generuj diagramy architektury
  generateArchitectureDiagrams() {
    # Stwórz szablon do analizy architektury
    cat > architecture-prompt.md << 'EOF'
    Przeanalizuj architekturę bazy kodu i stwórz:
    1. Diagram przeglądu systemu pokazujący główne komponenty
    2. Diagram przepływu danych pokazujący, jak dane poruszają się przez system
    3. Diagram wdrożenia pokazujący konfigurację infrastruktury
    4. Diagramy sekwencji dla kluczowych przepływów użytkownika

    Użyj @Codebase, aby zrozumieć strukturę projektu
    Użyj @Files w src/, aby przeanalizować relacje komponentów
    Odwołaj się do @Docs dla istniejących notatek architektury
    EOF

    cursor architecture-prompt.md docs/architecture/

    await this.saveDiagrams(diagrams);
  }
}

Automatyzacja oparta na zdarzeniach

Obsługa webhooków

export class WebhookAutomation {
  async handleWebhook(event: WebhookEvent) {
    switch (event.type) {
      case 'issue.created':
        await this.handleNewIssue(event);
        break;

      case 'deployment.failed':
        await this.handleFailedDeployment(event);
        break;

      case 'security.vulnerability':
        await this.handleSecurityAlert(event);
        break;

      case 'performance.degradation':
        await this.handlePerformanceIssue(event);
        break;
    }
  }

  # Obsługuj nowe problemy GitHub za pomocą Cursor
  handleNewIssue() {
    local ISSUE_NUMBER=$1
    local ISSUE_TITLE=$2
    local ISSUE_BODY=$3

    # Stwórz plik analizy problemu
    cat > "issue-${ISSUE_NUMBER}.md" << EOF
# Problem #${ISSUE_NUMBER}: ${ISSUE_TITLE}

## Opis:
${ISSUE_BODY}

## Zadania analizy:
1. Zidentyfikuj główną przyczynę
2. Określ, czy można automatycznie naprawić
3. Zaproponuj podejście implementacyjne
EOF

    # Otwórz w Cursor do analizy
    cursor "issue-${ISSUE_NUMBER}.md"

    # Użyj trybu Agent (Ctrl+I) z promptami:
    # "Przeanalizuj ten problem i określ, czy można go naprawić automatycznie"
    # "Przeszukaj @Codebase w poszukiwaniu powiązanego kodu, który może powodować ten problem"
    # "Sprawdź @Recent Changes, które mogły wprowadzić ten problem"

    # Jeśli naprawa jest możliwa, stwórz gałąź i implementuj
    echo "Tworzę gałąź naprawy..."
    git checkout -b "fix/issue-${ISSUE_NUMBER}"

    # Użyj agenta do implementacji naprawy:
    # "Zaimplementuj naprawę problemu opisanego na基於基na podstawie twojej analizy"
    # "Dodaj testy, aby zapobiec ponownemu wystąpieniu tego problemu"
    # "Zaktualizuj dokumentację w razie potrzeby"
  }
}

Monitorowanie w czasie rzeczywistym

class MonitoringAutomation {
  private monitors = new Map<string, Monitor>();

  async initialize() {
    // Monitor jakości kodu
    this.monitors.set('quality', new QualityMonitor({
      threshold: { complexity: 10, duplication: 5 },
      action: this.handleQualityIssue.bind(this)
    }));

    // Monitor wydajności
    this.monitors.set('performance', new PerformanceMonitor({
      threshold: { responseTime: 200, cpu: 80 },
      action: this.handlePerformanceIssue.bind(this)
    }));

    // Monitor bezpieczeństwa
    this.monitors.set('security', new SecurityMonitor({
      scanInterval: '1h',
      action: this.handleSecurityIssue.bind(this)
    }));
  }

  # Obsługuj problemy jakości kodu za pomocą Cursor
  handleQualityIssue() {
    local ISSUE_FILE=$1
    local ISSUE_TYPE=$2

    # Otwórz problematyczny plik w Cursor
    cursor "$ISSUE_FILE"

    # Użyj trybu Agent (Ctrl+I) na podstawie typu problemu:
    case $ISSUE_TYPE in
      "complexity")
        # "Refaktoryzuj @Files, aby zmniejszyć złożoność. Rozbij duże funkcje."
        ;;
      "duplication")
        # "Znajdź i wyeliminuj duplikujący się kod w @Files. Wyodrębnij wspólną logikę."
        ;;
      "performance")
        # "Optymalizuj wąskie gardła wydajności w @Files. Skup się na pętlach i zapytaniach."
        ;;
    esac
  }
}

Niestandardowe skrypty automatyzacji

Szkieletowanie projektu

#!/bin/bash
# scaffold-microservice.sh

# Szkieletuj mikroserwis za pomocą Cursor
scaffoldMicroservice() {
  SERVICE_NAME=$1
  LANGUAGE=$2
  FRAMEWORK=$3

  # Stwórz strukturę serwisu
  mkdir -p "services/$SERVICE_NAME"/{src,tests,docs,config}
  cd "services/$SERVICE_NAME"

  # Stwórz instrukcje szkieletowania
  cat > .cursor/scaffold-instructions.md << EOF
# Szkieletuj mikroserwis $SERVICE_NAME

## Konfiguracja:
- Język: $LANGUAGE
- Framework: $FRAMEWORK
- Serwis: $SERVICE_NAME

## Wygeneruj te pliki:

### 1. Struktura projektu
Stwórz standardową strukturę mikroserwisu z:
- src/ - Kod źródłowy
- tests/ - Pliki testów
- docs/ - Dokumentacja
- config/ - Pliki konfiguracyjne

### 2. Podstawowe pliki
- Plik pakietu/zależności (package.json, requirements.txt, itp.)
- Główny punkt wejścia aplikacji
- Zarządzanie konfiguracją
- Punkt końcowy kontroli zdrowia
- Przykładowe punkty końcowe CRUD

### 3. Konfiguracja testów
- Konfiguracja frameworka testowego
- Przykładowe testy jednostkowe
- Przykładowe testy integracyjne

### 4. CI/CD
- Dockerfile
- docker-compose.yml
- Przepływ pracy GitHub Actions

### 5. Dokumentacja
- README.md z instrukcjami konfiguracji
- Szablon dokumentacji API
- Zapisy decyzji architektonicznych
EOF

  # Otwórz w Cursor do szkieletowania
  cursor .cursor/scaffold-instructions.md

  # Użyj trybu Agent (Ctrl+I) z promptami:
  # "Stwórz kompletną strukturę mikroserwisu zgodnie z opisem"
  # "Użyj @Docs, aby postępować zgodnie ze wzorcami mikroserwisów naszej organizacji"
  # "Odwołaj się do @Cursor Rules dla standardów kodowania i najlepszych praktyk"
  # "Uwzględnij właściwą obsługę błędów i logowanie w całym systemie"
}

Operacje wsadowe

#!/bin/bash
# Wykonaj aktualizacje wsadowe w plikach
performBatchUpdate() {
  local PATTERN=$1
  local TRANSFORMATION=$2

  # Znajdź wszystkie pasujące pliki
  FILES=$(find . -name "$PATTERN" -type f)

  # Stwórz instrukcje transformacji
  cat > batch-transform.md << EOF
# Instrukcje transformacji wsadowej

## Wzorzec: $PATTERN
## Transformacja: $TRANSFORMATION

### Dla każdego pliku:
1. Zastosuj transformację konsekwentnie
2. Zachowaj istniejącą logikę i zachowanie
3. Zaktualizuj powiązane testy, jeśli istnieją
4. Zachowaj styl kodu i formatowanie

### Walidacja:
- Upewnij się, że nie ma błędów składni
- Sprawdź, czy logika jest zachowana
- Sprawdź, czy testy nadal przechodzą
EOF

  # Przetwarzaj pliki w paczkach używając Cursor
  echo "$FILES" | xargs -n 10 | while read -r batch; do
    echo "Przetwarzam paczkę: $batch"

    # Stwórz punkt kontrolny, zatwierdzając obecny stan
    git add -A && git commit -m "Punkt kontrolny przed transformacją wsadową"

    # Otwórz pliki w Cursor
    cursor $batch batch-transform.md

    # Użyj trybu Agent (Ctrl+I) z promptami:
    # "Zastosuj transformację opisaną do wszystkich @Files"
    # "Zapewnij spójność we wszystkich plikach"
    # "Zaktualizuj wszystkie powiązane pliki testów"

    # Waliduj po transformacji
    echo "Waliduję transformacje..."
    npm test || yarn test || make test

    if [ $? -ne 0 ]; then
      echo "Walidacja nie powiodła się, cofam..."
      git reset --hard HEAD~1
    fi
  done
}

# Przykładowe transformacje
# performBatchUpdate "*.js" "Konwertuj CommonJS do modułów ES6"
# performBatchUpdate "*.test.ts" "Zaktualizuj do nowej składni frameworka testowego"
# performBatchUpdate "*Controller.ts" "Dodaj właściwą obsługę błędów do wszystkich punktów końcowych"

Przykłady integracji

Przykłady integracji z MCP

Automatyzacja GitHub z MCP

// Używanie GitHub MCP do zaawansowanej automatyzacji
"Zaimplementuj inteligentną automatyzację PR:
1. Monitoruj wszystkie otwarte PR
2. Dla każdego PR:
   - Sprawdź, czy recenzje są zatwierdzone
   - Zweryfikuj status CI/CD
   - Sprawdź konflikty połączenia
   - Automatycznie połącz, jeśli wszystkie warunki są spełnione
   - Zaktualizuj powiązane problemy"

// Automatyczne zarządzanie wydaniami
"Stwórz automatyczny proces wydania:
1. Używając GitHub MCP:
   - Wygeneruj dziennik zmian z commitów
   - Stwórz projekt wydania
   - Prześlij artefakty budowy
   - Oznacz wersję wydania
   - Wyzwól przepływ pracy wdrożenia"

Automatyzacja Kubernetes

"Używając Kubernetes MCP do automatyzacji wdrożeń:
1. Sprawdź kondycję klastra
2. Wykonaj aktualizację stopniową:
   - Zaktualizuj obraz wdrożenia
   - Monitoruj status wdrożenia
   - Sprawdź kondycję podów
   - Zweryfikuj punkty końcowe serwisu
3. Jeśli wykryto problemy:
   - Wstrzymaj wdrożenie
   - Zbierz logi
   - Cofnij w razie potrzeby
   - Powiadom zespół przez Slack MCP"

Orkiestracja wielu narzędzi

// Złożony przepływ pracy automatyzacji
class MCPOrchestrator {
  async deployWithFullAutomation(version: string) {
    // Faza 1: Budowa i test
    await this.runWithMCP('GitHub MCP: Stwórz gałąź wydania');
    await this.runWithMCP('Jenkins MCP: Uruchom pełny zestaw testów');

    // Faza 2: Infrastruktura
    await this.runWithMCP('Terraform MCP: Zaktualizuj infrastrukturę');
    await this.runWithMCP('Kubernetes MCP: Przygotuj klaster');

    // Faza 3: Wdrożenie
    await this.runWithMCP('Wdróż aplikację w wersji');
    await this.runWithMCP('Uruchom kontrole zdrowia');

    // Faza 4: Monitorowanie
    await this.runWithMCP('Sentry MCP: Sprawdź błędy');
    await this.runWithMCP('Grafana MCP: Monitoruj metryki');

    // Faza 5: Powiadomienie
    await this.runWithMCP('Slack MCP: Wyślij podsumowanie wdrożenia');
    await this.runWithMCP('Linear MCP: Zaktualizuj status zadania');
  }
}

Integracja Jira

#!/bin/bash
# Synchronizuj bilety Jira z przepływem pracy rozwoju
syncWithJira() {
  # Uzyskaj bilety obecnego sprintu używając Jira CLI
  TICKETS=$(jira list --query "sprint = activeSprint()" --json)

  # Przetwórz każdy bilet
  echo "$TICKETS" | jq -r '.[] | @base64' | while read -r ticket_data; do
    # Dekoduj dane biletu
    TICKET=$(echo "$ticket_data" | base64 -d)
    TICKET_KEY=$(echo "$TICKET" | jq -r '.key')
    TICKET_TYPE=$(echo "$TICKET" | jq -r '.fields.issuetype.name')
    TICKET_SUMMARY=$(echo "$TICKET" | jq -r '.fields.summary')

    # Stwórz gałąź funkcji w razie potrzeby
    if ! git branch -r | grep -q "feature/$TICKET_KEY"; then
      git checkout -b "feature/$TICKET_KEY"
    fi

    # Generuj szablon dla historii
    if [ "$TICKET_TYPE" = "Story" ]; then
      generateStoryBoilerplate "$TICKET_KEY" "$TICKET"
    fi
  done
}

# Generuj szablon implementacji historii za pomocą Cursor
generateStoryBoilerplate() {
  local TICKET_KEY=$1
  local TICKET_JSON=$2

  # Wyodrębnij szczegóły biletu
  DESCRIPTION=$(echo "$TICKET_JSON" | jq -r '.fields.description')
  ACCEPTANCE_CRITERIA=$(echo "$TICKET_JSON" | jq -r '.fields.customfield_10100')

  # Stwórz plik wymagań
  cat > ".cursor/tickets/${TICKET_KEY}-requirements.md" << EOF
# Implementacja $TICKET_KEY

## Opis
$DESCRIPTION

## Kryteria akceptacji
$ACCEPTANCE_CRITERIA

## Zadania implementacyjne
1. Przeanalizuj wymagania i stwórz projekt techniczny
2. Zaimplementuj podstawową funkcjonalność z testami
3. Dodaj testy integracyjne
4. Zaktualizuj dokumentację
5. Stwórz PR ze szczegółowym opisem
EOF

  # Otwórz w Cursor do implementacji
  cursor ".cursor/tickets/${TICKET_KEY}-requirements.md" src/

  # Użyj trybu Agent (Ctrl+I) z promptami:
  # "Przeanalizuj wymagania w tym bilecie i zaproponuj podejście implementacyjne"
  # "Stwórz niezbędne pliki i strukturę folderów dla tej funkcji"
  # "Zaimplementuj funkcję zgodnie z TDD - napisz testy najpierw"
  # "Odwołaj się do @Docs dla naszych wzorców kodowania i @Cursor Rules dla standardów"

  # Zaktualizuj dokumentację
  cursor docs/features/
  # "Zaktualizuj dokumentację funkcji, aby uwzględnić implementację $TICKET_KEY"
}

# Przykład użycia:
# ./jira-automation.sh
# To zsynchronizuje wszystkie bilety aktywnego sprintu i pomoże je zaimplementować

Optymalizacja wydajności

Automatyzacja równoległa

class ParallelAutomation {
  private workers: Worker[] = [];

  async executeParallel(tasks: AutomationTask[]) {
    // Zainicjuj pulę workerów
    const numWorkers = os.cpus().length;
    for (let i = 0; i < numWorkers; i++) {
      this.workers.push(new Worker('./automation-worker.js'));
    }

    // Rozdziel zadania
    const taskQueue = [...tasks];
    const results = [];

    await Promise.all(
      this.workers.map(async (worker) => {
        while (taskQueue.length > 0) {
          const task = taskQueue.shift();
          const result = await this.executeTask(worker, task);
          results.push(result);
        }
      })
    );

    return results;
  }
}

Najlepsze praktyki

Zacznij od małego

Rozpocznij od prostych automatyzacji i stopniowo zwiększaj złożoność

Monitoruj wszystko

Śledź wskaźniki sukcesu automatyzacji i wpływ na wydajność

Eleganckie niepowodzenia

Zawsze uwzględnij mechanizmy wycofania i obsługę błędów

Nadzór ludzki

Zachowaj przegląd ludzki dla krytycznych automatyzacji

Najlepsze praktyki automatyzacji MCP

Inteligentne łączenie MCP

Kombinuj wiele serwerów MCP dla złożonych przepływów pracy

Obsługuj awarie MCP

Zawsze miej plany awaryjne, gdy serwery MCP są niedostępne

Zabezpiecz poświadczenia MCP

Używaj zmiennych środowiskowych i zarządzania sekretami dla tokenów MCP

Loguj operacje MCP

Śledź wszystkie operacje MCP dla audytu i debugowania

// Jedno polecenie orkiestruje wszystko
"Wdróż wersję 2.1.0 do produkcji:
- GitHub MCP: Stwórz wydanie
- Jenkins MCP: Zbuduj i przetestuj
- Terraform MCP: Zaktualizuj infrastrukturę
- K8s MCP: Wdróż aplikację
- Slack MCP: Powiadom zespół"

// Czas: 2 minuty konfiguracji
// Konserwacja: Minimalna
// Elastyczność: Wysoka

// Niestandardowe skrypty dla każdego narzędzia
async function deploy(version) {
  // Integracja API GitHub
  const github = new GitHubAPI(token);
  await github.createRelease(...);

  // Integracja API Jenkins
  const jenkins = new JenkinsAPI(...);
  await jenkins.triggerBuild(...);

  // Wrapper CLI Terraform
  await exec('terraform apply...');

  // Klient Kubernetes
  const k8s = new K8sClient(...);
  await k8s.updateDeployment(...);

  // Webhook Slack
  await sendSlackMessage(...);
}

// Czas: Dni rozwoju
// Konserwacja: Wysoka
// Elastyczność: Ograniczona

Lista kontrolna automatyzacji

Określ jasne cele
- Jaki proces ręczny zastępujesz?
- Jakie są kryteria sukcesu?
- Jak będziesz mierzyć wpływ?
Implementuj stopniowo
- Zacznij od operacji tylko do odczytu
- Dodaj operacje zapisu z zabezpieczeniami
- Włącz pełną automatyzację z monitorowaniem
Monitoruj i iteruj
- Śledź wskaźniki sukcesu/niepowodzenia
- Mierz oszczędności czasu
- Zbieraj opinie zespołu
- Ciągle ulepszaj
Dokumentuj wszystko
- Jak działa automatyzacja
- Jak rozwiązywać problemy
- Jak modyfikować lub rozszerzać

Następne kroki

Zidentyfikuj możliwości automatyzacji - Wylistuj powtarzalne zadania w swoim przepływie pracy
Stwórz pierwszą automatyzację - Zacznij od prostego, niskoryzykownego zadania
Zmierz wpływ - Śledź zaoszczędzony czas i poprawę jakości
Skaluj stopniowo - Rozwijaj pokrycie automatyzacji na podstawie sukcesu

Pamiętaj: celem automatyzacji nie jest zastąpienie deweloperów, ale wzmocnienie ich możliwości. Skup się na automatyzacji monotonnych zadań, aby ludzie mogli skupić się na kreatywności.