# Programmatisches Ausführen GitHub Copilot CLI

Verwenden Sie Copilot CLI im Terminal, in Skripts oder in Aktionsworkflows.

## Einführung

Sie können eine Eingabeaufforderung direkt in einem einzigen Befehl an Copilot CLI übergeben, ohne eine interaktive Sitzung zu starten. Dies ermöglicht es Ihnen, Copilot direkt vom Terminal aus zu nutzen und die CLI programmgesteuert in Skripten, CI/CD-Pipelines und Automatisierungsworkflows einzusetzen.

Um programmgesteuert zu verwenden Copilot CLI , können Sie eine der folgenden Aktionen ausführen:

* Verwenden Sie den `copilot` Befehl mit der `-p` oder `--prompt` Befehlszeilenoption, gefolgt von Ihrer Eingabeaufforderung.

  ```shell copy
  copilot -p "Explain this file: ./complex.ts"
  ```

* Leiten Sie eine Eingabeaufforderung an den `copilot`-Befehl weiter:

  ```shell copy
  echo "Explain this file: ./complex.ts" | copilot
  ```

  > \[!NOTE]
  > Piped Input wird ignoriert, wenn du auch einen Prompt mit der Option `-p` oder `--prompt` angibst.

## Tipps zur programmgesteuerten Nutzung von Copilot CLI

* **Geben Sie präzise Eingabeaufforderungen an –** klare, eindeutige Anweisungen liefern bessere Ergebnisse als vage Anfragen. Je mehr Kontext Sie geben – Dateinamen, Funktionsnamen, die genaue Änderung – desto weniger muss Copilot raten.
* **Schreibe Prompts sorgfältig in Anführungszeichen** – verwende einfache Anführungszeichen um deinen Prompt herum, wenn du die Interpretation von Sonderzeichen durch die Shell vermeiden willst.
* **Geben Sie immer minimale Berechtigungen –** verwenden Sie die `--allow-tool=[TOOLS...]``--allow-url=[URLs...]` Befehlszeilenoptionen, um Copilot nur die Tools und den Zugriff zu erteilen, die zum Ausführen der Aufgabe erforderlich sind. Vermeiden Sie die Verwendung von allzu großzügigen Optionen (z. B. `--allow-all`), es sei denn, Sie arbeiten in einer Sandbox-Umgebung. Weitere Informationen findest du unter [Informationen zu Cloud- und lokalen Sandboxes für GitHub Copilot](/de/copilot/concepts/about-cloud-and-local-sandboxes).
* Beim Erfassen der Ausgabe **wird `-s` (still)** verwendet. Dadurch werden Sitzungsmetadaten unterdrückt, sodass Sie sauberen Text erhalten.
* **Verwenden `--no-ask-user`** um zu verhindern, dass der Agent versucht, Klarstellungsfragen zu stellen.
* **Legen Sie ein Modell explizit** mit `--model` fest, um ein konsistentes Verhalten über alle Umgebungen hinweg zu gewährleisten.

Unter [Programmgesteuerte Referenz für die GitHub Copilot-CLI](/de/copilot/reference/copilot-cli-reference/cli-programmatic-reference) finden Sie Optionen, die bei der programmgesteuerten Ausführung Copilot CLI besonders nützlich sind.

## CI/CD-Integration

Ein gängiger Anwendungsfall für die programmgesteuerte Ausführung Copilot CLI besteht darin, einen CLI-Befehl in einen CI/CD-Workflowschritt einzuschließen.

Dieser Extrakt aus einem GitHub Actions Workflow zeigt ein einfaches Beispiel für das Ausführen eines Copilot CLI Befehls.

```yaml
# Workflow step using Copilot CLI
- name: Generate test coverage report
  env:
    COPILOT_GITHUB_TOKEN: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
  run: |
    copilot -p "Run the test suite and produce a coverage summary" \
      -s --allow-tool='shell(npm:*), write' --no-ask-user
```

Weitere Informationen findest du unter [Automatisieren von Aufgaben mit Copilot CLI und GitHub Actions](/de/copilot/how-tos/copilot-cli/automate-copilot-cli/automate-with-actions).

## Beispiele für die programmgesteuerte Verwendung

### Generieren einer Commit-Nachricht

```bash copy
copilot -p 'Write a commit message in plain text for the staged changes' -s \
  --allow-tool='shell(git:*)'
```

### Zusammenfassen einer Datei

```bash copy
copilot -p 'Summarize what src/auth/login.ts does in no more than 100 words' -s
```

### Schreiben von Tests für ein Modul

```bash copy
copilot -p 'Write unit tests for src/utils/validators.ts' \
  --allow-tool='write, shell(npm:*), shell(npx:*)'
```

### Beheben von Lintfehlern

```bash copy
copilot -p 'Fix all ESLint errors in this project' \
  --allow-tool='write, shell(npm:*), shell(npx:*), shell(git:*)'
```

### Erklärung eines diff

```bash copy
copilot -p 'Explain the changes in the latest commit on this branch and flag any potential issues' -s
```

### Code-Review eines Branches

Verwende den Schrägstrichbefehl `/review`, damit der integrierte `code-review`-Agent die Code-Änderungen in der aktuellen Verzweigung überprüft.

```bash copy
copilot -p '/review the changes on this branch compared to main. Focus on bugs and security issues.' \
  -s --allow-tool='shell(git:*)'
```

### Dokumentation generieren

```bash copy
copilot -p 'Generate JSDoc comments for all exported functions in src/api/' \
  --allow-tool=write
```

### Exportieren einer Sitzung

Speichern Sie das vollständige Sitzungstranskript in einer Markdown-Datei im lokalen Dateisystem.

```bash copy
copilot -p "Audit this project's dependencies for vulnerabilities" \
  --allow-tool='shell(npm:*), shell(npx:*)' \
  --share='./audit-report.md'
```

Speichern Sie das Sitzungstranskript in einem Gist auf GitHub.com, um die Freigabe zu erleichtern.

```bash copy
copilot -p 'Summarize the architecture of this project' --share-gist
```

> \[!NOTE]
> Gists sind nicht verfügbar für Enterprise Managed Users, oder wenn Sie GitHub Enterprise Cloud mit Datenresidenz (\*.ghe.com) verwenden.

## Shell-Skript-Muster

### Erfassen Sie die Ausgabe von Copilot in einer Variablen

```bash copy
result=$(copilot -p 'What version of Node.js does this project require? \
  Give the number only. No other text.' -s)
echo "Required Node version: $result"
```

### Verwendung in einer Bedingung

```bash copy
if copilot -p 'Does this project have any TypeScript errors? Reply only YES or NO.' -s \
  | grep -qi "no"; then
  echo "No type errors found."
else
  echo "Type errors detected."
fi
```

### Verarbeiten mehrerer Dateien

```bash copy
for file in src/api/*.ts; do
  echo "--- Reviewing $file ---" | tee -a review-results.md
  copilot -p "Review $file for error handling issues" -s --allow-all-tools | tee -a review-results.md
done
```

## Weiterführende Lektüre

* [GitHub Copilot CLI](/de/copilot/how-tos/copilot-cli)
* [Programmgesteuerte Referenz für die GitHub Copilot-CLI](/de/copilot/reference/copilot-cli-reference/cli-programmatic-reference)
* [GitHub Copilot CLI-Befehlsreferenz](/de/copilot/reference/copilot-cli-reference/cli-command-reference#command-line-options)