# Referenz zum Werkzeugsystem (/de/docs/verdent-for-vscode/advanced-features/tool-reference)

> Vollständige Referenz für das Werkzeugsystem von Verdent



### Was Sie lernen werden [#was-sie-lernen-werden]

Umfassende Referenz für das integrierte Werkzeugsystem von Verdent, einschließlich Dateioperationen, Suchfunktionen, Befehlsausführung und Integrationswerkzeugen.

***

## Übersicht der verfügbaren Werkzeuge [#übersicht-der-verfügbaren-werkzeuge]

Verdent for VS Code bietet ein umfassendes Toolkit für Codebearbeitung, Navigation und externe Interaktion.

<Tabs>
  <Tab title="Dateioperationen">
    | Werkzeug     | Zweck                                | Wichtige Fähigkeiten                                                               |
    | ------------ | ------------------------------------ | ---------------------------------------------------------------------------------- |
    | `file_read`  | Dateiinhalte lesen                   | Unterstützt Zeilenbereiche für große Dateien, funktioniert mit allen Textformaten  |
    | `file_edit`  | Gezielte Änderungen                  | Ersetzt exakte Textübereinstimmungen, mehrere Ersetzungen, erhält die Formatierung |
    | `file_write` | Dateien erstellen oder überschreiben | Vollständige Dateierstellung/-ersetzung, verarbeitet Textinhalte                   |
  </Tab>

  <Tab title="Suche & Navigation">
    | Werkzeug       | Zweck                          | Wichtige Fähigkeiten                                                   |
    | -------------- | ------------------------------ | ---------------------------------------------------------------------- |
    | `glob`         | Musterbasierte Dateisuche      | Glob-Muster (`**/*.ts`), Ausschlussmuster, Begrenzung der Ergebnisse   |
    | `grep_content` | Inhaltssuche mit Kontext       | Regex-Unterstützung, Kontextzeilen, Optionen für Groß-/Kleinschreibung |
    | `grep_file`    | Dateien mit Treffern auflisten | Schnelles Identifizieren von Dateien vor dem Lesen der Inhalte         |
    | `list_dir`     | Verzeichnisstruktur            | Zeigt Hierarchie, Ausschlussmuster, Tiefensteuerung                    |
  </Tab>

  <Tab title="Ausführung & Integration">
    | Werkzeug         | Zweck                         | Wichtige Fähigkeiten                                                      |
    | ---------------- | ----------------------------- | ------------------------------------------------------------------------- |
    | `bash`           | Ausführung von Shell-Befehlen | Timeout-Konfiguration, zusammenfassende Beschreibungen, Befehlsverkettung |
    | `spawn_subagent` | Delegation an Spezialisten    | Startet allgemeine, Explorer-, Verifier- oder Code-Reviewer-Subagenten    |
    | `todo_update`    | Aufgabenfortschritt verfolgen | Verwaltet Aufgabenlisten, aktualisiert den Status, Fortschrittsverfolgung |
  </Tab>

  <Tab title="Webzugriff">
    | Werkzeug     | Zweck                          | Wichtige Fähigkeiten                                                             |
    | ------------ | ------------------------------ | -------------------------------------------------------------------------------- |
    | `web_search` | Internetsuche                  | Ausführung von Abfragen, Steuerung der Ergebnisanzahl, Filterung nach Aktualität |
    | `web_fetch`  | Seiten abrufen und analysieren | Ruft Inhalte ab, extrahiert Informationen anhand von Abfragen                    |
  </Tab>
</Tabs>

***

## Werkzeugfähigkeiten und Anwendungsfälle [#werkzeugfähigkeiten-und-anwendungsfälle]

<Tabs>
  <Tab title="Dateioperationen">
    ### file\_read [#file_read]

    **Fähigkeiten:**

    * Liest vollständige Dateiinhalte oder bestimmte Zeilenbereiche
    * Unverzichtbar, um Code vor Änderungen zu verstehen
    * Effiziente Verarbeitung großer Dateien durch Bereichsangabe

    **Anwendungsfälle:**

    * Lesen von Konfigurationsdateien vor der Bearbeitung
    * Verstehen bestehender Implementierungsmuster
    * Überprüfen von Testdateien, um die Testabdeckung zu verstehen

    **Beispiel:**

    ```bash
    # Read entire file
    file_read("src/components/Button.tsx")

    # Read specific range for large files
    file_read("package-lock.json", start_line=1, max_lines=50)
    ```

    ***

    ### file\_edit [#file_edit]

    **Fähigkeiten:**

    * Präzise Textersetzung mittels exakter Zeichenkettenübereinstimmung
    * Mehrere Ersetzungsvorgänge mit dem Flag `multiple`
    * Erhält die Dateistruktur und Formatierung

    **Anwendungsfälle:**

    * Aktualisieren von Funktionsimplementierungen
    * Ändern von Konfigurationswerten
    * Umbenennen von Variablen über mehrere Dateien hinweg

    **Best Practice:** Für gezielte Änderungen verwenden. Für vollständige Neuschreibungen `file_write` stattdessen einsetzen.

    ***

    ### file\_write [#file_write]

    **Fähigkeiten:**

    * Erstellt neue Dateien von Grund auf
    * Ersetzt bestehende Dateiinhalte vollständig
    * Verarbeitet jedes textbasierte Format

    **Anwendungsfälle:**

    * Generieren neuer Komponenten oder Module
    * Erstellen von Konfigurationsdateien
    * Schreiben von Testdateien

    **Warnung:** Überschreibt bestehende Dateien vollständig. Für teilweise Änderungen `file_edit` verwenden.
  </Tab>

  <Tab title="Suche & Navigation">
    ### glob [#glob]

    **Fähigkeiten:**

    * Findet Dateien anhand von Mustern: `**/*.ts`, `src/**/*.js`
    * Filterung nach Verzeichnispfad
    * Ausschlussmuster zur Eingrenzung der Ergebnisse
    * Steuerung der Ergebnisanzahl

    **Anwendungsfälle:**

    * Auffinden aller Komponenten in einem Projekt
    * Lokalisieren von Testdateien
    * Identifizieren von Konfigurationsdateien über mehrere Verzeichnisse hinweg

    **Beispielmuster:**

    ```bash
    **/*.tsx          # All TypeScript React files
    src/**/*.test.js  # All test files in src
    **/config.*       # All config files anywhere
    ```

    ***

    ### grep\_content [#grep_content]

    **Fähigkeiten:**

    * Durchsucht Dateiinhalte mithilfe von Regex-Mustern
    * Zeigt Kontextzeilen vor/nach Treffern (Flags `-B`, `-A`)
    * Suche ohne Berücksichtigung der Groß-/Kleinschreibung
    * Filterung nach Dateityp mittels Glob-Mustern

    **Anwendungsfälle:**

    * Auffinden von Funktionsdefinitionen
    * Lokalisieren von API-Endpunktimplementierungen
    * Suchen nach bestimmten Fehlermeldungen
    * Identifizieren von Sicherheitsmustern

    **Beispiel:**

    ```bash
    # Find authentication-related code
    grep_content("auth.*login", glob="**/*.ts")

    # Search with context
    grep_content("TODO", glob="src/**", context_before=2, context_after=2)
    ```

    ***

    ### grep\_file [#grep_file]

    **Fähigkeiten:**

    * Listet Dateien mit Musterübereinstimmungen auf
    * Schneller als `grep_content`, wenn Sie nur Dateipfade benötigen
    * Unterstützung für Regex-Muster
    * Glob-Filterung nach Dateitypen

    **Anwendungsfälle:**

    * Identifizieren, welche Dateien überarbeitet werden müssen
    * Auffinden von Dateien, die bestimmte Module importieren
    * Lokalisieren von Dateien mit veralteten Mustern

    **Best Practice:** Zunächst `grep_file` verwenden, um relevante Dateien zu identifizieren, danach `file_read` für die detaillierte Untersuchung.

    ***

    ### list\_dir [#list_dir]

    **Fähigkeiten:**

    * Zeigt die Verzeichnishierarchie an
    * Steuerung der Tiefe mit dem Parameter `max_depth`
    * Ausschlussmuster zur Filterung der Ausgabe

    **Anwendungsfälle:**

    * Verstehen der Projektstruktur
    * Überprüfen der Verzeichnisorganisation
    * Auffinden bestimmter Unterverzeichnisse
  </Tab>

  <Tab title="Ausführung & Integration">
    ### bash [#bash]

    **Fähigkeiten:**

    * Führt Shell-Befehle aus
    * Maximales Timeout: 120 Sekunden (2 Minuten, feste Obergrenze)
    * Verkettung von Befehlen mit `&&` bei Abhängigkeiten
    * Liefert beschreibende Zusammenfassungen zur Klarheit

    **Anwendungsfälle:**

    * Ausführen von Tests
    * Erstellen von Projekten (Build)
    * Installieren von Abhängigkeiten
    * Git-Operationen
    * Datenbankmigrationen

    **Beispiel:**

    ```bash
    # Run tests
    bash("npm test", timeout=60000, summary="Run Jest test suite")

    # Chain dependent commands
    bash("npm install && npm run build", timeout=120000)
    ```

    **Sicherheit:** Befehle werden mit den Berechtigungen des Nutzers ausgeführt. Überprüfen Sie Befehle in Manual Accept Mode.

    ***

    ### spawn\_subagent [#spawn_subagent]

    **Fähigkeiten:**

    * Startet spezialisierte Subagenten mit isolierten Kontexten
    * Typen: `explorer`, `verifier`, `code-reviewer`
    * Delegiert komplexe Aufgaben, ohne den Hauptkontext zu belasten
    * Parallele Subagenten-Ausführung für mehr Effizienz

    **Anwendungsfälle:**

    * **Explorer:** Durchsuchen großer Codebasen nach Mustern
    * **Verifier:** Validierung der Implementierungslogik
    * **Code-reviewer:** Sicherheits- und Qualitätsbewertung

    **Best Practice:** Delegieren Sie explorative Recherchen an den Explorer-Subagenten, um den Kontext des Hauptgesprächs zu schonen.

    ***

    ### todo\_update [#todo_update]

    **Fähigkeiten:**

    * Erstellt und verwaltet Aufgabenlisten
    * Aktualisiert den Aufgabenstatus (ausstehend, in Bearbeitung, abgeschlossen)
    * Verfolgt den Fortschritt komplexer Implementierungen

    **Anwendungsfälle:**

    * Aufteilen mehrstufiger Funktionen
    * Nachverfolgen des Fortschritts bei Refactorings
    * Verwalten von Migrationsaufgaben
  </Tab>

  <Tab title="Webzugriff">
    ### web\_search [#web_search]

    **Fähigkeiten:**

    * Abfrage von Internetsuchmaschinen
    * Steuerung der Ergebnisanzahl
    * Filterung nach Aktualität (letzte Tage)

    **Anwendungsfälle:**

    * Auffinden von Dokumentation für unbekannte APIs
    * Recherchieren von Fehlermeldungen
    * Prüfen aktueller Best Practices

    ***

    ### web\_fetch [#web_fetch]

    **Fähigkeiten:**

    * Ruft Webseiteninhalte ab
    * Analysiert Inhalte anhand bestimmter Abfragen
    * Extrahiert strukturierte Informationen

    **Anwendungsfälle:**

    * Lesen von Dokumentationsseiten
    * Analysieren von API-Dokumentation
    * Extrahieren von Beispielen aus Tutorials
  </Tab>
</Tabs>

***

## Unterstützung von Dateiformaten [#unterstützung-von-dateiformaten]

Verdent funktioniert mit allen textbasierten Dateiformaten über seine Dateioperations-Werkzeuge.

<Tabs>
  <Tab title="Quellcode">
    | Kategorie      | Sprachen/Erweiterungen                              |
    | -------------- | --------------------------------------------------- |
    | **Web**        | JavaScript, TypeScript, HTML, CSS, SCSS, LESS       |
    | **Backend**    | Python, Java, Go, Rust, C, C++, C#, Ruby, PHP, Perl |
    | **Mobile**     | Swift, Kotlin, Dart (Flutter), Objective-C          |
    | **Funktional** | Haskell, Scala, Elixir, Clojure, F#                 |
    | **Skripting**  | Bash, PowerShell, Zsh, Fish                         |
    | **Daten**      | SQL, R, Julia, MATLAB                               |
  </Tab>

  <Tab title="Konfiguration">
    | Format   | Häufige Beispiele                                              |
    | -------- | -------------------------------------------------------------- |
    | **JSON** | package.json, tsconfig.json, settings.json                     |
    | **YAML** | docker-compose.yml, GitHub Actions, Kubernetes-Konfigurationen |
    | **TOML** | Cargo.toml, pyproject.toml                                     |
    | **XML**  | pom.xml, web.xml, Konfigurationsdateien                        |
    | **INI**  | .gitconfig, .editorconfig                                      |
    | **ENV**  | .env-Dateien, Umgebungskonfiguration                           |
    | **HCL**  | Terraform-Konfiguration                                        |
  </Tab>

  <Tab title="Dokumentation">
    | Format               | Anwendungsfälle                                   |
    | -------------------- | ------------------------------------------------- |
    | **Markdown**         | README.md, Dokumentationsdateien                  |
    | **HTML**             | Vorlagen, Webseiten                               |
    | **LaTeX**            | Wissenschaftliche Dokumente, akademische Arbeiten |
    | **reStructuredText** | Python-Dokumentation                              |
    | **AsciiDoc**         | Technische Dokumentation                          |
  </Tab>

  <Tab title="Daten & Build">
    ### Datenformate [#datenformate]

    | Format                 | Beschreibung                  |
    | ---------------------- | ----------------------------- |
    | **CSV/TSV**            | Tabellarische Datendateien    |
    | **Textbasierte Daten** | Logdateien, Datenauszüge      |
    | **JSON/YAML**          | Strukturierter Datenaustausch |

    ### Build- und Paketdateien [#build--und-paketdateien]

    | Datei                | Zweck                  |
    | -------------------- | ---------------------- |
    | **Makefile**         | Build-Automatisierung  |
    | **package.json**     | Node.js-Abhängigkeiten |
    | **requirements.txt** | Python-Pakete          |
    | **Gemfile**          | Ruby-Gems              |
    | **Cargo.toml**       | Rust-Pakete            |
    | **build.gradle**     | Gradle-Builds          |
  </Tab>

  <Tab title="Einschränkungen bei Binärdateien">
    | Formattyp                    | Beispiele                  | Bearbeitbarkeit          |
    | ---------------------------- | -------------------------- | ------------------------ |
    | **Bilder**                   | PNG, JPG, GIF, SVG (binär) | Nicht direkt bearbeitbar |
    | **Videos**                   | MP4, AVI, MOV              | Nicht direkt bearbeitbar |
    | **Kompilierte Binärdateien** | EXE, DLL, SO               | Nicht direkt bearbeitbar |
    | **Archive**                  | ZIP, TAR, GZ               | Nicht direkt bearbeitbar |
    | **Office-Dokumente**         | DOCX, XLSX, PPTX           | Nicht direkt bearbeitbar |
    | **PDFs**                     | PDF-Dateien                | Nicht direkt bearbeitbar |

    <Note>
      Binärdateien können im Code referenziert werden, lassen sich aber nicht über die Datei-Werkzeuge ändern.
    </Note>
  </Tab>
</Tabs>

***

## Unterstützung von Programmiersprachen [#unterstützung-von-programmiersprachen]

Verdent bietet umfassende Unterstützung für alle textbasierten Programmiersprachen und Frameworks.

<Tabs>
  <Tab title="Webentwicklung">
    | Sprache/Framework | Unterstützungsniveau | Häufige Anwendungsfälle                          |
    | ----------------- | -------------------- | ------------------------------------------------ |
    | JavaScript        | Ausgezeichnet        | Frontend-Logik, Node.js-Backends, Tooling        |
    | TypeScript        | Ausgezeichnet        | Typsichere Webanwendungen, große Projekte        |
    | React             | Ausgezeichnet        | Komponentenbasierte UIs, Hooks, State-Management |
    | Vue               | Ausgezeichnet        | Progressive Web-Apps, Single-File-Komponenten    |
    | Angular           | Ausgezeichnet        | Unternehmensanwendungen, TypeScript-Integration  |
    | Svelte            | Sehr gut             | Kompilierte Komponenten, reaktive Programmierung |
    | HTML/CSS          | Ausgezeichnet        | Markup, Styling, responsives Design              |
    | SCSS/LESS         | Ausgezeichnet        | Fortgeschrittenes Styling, Variablen, Mixins     |
  </Tab>

  <Tab title="Backend">
    | Sprache/Framework    | Unterstützungsniveau | Häufige Anwendungsfälle                          |
    | -------------------- | -------------------- | ------------------------------------------------ |
    | Python               | Ausgezeichnet        | APIs, Datenverarbeitung, Automatisierung         |
    | Django/Flask/FastAPI | Ausgezeichnet        | Webframeworks, REST-APIs                         |
    | Node.js/Express      | Ausgezeichnet        | JavaScript-Backends, Microservices               |
    | Java/Spring          | Ausgezeichnet        | Unternehmensanwendungen, Spring Boot             |
    | Go                   | Ausgezeichnet        | Hochleistungsdienste, CLIs                       |
    | Rust                 | Sehr gut             | Systemprogrammierung, performancekritischer Code |
    | C/C++                | Sehr gut             | Systeme, Embedded, Game-Engines                  |
    | C# / .NET            | Ausgezeichnet        | Windows-Anwendungen, Webdienste, Unity           |
    | Ruby/Rails           | Sehr gut             | Webanwendungen, schnelle Entwicklung             |
    | PHP                  | Gut                  | WordPress, Laravel, Legacy-Anwendungen           |
  </Tab>

  <Tab title="Mobile">
    | Sprache/Framework | Unterstützungsniveau | Häufige Anwendungsfälle            |
    | ----------------- | -------------------- | ---------------------------------- |
    | Swift             | Ausgezeichnet        | Native iOS/macOS-Apps              |
    | Kotlin            | Ausgezeichnet        | Native Android-Apps                |
    | Dart/Flutter      | Ausgezeichnet        | Plattformübergreifende mobile Apps |
    | React Native      | Ausgezeichnet        | JavaScript-basierte mobile Apps    |
    | Objective-C       | Gut                  | Legacy-iOS/macOS-Apps              |
  </Tab>

  <Tab title="Daten & Wissenschaft">
    | Sprache | Unterstützungsniveau | Häufige Anwendungsfälle                        |
    | ------- | -------------------- | ---------------------------------------------- |
    | Python  | Ausgezeichnet        | NumPy, Pandas, scikit-learn, TensorFlow        |
    | R       | Sehr gut             | Statistische Analyse, Datenvisualisierung      |
    | SQL     | Ausgezeichnet        | Datenbankabfragen, Schemadesign                |
    | Julia   | Gut                  | Wissenschaftliches Rechnen, numerische Analyse |
  </Tab>

  <Tab title="Systeme & Low-Level">
    | Sprache   | Unterstützungsniveau | Häufige Anwendungsfälle              |
    | --------- | -------------------- | ------------------------------------ |
    | C         | Sehr gut             | Systemprogrammierung, Embedded       |
    | C++       | Sehr gut             | Performancekritische Anwendungen     |
    | Rust      | Sehr gut             | Speichersichere Systemprogrammierung |
    | Go        | Ausgezeichnet        | Nebenläufige Systeme, Clouddienste   |
    | Assembler | Gut                  | Low-Level-Optimierung, Debugging     |
  </Tab>
</Tabs>

**Qualität der Unterstützung:** Gängige Sprachen (JavaScript, Python, TypeScript) verfügen aufgrund umfangreicher Trainingsdaten über eine stärkere Unterstützung. Weniger verbreitete oder domänenspezifische Sprachen können eine geringere Unterstützungsqualität aufweisen, bleiben aber funktionsfähig.

***

## Nutzungsgrenzen und Best Practices [#nutzungsgrenzen-und-best-practices]

<Tabs>
  <Tab title="Dateioperationen">
    ### Effizienz von file\_read [#effizienz-von-file_read]

    **Best Practices:**

    * Verwenden Sie Zeilenbereiche für Dateien mit mehr als 500 Zeilen, um eine Überlastung des Kontexts zu vermeiden
    * Lesen Sie nur die für die Aufgabe relevanten Abschnitte
    * Bei großen Dateien zunächst `grep_content` verwenden, um relevante Zeilennummern zu identifizieren

    ```bash
    # Good: Read specific section
    file_read("large-config.json", start_line=100, max_lines=50)

    # Less efficient: Read entire large file
    file_read("large-config.json")  # May consume excessive context
    ```

    ***

    ### Präzision von file\_edit [#präzision-von-file_edit]

    **Best Practices:**

    * Stellen Sie exakte Zeichenkettenübereinstimmungen sicher, um fehlgeschlagene Bearbeitungen zu vermeiden
    * Für mehrere ähnliche Änderungen das Flag `multiple=true` verwenden
    * Dateipfade vor der Bearbeitung überprüfen

    ***

    ### Sicherheit von file\_write [#sicherheit-von-file_write]

    **Best Practices:**

    * Pfade doppelt prüfen, um versehentliches Überschreiben zu verhindern
    * Nur für neue Dateien oder vollständige Neuschreibungen verwenden
    * Für Änderungen aus Sicherheitsgründen `file_edit` bevorzugen
  </Tab>

  <Tab title="Suche & Navigation">
    ### Spezifität von glob-Mustern [#spezifität-von-glob-mustern]

    **Best Practices:**

    * Verwenden Sie spezifische Muster, um den Umfang einzugrenzen: `src/**/*.ts` anstelle von `**/*`
    * Verzeichnisse mit Ausschlussmustern ausschließen: `!**/node_modules/**`
    * Ergebnisse begrenzen, um eine übermäßige Ausgabe zu vermeiden

    ```bash
    # Good: Specific scope
    glob("src/components/**/*.tsx", max_results=50)

    # Less efficient: Too broad
    glob("**/*")  # Returns thousands of results
    ```

    ***

    ### grep-Strategie [#grep-strategie]

    **Empfohlener Arbeitsablauf:**

    1. `grep_file` verwenden, um relevante Dateien zu identifizieren
    2. Bestimmte Dateien mit `file_read` lesen
    3. `grep_content` verwenden, wenn Sie den umgebenden Kontext benötigen

    **Leistungstipps:**

    * Regex-Muster können länger dauern als literale Zeichenketten
    * Suchen ohne Berücksichtigung der Groß-/Kleinschreibung sind langsamer
    * Kontextzeilen (`-A`, `-B`) auf das Notwendige begrenzen
  </Tab>

  <Tab title="Befehlsausführung">
    ### Best Practices für bash [#best-practices-für-bash]

    **Sichere Befehlsausführung:**

    * Klare Zusammenfassungen für Befehlsbeschreibungen liefern
    * Angemessene Timeouts für lang laufende Operationen festlegen
    * Abhängige Befehle mit `&&` verketten
    * Destruktive Befehle sorgfältig prüfen (rm, drop, truncate)

    ```bash
    # Good: Clear summary, reasonable timeout
    bash("npm run build", timeout=120000, summary="Build production bundle")

    # Good: Chained dependencies
    bash("npm install && npm run test", timeout=180000)
    ```

    ***

    ### Sicherheitsüberlegungen [#sicherheitsüberlegungen]

    **Kritische Sicherheitsregeln:**

    * Befehle werden mit den Berechtigungen des Nutzers ausgeführt
    * Niemals nicht vertrauenswürdige Befehle ausführen
    * Manual Accept Mode für die Überprüfung in gemeinsam genutzten Codebasen verwenden
    * Befehle vermeiden, die Zugangsdaten oder sensible Daten offenlegen

    <Warning>
      Überprüfen Sie bash-Befehle in Manual Accept Mode immer, wenn Sie in gemeinsam genutzten Codebasen oder Produktionsumgebungen arbeiten.
    </Warning>
  </Tab>

  <Tab title="Subagenten & Kontext">
    ### Effizienz der Subagenten-Delegation [#effizienz-der-subagenten-delegation]

    **Wann Subagenten verwendet werden sollten:**

    * **Explorer:** Codebasis-Suchen, Architekturfragen (schont den Hauptkontext)
    * **Verifier:** Schnelle Validierungsprüfungen (isolierte Verifikation)
    * **Code-reviewer:** Sicherheits- und Qualitätsprüfungen (detaillierte Analyse)
    * **General:** Komplexe mehrstufige Aufgaben (parallele Ausführung)

    **Best Practice:**
    Delegieren Sie explorative und recherchierende Aufgaben an Subagenten, um den Kontext des Hauptgesprächs für die aktive Entwicklungsarbeit zu schonen.

    ***

    ### Kontextverwaltung [#kontextverwaltung]

    **Strategische Werkzeugnutzung:**

    * Dateien strategisch lesen – nur das, was benötigt wird
    * Subagenten für Hintergrundrecherchen verwenden
    * Kontextverbrauch während langer Sitzungen überwachen
    * Komplexe Vorgänge mit todo\_update in Schritte aufteilen

    **Effiziente Arbeitsabläufe:**

    1. **Planung:** glob/grep verwenden, um den Umfang zu bestimmen
    2. **Lesen:** Nur relevante Dateien/Abschnitte lesen
    3. **Ausführung:** Bei Bedarf an Subagenten delegieren
    4. **Verifikation:** Schnelle Prüfungen mit dem Verifier-Subagenten
  </Tab>

  <Tab title="Leistung">
    ### Dateigrößenbeschränkungen [#dateigrößenbeschränkungen]

    **Umgang mit großen Dateien:**
    Sehr große Dateien (>10.000 Zeilen) sollten abschnittsweise gelesen werden, um Folgendes zu vermeiden:

    * Erschöpfung des Kontextfensters
    * Langsame Antwortzeiten
    * Speicherprobleme

    <Tip>
      Verwenden Sie für Dateien mit mehr als 500 Zeilen stets Zeilenbereiche mit `file_read`, um eine optimale Leistung zu erhalten.
    </Tip>

    ***

    ### Standard-Timeouts der Werkzeuge [#standard-timeouts-der-werkzeuge]

    **Werkzeuggrenzen:**

    * **Bash-Timeout:** maximal 120 Sekunden (2 Minuten)
    * **Dateioperationen:** keine Größenbeschränkungen (große Dateien werden automatisch in Batches gelesen)
    * **Umgang mit großen Dateien:** Dateien >256 KB liefern nur die ersten 256 KB des Inhalts zurück
    * **Suchergebnisse:** keine Begrenzungen bei den Ergebnissen von `glob` oder `grep_content`
    * **Gleichzeitige Subagenten:** keine Begrenzung bei der parallelen Ausführung

    **Timeout-Konfiguration:**

    * Explizite Timeouts für lang laufende Operationen festlegen
    * Auf hängende Prozesse achten
    * Befehle, die das 2-Minuten-Timeout überschreiten, werden beendet

    ***

    ### Gleichzeitige Operationen [#gleichzeitige-operationen]

    **Parallele Ausführung:**
    Mehrere Subagenten können parallel ausgeführt werden, um komplexe Vorgänge zu beschleunigen. Der Hauptagent übernimmt die Koordination automatisch.

    **Leistungsvorteile:**

    * Verkürzte Gesamtausführungszeit bei mehrstufigen Aufgaben
    * Effiziente Ressourcennutzung
    * Automatische Aufgabenorchestrierung
    * Keine Begrenzung bei der Anzahl gleichzeitiger Subagenten
  </Tab>
</Tabs>

***

## Siehe auch [#siehe-auch]

<CardGroup cols="2">
  <Card title="Subagenten-Verwaltung" icon="users" href="/docs/verdent-for-vscode/agents-rules/subagent-management">
    Erfahren Sie mehr über spezialisierte Agenten
  </Card>

  <Card title="Ausführungsmodi" icon="sliders" href="/docs/verdent-for-vscode/execution-modes/overview">
    Steuern Sie die Werkzeugausführung mit Modi
  </Card>
</CardGroup>