Prompt : Reverse-Engineer Wispr Flow pour la Transcription Vocale Locale

L'objectif est de reproduire les fonctionnalités essentielles de Wispr Flow (transcription vocale avec raccourci global, historique, collage au curseur) en utilisant des modèles de speech-to-text locaux (Whisper via faster-whisper ou WhisperX) et une interface Python légère. L'application doit fonctionner en arrière-plan, être déclenchée par un raccourci clavier, transcrire la voix en continu, et coller le résultat à l'emplacement du curseur.

Voici le prompt exact, structuré pour Claude Code dans Fable 5, pour reverse-engineer et reconstruire l'application :

**Prompt Claude Code**

**Rôle** : Tu es un ingénieur logiciel expert en Python et en speech-to-text local.

**Contexte** : Je souhaite cloner les fonctionnalités essentielles de Wispr Flow, une app de dictée vocale, pour créer une version locale sans limites.

**Fonctionnalités à implémenter** :

1. **Raccourci clavier global** (par exemple Ctrl+Alt+V) qui démarre/arrête l'enregistrement et colle la transcription à la position du curseur.

2. **Enregistrement audio** depuis le microphone par défaut, avec détection de silence pour arrêter automatiquement après 2 secondes de silence OU via le raccourci.

3. **Transcription locale** en utilisant le modèle `faster-whisper` (ou WhisperX) avec le modèle `large-v3` (ou `base` pour la vitesse).

4. **Historique des transcriptions** sauvegardé localement dans un fichier JSON, consultable via un clic droit sur l'icône de la barre des tâches.

5. **Collage intelligent** : la transcription remplace le texte sélectionné ou est collée à la position du curseur dans n'importe quelle application.

6. **Icône dans la zone de notification** (system tray) pour contrôler l'application (Démarrer/Arrêter, Historique, Quitter).

7. **Mesure de la latence** (temps de traitement) et optimisation pour rester sous 0.5 seconde pour un segment de 20 secondes.

**Contraintes techniques** :

**Livrables attendus** :

1. Un script Python principal (`voice_transcriber.py`) avec l'implémentation complète.

2. Un fichier `requirements.txt`.

3. Un fichier `config.json` pour les préférences (raccourci, modèle, langue).

4. Un script de test unitaire pour la transcription.

5. Un fichier `README.md` avec les instructions d'installation.

**Spécifications détaillées** :

**Tests à écrire et exécuter** :

Voici une version simplifiée mais fonctionnelle du script principal, structurée pour être directement utilisable ou affinée par Claude Code :

```python

import sys, json, threading, time, queue

from pathlib import Path

import sounddevice as sd

import numpy as np

from faster_whisper import WhisperModel

from pynput import keyboard

import pyautogui

import pystray

from PIL import Image, ImageDraw

class VoiceTranscriber:

def __init__(self, config_path='config.json'):

with open(config_path) as f:

self.config = json.load(f)

self.model = WhisperModel(self.config.get('model', 'base'),

device=self.config.get('device', 'cuda'),

compute_type='float16')

self.audio_queue = queue.Queue()

self.is_recording = False

self.audio_frames = []

self.sample_rate = 16000

self.stream = None

def start_recording(self):

self.is_recording = True

self.audio_frames = []

def callback(indata, frames, time, status):

if status: print(f"Stream status: {status}")

self.audio_frames.append(indata.copy())

self.stream = sd.InputStream(samplerate=self.sample_rate, channels=1, callback=callback)

self.stream.start()

def stop_and_transcribe(self):

if not self.is_recording: return ''

self.is_recording = False

if self.stream:

self.stream.stop()

self.stream.close()

if not self.audio_frames: return ''

audio = np.concatenate(self.audio_frames, axis=0).flatten()

start_time = time.time()

segments, _ = self.model.transcribe(audio.astype(np.float32), language=self.config.get('language', 'fr'))

text = ' '.join([seg.text for seg in segments])

latency = time.time() - start_time

print(f"Transcription en {latency:.2f}s")

return text

def paste_text(self, text):

if text:

pyautogui.write(text)

def on_press(self, key):

try:

shortcut = self.config.get('shortcut', 'ctrl+alt+v')

if key == keyboard.KeyCode.from_char(key) and ...: # Logique de détection

if not self.is_recording:

threading.Thread(target=self.start_recording).start()

else:

text = self.stop_and_transcribe()

threading.Thread(target=self.paste_text, args=(text,)).start()

except Exception as e:

print(f"Erreur: {e}")

# Configuration par défaut (config.json) :

config_template = {

"shortcut": "ctrl+alt+v",

"model": "base",

"language": "fr",

"device": "cuda",

"history_max": 100

}

print("VoiceTranscriber prêt. Copiez-moi dans le dossier de votre projet et exécutez avec Claude Code.")

```

Installez les dépendances suivantes dans votre environnement Python (3.10+) :

```text

faster-whisper

sounddevice

numpy

pynput

pyautogui

pystray

Pillow

```

**Note sur le GPU** : Pour des performances optimales, installez CUDA Toolkit et cuDNN compatibles avec `faster-whisper`. Sinon, le CPU fonctionnera, mais avec une latence plus élevée.

Pour atteindre les 0,2 seconde de transcription pour 20 secondes d'audio comme décrit dans le post original, activez `device='cuda'` et `compute_type='int8_float16'` sur GPU NVIDIA récent, ou utilisez le modèle `tiny.en` pour les tests rapides. Sur CPU, le modèle `base` transcrit environ 5x plus vite que le temps réel sur un processeur moderne, soit environ 4 secondes pour 20 secondes d'audio. La latence annoncée suppose probablement l'utilisation d'un GPU très performant ou d'un modèle optimisé.

Cette reconstitution est basée sur une interprétation publique du fonctionnement de Wispr Flow et ne contient aucun code propriétaire. Elle est destinée à un usage éducatif et personnel. La reconstitution exacte du comportement de Wispr Flow (gestion de l'audio en arrière-plan sur macOS, intégration parfaite avec les API système) peut nécessiter des ajustements supplémentaires non couverts ici. Veuillez respecter les droits de propriété intellectuelle et les conditions d'utilisation de Wispr Flow.