KI Agent für 10 IDEs: So geht die Umwandlung

Kurz gesagt

Eine KI-Agenten-Datei in 3 Schritten in 10 IDEs konvertieren: (1) YAML-Frontmatter mit den Bash-Funktionen get_field(), get_body() und to_kebab() parsen, (2) mit convert.sh in werkzeugspezifische Formate umwandeln (Claude Code .md, Cursor .mdc, Aider CONVENTIONS.md, Windsurf .windsurfrules), (3) mit install.sh in die richtigen Pfade installieren. Einmal schreiben, automatisch konvertieren, überall bereitstellen.

Eine Agenten-Datei. Zehn IDEs. Erfahren Sie, wie das Agency-Projekt eine einzelne Markdown-Datei so konvertiert, dass sie über Claude Code, Cursor, Aider, Windsurf, GitHub Copilot und 6+ weitere Tools hinweg funktioniert.

Sie schreiben einen KI-Agenten. Jetzt möchten Sie ihn verfügbar machen in:

Claude Code (.md-Dateien in ~/.claude/agents/)
Cursor (.mdc-Dateien in .cursor/rules/)
Aider (eine einzelne CONVENTIONS.md im Projekt-Stammverzeichnis)
Windsurf (eine einzelne .windsurfrules-Datei)
GitHub Copilot (.md-Dateien in ~/.github/agents/)
Und 5+ weitere Tools

Schreiben Sie 10 Versionen? Nein. Sie schreiben einmal, konvertieren automatisch.

Das Agency-Projekt löst dies mit zwei Bash-Skripten:

convert.sh — Wandelt Agenten-Dateien in werkzeugspezifische Formate um
install.sh — Kopiert konvertierte Dateien an die richtigen Pfade

In diesem Tutorial werden Sie beide Skripte analysieren und nachvollziehen. Sie lernen, wie man YAML-Frontmatter parst, den Hauptinhalt extrahiert und Konvertierungs-Pipelines für jedes Tool erstellt.

💡

Ganz gleich, ob Sie Agenten für API-Entwicklungsworkflows mit Apidog-Integration bereitstellen oder spezialisierte Test-Agenten erstellen, das Konvertierungssystem stellt sicher, dass sie in allen bevorzugten IDEs Ihres Teams funktionieren.

button

Das Agentenformat

Jeder Agent in The Agency verwendet die gleiche Struktur:

---
name: API Tester
description: Specialized in API testing with Apidog, Postman, and automated validation
color: purple
emoji: 🧪
vibe: Breaks APIs before users do.
---

# API Tester Agent Personality

You are **API Tester**, an expert in API validation...

## Identity & Memory
- Role: API testing specialist
- Personality: Thorough, skeptical, evidence-focused
...

Die Datei hat zwei Teile:

Frontmatter — YAML-Metadaten zwischen den ----Trennzeichen
Hauptteil — Markdown-Inhalt nach dem zweiten ---

Konvertierung bedeutet: Frontmatter-Felder extrahieren, den Hauptteil in das Zielformat umwandeln, in den richtigen Pfad schreiben.

Schritt 1: YAML-Frontmatter parsen

Erstellen Sie parse-frontmatter.sh:

#!/usr/bin/env bash
#
# parse-frontmatter.sh — Extrahiert YAML-Frontmatter-Felder aus Agenten-Dateien
#

set -euo pipefail

# Extrahiert einen einzelnen Feldwert aus dem YAML-Frontmatter
# Verwendung: get_field <Feld> <Datei>
get_field() {
  local field="$1" file="$2"
  awk -v f="$field" '
    /^---$/ { fm++; next }
    fm == 1 && $0 ~ "^" f ": " {
      sub("^" f ": ", "");
      print;
      exit
    }
  ' "$file"
}

# Entfernt Frontmatter, gibt nur den Hauptteil zurück
# Verwendung: get_body <Datei>
get_body() {
  awk 'BEGIN{fm=0} /^---$/{fm++; next} fm>=2{print}' "$1"
}

# Konvertiert Namen in kebab-case-Slug
# Verwendung: to_kebab "API Tester" → api-tester
to_kebab() {
  echo "$1" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9]/-/g' | sed 's/--*/-/g'
}

# Demo
if [[ "${1:-}" == "--demo" ]]; then
  AGENT_FILE="${2:-test-agent.md}"
  echo "Datei: $AGENT_FILE"
  echo "Name: $(get_field 'name' "$AGENT_FILE")"
  echo "Beschreibung: $(get_field 'description' "$AGENT_FILE")"
  echo "Slug: $(to_kebab "$(get_field 'name' "$AGENT_FILE")")"
  echo "---"
  echo "Vorschau Hauptteil:"
  get_body "$AGENT_FILE" | head -10
fi

Testen Sie es:

chmod +x parse-frontmatter.sh
./parse-frontmatter.sh --demo engineering-backend-architect.md

Ausgabe:

Datei: engineering-backend-architect.md
Name: Backend Architect
Beschreibung: Senior backend architect specializing in scalable system design...
Slug: backend-architect
---
Vorschau Hauptteil:
# Backend Architect Agent Personality

You are **Backend Architect**, a senior backend architect...

Schritt 2: In Claude Code-Format konvertieren

Claude Code verwendet reine .md-Dateien. Keine Konvertierung nötig – einfach kopieren:

convert_claude_code() {
  local agent_file="$1"
  local dest="$HOME/.claude/agents/"
  mkdir -p "$dest"
  cp "$agent_file" "$dest/"
  echo "  Claude Code: $(basename "$agent_file")"
}

Schritt 3: In Cursor-Format konvertieren

Cursor verwendet .mdc-Dateien mit einem Frontmatter-Feld für die Beschreibung:

convert_cursor() {
  local agent_file="$1"
  local name=$(get_field 'name' "$agent_file")
  local description=$(get_field 'description' "$agent_file")
  local slug=$(to_kebab "$name")
  local body=$(get_body "$agent_file")

  local output=".cursor/rules/agency-${slug}.mdc"
  mkdir -p "$(dirname "$output")"

  cat > "$output" << EOF
---
description: Agency agent: $description
---
$body
EOF

  echo "  Cursor: agency-${slug}.mdc"
}

Eingabe:

---
name: API Tester
description: Specialized in API testing...
---

# API Tester Agent...

Ausgabe (.mdc):

---
description: Agency agent: Specialized in API testing...
---

# API Tester Agent...

Schritt 4: In Aider-Format konvertieren

Aider verwendet eine einzelne CONVENTIONS.md-Datei, die alle Agenten enthält:

convert_aider() {
  local agent_file="$1"
  local output="CONVENTIONS.md"

  # Mit Trennzeichen anhängen
  echo "" >> "$output"
  echo "---" >> "$output"
  echo "" >> "$output"
  cat "$agent_file" >> "$output"

  echo "  Aider: angehängt an $output"
}

Die vollständige Datei erstellen:

build_aider() {
  local output="CONVENTIONS.md"
  echo "# Agency-Agenten für Aider" > "$output"
  echo "" >> "$output"
  echo "Diese Datei enthält alle Agency-Agenten für die Aider-Integration." >> "$output"
  echo "" >> "$output"

  for agent_file in engineering/*.md design/*.md testing/*.md; do
    convert_aider "$agent_file"
  done
}

Schritt 5: In Windsurf-Format konvertieren

Windsurf verwendet eine einzelne .windsurfrules-Datei (ähnlich wie Aider):

convert_windsurf() {
  local agent_file="$1"
  local output=".windsurfrules"

  echo "" >> "$output"
  echo "---" >> "$output"
  echo "" >> "$output"
  cat "$agent_file" >> "$output"

  echo "  Windsurf: angehängt an $output"
}

Schritt 6: In Antigravity-Format konvertieren

Antigravity (Gemini) verwendet SKILL.md-Dateien in Unterverzeichnissen:

convert_antigravity() {
  local agent_file="$1"
  local name=$(get_field 'name' "$agent_file")
  local slug=$(to_kebab "$name")
  local output="integrations/antigravity/skills/agency-${slug}/SKILL.md"

  mkdir -p "$(dirname "$output")"

  cat > "$output" << EOF
# Agency Agent: $name

$(get_body "$agent_file")
EOF

  echo "  Antigravity: agency-${slug}/SKILL.md"
}

Schritt 7: In OpenClaw-Format konvertieren

OpenClaw verwendet drei Dateien pro Agent (SOUL.md, AGENTS.md, IDENTITY.md):

convert_openclaw() {
  local agent_file="$1"
  local name=$(get_field 'name' "$agent_file")
  local description=$(get_field 'description' "$agent_file")
  local slug=$(to_kebab "$name")
  local body=$(get_body "$agent_file")

  local output_dir="integrations/openclaw/agency-${slug}"
  mkdir -p "$output_dir"

  # SOUL.md - Hauptdefinition des Agenten
  cat > "$output_dir/SOUL.md" << EOF
# $name

$description

---

$body
EOF

  # AGENTS.md - Agentenfähigkeiten
  cat > "$output_dir/AGENTS.md" << EOF
# Agentenfähigkeiten: $name

- Spezialisiertes Fachwissen im Bereich
- Ergebnisorientierte Ausgabe
- Erfolgsmetriken definiert

Siehe SOUL.md für die vollständige Definition.
EOF

  # IDENTITY.md - Agentenidentität
  cat > "$output_dir/IDENTITY.md" << EOF
# Identität: $name

- Name: $name
- Beschreibung: $description
- Quelle: The Agency (agency-agents Repo)
EOF

  echo "  OpenClaw: agency-${slug}/"
}

Schritt 8: Das vollständige convert.sh-Skript

Hier ist das vollständige Konvertierungsskript (vereinfacht):

#!/usr/bin/env bash
#
# convert.sh — Alle Agency-Agenten in werkzeugspezifische Formate konvertieren
#

set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
REPO_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
OUT_DIR="$REPO_ROOT/integrations"

# Frontmatter-Helfer
get_field() {
  local field="$1" file="$2"
  awk -v f="$field" '
    /^---$/ { fm++; next }
    fm == 1 && $0 ~ "^" f ": " { sub("^" f ": ", ""); print; exit }
  ' "$file"
}

get_body() {
  awk 'BEGIN{fm=0} /^---$/{fm++; next} fm>=2{print}' "$1"
}

to_kebab() {
  echo "$1" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9]/-/g' | sed 's/--*/-/g'
}

# Konvertierungsfunktionen
convert_claude_code() {
  local agent_file="$1"
  local dest="$OUT_DIR/claude-code/"
  mkdir -p "$dest"
  cp "$agent_file" "$dest/"
}

convert_cursor() {
  local agent_file="$1"
  local name=$(get_field 'name' "$agent_file")
  local slug=$(to_kebab "$name")
  local body=$(get_body "$agent_file")

  mkdir -p "$OUT_DIR/cursor/.cursor/rules/"
  cat > "$OUT_DIR/cursor/.cursor/rules/agency-${slug}.mdc" << EOF
---
description: Agency agent: $(get_field 'description' "$agent_file")
---
$body
EOF
}

convert_aider() {
  local output="$OUT_DIR/aider/CONVENTIONS.md"
  echo "" >> "$output"
  echo "---" >> "$output"
  cat "$agent_file" >> "$output"
}

convert_windsurf() {
  local output="$OUT_DIR/windsurf/.windsurfrules"
  echo "" >> "$output"
  echo "---" >> "$output"
  cat "$agent_file" >> "$output"
}

# Hauptkonvertierungsschleife
echo "Agency-Agenten werden konvertiert..."

AGENT_DIRS=(engineering design testing marketing sales)

for dir in "${AGENT_DIRS[@]}"; do
  for agent_file in "$REPO_ROOT/$dir"/*.md; do
    [[ -f "$agent_file" ]] || continue

    name=$(get_field 'name' "$agent_file")
    echo "Verarbeite: $name"

    convert_claude_code "$agent_file"
    convert_cursor "$agent_file"
  done
done

# Kombinierte Dateien erstellen
echo "# Agency-Agenten für Aider" > "$OUT_DIR/aider/CONVENTIONS.md"
for dir in "${AGENT_DIRS[@]}"; do
  for agent_file in "$REPO_ROOT/$dir"/*.md; do
    [[ -f "$agent_file" ]] || continue
    convert_aider "$agent_file"
  done
done

echo "# Agency-Agenten für Windsurf" > "$OUT_DIR/windsurf/.windsurfrules"
for dir in "${AGENT_DIRS[@]}"; do
  for agent_file in "$REPO_ROOT/$dir"/*.md; do
    [[ -f "$agent_file" ]] || continue
    convert_windsurf "$agent_file"
  done
done

echo "Konvertierung abgeschlossen!"
echo "  Claude Code: $OUT_DIR/claude-code/"
echo "  Cursor: $OUT_DIR/cursor/.cursor/rules/"
echo "  Aider: $OUT_DIR/aider/CONVENTIONS.md"
echo "  Windsurf: $OUT_DIR/windsurf/.windsurfrules"

Ausführen:

chmod +x convert.sh
./convert.sh

Schritt 9: In jedem Tool installieren

Nach der Konvertierung die Dateien in werkzeugspezifische Pfade kopieren:

#!/usr/bin/env bash
#
# install.sh — Installiert konvertierte Agenten in Ihren lokalen Tools
#

set -euo pipefail

# Claude Code
install_claude_code() {
  local src="$REPO_ROOT/integrations/claude-code/"
  local dest="$HOME/.claude/agents/"
  mkdir -p "$dest"
  cp "$src"/*.md "$dest/"
  echo "Claude Code: $(find "$dest" -name '*.md' | wc -l) Agenten installiert"
}

# Cursor
install_cursor() {
  local src="$REPO_ROOT/integrations/cursor/.cursor/rules/"
  local dest="./.cursor/rules/"
  mkdir -p "$dest"
  cp "$src"/*.mdc "$dest/"
  echo "Cursor: $(find "$dest" -name '*.mdc' | wc -l) Regeln installiert"
}

# Aider
install_aider() {
  local src="$REPO_ROOT/integrations/aider/CONVENTIONS.md"
  local dest="./CONVENTIONS.md"
  cp "$src" "$dest"
  echo "Aider: CONVENTIONS.md installiert"
}

# Windsurf
install_windsurf() {
  local src="$REPO_ROOT/integrations/windsurf/.windsurfrules"
  local dest="./.windsurfrules"
  cp "$src" "$dest"
  echo "Windsurf: .windsurfrules installiert"
}

# Alle erkannten Tools installieren
install_all() {
  if [[ -d "$HOME/.claude/agents/" ]]; then
    install_claude_code
  fi
  if command -v cursor &>/dev/null || [[ -d "./.cursor/" ]]; then
    install_cursor
  fi
  if command -v aider &>/dev/null; then
    install_aider
  fi
}

install_all

Formatvergleich

Tool	Format	Umfang	Konvertierung
Claude Code	`.md`	Benutzerweit (`~/.claude/agents/`)	Unverändert kopieren
Cursor	`.mdc`	Projekt (`.cursor/rules/`)	Beschreibung als Frontmatter hinzufügen
Aider	`CONVENTIONS.md`	Projekt-Stammverzeichnis	Alle Agenten verketten
Windsurf	`.windsurfrules`	Projekt-Stammverzeichnis	Alle Agenten verketten
GitHub Copilot	`.md`	Benutzerweit (`~/.github/agents/`)	Unverändert kopieren
Antigravity	`SKILL.md`	Benutzerweit (`~/.gemini/antigravity/`)	In Skill-Verzeichnis verpacken
OpenClaw	`SOUL.md` + andere	Benutzerweit (`~/.openclaw/`)	In 3 Dateien aufteilen
Gemini CLI	Erweiterung	Benutzerweit (`~/.gemini/extensions/`)	Manifest + Skills generieren
OpenCode	`.md`	Projekt (`.opencode/agents/`)	Unverändert kopieren
Qwen Code	`.md`	Projekt (`.qwen/agents/`)	Als SubAgent kopieren

Erstellen Sie Ihr eigenes Konvertierungsskript

Vorlage zum Hinzufügen eines neuen Tools:

#!/usr/bin/env bash

# 1. Konvertierungsfunktion definieren
convert_your_tool() {
  local agent_file="$1"
  local name=$(get_field 'name' "$agent_file")
  local description=$(get_field 'description' "$agent_file")
  local slug=$(to_kebab "$name")
  local body=$(get_body "$agent_file")

  # 2. Ausgabepfad erstellen
  local output="path/to/your/tool/agency-${slug}.ext"
  mkdir -p "$(dirname "$output")"

  # 3. Konvertierten Inhalt schreiben
  cat > "$output" << EOF
# Ihr werkzeugspezifisches Format
# Verwenden Sie: $name, $description, $body
EOF

  echo "  IhrTool: agency-${slug}.ext"
}

# 4. Zur Hauptschleife hinzufügen
for agent_file in engineering/*.md; do
  convert_your_tool "$agent_file"
done

Was Sie erstellt haben

Komponente	Zweck
`get_field()`	YAML-Frontmatter-Werte extrahieren
`get_body()`	Frontmatter entfernen, Markdown-Hauptteil zurückgeben
`to_kebab()`	Namen in URL-sichere Slugs konvertieren
`convert_cursor()`	In `.mdc`-Format umwandeln
`convert_aider()`	In einer einzigen Datei verketten
`convert_windsurf()`	In einer einzigen Datei verketten
`convert_antigravity()`	Skill-Verzeichnisse erstellen
`convert_openclaw()`	In 3 Dateien pro Agent aufteilen
`install.sh`	An werkzeugspezifische Pfade kopieren

Nächste Schritte

Die Skripte erweitern:

Parallele Konvertierung mit xargs -P oder GNU parallel hinzufügen
Validierung hinzufügen (Prüfung auf erforderliche Frontmatter-Felder)
Dry-Run-Modus hinzufügen (--dry-run-Flag)

Weitere Tools hinzufügen:

VS Code-Erweiterungen
JetBrains-IDEs
Benutzerdefinierte interne Tools

Für große Repos optimieren:

Geparstes Frontmatter cachen
find mit -print0 für sichere Dateiverarbeitung verwenden
Fortschrittsbalken für 100+ Agenten hinzufügen

Fehlerbehebung bei häufigen Problemen

Konvertierungsskript schlägt fehl mit „bad substitution“:

Stellen Sie sicher, dass Sie Bash verwenden, nicht Sh: #!/usr/bin/env bash
Bash-Version überprüfen: bash --version (sollte 4.0+ sein)
Explizit mit Bash ausführen: bash convert.sh
Nach Windows-Zeilenumbrüchen suchen: sed -i 's/\r$//' convert.sh

Frontmatter-Felder werden nicht extrahiert:

Überprüfen Sie, ob das YAML-Format : (Doppelpunkt Leerstelle) verwendet, nicht nur :
Auf zusätzliche Leerzeichen vor Feldnamen prüfen
Stellen Sie sicher, dass die Frontmatter-Trennzeichen genau --- (3 Bindestriche) sind
Parsen manuell testen: ./parse-frontmatter.sh --demo agent.md

Slug-Generierung erzeugt fehlerhafte Namen:

Die Funktion to_kebab() mit Randfällen testen
Sonderzeichen behandeln: to_kebab() { echo "$1" | iconv -f utf8 -t ascii//translit | ... }
Fallback für leere Slugs hinzufügen: [[ -z "$slug" ]] && slug="unknown-agent"
Originalnamen zur Fehlerbehebung protokollieren

Cursor-Regeln werden nicht geladen:

Überprüfen Sie, ob .mdc-Dateien gültiges Frontmatter mit description enthalten
Cursors MCP-Konfiguration prüfen: .cursor/mcp.json
Stellen Sie sicher, dass sich die Dateien in .cursor/rules/ und nicht in .cursor/agents/ befinden
Cursor nach dem Hinzufügen neuer Regeln neu starten

Aider CONVENTIONS.md wird zu groß:

Nach Kategorie aufteilen: CONVENTIONS-engineering.md, CONVENTIONS-design.md
Automatische Bereinigung für veraltete Agenten implementieren
Inhaltsverzeichnis oben hinzufügen
Pro-Agent-Dateien mit Include-Direktiven in Betracht ziehen

Leistungsoptimierung für große Konvertierungen

Parallele Verarbeitung:

Für Repositories mit über 100 Agenten GNU parallel verwenden:

#!/usr/bin/env bash
# convert-parallel.sh

export OUT_DIR="$REPO_ROOT/integrations"

# Funktionen für die parallele Nutzung exportieren
export -f get_field get_body to_kebab convert_cursor convert_claude_code

# Alle Agenten-Dateien finden und parallel verarbeiten
find "$REPO_ROOT" -name "*.md" -type f | \
  parallel -j 8 --progress '
    name=$(get_field "name" {})
    slug=$(to_kebab "$name")
    echo "Konvertiere: $name"
    convert_cursor "{}"
    convert_claude_code "{}"
  '

echo "Parallele Konvertierung abgeschlossen!"

Inkrementelle Konvertierung:

Nur geänderte Dateien konvertieren:

#!/usr/bin/env bash
# convert-incremental.sh

CACHE_FILE="$REPO_ROOT/.conversion-cache"

# Vorherigen Zustand laden
declare -A PREV_HASHES
if [[ -f "$CACHE_FILE" ]]; then
  while IFS='=' read -r file hash; do
    PREV_HASHES["$file"]="$hash"
  done < "$CACHE_FILE"
fi

# Jeden Agenten verarbeiten
for agent_file in engineering/*.md; do
  CURRENT_HASH=$(md5sum "$agent_file" | cut -d' ' -f1)
  PREV_HASH="${PREV_HASHES[$agent_file]:-}"

  if [[ "$CURRENT_HASH" != "$PREV_HASH" ]]; then
    echo "Geändert: $agent_file"
    convert_cursor "$agent_file"
    convert_claude_code "$agent_file"
    NEW_HASHES["$agent_file"]="$CURRENT_HASH"
  else
    echo "Unverändert: $agent_file"
  fi
done

# Cache speichern
for file in "${!NEW_HASHES[@]}"; do
  echo "$file=${NEW_HASHES[$file]}"
done > "$CACHE_FILE"

Fortschrittsverfolgung:

Visuellen Fortschritt für lange Konvertierungen hinzufügen:

#!/usr/bin/env bash

total_files=$(find "$REPO_ROOT" -name "*.md" -type f | wc -l)
current=0

for agent_file in "$REPO_ROOT"/**/*.md; do
  ((current++))
  percent=$((current * 100 / total_files))

  # Fortschrittsbalken
  filled=$((percent / 5))
  empty=$((20 - filled))
  bar=$(printf '%*s' "$filled" | tr ' ' '#')
  spaces=$(printf '%*s' "$empty" | tr ' ' ' ')

  name=$(get_field 'name' "$agent_file")
  echo -ne "\r[${bar}${spaces}] ${percent}% - $name"

  convert_cursor "$agent_file"
done

echo -ne "\n"

Sicherheitsaspekte für geteilte Agenten

Validierung von Agentenquellen:

Beim Herunterladen von Agenten aus externen Quellen:

#!/usr/bin/env bash
# validate-agent.sh

validate_agent() {
  local file="$1"

  # Erforderliche Frontmatter-Felder prüfen
  local name=$(get_field 'name' "$file")
  local description=$(get_field 'description' "$file")

  if [[ -z "$name" ]]; then
    echo "FEHLER: 'name'-Feld fehlt in $file"
    return 1
  fi

  if [[ -z "$description" ]]; then
    echo "WARNUNG: 'description'-Feld fehlt in $file"
  fi

  # Auf bösartige Muster im Hauptteil prüfen
  local body=$(get_body "$file")

  if echo "$body" | grep -q 'rm -rf\|curl.*\|wget.*\|eval\|exec'; then
    echo "WARNUNG: Potenziell gefährliche Muster in $file"
    return 1
  fi

  echo "GÜLTIG: $name"
  return 0
}

Sandboxing der Agenten-Ausführung:

Für nicht vertrauenswürdige Agenten in isolierten Umgebungen ausführen:

Docker-Container für die Agenten-Ausführung verwenden
Dateisystemzugriff mit Nur-Lese-Mounts einschränken
Netzwerkzugriff auf bestimmte Domänen beschränken
Alle Agentenaktionen für Audit-Trails protokollieren

Eine Agenten-Datei. Zehn IDEs. Zwei Bash-Skripte.

Das ist die Stärke der Konvertierungsautomatisierung. Einmal schreiben, automatisch konvertieren, überall installieren.

Sie sind dran: Fügen Sie Konvertierungsunterstützung für Ihr bevorzugtes KI-Tool hinzu. Teilen Sie das Skript. Machen Sie Agenten portabel.

Wichtigste Erkenntnisse

Einmal schreiben, in über 10 Formate konvertieren — Eine einzige Markdown-Datei mit YAML-Frontmatter wird in Claude Code, Cursor, Aider, Windsurf und 6+ weitere Tools umgewandelt
Bash-Parsing übernimmt die Frontmatter-Extraktion — get_field() extrahiert YAML-Werte, get_body() entfernt Frontmatter, to_kebab() erstellt URL-sichere Slugs
Werkzeugspezifische Formate erfordern unterschiedliche Transformationen — Claude Code kopiert unverändert, Cursor fügt die Beschreibung als Frontmatter hinzu, Aider/Windsurf verketten alle Agenten
Installationsskripte kopieren an die richtigen Pfade — Benutzerweite Tools verwenden ~/.claude/agents/, Projekt-Tools verwenden .cursor/rules/ oder Dateien im Projekt-Stammverzeichnis
Mit Vorlagen für neue Tools erweitern — Die Funktion convert_your_tool() definieren, zur Hauptschleife hinzufügen, Formatanforderungen dokumentieren

button

Häufig gestellte Fragen (FAQ)

Was ist convert.sh und wie funktioniert es? convert.sh ist ein Bash-Skript, das YAML-Frontmatter aus Markdown-Dateien von Agenten parst, den Hauptinhalt extrahiert und jeden Agenten in werkzeugspezifische Formate umwandelt. Es verwendet awk zum Parsen, sed zur Slug-Konvertierung und Heredocs zur Ausgabegenerierung.

Wie funktioniert das Parsen von Frontmatter in Bash? Die Funktion get_field() verwendet awk, um Frontmatter-Trennzeichen (---) zu verfolgen, die Zeile zu finden, die dem Feldnamen entspricht, und den Wert zu extrahieren. get_body() gibt alle Zeilen nach dem zweiten ----Trennzeichen aus.

Welche IDEs und Tools werden unterstützt? Claude Code (.md), Cursor (.mdc), Aider (CONVENTIONS.md), Windsurf (.windsurfrules), GitHub Copilot (.md), Antigravity (SKILL.md), OpenClaw (SOUL.md + 2 Dateien), Gemini CLI-Erweiterungen, OpenCode und Qwen Code.

Wie füge ich Konvertierungsunterstützung für ein neues Tool hinzu? Erstellen Sie eine Funktion convert_yourtool(), die Frontmatter-Felder extrahiert, den Hauptteil in das Format Ihres Tools umwandelt und in den richtigen Pfad schreibt. Fügen Sie den Funktionsaufruf zur Hauptkonvertierungsschleife hinzu.

Kann ich Konvertierungen parallel ausführen, um die Verarbeitung zu beschleunigen? Ja. Verwenden Sie xargs -P oder GNU parallel, um mehrere Agenten-Dateien gleichzeitig zu verarbeiten. Bei über 100 Agenten kann die parallele Konvertierung die Laufzeit von Minuten auf Sekunden reduzieren.

Wie überprüfe ich, ob Frontmatter-Felder existieren? Fügen Sie Validierungsprüfungen in Ihrer Konvertierungsfunktion hinzu: [[ -z "$name" ]] && echo "Missing name field" && exit 1. Führen Sie die Validierung durch, bevor Sie Ausgabedateien schreiben.

Was passiert, wenn die Konvertierung für einige Agenten fehlschlägt? Verwenden Sie set -euo pipefail, um bei Fehlern schnell abzubrechen. Fügen Sie Fehlerbehandlung mit || continue hinzu, um fehlerhafte Dateien zu überspringen. Protokollieren Sie Fehler zur Fehlerbehebung in einer separaten Datei.