Communitygithub.com

ASoudy/AGS

Transformez des enregistrements audio en documentation Markdown professionnelle avec des résumés intelligents utilisant l'intégration LLM.

Qu'est-ce que AGS ?

Cette compétence automatise la transcription audio-texte avec une sortie Markdown professionnelle, extrayant des métadonnées techniques riches (intervenants, horodatages, langue, taille du fichier, durée) et générant des comptes rendus de réunion structurés et des résumés exécutifs. Elle utilise Faster-Whisper ou Whisper sans configuration, fonctionnant universellement sur tous les projets sans chemins codés en dur ni clés API. Inspirée d'outils comme Plaud, cette compétence transforme les enregistrements audio bruts en documentation exploitable, ce qui la rend idéale pour les réunions, entretiens, conférences et analyses de contenu. Elle prend en charge les formats audio courants (MP3, WAV, M4A, OGG, FLAC, WEBM) et offre des fonctionnalités de détection automatique des outils de transcription, d'installation des dépendances, de validation des fichiers, de génération de comptes rendus, et même d'amélioration des prompts utilisateur via l'IA. Les agents peuvent l'invoquer pour transcrire des fichiers audio, générer des procès-verbaux de réunion, identifier les intervenants (diarisation), produire des sous-titres (SRT, VTT), ou créer des résumés exécutifs de longs contenus audio.

Compatible avec✓Claude Code✓Codex CLI~Cursor
npx skills add https://github.com/ASoudy/AGS/tree/HEAD/claude_skills_libraries/landing-page-mastery/skills/audio-transcriber

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Objectif

Cette compétence automatise la transcription audio-texte avec une sortie Markdown professionnelle, extrayant des métadonnées techniques riches (intervenants, horodatages, langue, taille du fichier, durée) et générant des comptes rendus de réunion structurés et des résumés exécutifs. Elle utilise Faster-Whisper ou Whisper sans configuration, fonctionnant universellement sur tous les projets sans chemins codés en dur ni clés API.

Inspirée d'outils comme Plaud, cette compétence transforme les enregistrements audio bruts en documentation exploitable, ce qui la rend idéale pour les réunions, entretiens, conférences et analyses de contenu.

Quand l'utiliser

Invoquez cette compétence lorsque :

  • L'utilisateur a besoin de transcrire des fichiers audio/vidéo en texte
  • L'utilisateur souhaite que des comptes rendus de réunion soient générés automatiquement à partir d'enregistrements
  • L'utilisateur nécessite l'identification des intervenants (diarisation) dans les conversations
  • L'utilisateur a besoin de sous-titres (formats SRT, VTT)
  • L'utilisateur souhaite des résumés exécutifs de longs contenus audio
  • L'utilisateur pose des questions du type "transcrire cet audio", "convertir l'audio en texte", "générer des notes de réunion à partir d'un enregistrement"
  • L'utilisateur a des fichiers audio dans des formats courants (MP3, WAV, M4A, OGG, FLAC, WEBM)

Flux de travail

Étape 0 : Découverte (Détection automatique des outils de transcription)

Objectif : Identifier les moteurs de transcription disponibles sans configuration utilisateur.

Actions :

Exécutez des commandes de détection pour trouver les outils installés :

# Vérifier la présence de Faster-Whisper (recommandé - 4 à 5 fois plus rapide)
if python3 -c "import faster_whisper" 2>/dev/null; then
    TRANSCRIBER="faster-whisper"
    echo "✅ Faster-Whisper détecté (optimisé)"
# Repli sur Whisper original
elif python3 -c "import whisper" 2>/dev/null; then
    TRANSCRIBER="whisper"
    echo "✅ OpenAI Whisper détecté"
else
    TRANSCRIBER="none"
    echo "⚠️  Aucun outil de transcription trouvé"
fi

# Vérifier la présence de ffmpeg (conversion de formats audio)
if command -v ffmpeg &>/dev/null; then
    echo "✅ ffmpeg disponible (conversion de format activée)"
else
    echo "ℹ️  ffmpeg non trouvé (prise en charge limitée des formats)"
fi

Si aucun transcribeur trouvé :

Proposez l'installation automatique à l'aide du script fourni :

echo "⚠️  Aucun outil de transcription trouvé"
echo ""
echo "🔧 Installer automatiquement les dépendances ? (Recommandé)"
read -p "Exécuter le script d'installation ? [O/N] : " AUTO_INSTALL

if [[ ! "$AUTO_INSTALL" =~ ^[Nn] ]]; then
    # Obtenir le répertoire de la compétence (fonctionne pour les installations par dépôt et par lien symbolique)
    SKILL_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
    
    # Exécuter le script d'installation
    if [[ -f "$SKILL_DIR/scripts/install-requirements.sh" ]]; then
        bash "$SKILL_DIR/scripts/install-requirements.sh"
    else
        echo "❌ Script d'installation introuvable"
        echo ""
        echo "📦 Installation manuelle :"
        echo "  pip install faster-whisper  # Recommandé"
        echo "  pip install openai-whisper  # Alternative"
        echo "  brew install ffmpeg         # Optionnel (macOS)"
        exit 1
    fi
    
    # Vérifier que l'installation a réussi
    if python3 -c "import faster_whisper" 2>/dev/null || python3 -c "import whisper" 2>/dev/null; then
        echo "✅ Installation réussie ! Passage à la transcription..."
    else
        echo "❌ Échec de l'installation. Veuillez installer manuellement."
        exit 1
    fi
else
    echo ""
    echo "📦 Installation manuelle requise :"
    echo ""
    echo "Recommandé (le plus rapide) :"
    echo "  pip install faster-whisper"
    echo ""
    echo "Alternative (original) :"
    echo "  pip install openai-whisper"
    echo ""
    echo "Optionnel (conversion de format) :"
    echo "  brew install ffmpeg  # macOS"
    echo "  apt install ffmpeg   # Linux"
    echo ""
    exit 1
fi

Cela garantit que les utilisateurs peuvent installer les dépendances avec une seule confirmation, ou opter pour une installation manuelle s'ils le préfèrent.

Si un transcribeur est trouvé :

Passez à l'étape 0b (Détection CLI).

Étape 1 : Valider le fichier audio

Objectif : Vérifier que le fichier existe, contrôler le format et extraire les métadonnées.

Actions :

  1. Accepter le chemin du fichier ou l'URL de l'utilisateur :

    • Fichier local : meeting.mp3
    • URL : https://example.com/audio.mp3 (télécharger dans un répertoire temporaire)
  2. Vérifier que le fichier existe :

if [[ ! -f "$AUDIO_FILE" ]]; then
    echo "❌ Fichier introuvable : $AUDIO_FILE"
    exit 1
fi
  1. Extraire les métadonnées à l'aide de ffprobe ou d'utilitaires de fichiers :
# Obtenir la taille du fichier
FILE_SIZE=$(du -h "$AUDIO_FILE" | cut -f1)

# Obtenir la durée et le format à l'aide de ffprobe
DURATION=$(ffprobe -v error -show_entries format=duration \
    -of default=noprint_wrappers=1:nokey=1 "$AUDIO_FILE" 2>/dev/null)
FORMAT=$(ffprobe -v error -select_streams a:0 -show_entries \
    stream=codec_name -of default=noprint_wrappers=1:nokey=1 "$AUDIO_FILE" 2>/dev/null)

# Convertir la durée au format HH:MM:SS
DURATION_HMS=$(date -u -r "$DURATION" +%H:%M:%S 2>/dev/null || echo "Inconnue")
  1. Vérifier la taille du fichier (avertir si volumineux pour les API cloud) :
SIZE_MB=$(du -m "$AUDIO_FILE" | cut -f1)
if [[ $SIZE_MB -gt 25 ]]; then
    echo "⚠️  Fichier volumineux ($FILE_SIZE) - le traitement peut prendre plusieurs minutes"
fi
  1. Valider le format (pris en charge : MP3, WAV, M4A, OGG, FLAC, WEBM) :
EXTENSION="${AUDIO_FILE##*.}"
SUPPORTED_FORMATS=("mp3" "wav" "m4a" "ogg" "flac" "webm" "mp4")

if [[ ! " ${SUPPORTED_FORMATS[@]} " =~ " ${EXTENSION,,} " ]]; then
    echo "⚠️  Format non pris en charge : $EXTENSION"
    if command -v ffmpeg &>/dev/null; then
        echo "🔄 Conversion en WAV..."
        ffmpeg -i "$AUDIO_FILE" -ar 16000 "${AUDIO_FILE%.*}.wav" -y
        AUDIO_FILE="${AUDIO_FILE%.*}.wav"
    else
        echo "❌ Installez ffmpeg pour convertir les formats : brew install ffmpeg"
        exit 1
    fi
fi

Étape 3 : Générer la sortie Markdown

Objectif : Créer un Markdown structuré avec les métadonnées, la transcription, le compte rendu de réunion et le résumé.

Modèle de sortie :

# Rapport de transcription audio

## 📊 Métadonnées

| Champ | Valeur |
|-------|--------|
| **Nom du fichier** | {filename} |
| **Taille du fichier** | {file_size} |
| **Durée** | {duration_hms} |
| **Langue** | {language} ({language_code}) |
| **Date de traitement** | {process_date} |
| **Intervenants identifiés** | {num_speakers} |
| **Moteur de transcription** | {engine} (modèle : {model}) |


## 📋 Compte rendu de réunion

### Participants
- {speaker_1}
- {speaker_2}
- ...

### Sujets abordés
1. **{topic_1}** ({timestamp})
   - {key_point_1}
   - {key_point_2}

2. **{topic_2}** ({timestamp})
   - {key_point_1}

### Décisions prises
- ✅ {decision_1}
- ✅ {decision_2}

### Éléments d'action
- [ ] **{action_1}** - Attribué à : {speaker} - Échéance : {date_if_mentioned}
- [ ] **{action_2}** - Attribué à : {speaker}


*Généré par la compétence audio-transcriber v1.0.0*  
*Moteur de transcription : {engine} | Temps de traitement : {elapsed_time}s*

Implémentation :

Utilisez Python ou bash avec un modèle d'IA (Claude/GPT) pour la synthèse intelligente :

def generate_meeting_minutes(segments):
    """Extraire les sujets, décisions, éléments d'action de la transcription."""
    
    # Regrouper les segments par sujet (regroupement simple par horodatages)
    topics = cluster_by_topic(segments)
    
    # Identifier les éléments d'action (mots-clés : "devrait", "va", "doit", "action")
    action_items = extract_action_items(segments)
    
    # Identifier les décisions (mots-clés : "décidé", "convenu", "approuvé")
    decisions = extract_decisions(segments)
    
    return {
        "topics": topics,
        "decisions": decisions,
        "action_items": action_items
    }

def generate_summary(segments, max_paragraphs=5):
    """Créer un résumé exécutif à l'aide de l'IA (Claude/GPT via API ou modèle local)."""
    
    full_text = " ".join([s["text"] for s in segments])
    
    # Utiliser l'approche Chain of Density (des frameworks prompt-engineer)
    summary_prompt = f"""
    Résumez la transcription suivante en {max_paragraphs} paragraphes concis.
    Concentrez-vous sur les sujets clés, les décisions et les éléments d'action.
    
    Transcription :
    {full_text}
    """
    
    # Appeler le modèle d'IA (espace réservé - l'utilisateur peut intégrer l'API Claude ou utiliser un modèle local)
    summary = call_ai_model(summary_prompt)
    
    return summary

Nommage des fichiers de sortie :

# v1.1.0 : Utiliser un horodatage pour éviter d'écraser les fichiers
TIMESTAMP=$(date +%Y%m%d-%H%M%S)
TRANSCRIPT_FILE="transcript-${TIMESTAMP}.md"
ATA_FILE="ata-${TIMESTAMP}.md"

echo "$TRANSCRIPT_CONTENT" > "$TRANSCRIPT_FILE"
echo "✅ Transcription enregistrée : $TRANSCRIPT_FILE"

if [[ -n "$ATA_CONTENT" ]]; then
    echo "$ATA_CONTENT" > "$ATA_FILE"
    echo "✅ Compte rendu enregistré : $ATA_FILE"
fi

SCÉNARIO A : Invite personnalisée fournie par l'utilisateur

Flux de travail :

  1. Afficher l'invite de l'utilisateur :

    📝 Invite fournie par l'utilisateur :
    ┌──────────────────────────────────┐
    │ [Aperçu de l'invite utilisateur]  │
    └──────────────────────────────────┘
    
  2. Améliorer automatiquement avec prompt-engineer (si disponible) :

    🔧 Amélioration de l'invite avec prompt-engineer...
    [Appelle : gh copilot -p "améliorez cette invite : {user_prompt}"]
    
  3. Afficher les deux versions :

    ✨ Version améliorée :
    ┌──────────────────────────────────┐
    │ Rôle : Vous êtes un documentateur... │
    │ Instructions : Transformez...      │
    │ Étapes : 1) ... 2) ...            │
    │ Objectif final : ...               │
    └──────────────────────────────────┘
    
    📝 Version originale :
    ┌──────────────────────────────────┐
    │ [Invite originale de l'utilisateur] │
    └──────────────────────────────────┘
    
  4. Demander laquelle utiliser :

    💡 Utiliser la version améliorée ? [o/n] (par défaut : o) :
    
  5. Traiter avec l'invite sélectionnée :

    • Si "o" : utiliser la version améliorée
    • Si "n" : utiliser l'originale

Traitement LLM (les deux scénarios)

Une fois l'invite finalisée :

from rich.progress import Progress, SpinnerColumn, TextColumn

def process_with_llm(transcript, prompt, cli_tool='claude'):
    full_prompt = f"{prompt}\n\n---\n\nTranscription :\n\n{transcript}"
    
    with Progress(
        SpinnerColumn(),
        TextColumn("[progress.description]{task.description}"),
        transient=True
    ) as progress:
        progress.add_task(
            description=f"🤖 Traitement avec {cli_tool}...",
            total=None
        )
        
        if cli_tool == 'claude':
            result = subprocess.run(
                ['claude', '-'],
                input=full_prompt,
                capture_output=True,
                text=True,
                timeout=300  # 5 minutes
            )
        elif cli_tool == 'gh-copilot':
            result = subprocess.run(
                ['gh', 'copilot', 'suggest', '-t', 'shell', full_prompt],
                capture_output=True,
                text=True,
                timeout=300
            )
    
    if result.returncode == 0:
        return result.stdout.strip()
    else:
        return None

Affichage de la progression :

🤖 Traitement avec claude... ⠋
[Après la fin :]
✅ Compte rendu généré avec succès !

Sortie finale

Succès (les deux fichiers) :

💾 Sauvegarde des fichiers...

✅ Fichiers créés :
  - transcript-20260203-023045.md  (transcription brute)
  - ata-20260203-023045.md         (traité avec LLM)

🧹 Fichiers temporaires supprimés : metadata.json, transcription.json

✅ Terminé ! Temps total : 3m 45s

Transcription uniquement (l'utilisateur a refusé LLM) :

💾 Sauvegarde des fichiers...

✅ Fichier créé :
  - transcript-20260203-023045.md

ℹ️  Compte rendu non généré (traitement LLM refusé par l'utilisateur)

🧹 Fichiers temporaires supprimés : metadata.json, transcription.json

✅ Terminé !

Étape 5 : Afficher le résumé des résultats

Objectif : Montrer l'état d'achèvement et les prochaines étapes.

Sortie :

echo ""
echo "✅ Transcription terminée !"
echo ""
echo "📊 Résultats :"
echo "  Fichier : $OUTPUT_FILE"
echo "  Langue : $LANGUAGE"
echo "  Durée : $DURATION_HMS"
echo "  Intervenants : $NUM_SPEAKERS"
echo "  Mots : $WORD_COUNT"
echo "  Temps de traitement : ${ELAPSED_TIME}s"
echo ""
echo "📝 Générés :"
echo "  - $OUTPUT_FILE (rapport Markdown)"
[if alternative formats:]
echo "  - ${OUTPUT_FILE%.*}.srt (Sous-titres)"
echo "  - ${OUTPUT_FILE%.*}.json (Données structurées)"
echo ""
echo "🎯 Prochaines étapes :"
echo "  1. Examinez le compte rendu de réunion et les éléments d'action"
echo "  2. Partagez le rapport avec les participants"
echo "  3. Suivez la réalisation des éléments d'action"

Exemple d'utilisation

Exemple 1 : Transcription de base

Entrée utilisateur :

copilot> transcrit l'audio en markdown : meeting-2026-02-02.mp3

Sortie de la compétence :

✅ Faster-Whisper détecté (optimisé)
✅ ffmpeg disponible (conversion de format activée)

📂 Fichier : meeting-2026-02-02.mp3
📊 Taille : 12.3 MB
⏱️  Durée : 00:45:32

🎙️  Traitement...
[████████████████████] 100%

✅ Langue détectée : portugais (pt-BR)
👥 Intervenants identifiés : 4
📝 Génération de la sortie Markdown...

✅ Transcription terminée !

📊 Résultats :
  Fichier : meeting-2026-02-02.md
  Langue : pt-BR
  Durée : 00:45:32
  Intervenants : 4
  Mots : 6,842
  Temps de traitement : 127s

📝 Générés :
  - meeting-2026-02-02.md (rapport Markdown)

🎯 Prochaines étapes :
  1. Examinez le compte rendu de réunion et les éléments d'action
  2. Partagez le rapport avec les participants
  3. Suivez la réalisation des éléments d'action

Exemple 3 : Traitement par lots

Entrée utilisateur :

copilot> transcrivez ces audios : recordings/*.mp3

Sortie de la compétence :

📦 Mode batch : 5 fichiers trouvés
  1. team-standup.mp3
  2. client-call.mp3
  3. brainstorm-session.mp3
  4. product-demo.mp3
  5. retrospective.mp3

🎙️  Traitement du lot...

[1/5] team-standup.mp3 ✅ (2m 34s)
[2/5] client-call.mp3 ✅ (15m 12s)
[3/5] brainstorm-session.mp3 ✅ (8m 47s)
[4/5] product-demo.mp3 ✅ (22m 03s)
[5/5] retrospective.mp3 ✅ (11m 28s)

✅ Lot terminé !
📝 5 rapports Markdown générés
⏱️  Temps de traitement total : 6m 15s

Exemple 5 : Avertissement pour fichier volumineux

Entrée utilisateur :

copilot> transcrit l'audio en markdown : conference-keynote.mp3

Sortie de la compétence :

✅ Faster-Whisper détecté (optimisé)

📂 Fichier : conference-keynote.mp3
📊 Taille : 87.2 MB
⏱️  Durée : 02:15:47
⚠️  Fichier volumineux (87.2 MB) - le traitement peut prendre plusieurs minutes

Continuer ? [O/N] :

Utilisateur : O

🎙️  Traitement... (cela peut prendre 10 à 15 minutes)
[████░░░░░░░░░░░░░░░░] 20% - Temps restant estimé : 12m

Remarques importantes

  • Respect de la vie privée par défaut : La transcription s'exécute localement sans envoyer l'audio au cloud (sauf si vous utilisez des API LLM qui ne prennent en charge que les appels cloud).
  • Flexibilité du LLM : Lors de l'étape 4, les utilisateurs VOIENT l'invite qui sera envoyée au LLM, et ils PEUVENT la modifier/améliorer avant le traitement. Cela garantit la transparence et le contrôle utilisateur.
  • Modèles locaux : Pour une confidentialité totale et un fonctionnement hors ligne, les utilisateurs peuvent configurer des modèles locaux (par ex., ollama) à la place des API cloud.

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

ASoudy/AGS

Advanced JavaScript animation library skill for creating complex, high-performance web animations.

ASoudy/AGS

Astropy is the core Python package for astronomy, providing essential functionality for astronomical research and data analysis.

ASoudy/AGS

Build content-focused websites with Astro — zero JS by default, islands architecture, multi-framework components, and Markdown/MDX support.

ASoudy/AGS

One sentence - what this skill does and when to invoke it

ASoudy/AGS

Audit and fix animation performance issues including layout thrashing, compositor properties, scroll-linked motion, and blur effects. Use when animations stutter, transitions jank, or reviewing CSS/JS animation performance.

ASoudy/AGS

Internationalization and localization patterns. Detecting hardcoded strings, managing translations, locale files, RTL support.

ASoudy/AGS

Pull a YouTube video transcript into a queryable markdown vault with yt-dlp subtitle discovery, VTT cleanup, metadata frontmatter, and capture-seed stubs.

ASoudy/AGS

Expert in building portfolios that actually land jobs and clients - not just showing work, but creating memorable experiences. Covers developer portfolios, designer portfolios, creative portfolios, and portfolios that convert visitors into opportunities.

ASoudy/AGS

Generates high-converting Next.js/React landing pages with Tailwind CSS. Uses PAS, AIDA, and BAB frameworks for optimized copy/components (Heroes, Features, Pricing). Focuses on Core Web Vitals/SEO.

ASoudy/AGS

AI-powered animation tool for creating motion in logos, UI, icons, and social media assets.

ASoudy/AGS

CRITICAL: Use for Makepad animation system. Triggers on: makepad animation, makepad animator, makepad hover, makepad state, makepad transition, "from: { all: Forward", makepad pressed, makepad 动画, makepad 状态, makepad 过渡, makepad 悬停效果

ASoudy/AGS

Comprehensive patterns for Next.js 14+ App Router architecture, Server Components, and modern full-stack React development.

ASoudy/AGS

Next.js App Router principles. Server Components, data fetching, routing patterns.

ASoudy/AGS

Expert integration of Supabase Auth with Next.js App Router

ASoudy/AGS

React and Next.js 14+ application development with App Router, Server Components, TypeScript, Tailwind CSS, and modern frontend patterns.

ASoudy/AGS

Best practices for Remotion - Video creation in React

ASoudy/AGS

Generate walkthrough videos from Stitch projects using Remotion with smooth transitions, zooming, and text overlays

ASoudy/AGS

Seek and analyze video content using Memories.ai Large Visual Memory Model for persistent video intelligence

ASoudy/AGS

Writes complete, structured landing pages optimized for SEO ranking, AEO citation, and visitor conversion. Activate when the user wants to write or generate a landing page for a product, service, or offer.

ASoudy/AGS

Skill for discovering and researching autonomous AI agents, tools, and ecosystems using the AgentFolio directory.

Skills associés