Automatyzacja skryptów

Automatyzacja skryptów

Automatyzacja skryptów przekształca Claude Code z interaktywnego asystenta w potężny silnik automatyzacji. Łącząc hooki, niestandardowe polecenia, tryb headless i wzorce skryptowe, możesz zautomatyzować wszystko od formatowania kodu po migracje na dużą skalę. Ten przewodnik ujawnia jak budować przepływy pracy automatyzacji, które działają autonomicznie, zachowując jednocześnie elastyczność interwencji w razie potrzeby.

Moc hooków

Zrozumienie systemu hooków

Hooki to tajna broń Claude Code dla automatyzacji. To polecenia powłoki, które wykonują się automatycznie w określonych punktach cyklu życia Claude, przekształcając powtarzalne ręczne zadania w płynne operacje w tle.

Wydarzenia hooków

System hooków zapewnia pięć strategicznych punktów interwencji:

• PreToolUse: Przed wykonaniem przez Claude jakiegokolwiek narzędzia/polecenia
• PostToolUse: Po pomyślnym ukończeniu narzędzia/polecenia
• UserPromptSubmit: Gdy wysyłasz prompt do Claude
• Notification: Gdy Claude wysyła powiadomienie
• Stop: Gdy Claude kończy swoją odpowiedź

Tworzenie pierwszego hooka

Zacznijmy od najczęstszej automatyzacji: automatycznego formatowania kodu.

1. Utwórz konfigurację hooków

   mkdir -p .claude

2. Dodaj do .claude/settings.json

   {
     "hooks": [
       {
         "matcher": "Edit|Write",
         "hooks": [
           {
             "type": "command",
             "command": "prettier --write \"$CLAUDE_FILE_PATHS\""
           }
         ]
       }
     ]
   }

3. Przetestuj hooka

   # Poproś Claude o utworzenie nieformatowanego pliku JavaScript
   claude "Utwórz plik test.js z nieformatowanym kodem"
   # Plik zostanie automatycznie sformatowany po utworzeniu!

Zaawansowane wzorce hooków

Formatowanie specyficzne dla języka

{
  "hooks": [
    {
      "matcher": "Edit",
      "hooks": [
        {
          "type": "command",
          "command": "if [[ \"$CLAUDE_FILE_PATHS\" =~ \\.(ts|tsx)$ ]]; then npx prettier --write \"$CLAUDE_FILE_PATHS\"; elif [[ \"$CLAUDE_FILE_PATHS\" =~ \\.py$ ]]; then black \"$CLAUDE_FILE_PATHS\"; elif [[ \"$CLAUDE_FILE_PATHS\" =~ \\.go$ ]]; then gofmt -w \"$CLAUDE_FILE_PATHS\"; fi"
        }
      ]
    }
  ]
}

Sprawdzanie typów

{
  "hooks": [
    {
      "matcher": "Edit",
      "hooks": [
        {
          "type": "command",
          "command": "if [[ \"$CLAUDE_FILE_PATHS\" =~ \\.(ts|tsx)$ ]]; then npx tsc --noEmit --skipLibCheck \"$CLAUDE_FILE_PATHS\" || echo '⚠️ Wykryto błędy TypeScript - proszę przejrzeć'; fi"
        }
      ]
    }
  ]
}

Skanowanie bezpieczeństwa

{
  "hooks": [
    {
      "matcher": "Write|Edit",
      "hooks": [
        {
          "type": "command",
          "command": "if [[ \"$CLAUDE_FILE_PATHS\" =~ \\.(js|ts|py)$ ]]; then semgrep --config=auto \"$CLAUDE_FILE_PATHS\" || echo 'Skanowanie bezpieczeństwa ukończone'; fi"
        }
      ]
    }
  ]
}

Zmienne hooków i przepływ sterowania

Hooki otrzymują bogaty kontekst poprzez zmienne środowiskowe:

# Dostępne we wszystkich hookach
$CLAUDE_FILE_PATHS      # Lista plików dotkniętych oddzielona spacjami
$CLAUDE_SESSION_ID      # Unikalny identyfikator sesji
$CLAUDE_TOOL_NAME       # Nazwa wykonywanego narzędzia
$CLAUDE_USER_PROMPT     # Oryginalny prompt użytkownika

# Payload JSON przez stdin
{
  "hookEventName": "PostToolUse",
  "sessionId": "uuid-here",
  "toolName": "Edit",
  "filePaths": ["src/index.ts"],
  "result": "success"
}

Kody wyjścia hooków

Hooki mogą kontrolować zachowanie Claude poprzez kody wyjścia:

• Exit 0: Kontynuuj normalnie
• Exit 1: Anuluj operację (tylko PreToolUse)
• Exit 2-255: Loguj ostrzeżenie ale kontynuuj

Niestandardowe polecenia slash

Budowanie automatyzacji wielokrotnego użytku

Niestandardowe polecenia slash przekształcają złożone przepływy pracy automatyzacji w proste, sparametryzowane polecenia. Są przechowywane jako pliki Markdown i mogą być dzielone w zespole.

1. Utwórz katalog poleceń

   mkdir -p .claude/commands

2. Utwórz swoje pierwsze polecenie (.claude/commands/test.md)

   Proszę utwórz kompleksowe testy dla: $ARGUMENTS
   
   Wymagania testów:
   - Używaj naszego standardowego frameworka testowego
   - Dołącz testy jednostkowe i integracyjne
   - Mockuj zewnętrzne zależności
   - Testuj przypadki błędów i warunki graniczne
   - Osiągnij co najmniej 80% pokrycia
   - Umieść testy w katalogu __tests__
   - Podążaj za naszą konwencją nazewnictwa: *.test.ts

3. Użyj polecenia

   claude
   > /test UserService
   # Claude generuje kompleksowe testy dla UserService

Wzorce poleceń dla automatyzacji

Polecenie migracji

.claude/commands/migrate.md

Migruj $ARGUMENTS z naszego starego API na nowe API:

1. Znajdź wszystkie użycia starego API
2. Zaktualizuj importy aby używały nowego pakietu
3. Przekształć wywołania metod na nową składnię
4. Zaktualizuj wszelkie definicje typów
5. Uruchom testy aby zweryfikować migrację
6. Utwórz raport migracji

Audyt bezpieczeństwa

.claude/commands/audit.md

Wykonaj audyt bezpieczeństwa na: $ARGUMENTS

- Sprawdź luki SQL injection
- Skanuj możliwości XSS
- Przejrzyj przepływy uwierzytelniania
- Sprawdź ujawnione sekrety
- Zweryfikuj walidację wejścia
- Wygeneruj raport bezpieczeństwa

Analiza wydajności

.claude/commands/perf.md

Przeanalizuj wydajność: $ARGUMENTS

- Sprofiluj wykonanie kodu
- Zidentyfikuj wąskie gardła
- Sprawdź zapytania N+1
- Przejrzyj złożoność algorytmów
- Zasugeruj optymalizacje
- Utwórz testy benchmark

Generator dokumentacji

.claude/commands/doc.md

Wygeneruj dokumentację dla: $ARGUMENTS

- Utwórz kompleksowe docstringi
- Wygeneruj dokumentację API
- Dołącz przykłady użycia
- Udokumentuj przypadki graniczne
- Utwórz przewodniki markdown
- Zaktualizuj README w razie potrzeby

Organizacja zagnieżdżonych poleceń

Dla większych zespołów, organizuj polecenia hierarchicznie:

.claude/commands/
├── backend/
│   ├── migrate.md      # /backend:migrate
│   ├── optimize.md     # /backend:optimize
│   └── test.md         # /backend:test
├── frontend/
│   ├── component.md    # /frontend:component
│   ├── style.md        # /frontend:style
│   └── test.md         # /frontend:test
└── devops/
    ├── deploy.md       # /devops:deploy
    └── monitor.md      # /devops:monitor

Automatyzacja trybu headless

Automatyzacja potoków CI/CD

Tryb headless umożliwia Claude Code działanie w środowiskach nieinteraktywnych, idealne dla automatyzacji CI/CD.

Podstawowe użycie

# Uruchom pojedyncze polecenie
claude -p "Napraw wszystkie błędy lintingu" --output-format stream-json

# Z określonymi dozwolonymi narzędziami
claude -p "Zaktualizuj zależności" --allowedTools "Edit Bash(npm:*)"

# Tryb verbose do debugowania
claude -p "Uruchom audyt bezpieczeństwa" --verbose

GitHub Actions

name: Przegląd kodu AI
on: [pull_request]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4

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

      - name: Uruchom przegląd AI
        run: |
          claude -p "Przejrzyj zmiany w tym PR pod kątem:
            - Problemów jakości kodu
            - Luk bezpieczeństwa
            - Problemów wydajności
            - Zasugeruj ulepszenia
            Wynik jako markdown" \
          --output-format stream-json > review.json

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

Hook pre-commit

.git/hooks/pre-commit

#!/bin/bash
# Uruchom Claude Code aby sprawdzić staged files
staged_files=$(git diff --cached --name-only)

if [ ! -z "$staged_files" ]; then
  claude -p "Sprawdź te pliki pod kątem problemów: $staged_files
    - Szukaj instrukcji console.log
    - Sprawdź zakomentowany kod
    - Zweryfikuj czy sekrety nie są ujawnione
    Zgłoś wszelkie znalezione problemy" \
  --allowedTools "Read" \
  --output-format stream-json | jq -r '.content'

  # Wyjdź z błędem jeśli znaleziono problemy
  if [ $? -ne 0 ]; then
    echo "Sprawdzenie pre-commit nie powiodło się. Proszę naprawić problemy przed commitem."
    exit 1
  fi
fi

Wzorce przetwarzania wsadowego

Wzorzec rozkładania

Użyj tego wzorca do niezależnego przetwarzania wielu plików:

migrate-components.sh

#!/bin/bash
# Wygeneruj listę zadań
find src/components -name "*.jsx" > components.txt

# Przetwórz każdy komponent
while read -r file; do
  echo "Migracja $file..."
  claude -p "Konwertuj $file z komponentu klasowego na komponent funkcyjny z hookami.
    Zwróć 'OK' jeśli się powiodło, 'FAIL' jeśli nie jest możliwe." \
    --allowedTools "Edit Read" \
    --output-format stream-json | jq -r '.status'
done < components.txt

Wzorzec potoku

Łącz Claude Code z innymi narzędziami:

# Analizuj logi i wysyłaj alerty
tail -f /var/log/app.log | \
claude -p "Monitoruj ten strumień logów. Jeśli zobaczysz jakiekolwiek błędy lub anomalie,
  wypisz obiekt JSON z severity i message" \
  --output-format stream-json | \
jq -c 'select(.severity == "high")' | \
while read alert; do
  # Wyślij do systemu alertów
  curl -X POST https://alerts.example.com/webhook \
    -H "Content-Type: application/json" \
    -d "$alert"
done

Automatyzacja wielu instancji

Przepływy pracy przetwarzania równoległego

Uruchom wiele instancji Claude dla masowej paralelizacji:

parallel-refactor.sh

#!/bin/bash
# Utwórz katalogi robocze
for i in {1..4}; do
  git worktree add "../refactor-$i" "refactor-branch-$i"
done

# Uruchom równoległe instancje Claude
tmux new-session -d -s refactor-1 'cd ../refactor-1 && claude -p "Refaktoryzuj moduł uwierzytelniania"'
tmux new-session -d -s refactor-2 'cd ../refactor-2 && claude -p "Refaktoryzuj zarządzanie użytkownikami"'
tmux new-session -d -s refactor-3 'cd ../refactor-3 && claude -p "Refaktoryzuj przetwarzanie płatności"'
tmux new-session -d -s refactor-4 'cd ../refactor-4 && claude -p "Refaktoryzuj system powiadomień"'

# Monitoruj postęp
watch -n 5 'tmux list-sessions'

Skoordynowane aktualizacje wielu serwisów

Automatyzuj zmiany w wielu serwisach:

update-api-version.sh

#!/bin/bash
services=("user-service" "order-service" "payment-service" "notification-service")
new_version="v2.0"

for service in "${services[@]}"; do
  echo "Aktualizacja $service do API $new_version..."

  cd "../$service" || continue

  claude -p "Zaktualizuj ten serwis aby używał API $new_version:
    1. Zaktualizuj bibliotekę kliencką do $new_version
    2. Zmodyfikuj wszystkie wywołania API aby używały nowych endpointów
    3. Zaktualizuj typy żądań/odpowiedzi
    4. Uruchom testy aby zweryfikować
    5. Commituj z wiadomością: 'chore: update to API $new_version'
    " --allowedTools all --dangerously-skip-permissions

  # Wypchnij zmiany
  git push origin "api-update-$new_version"
done

# Utwórz PR dla wszystkich serwisów
gh pr create --title "Zaktualizuj wszystkie serwisy do API $new_version" \
  --body "Automatyczna aktualizacja wszystkich serwisów aby używały API $new_version"

Wzorce automatyzacji korporacyjnej

Automatyzacja zgodności

Automatyzuj sprawdzenia bezpieczeństwa i zgodności:

{
  "hooks": [
    {
      "matcher": "UserPromptSubmit",
      "hooks": [
        {
          "type": "command",
          "command": "./scripts/compliance-check.sh \"$CLAUDE_USER_PROMPT\""
        }
      ]
    },
    {
      "matcher": "Write|Edit",
      "hooks": [
        {
          "type": "command",
          "command": "./scripts/security-scan.sh \"$CLAUDE_FILE_PATHS\""
        }
      ]
    }
  ]
}

Potok generowania dokumentacji

Automatycznie utrzymuj dokumentację:

.claude/commands/release.md

Przygotuj wydanie $ARGUMENTS:

1. Wygeneruj changelog z commitów git
2. Zaktualizuj numery wersji we wszystkich plikach
3. Wygeneruj dokumentację API
4. Zaktualizuj dokumentację SDK
5. Utwórz przewodnik migracji jeśli potrzeba
6. Wygeneruj notatki wydania
7. Utwórz tag git
8. Zbuduj i przetestuj artefakty wydania

Używaj naszych standardowych szablonów i podążaj za semantic versioning.

Monitorowanie i observability

Śledź użycie Claude Code dla insights:

.claude/hooks/usage-tracker.sh

#!/bin/bash
# Loguj wszystkie użycia narzędzi
echo "{
  \"timestamp\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\",
  \"session_id\": \"$CLAUDE_SESSION_ID\",
  \"tool\": \"$CLAUDE_TOOL_NAME\",
  \"files\": \"$CLAUDE_FILE_PATHS\",
  \"user\": \"$(whoami)\",
  \"project\": \"$(basename $(pwd))\"
}" >> ~/.claude/usage.jsonl

# Wyślij do systemu monitoringu
if [ "$CLAUDE_TOOL_NAME" = "Stop" ]; then
  # Sesja zakończona, wyślij metryki
  curl -X POST https://metrics.example.com/claude-usage \
    -H "Content-Type: application/json" \
    -d @~/.claude/usage.jsonl

  # Wyczyść log
  > ~/.claude/usage.jsonl
fi

Najlepsze praktyki

Wytyczne automatyzacji

RÓB:

• Zacznij prosto i stopniowo dodawaj złożoność
• Testuj hooki dokładnie przed wdrożeniem
• Używaj timeoutów aby zapobiec zawieszaniu procesów
• Loguj wyniki automatyzacji do debugowania
• Używaj kontroli wersji dla skryptów automatyzacji
• Dziel się udanymi wzorcami z zespołem

NIE RÓB:

• Nie automatyzuj nadmiernie do punktu utraty kontroli
• Nie pomijaj walidacji w zautomatyzowanych przepływach
• Nie ignoruj obsługi błędów w skryptach
• Nie używaj zbyt permisywnych list dozwolonych narzędzi
• Nie zapominaj dokumentować automatyzacji

Optymalizacja wydajności

Podczas budowania przepływów pracy automatyzacji, rozważ:

1. Minimalizuj ładowanie kontekstu - Używaj skoncentrowanych promptów w trybie headless
2. Grupuj podobne operacje - Przetwarzaj wiele plików w jednej sesji
3. Cache’uj częste operacje - Przechowuj wyniki kosztownych obliczeń
4. Używaj odpowiednich modeli - Sonnet 4 dla prostych zadań, Opus 4 dla złożonego rozumowania
5. Monitoruj użycie tokenów - Śledź koszty w zautomatyzowanych przepływach

Względy bezpieczeństwa

Uwaga

Podczas automatyzacji z Claude Code:

• Nigdy nie przechowuj kluczy API w skryptach - używaj zmiennych środowiskowych
• Waliduj wszystkie wejścia w hookach aby zapobiec atakom injection
• Używaj minimalnych uprawnień narzędzi w trybie headless
• Audytuj logi automatyzacji regularnie
• Implementuj rate limiting dla wywołań API

Podsumowanie

Automatyzacja skryptów w Claude Code przekształca powtarzalne zadania w magię działającą w tle. Opanowując hooki, niestandardowe polecenia, tryb headless i wzorce automatyzacji, tworzysz przepływy pracy, które obsługują nudne czynności podczas gdy Ty skupiasz się na kreatywnych. Zacznij od prostych hooków formatowania, stopniowo buduj swoją bibliotekę poleceń, a wkrótce będziesz mieć zestaw automatyzacji, który sprawi że cały Twój zespół będzie bardziej produktywny. Kluczem jest znalezienie właściwej równowagi – automatyzuj powtarzalne, ale zachowaj ludzki nadzór nad krytycznymi.