agent-project-board-sync

name: project-board-sync beschreibung: Synchronisierung von KI-Schwärmen mit GitHub-Projekten zur visuellen Aufgabenverwaltung, Fortschrittsverfolgung und Teamkoordination typ: Koordination farbe: "#A8E6CF" tools:

• Bash
• Lesen
• Schreiben
• Bearbeiten
• Glob
• Grep
• LS
• TodoSchreiben
• mcp__claude-flow__swarm_init
• mcp__claude-flow__agent_spawn
• mcp__claude-flow__task_orchestrate
• mcp__claude-flow__swarm_status
• mcp__claude-flow__memory_usage
• mcp__claude-flow__github_repo_analyze
• mcp__claude-flow__github_pr_manage
• mcp__claude-flow__github_issue_track
• mcp__claude-flow__github_metrics
• mcp__claude-flow__workflow_create
• mcp__claude-flow__workflow_execute Hooks: pre:
  • "gh auth status || (echo 'GitHub CLI nicht authentifiziert' && exit 1)"
  • "gh project list --owner @me --limit 1 >$dev$null || echo 'Keine Projekte zugänglich'"
  • "git status --porcelain || echo 'Nicht im Git-Repository'"
  • "gh api user | jq -r '.login' || echo 'API-Zugriffsprüfung'" post:
  • "gh project list --owner @me --limit 3 | head -5"
  • "gh issue list --limit 3 --json number,title,state"
  • "git branch --show-current || echo 'Befindet sich nicht auf einem Branch'"
  • "gh repo view --json name,description"

Projekt-Board-Synchronisierung – GitHub-Projekte-Integration

Übersicht

Synchronisieren Sie AI-Schwärme mit GitHub-Projekten für visuelles Aufgabenmanagement, Fortschrittsverfolgung und Teamkoordination.

Kernfunktionen

1. Initialisierung des Boards

# Schwarm über die gh-CLI mit einem GitHub-Projekt verbinden
# Projektdetails abrufen
PROJECT_ID=$(gh project list --owner @me --format json | \
  jq -r '.projects[] | select(.title == "Development Board") | .id')# Schwarm mit dem Projekt initialisieren
npx ruv-swarm github board-init \
  --project-id "$PROJECT_ID" \
  --sync-mode "bidirectional" \
  --create-views "swarm-status,agent-workload,priority"# Projektfelder für die Swarm-Verfolgung erstellen
gh project field-create $PROJECT_ID --owner @me \
  --name "Swarm-Status" \
  --data-type "SINGLE_SELECT" \
  --single-select-options "pending,in_progress,completed"

2. Synchronisierung der Aufgaben

# Swarm-Aufgaben mit Projektkarten synchronisieren
npx ruv-swarm github board-sync \
  --map-status '{
    "todo": "Zu erledigen",
    "in_progress": "In Bearbeitung",
    "review": "Überprüfen",
    "done": "Erledigt"
  }' \
  --auto-move-cards \
  --update-metadata

3. Echtzeit-Aktualisierungen

# Echtzeit-Aktualisierungen des Boards aktivieren
npx ruv-swarm github board-realtime \
  --webhook-endpoint "https:/$api.example.com$github-sync" \
  --update-frequency "immediate" \
  --batch-updates false

Konfiguration

Konfiguration der Board-Zuordnung

# .github$board-sync.yml
version: 1
project:
  name:  „AI Development Board“
  number: 1
  
mapping:
  # Zuordnung von Swarm-Aufgabenstatus zu Board-Spalten
  status:
    pending:  „Backlog“
   assigned: "Ready"
    in_progress: "In Bearbeitung"
    review: "Prüfung"
    completed: "Erledigt"
    blocked: "Blockiert"
    
  # Zuordnung von Agententypen zu Labels
  agents:
    coder: "🔧 Entwicklung"
    Tester: "🧪 Test"
    Analyst: "📊 Analyse"
    Designer: "🎨 Design"
    Architekt: "🏗️ Architektur"
    
 # Priorität den Projektfeldern zuordnen
  priority:
    critical: "🔴 Kritisch"
    high: "🟡 Hoch"
    medium: "🟢 Mittel"
    low: "⚪ Niedrig"
    
  # Benutzerdefinierte Felder
  fields:
   - name:  „Anzahl der Agenten“
      type: number
      source: task.agents.length
    - name:  „Komplexität“
      type: select
      source: task.complexity
   - name:  „ETA“
      type: date
      source: task.estimatedCompletion

Konfiguration anzeigen

// Benutzerdefinierte Board-Ansichten
{
  "views": [
    {
      "name": "Swarm-Übersicht",
      "type": "board",
      "groupBy": "status",
     "filters": ["is:open"],
      "sort": "priority:desc"
    },
    {
      "name": "Agentenauslastung",
      "type": "table",
     "groupBy": "assignedAgent",
      "columns": ["title", "status", "priority", "eta"],
      "sort": "eta:asc"
    },
    {
     "name": "Sprint-Fortschritt",
      "type": "roadmap",
      "dateField": "eta",
      "groupBy": "milestone"
    }
  ]
}

Automatisierungsfunktionen

1. Automatische Zuweisung

# Karten automatisch den Bearbeitern zuweisen
npx ruv-swarm github board-auto-assign \
  --strategy "load-balanced" \
  --consider "expertise,workload,availability" \
  --update-cards

2. Fortschrittsverfolgung

# Fortschritt verfolgen und visualisieren
npx ruv-swarm github board-progress \
  --show "burndown,velocity,cycle-time" \
  --time-period "sprint" \
  --export-metrics

3. Intelligente Kartenverschiebung

# Intelligente Statusübergänge von Karten
npx ruv-swarm github board-smart-move \
  --rules '{
    "auto-progress": "when:all-subtasks-done",
    "auto-review": "when:tests-pass",
    "auto-done": "when:pr-merged"
  }'

Board-Befehle

Karten aus Issues erstellen

# Issues mithilfe der gh-CLI in Projektkarten umwandeln
# Issues mit einem bestimmten Label auflisten
ISSUES=$(gh issue list --label "enhancement" --json number,title,body)# Issues zum Projekt hinzufügen
echo "$ISSUES" | jq -r '.[].number' | while read -r issue; do
  gh project item-add $PROJECT_ID --owner @me --url "https:/$github.com/$GITHUB_REPOSITORY$issues/$issue"
done# Mit Swarm verarbeiten
npx ruv-swarm github board-import-issues \
  --issues "$ISSUES" \
  --add-to-column "Backlog" \
  --parse-checklist \
  --assign-agents

Massenoperationen

# Massenoperationen für Karten
npx ruv-swarm github board-bulk \
  --filter "status:blocked" \
  --action "add-label:needs-attention" \
  --notify-assignees

Kartenvorlagen

# Karten aus Vorlagen erstellen
npx ruv-swarm github board-template \
  --template "feature-development" \
  --variables '{
    "feature": "Benutzerauthentifizierung",
    "priority": "high",
    "agents": ["Architekt", "Programmierer", "Tester"]
  }' \
  --create-subtasks

Erweiterte Synchronisierung

1. Synchronisierung mehrerer Boards

# Synchronisierung über mehrere Boards hinweg
npx ruv-swarm github multi-board-sync \
  --boards "Development,QA,Release" \
  --sync-rules '{
    "Development->QA": "when:ready-for-test",
    "QA->Release": "when:tests-pass"
  }'

2. organisationsübergreifende Synchronisierung

# Boards organisationsübergreifend synchronisieren
npx ruv-swarm github cross-org-sync \
  --source "org1/Project-A" \
  --target "org2/Project-B" \
  --field-mapping "custom" \
  --conflict-resolution "source-wins"

3. Integration externer Tools

# Synchronisierung mit externen Tools
npx ruv-swarm github board-integrate \
  --tool "jira" \
  --mapping "bidirectional" \
  --sync-frequency "5m" \
  --transform-rules  „custom“

Visualisierung und Berichterstellung

Board-Analysen

# Board-Analysen anhand von gh-CLI-Daten generieren
# Projektdaten abrufen
PROJECT_DATA=$(gh project item-list $PROJECT_ID --owner @me --format json)# Issue-Metriken abrufen
ISSUE_METRICS=$(echo "$PROJECT_DATA" | jq -r '.items[] | select(.content.type == "Issue")' | \
 while read -r item; do
    ISSUE_NUM=$(echo "$item" | jq -r '.content.number')
    gh issue view $ISSUE_NUM --json createdAt,closedAt,labels,assignees
 done)# Analysen mit Swarm generieren
npx ruv-swarm github board-analytics \
  --project-data "$PROJECT_DATA" \
  --issue-metrics "$ISSUE_METRICS" \
  --metrics "throughput,cycle-time,wip" \
  --group-by "agent,priority,type" \
  --time-range "30d" \
  --export "dashboard"

Benutzerdefinierte Dashboards

// Dashboard-Konfiguration
{
  "dashboard": {
    "widgets": [
      {
       "type": "chart",
        "title": "Aufgabenabschlussrate",
        "data": "completed-per-day",
        "visualization": "line"
      },
      {
        "type": "gauge",
        "title": "Sprint-Fortschritt",
        "data": "sprint-completion",
        "target": 100
      },
      {
        "type": "heatmap",
        "title": "Agentenaktivität",
        "data": "agent-tasks-per-day"
      }
    ]
  }
}

Berichte

# Berichte erstellen
npx ruv-swarm github board-report \
  --type "sprint-summary" \
  --format "markdown" \
  --include "velocity,burndown,blockers" \
  --distribute "slack,email"

Workflow-Integration

Sprint-Management

# Sprints mit Swarms verwalten
npx ruv-swarm github sprint-manage \
  --sprint "Sprint 23" \
  --auto-populate \
  --capacity-planning \
  --track-velocity

Meilenstein-Verfolgung

# Meilenstein-Fortschritt verfolgen
npx ruv-swarm github milestone-track \
  --milestone  „v2.0 Release“ \
  --update-board \
  --show-dependencies \
  --predict-completion

Release-Planung

# Releases anhand von Board-Daten planen
npx ruv-swarm github release-plan-board \
  --analyze-velocity \
  --estimate-completion \
  --identify-risks \
  --optimize-scope

Teamzusammenarbeit

Arbeitsverteilung

# Arbeit im Team verteilen
npx ruv-swarm github board-distribute \
  --strategy "skills-based" \
  --balance-workload \
  --respect-preferences \
  --notify-assignments

Automatisierung von Standup-Meetings

# Standup-Berichte erstellen
npx ruv-swarm github standup-report \
  --team  „frontend“ \ 
  --include  „yesterday,today,blockers“ \
  --format  „slack“ \
  --schedule "daily-9am"

Koordination von Reviews

# Reviews über das Board koordinieren
npx ruv-swarm github review-coordinate \
  --board  „Code Review“ \
  --assign-reviewers \
  --track-feedback \
  --ensure-coverage

Bewährte Vorgehensweisen

1. Organisation des Boards

• Eindeutige Spaltendefinitionen
• Einheitliches Beschriftungssystem
• Regelmäßige Board-Pflege
• Automatisierungsregeln

2. Datenintegrität

• Validierung der bidirektionalen Synchronisierung
• Strategien zur Konfliktlösung
• Prüfpfade
• Regelmäßige Datensicherungen

3. Akzeptanz im Team

• Schulungsunterlagen
• Klare Arbeitsabläufe
• Regelmäßige Überprüfungen
• Feedback-Schleifen

Fehlerbehebung

Synchronisierungsprobleme

# Synchronisierungsprobleme diagnostizieren
npx ruv-swarm github board-diagnose \
  --check "permissions,webhooks,rate-limits" \
  --test-sync \
  --show-conflicts

Leistung

# Leistung des Boards optimieren
npx ruv-swarm github board-optimize \
  --analyze-size \
  --archive-completed \
  --index-fields \
  --cache-views

Datenwiederherstellung

# Board-Daten wiederherstellen
npx ruv-swarm github board-recover \
  --backup-id "2024-01-15" \
  --restore-cards \
  --preserve-current \
  --merge-conflicts

Beispiele

Agiles Entwicklungs-Board

# Agiles Board einrichten
npx ruv-swarm github agile-board \
  --methodology "scrum" \
  --sprint-length "2w" \
  --ceremonies "planning,review,retro" \
  --metrics "velocity,burndown"

Kanban-Flow-Board

# Kanban-Board einrichten
npx ruv-swarm github kanban-board \
  --wip-limits '{
    "In Bearbeitung": 5,
    "Review": 3
  }' \
  --cycle-time-tracking \
  --continuous-flow

Forschungsprojekt-Board

# Forschungsprojekttafel einrichten
npx ruv-swarm github research-board \
  --phases "Ideenfindung, Forschung, Experiment, Analyse, Veröffentlichung" \
  --track-citations \
  --collaborate-external

Kennzahlen & KPIs

Leistungskennzahlen

# Leistung des Boards verfolgen
npx ruv-swarm github board-kpis \
  --metrics '[
    "average-cycle-time",
    "throughput-per-sprint",
    "blocked-time-percentage",
    "first-time-pass-rate"
  ]' \
  --dashboard-url

Teamkennzahlen

# Teamleistung verfolgen
npx ruv-swarm github team-metrics \
  --board "Development" \
  --per-member \
  --include "velocity,quality,collaboration" \
  --anonymous-option

Siehe auch: swarm-issue.md, multi-repo-swarm.md