PayPerTranscript 0.2.0__py3-none-any.whl

paypertranscript/core/hotkey.py

@@ -0,0 +1,294 @@
+"""Globaler Hotkey-Listener für PayPerTranscript.
+
+Nutzt pynput für systemweite Hotkey-Erkennung.
+Unterstützt Hold-to-Record und Toggle-Modus.
+"""
+
+import threading
+from collections.abc import Callable
+from typing import Any
+
+from pynput import keyboard
+
+from paypertranscript.core.logging import get_logger
+
+log = get_logger("core.hotkey")
+
+# Mapping von Config-Strings zu pynput-Keys
+_KEY_MAP: dict[str, keyboard.Key | str] = {
+    "ctrl": keyboard.Key.ctrl_l,
+    "ctrl_l": keyboard.Key.ctrl_l,
+    "ctrl_r": keyboard.Key.ctrl_r,
+    "shift": keyboard.Key.shift_l,
+    "shift_l": keyboard.Key.shift_l,
+    "shift_r": keyboard.Key.shift_r,
+    "alt": keyboard.Key.alt_l,
+    "alt_l": keyboard.Key.alt_l,
+    "alt_r": keyboard.Key.alt_r,
+    "cmd": keyboard.Key.cmd,
+    "win": keyboard.Key.cmd,
+    "cmd_l": keyboard.Key.cmd_l,
+    "cmd_r": keyboard.Key.cmd_r,
+    "space": keyboard.Key.space,
+    "tab": keyboard.Key.tab,
+    "caps_lock": keyboard.Key.caps_lock,
+    "f1": keyboard.Key.f1,
+    "f2": keyboard.Key.f2,
+    "f3": keyboard.Key.f3,
+    "f4": keyboard.Key.f4,
+    "f5": keyboard.Key.f5,
+    "f6": keyboard.Key.f6,
+    "f7": keyboard.Key.f7,
+    "f8": keyboard.Key.f8,
+    "f9": keyboard.Key.f9,
+    "f10": keyboard.Key.f10,
+    "f11": keyboard.Key.f11,
+    "f12": keyboard.Key.f12,
+}
+
+# Keys die als Modifier gelten (haben links/rechts Varianten)
+_MODIFIER_GROUPS: dict[str, set[keyboard.Key]] = {
+    "ctrl": {keyboard.Key.ctrl_l, keyboard.Key.ctrl_r},
+    "shift": {keyboard.Key.shift_l, keyboard.Key.shift_r},
+    "alt": {keyboard.Key.alt_l, keyboard.Key.alt_r},
+    "cmd": {keyboard.Key.cmd, keyboard.Key.cmd_l, keyboard.Key.cmd_r},
+}
+
+# Alt-Keys fuer Menu-Bar-Workaround (Windows aktiviert Menueleiste bei bare Alt-Release)
+_ALT_KEYS: set[keyboard.Key] = {keyboard.Key.alt_l, keyboard.Key.alt_r}
+
+
+def _resolve_key(key_str: str) -> keyboard.Key | keyboard.KeyCode:
+    """Löst einen Config-String in ein pynput-Key-Objekt auf."""
+    lower = key_str.lower().strip()
+    if lower in _KEY_MAP:
+        return _KEY_MAP[lower]
+    # Einzelner Buchstabe/Zeichen
+    if len(lower) == 1:
+        return keyboard.KeyCode.from_char(lower)
+    raise ValueError(f"Unbekannter Key: '{key_str}'")
+
+
+def _is_modifier(key: keyboard.Key | keyboard.KeyCode) -> bool:
+    """Prüft ob ein Key ein Modifier ist."""
+    for group in _MODIFIER_GROUPS.values():
+        if key in group:
+            return True
+    return False
+
+
+def _get_modifier_group(key_str: str) -> set[keyboard.Key] | None:
+    """Gibt die Modifier-Gruppe für einen Config-String zurück."""
+    lower = key_str.lower().strip()
+    # Direkte Zuordnung
+    if lower in _MODIFIER_GROUPS:
+        return _MODIFIER_GROUPS[lower]
+    # Auch "win" → "cmd"
+    if lower == "win":
+        return _MODIFIER_GROUPS["cmd"]
+    return None
+
+
+class HotkeyListener:
+    """Globaler Hotkey-Listener mit Hold-to-Record und Toggle-Modus.
+
+    Callbacks:
+        on_hold_start: Wird aufgerufen wenn Hold-Hotkey gedrückt wird.
+        on_hold_stop: Wird aufgerufen wenn Hold-Hotkey losgelassen wird.
+        on_toggle: Wird aufgerufen wenn Toggle-Hotkey gedrückt wird.
+    """
+
+    def __init__(
+        self,
+        hold_hotkey: list[str] | None = None,
+        toggle_hotkey: list[str] | None = None,
+        on_hold_start: Callable[[], Any] | None = None,
+        on_hold_stop: Callable[[], Any] | None = None,
+        on_toggle: Callable[[], Any] | None = None,
+    ) -> None:
+        self._on_hold_start = on_hold_start
+        self._on_hold_stop = on_hold_stop
+        self._on_toggle = on_toggle
+
+        # Hold-Hotkey parsen
+        self._hold_keys: list[keyboard.Key | keyboard.KeyCode] = []
+        self._hold_modifier_groups: list[set[keyboard.Key]] = []
+        if hold_hotkey:
+            for key_str in hold_hotkey:
+                group = _get_modifier_group(key_str)
+                if group:
+                    self._hold_modifier_groups.append(group)
+                self._hold_keys.append(_resolve_key(key_str))
+            log.info("Hold-Hotkey konfiguriert: %s", " + ".join(hold_hotkey))
+
+        # Toggle-Hotkey parsen
+        self._toggle_keys: list[keyboard.Key | keyboard.KeyCode] = []
+        self._toggle_modifier_groups: list[set[keyboard.Key]] = []
+        if toggle_hotkey:
+            for key_str in toggle_hotkey:
+                group = _get_modifier_group(key_str)
+                if group:
+                    self._toggle_modifier_groups.append(group)
+                self._toggle_keys.append(_resolve_key(key_str))
+            log.info("Toggle-Hotkey konfiguriert: %s", " + ".join(toggle_hotkey))
+
+        # State-Tracking
+        self._pressed_keys: set[keyboard.Key | keyboard.KeyCode] = set()
+        self._hold_active = False
+        self._toggle_combo_held = False
+        self._listener: keyboard.Listener | None = None
+        self._lock = threading.Lock()
+        self._kb_controller: keyboard.Controller | None = None
+
+    def _normalize_key(self, key: keyboard.Key | keyboard.KeyCode) -> keyboard.Key | keyboard.KeyCode:
+        """Normalisiert einen Key (z.B. ctrl_l/ctrl_r werden nicht zusammengefasst)."""
+        return key
+
+    def _check_combo(
+        self,
+        target_keys: list[keyboard.Key | keyboard.KeyCode],
+        modifier_groups: list[set[keyboard.Key]],
+    ) -> bool:
+        """Prüft ob eine Tastenkombination aktuell gedrückt ist."""
+        if not target_keys:
+            return False
+
+        for i, target_key in enumerate(target_keys):
+            # Für Modifier: prüfe ob *irgendein* Key aus der Gruppe gedrückt ist
+            if i < len(modifier_groups) and modifier_groups[i]:
+                if not (modifier_groups[i] & self._pressed_keys):
+                    return False
+            else:
+                if target_key not in self._pressed_keys:
+                    return False
+        return True
+
+    def _combo_uses_alt(self, target_keys: list[keyboard.Key | keyboard.KeyCode]) -> bool:
+        """Prueft ob Alt Teil der Hotkey-Kombination ist."""
+        for key in target_keys:
+            if key in _ALT_KEYS:
+                return True
+        return False
+
+    def _cancel_alt_menu(self) -> None:
+        """Sendet einen Shift-Tap um Windows-Menueleisten-Aktivierung nach Alt-Release zu verhindern."""
+        try:
+            if self._kb_controller is None:
+                self._kb_controller = keyboard.Controller()
+            self._kb_controller.tap(keyboard.Key.shift)
+            log.debug("Alt-Menu-Workaround: Shift-Tap gesendet")
+        except Exception as e:
+            log.debug("Alt-Menu-Workaround fehlgeschlagen: %s", e)
+
+    def _on_press(self, key: keyboard.Key | keyboard.KeyCode) -> None:
+        """Callback für Key-Press-Events."""
+        with self._lock:
+            self._pressed_keys.add(key)
+
+            # Hold-Hotkey prüfen
+            if not self._hold_active and self._check_combo(self._hold_keys, self._hold_modifier_groups):
+                self._hold_active = True
+                log.debug("Hold-Hotkey gedrückt")
+                if self._on_hold_start:
+                    threading.Thread(target=self._on_hold_start, daemon=True).start()
+
+            # Toggle-Hotkey prüfen
+            if self._toggle_keys and self._check_combo(self._toggle_keys, self._toggle_modifier_groups):
+                self._toggle_combo_held = True
+                log.debug("Toggle-Hotkey gedrückt")
+                if self._on_toggle:
+                    threading.Thread(target=self._on_toggle, daemon=True).start()
+
+    def _on_release(self, key: keyboard.Key | keyboard.KeyCode) -> None:
+        """Callback für Key-Release-Events."""
+        cancel_alt = False
+
+        with self._lock:
+            self._pressed_keys.discard(key)
+
+            # Hold-Hotkey: Aufnahme stoppen wenn einer der Hold-Keys losgelassen wird
+            if self._hold_active:
+                if not self._check_combo(self._hold_keys, self._hold_modifier_groups):
+                    self._hold_active = False
+                    log.debug("Hold-Hotkey losgelassen")
+                    if key in _ALT_KEYS and self._combo_uses_alt(self._hold_keys):
+                        cancel_alt = True
+                    if self._on_hold_stop:
+                        threading.Thread(target=self._on_hold_stop, daemon=True).start()
+
+            # Toggle-Hotkey: Alt-Workaround wenn Combo losgelassen wird
+            if self._toggle_combo_held:
+                if not self._check_combo(self._toggle_keys, self._toggle_modifier_groups):
+                    self._toggle_combo_held = False
+                    if key in _ALT_KEYS and self._combo_uses_alt(self._toggle_keys):
+                        cancel_alt = True
+
+        # Alt-Menu-Workaround AUSSERHALB des Locks ausfuehren
+        if cancel_alt:
+            self._cancel_alt_menu()
+
+    def start(self) -> None:
+        """Startet den globalen Hotkey-Listener."""
+        if self._listener is not None:
+            log.warning("Listener läuft bereits")
+            return
+
+        self._listener = keyboard.Listener(
+            on_press=self._on_press,
+            on_release=self._on_release,
+        )
+        self._listener.daemon = True
+        self._listener.start()
+        log.info("Hotkey-Listener gestartet")
+
+    def stop(self) -> None:
+        """Stoppt den globalen Hotkey-Listener."""
+        if self._listener is not None:
+            self._listener.stop()
+            self._listener = None
+            self._pressed_keys.clear()
+            self._hold_active = False
+            self._toggle_combo_held = False
+            log.info("Hotkey-Listener gestoppt")
+
+    def update_hotkeys(
+        self,
+        hold_hotkey: list[str] | None = None,
+        toggle_hotkey: list[str] | None = None,
+    ) -> None:
+        """Aktualisiert die Hotkey-Konfiguration zur Laufzeit."""
+        with self._lock:
+            if hold_hotkey is not None:
+                self._hold_keys = []
+                self._hold_modifier_groups = []
+                for key_str in hold_hotkey:
+                    group = _get_modifier_group(key_str)
+                    if group:
+                        self._hold_modifier_groups.append(group)
+                    self._hold_keys.append(_resolve_key(key_str))
+                log.info("Hold-Hotkey aktualisiert: %s", " + ".join(hold_hotkey))
+
+            if toggle_hotkey is not None:
+                self._toggle_keys = []
+                self._toggle_modifier_groups = []
+                for key_str in toggle_hotkey:
+                    group = _get_modifier_group(key_str)
+                    if group:
+                        self._toggle_modifier_groups.append(group)
+                    self._toggle_keys.append(_resolve_key(key_str))
+                log.info("Toggle-Hotkey aktualisiert: %s", " + ".join(toggle_hotkey))
+
+            # State zurücksetzen
+            self._hold_active = False
+            self._toggle_combo_held = False
+            self._pressed_keys.clear()
+
+    @property
+    def is_hold_active(self) -> bool:
+        """Gibt zurück, ob der Hold-Hotkey gerade gedrückt wird."""
+        return self._hold_active
+
+    @property
+    def is_running(self) -> bool:
+        """Gibt zurück, ob der Listener läuft."""
+        return self._listener is not None and self._listener.is_alive()

paypertranscript/core/logging.py

@@ -0,0 +1,65 @@
+"""Logging-System für PayPerTranscript.
+
+Rotierende Log-Dateien in %APPDATA%\\PayPerTranscript\\logs\\,
+RotatingFileHandler mit max. 5MB pro Datei, 3 Backups.
+"""
+
+import logging
+import sys
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+
+APP_NAME = "PayPerTranscript"
+APPDATA_DIR = Path.home() / "AppData" / "Roaming" / APP_NAME
+LOG_DIR = APPDATA_DIR / "logs"
+
+LOG_FORMAT = "[%(asctime)s] [%(levelname)s] [%(name)s] %(message)s"
+LOG_DATE_FORMAT = "%Y-%m-%d %H:%M:%S"
+LOG_FILE = "paypertranscript.log"
+MAX_BYTES = 5 * 1024 * 1024  # 5 MB
+BACKUP_COUNT = 3
+
+
+def setup_logging(debug: bool = False) -> None:
+    """Initialisiert das Logging-System.
+
+    Args:
+        debug: Wenn True, wird DEBUG-Level geloggt, sonst INFO.
+    """
+    LOG_DIR.mkdir(parents=True, exist_ok=True)
+
+    level = logging.DEBUG if debug else logging.INFO
+    formatter = logging.Formatter(LOG_FORMAT, datefmt=LOG_DATE_FORMAT)
+
+    # Root-Logger konfigurieren
+    root_logger = logging.getLogger()
+    root_logger.setLevel(level)
+
+    # Vorhandene Handler entfernen (bei erneutem Aufruf)
+    root_logger.handlers.clear()
+
+    # Datei-Handler (rotierend)
+    file_handler = RotatingFileHandler(
+        LOG_DIR / LOG_FILE,
+        maxBytes=MAX_BYTES,
+        backupCount=BACKUP_COUNT,
+        encoding="utf-8",
+    )
+    file_handler.setLevel(level)
+    file_handler.setFormatter(formatter)
+    root_logger.addHandler(file_handler)
+
+    # Console-Handler (stderr)
+    console_handler = logging.StreamHandler(sys.stderr)
+    console_handler.setLevel(level)
+    console_handler.setFormatter(formatter)
+    root_logger.addHandler(console_handler)
+
+
+def get_logger(name: str) -> logging.Logger:
+    """Gibt einen benannten Logger zurück.
+
+    Args:
+        name: Modul-Name (z.B. 'core.config', 'providers.groq').
+    """
+    return logging.getLogger(f"{APP_NAME}.{name}")

paypertranscript/core/paths.py

@@ -0,0 +1,28 @@
+"""Pfad-Aufloesung fuer Assets.
+
+Assets liegen im paypertranscript-Package-Verzeichnis unter assets/.
+"""
+
+from pathlib import Path
+
+_PACKAGE_DIR = Path(__file__).resolve().parent.parent
+
+
+def get_assets_dir() -> Path:
+    """Gibt den Pfad zum assets/ Verzeichnis zurueck."""
+    return _PACKAGE_DIR / "assets"
+
+
+def get_styles_dir() -> Path:
+    """Gibt den Pfad zum assets/styles/ Verzeichnis zurueck."""
+    return get_assets_dir() / "styles"
+
+
+def get_sounds_dir() -> Path:
+    """Gibt den Pfad zum assets/sounds/ Verzeichnis zurueck."""
+    return get_assets_dir() / "sounds"
+
+
+def get_icons_dir() -> Path:
+    """Gibt den Pfad zum assets/icons/ Verzeichnis zurueck."""
+    return get_assets_dir() / "icons"

paypertranscript/core/recorder.py

@@ -0,0 +1,167 @@
+"""Audio-Aufnahme für PayPerTranscript.
+
+Callback-basiertes Recording mit sounddevice (16kHz, Mono, int16).
+Persistenter Stream — wird einmal erstellt und wiederverwendet.
+"""
+
+import threading
+import time
+from pathlib import Path
+
+import numpy as np
+import sounddevice as sd
+import soundfile as sf
+
+from paypertranscript.core.logging import get_logger
+
+log = get_logger("core.recorder")
+
+SAMPLE_RATE = 16000
+CHANNELS = 1
+DTYPE = "int16"
+BLOCKSIZE = 1024  # Frames pro Callback (~64ms bei 16kHz)
+
+
+class AudioRecorder:
+    """Nimmt Audio auf via sounddevice InputStream.
+
+    Nutzt einen persistenten Stream mit Callback. Frames werden in einer
+    Liste gesammelt und bei Stop mit numpy.concatenate() zusammengeführt.
+    """
+
+    def __init__(self) -> None:
+        self._frames: list[np.ndarray] = []
+        self._is_recording = False
+        self._lock = threading.Lock()
+        self._stream: sd.InputStream | None = None
+        self._start_time: float = 0.0
+        self._amplitude: float = 0.0  # Aktuelle Amplitude für Visualizer
+
+    def _audio_callback(
+        self,
+        indata: np.ndarray,
+        frames: int,
+        time_info: object,
+        status: sd.CallbackFlags,
+    ) -> None:
+        """Callback des InputStream — sammelt Frames während der Aufnahme."""
+        if status:
+            log.warning("Audio-Callback Status: %s", status)
+        if self._is_recording:
+            self._frames.append(indata.copy())
+            # Amplitude berechnen (RMS, normalisiert auf 0-1 für int16)
+            self._amplitude = float(np.sqrt(np.mean(indata.astype(np.float32) ** 2)) / 32768.0)
+
+    def start_stream(self) -> None:
+        """Erstellt und startet den persistenten Audio-Stream."""
+        if self._stream is not None:
+            log.debug("Audio-Stream existiert bereits")
+            return
+
+        try:
+            self._stream = sd.InputStream(
+                samplerate=SAMPLE_RATE,
+                channels=CHANNELS,
+                dtype=DTYPE,
+                blocksize=BLOCKSIZE,
+                callback=self._audio_callback,
+            )
+            self._stream.start()
+            log.info("Audio-Stream gestartet (%.0f Hz, %d Kanal, %s)", SAMPLE_RATE, CHANNELS, DTYPE)
+        except sd.PortAudioError as e:
+            log.error("Audio-Stream konnte nicht gestartet werden: %s", e)
+            self._stream = None
+            raise
+
+    def stop_stream(self) -> None:
+        """Stoppt und schließt den persistenten Audio-Stream."""
+        if self._stream is not None:
+            try:
+                self._stream.stop()
+                self._stream.close()
+            except sd.PortAudioError as e:
+                log.warning("Fehler beim Schließen des Audio-Streams: %s", e)
+            self._stream = None
+            log.info("Audio-Stream gestoppt")
+
+    def start_recording(self) -> None:
+        """Startet die Aufnahme (sammelt ab jetzt Frames)."""
+        with self._lock:
+            if self._is_recording:
+                log.warning("Aufnahme läuft bereits")
+                return
+
+            self._frames.clear()
+            self._amplitude = 0.0
+            self._start_time = time.perf_counter()
+            self._is_recording = True
+            log.info("Aufnahme gestartet")
+
+    def stop_recording(self) -> np.ndarray | None:
+        """Stoppt die Aufnahme und gibt die aufgenommenen Frames zurück.
+
+        Returns:
+            NumPy-Array mit Audio-Daten (int16) oder None wenn keine Daten.
+        """
+        with self._lock:
+            if not self._is_recording:
+                log.warning("Keine aktive Aufnahme zum Stoppen")
+                return None
+
+            self._is_recording = False
+            duration = time.perf_counter() - self._start_time
+            frames = self._frames.copy()
+            self._frames.clear()
+            self._amplitude = 0.0
+
+        if not frames:
+            log.warning("Aufnahme gestoppt — keine Audio-Daten aufgenommen")
+            return None
+
+        audio = np.concatenate(frames)
+        actual_duration = len(audio) / SAMPLE_RATE
+        log.info(
+            "Aufnahme gestoppt — Dauer: %.2fs (%.2fs wall), %d Samples",
+            actual_duration,
+            duration,
+            len(audio),
+        )
+        return audio
+
+    def save_wav(self, audio: np.ndarray, path: Path) -> Path:
+        """Speichert Audio-Daten als WAV-Datei.
+
+        Args:
+            audio: NumPy-Array mit Audio-Daten (int16).
+            path: Ziel-Pfad für die WAV-Datei.
+
+        Returns:
+            Der Pfad zur gespeicherten Datei.
+        """
+        sf.write(str(path), audio, SAMPLE_RATE, subtype="PCM_16")
+        file_size = path.stat().st_size
+        duration = len(audio) / SAMPLE_RATE
+        log.info(
+            "WAV gespeichert: %s (%.2fs, %.1f KB)",
+            path.name,
+            duration,
+            file_size / 1024,
+        )
+        return path
+
+    @property
+    def is_recording(self) -> bool:
+        """Gibt zurück, ob gerade aufgenommen wird."""
+        return self._is_recording
+
+    @property
+    def amplitude(self) -> float:
+        """Aktuelle Audio-Amplitude (0.0–1.0) für Visualizer."""
+        return self._amplitude
+
+    @property
+    def recording_duration(self) -> float:
+        """Aktuelle Aufnahmedauer in Sekunden (0 wenn nicht aufgenommen wird)."""
+        if self._is_recording:
+            return time.perf_counter() - self._start_time
+        return 0.0

paypertranscript/core/session_logger.py

@@ -0,0 +1,138 @@
+"""Session-Logging fuer PayPerTranscript.
+
+Thread-sichere Speicherung von Transkriptions-Sessions in tracking.json.
+"""
+
+import json
+import threading
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from paypertranscript.core.config import TRACKING_FILE
+from paypertranscript.core.logging import get_logger
+
+log = get_logger("core.session_logger")
+
+
+def _empty_totals() -> dict[str, Any]:
+    """Leere Totals-Struktur."""
+    return {
+        "session_count": 0,
+        "total_audio_seconds": 0.0,
+        "total_billed_seconds": 0.0,
+        "total_stt_cost_usd": 0.0,
+        "total_llm_cost_usd": 0.0,
+        "total_cost_usd": 0.0,
+    }
+
+
+class SessionLogger:
+    """Thread-sicherer Session-Logger fuer tracking.json."""
+
+    def __init__(self, tracking_file: Path = TRACKING_FILE) -> None:
+        self._file = tracking_file
+        self._lock = threading.Lock()
+        log.info("SessionLogger initialisiert: %s", self._file)
+
+    def _read_tracking(self) -> dict[str, Any]:
+        """Liest tracking.json (muss unter Lock aufgerufen werden)."""
+        if self._file.exists():
+            try:
+                raw = json.loads(self._file.read_text(encoding="utf-8"))
+                if isinstance(raw, dict):
+                    return raw
+            except (json.JSONDecodeError, OSError) as e:
+                log.warning("tracking.json konnte nicht gelesen werden: %s", e)
+        return {"sessions": [], "totals": _empty_totals()}
+
+    def _write_tracking(self, data: dict[str, Any]) -> None:
+        """Schreibt tracking.json (muss unter Lock aufgerufen werden)."""
+        self._file.parent.mkdir(parents=True, exist_ok=True)
+        try:
+            self._file.write_text(
+                json.dumps(data, indent=2, ensure_ascii=False),
+                encoding="utf-8",
+            )
+        except OSError as e:
+            log.error("tracking.json konnte nicht geschrieben werden: %s", e)
+
+    def log_session(self, session: dict[str, Any]) -> None:
+        """Loggt eine abgeschlossene Transkriptions-Session.
+
+        Thread-safe. Liest tracking.json, haengt Session an, aktualisiert Totals.
+
+        Args:
+            session: Dict mit Session-Daten (Felder aus PRD 5.7).
+        """
+        with self._lock:
+            tracking = self._read_tracking()
+
+            tracking.setdefault("sessions", []).append(session)
+
+            totals = tracking.setdefault("totals", _empty_totals())
+            totals["session_count"] = totals.get("session_count", 0) + 1
+            totals["total_audio_seconds"] = (
+                totals.get("total_audio_seconds", 0.0)
+                + session.get("audio_duration_seconds", 0.0)
+            )
+            totals["total_billed_seconds"] = (
+                totals.get("total_billed_seconds", 0.0)
+                + session.get("billed_seconds", 0.0)
+            )
+            totals["total_stt_cost_usd"] = (
+                totals.get("total_stt_cost_usd", 0.0)
+                + session.get("stt_cost_usd", 0.0)
+            )
+            totals["total_llm_cost_usd"] = (
+                totals.get("total_llm_cost_usd", 0.0)
+                + session.get("llm_cost_usd", 0.0)
+            )
+            totals["total_cost_usd"] = (
+                totals.get("total_cost_usd", 0.0)
+                + session.get("total_cost_usd", 0.0)
+            )
+
+            self._write_tracking(tracking)
+
+        log.info(
+            "Session geloggt: %.1fs Audio, $%.6f total",
+            session.get("audio_duration_seconds", 0),
+            session.get("total_cost_usd", 0),
+        )
+
+    def get_tracking_data(self) -> dict[str, Any]:
+        """Gibt alle Tracking-Daten zurueck (thread-safe read)."""
+        with self._lock:
+            return self._read_tracking()
+
+    def get_sessions(self, days: int | None = None) -> list[dict[str, Any]]:
+        """Gibt Sessions zurueck, optional gefiltert auf letzte N Tage.
+
+        Args:
+            days: Wenn angegeben, nur Sessions der letzten N Tage.
+
+        Returns:
+            Liste von Session-Dicts.
+        """
+        data = self.get_tracking_data()
+        sessions = data.get("sessions", [])
+
+        if days is not None:
+            cutoff = datetime.now(timezone.utc).timestamp() - (days * 86400)
+            filtered = []
+            for s in sessions:
+                try:
+                    ts = datetime.fromisoformat(s["timestamp"]).timestamp()
+                    if ts >= cutoff:
+                        filtered.append(s)
+                except (KeyError, ValueError):
+                    pass
+            return filtered
+
+        return sessions
+
+    def get_totals(self) -> dict[str, Any]:
+        """Gibt aggregierte Totals zurueck."""
+        data = self.get_tracking_data()
+        return data.get("totals", _empty_totals())