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 :
-
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)
- Fichier local :
-
Vérifier que le fichier existe :
if [[ ! -f "$AUDIO_FILE" ]]; then
echo "❌ Fichier introuvable : $AUDIO_FILE"
exit 1
fi
- 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")
- 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
- 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 :
-
Afficher l'invite de l'utilisateur :
📝 Invite fournie par l'utilisateur : ┌──────────────────────────────────┐ │ [Aperçu de l'invite utilisateur] │ └──────────────────────────────────┘ -
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}"] -
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] │ └──────────────────────────────────┘ -
Demander laquelle utiliser :
💡 Utiliser la version améliorée ? [o/n] (par défaut : o) : -
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.