meeting-noter 2.0.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

meeting_noter/gui/utils/workers.py

@@ -0,0 +1,258 @@
+"""Background worker threads for Meeting Noter GUI."""
+
+from __future__ import annotations
+
+import os
+import time
+from pathlib import Path
+from typing import Optional
+
+from PySide6.QtCore import QThread, Signal
+
+from meeting_noter.config import get_config
+from meeting_noter.daemon import is_process_running, read_pid_file
+
+
+DEFAULT_PID_FILE = Path.home() / ".meeting-noter.pid"
+WATCHER_PID_FILE = Path.home() / ".meeting-noter-watcher.pid"
+LOG_FILE = Path.home() / ".meeting-noter.log"
+
+
+class StatusPollingWorker(QThread):
+    """Polls daemon/watcher status periodically."""
+
+    status_updated = Signal(bool, bool, str)  # watcher_running, daemon_running, meeting_name
+
+    def __init__(self, interval_ms: int = 2000):
+        super().__init__()
+        self._stop_flag = False
+        self._interval = interval_ms
+
+    def run(self):
+        """Poll status until stopped."""
+        while not self._stop_flag:
+            watcher = self._check_watcher()
+            daemon, name = self._check_daemon()
+            self.status_updated.emit(watcher, daemon, name or "")
+            self.msleep(self._interval)
+
+    def stop(self):
+        """Stop the worker."""
+        self._stop_flag = True
+        self.wait()
+
+    def _check_watcher(self) -> bool:
+        """Check if watcher is running."""
+        if WATCHER_PID_FILE.exists():
+            try:
+                pid = int(WATCHER_PID_FILE.read_text().strip())
+                os.kill(pid, 0)
+                return True
+            except (ProcessLookupError, ValueError, FileNotFoundError, PermissionError):
+                pass
+        return False
+
+    def _check_daemon(self) -> tuple[bool, Optional[str]]:
+        """Check if daemon is running and get recording name."""
+        daemon_pid = read_pid_file(DEFAULT_PID_FILE)
+        if daemon_pid and is_process_running(daemon_pid):
+            recording_name = self._get_current_recording_name()
+            return True, recording_name
+        return False, None
+
+    def _get_current_recording_name(self) -> Optional[str]:
+        """Get the name of the current recording from the log file."""
+        if not LOG_FILE.exists():
+            return None
+
+        try:
+            with open(LOG_FILE, "r") as f:
+                lines = f.readlines()
+
+            for line in reversed(lines[-50:]):
+                if "Recording started:" in line:
+                    parts = line.split("Recording started:")
+                    if len(parts) > 1:
+                        filename = parts[1].strip().replace(".mp3", "")
+                        name_parts = filename.split("_", 2)
+                        if len(name_parts) >= 3:
+                            return name_parts[2]
+                        return filename
+                elif "Recording saved:" in line or "Recording discarded" in line:
+                    break
+            return None
+        except Exception:
+            return None
+
+
+class LiveTranscriptWatcher(QThread):
+    """Watches live transcript file for changes."""
+
+    new_content = Signal(str)  # new text content
+    file_changed = Signal(str)  # new file name
+    recording_ended = Signal()
+
+    def __init__(self, interval_ms: int = 500):
+        super().__init__()
+        self._stop_flag = False
+        self._interval = interval_ms
+        self._current_file: Optional[Path] = None
+        self._last_content = ""
+        self._last_mtime = 0.0
+
+    def run(self):
+        """Watch for live transcript updates."""
+        while not self._stop_flag:
+            self._check_live_transcript()
+            self.msleep(self._interval)
+
+    def stop(self):
+        """Stop the worker."""
+        self._stop_flag = True
+        self.wait()
+
+    def _check_live_transcript(self) -> None:
+        """Check for live transcript updates."""
+        config = get_config()
+        live_dir = config.recordings_dir / "live"
+
+        if not live_dir.exists():
+            return
+
+        # Find the most recent live file
+        try:
+            live_files = sorted(
+                live_dir.glob("*.live.txt"),
+                key=lambda p: p.stat().st_mtime,
+                reverse=True,
+            )
+        except Exception:
+            return
+
+        if not live_files:
+            if self._current_file is not None:
+                self.recording_ended.emit()
+                self._current_file = None
+                self._last_content = ""
+            return
+
+        live_file = live_files[0]
+
+        # Check if file is recent (active within last 30 seconds)
+        try:
+            file_mtime = live_file.stat().st_mtime
+            if time.time() - file_mtime > 30:
+                if self._current_file is not None:
+                    self.recording_ended.emit()
+                    self._current_file = None
+                    self._last_content = ""
+                return
+        except Exception:
+            return
+
+        # Detect new file (new recording started)
+        if self._current_file != live_file:
+            self._current_file = live_file
+            self._last_content = ""
+            self._last_mtime = file_mtime
+            meeting_name = live_file.stem.replace(".live", "")
+            self.file_changed.emit(meeting_name)
+
+        # Read and emit new content
+        try:
+            content = live_file.read_text()
+            if len(content) > len(self._last_content):
+                new_content = content[len(self._last_content) :]
+                self.new_content.emit(new_content)
+                self._last_content = content
+        except Exception:
+            pass
+
+
+class TranscriptionWorker(QThread):
+    """Runs transcription in background."""
+
+    progress = Signal(str)  # status message
+    finished = Signal(str)  # transcript path
+    error = Signal(str)  # error message
+
+    def __init__(self, audio_path: Path, model: str = ""):
+        super().__init__()
+        self._audio_path = audio_path
+        self._model = model
+
+    def run(self):
+        """Run transcription."""
+        import subprocess
+        import sys
+
+        try:
+            self.progress.emit("Starting transcription...")
+
+            cmd = [sys.executable, "-m", "meeting_noter.cli", "transcribe", str(self._audio_path)]
+            if self._model:
+                cmd.extend(["--model", self._model])
+
+            result = subprocess.run(cmd, capture_output=True, text=True)
+
+            if result.returncode == 0:
+                # Extract transcript path from output
+                output = result.stdout
+                for line in output.splitlines():
+                    if "Transcript saved:" in line:
+                        path = line.split("Transcript saved:")[-1].strip()
+                        self.finished.emit(path)
+                        return
+                self.finished.emit("")
+            else:
+                self.error.emit(result.stderr or "Transcription failed")
+
+        except Exception as e:
+            self.error.emit(str(e))
+
+
+class LogWatcher(QThread):
+    """Watches log file for new content."""
+
+    new_content = Signal(str)  # new log lines
+
+    def __init__(self, interval_ms: int = 1000):
+        super().__init__()
+        self._stop_flag = False
+        self._interval = interval_ms
+        self._last_size = 0
+
+    def run(self):
+        """Watch log file for changes."""
+        while not self._stop_flag:
+            self._check_log_file()
+            self.msleep(self._interval)
+
+    def stop(self):
+        """Stop the worker."""
+        self._stop_flag = True
+        self.wait()
+
+    def _check_log_file(self) -> None:
+        """Check for new log content."""
+        if not LOG_FILE.exists():
+            return
+
+        try:
+            current_size = LOG_FILE.stat().st_size
+            if current_size > self._last_size:
+                with open(LOG_FILE, "r") as f:
+                    f.seek(self._last_size)
+                    new_content = f.read()
+                    if new_content:
+                        self.new_content.emit(new_content)
+                self._last_size = current_size
+            elif current_size < self._last_size:
+                # File was truncated, reset
+                self._last_size = 0
+        except Exception:
+            pass
+
+    def reset(self):
+        """Reset the file position."""
+        self._last_size = 0

meeting_noter/gui/widgets/__init__.py

@@ -0,0 +1,6 @@
+"""Reusable widgets for Meeting Noter GUI."""
+
+from meeting_noter.gui.widgets.sidebar import Sidebar
+from meeting_noter.gui.widgets.status_indicator import StatusIndicator
+
+__all__ = ["Sidebar", "StatusIndicator"]

meeting_noter/gui/widgets/sidebar.py

@@ -0,0 +1,210 @@
+"""Navigation sidebar widget for Meeting Noter GUI."""
+
+from __future__ import annotations
+
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtGui import QFont
+from PySide6.QtWidgets import (
+    QButtonGroup,
+    QFrame,
+    QLabel,
+    QPushButton,
+    QSizePolicy,
+    QSpacerItem,
+    QVBoxLayout,
+    QWidget,
+)
+
+
+class SidebarButton(QPushButton):
+    """A navigation button for the sidebar."""
+
+    def __init__(self, text: str, icon: str = "", parent=None):
+        super().__init__(parent)
+        display_text = f"  {icon}   {text}" if icon else f"  {text}"
+        self.setText(display_text)
+        self.setCheckable(True)
+        self.setMinimumHeight(50)
+        self.setCursor(Qt.PointingHandCursor)
+
+
+class Sidebar(QWidget):
+    """Navigation sidebar with icon buttons."""
+
+    screen_selected = Signal(str)  # Emits screen name when clicked
+    quit_requested = Signal()  # Emits when quit button clicked
+
+    # Navigation items with better Unicode icons
+    NAV_ITEMS = [
+        ("dashboard", "Dashboard", "⌂"),  # Home
+        ("recordings", "Recordings", "◉"),  # Record
+        ("search", "Search", "⌕"),  # Search
+        ("settings", "Settings", "⚙"),  # Gear
+        ("logs", "Logs", "☰"),  # Menu/logs
+    ]
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setObjectName("sidebar")
+        self.setMinimumWidth(220)
+        self.setMaximumWidth(220)
+
+        self._setup_ui()
+        self._connect_signals()
+
+    def _setup_ui(self):
+        """Set up the sidebar UI."""
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(0)
+
+        # Title/Logo area
+        title_frame = QFrame()
+        title_frame.setObjectName("sidebar-title-frame")
+        title_layout = QVBoxLayout(title_frame)
+        title_layout.setContentsMargins(20, 20, 20, 20)
+
+        title = QLabel("Meeting Noter")
+        title.setObjectName("sidebar-title")
+        title_font = QFont("Menlo, Monaco, Courier New, monospace", 18)
+        title_font.setBold(True)
+        title.setFont(title_font)
+        title.setAlignment(Qt.AlignCenter)
+        title_layout.addWidget(title)
+
+        subtitle = QLabel("v2.0")
+        subtitle.setObjectName("sidebar-subtitle")
+        subtitle.setAlignment(Qt.AlignCenter)
+        subtitle.setStyleSheet("color: #5a5a5a; font-size: 12px;")
+        title_layout.addWidget(subtitle)
+
+        layout.addWidget(title_frame)
+
+        # Separator
+        separator = QFrame()
+        separator.setFrameShape(QFrame.HLine)
+        separator.setStyleSheet("background-color: #3c3c3c; max-height: 1px;")
+        layout.addWidget(separator)
+
+        # Navigation section label
+        nav_label = QLabel("  NAVIGATION")
+        nav_label.setObjectName("sidebar-section-label")
+        nav_label.setStyleSheet(
+            "color: #5a5a5a; font-size: 11px; font-weight: 600; "
+            "letter-spacing: 1px; padding: 15px 0 5px 15px;"
+        )
+        layout.addWidget(nav_label)
+
+        # Navigation buttons
+        self._button_group = QButtonGroup(self)
+        self._button_group.setExclusive(True)
+        self._buttons: dict[str, SidebarButton] = {}
+
+        button_font = QFont("Menlo, Monaco, Courier New, monospace", 14)
+
+        for screen_id, label, icon in self.NAV_ITEMS:
+            btn = SidebarButton(label, icon)
+            btn.setFont(button_font)
+            btn.setProperty("screen_id", screen_id)
+            self._buttons[screen_id] = btn
+            self._button_group.addButton(btn)
+            layout.addWidget(btn)
+
+        # Spacer
+        layout.addItem(QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding))
+
+        # Status area at bottom
+        separator2 = QFrame()
+        separator2.setFrameShape(QFrame.HLine)
+        separator2.setStyleSheet("background-color: #3c3c3c; max-height: 1px;")
+        layout.addWidget(separator2)
+
+        self._status_frame = QFrame()
+        self._status_frame.setObjectName("sidebar-status")
+        status_layout = QVBoxLayout(self._status_frame)
+        status_layout.setContentsMargins(15, 15, 15, 15)
+
+        status_label = QLabel("STATUS")
+        status_label.setStyleSheet(
+            "color: #5a5a5a; font-size: 11px; font-weight: 600; letter-spacing: 1px;"
+        )
+        status_layout.addWidget(status_label)
+
+        self._status_text = QLabel("● Idle")
+        self._status_text.setObjectName("sidebar-status-text")
+        status_font = QFont("Menlo, Monaco, Courier New, monospace", 13)
+        self._status_text.setFont(status_font)
+        self._status_text.setStyleSheet("color: #5a5a5a; padding-top: 5px;")
+        status_layout.addWidget(self._status_text)
+
+        layout.addWidget(self._status_frame)
+
+        # Quit button at bottom
+        separator3 = QFrame()
+        separator3.setFrameShape(QFrame.HLine)
+        separator3.setStyleSheet("background-color: #3c3c3c; max-height: 1px;")
+        layout.addWidget(separator3)
+
+        self._quit_btn = QPushButton("  ⏻   Quit")
+        self._quit_btn.setFont(button_font)
+        self._quit_btn.setMinimumHeight(50)
+        self._quit_btn.setCursor(Qt.PointingHandCursor)
+        self._quit_btn.setStyleSheet("""
+            QPushButton {
+                background-color: transparent;
+                border: none;
+                border-radius: 6px;
+                padding: 12px 15px;
+                text-align: left;
+                color: #808080;
+                font-size: 14px;
+                margin: 3px 10px;
+            }
+            QPushButton:hover {
+                background-color: #2a1a1a;
+                color: #f14c4c;
+            }
+        """)
+        layout.addWidget(self._quit_btn)
+
+        # Bottom padding
+        layout.addSpacing(10)
+
+        # Select dashboard by default
+        self._buttons["dashboard"].setChecked(True)
+
+    def _connect_signals(self):
+        """Connect button signals."""
+        for btn in self._buttons.values():
+            btn.clicked.connect(self._on_button_clicked)
+        self._quit_btn.clicked.connect(self._on_quit_clicked)
+
+    def _on_button_clicked(self):
+        """Handle navigation button click."""
+        btn = self.sender()
+        if btn:
+            screen_id = btn.property("screen_id")
+            self.screen_selected.emit(screen_id)
+
+    def _on_quit_clicked(self):
+        """Handle quit button click."""
+        self.quit_requested.emit()
+
+    def select_screen(self, screen_id: str):
+        """Programmatically select a screen."""
+        if screen_id in self._buttons:
+            self._buttons[screen_id].setChecked(True)
+
+    def update_status(self, is_recording: bool, meeting_name: str = ""):
+        """Update the status display."""
+        if is_recording:
+            if meeting_name:
+                display_name = meeting_name[:18] + "..." if len(meeting_name) > 18 else meeting_name
+                status = f"● {display_name}"
+            else:
+                status = "● Recording..."
+            self._status_text.setStyleSheet("color: #f14c4c; padding-top: 5px;")
+        else:
+            status = "● Idle"
+            self._status_text.setStyleSheet("color: #5a5a5a; padding-top: 5px;")
+        self._status_text.setText(status)

meeting_noter/gui/widgets/status_indicator.py

@@ -0,0 +1,108 @@
+"""Status indicator widget for Meeting Noter GUI."""
+
+from __future__ import annotations
+
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QFont
+from PySide6.QtWidgets import QHBoxLayout, QLabel, QVBoxLayout, QWidget
+
+from meeting_noter.gui.theme.dark_theme import COLORS
+
+
+class StatusIndicator(QWidget):
+    """Widget to display current recording status."""
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setObjectName("status-indicator")
+        self._setup_ui()
+        self._set_idle_state()
+
+    def _setup_ui(self):
+        """Set up the status indicator UI."""
+        self.setStyleSheet(
+            "background-color: #0d0d0d; border: 1px solid #2a2a2a; border-radius: 8px;"
+        )
+
+        layout = QHBoxLayout(self)
+        layout.setContentsMargins(20, 20, 20, 20)
+        layout.setSpacing(20)
+
+        # Status dot
+        self._dot = QLabel("●")
+        self._dot.setObjectName("status-dot")
+        self._dot.setAlignment(Qt.AlignCenter)
+        dot_font = QFont("Menlo, Monaco, Courier New, monospace", 32)
+        self._dot.setFont(dot_font)
+        layout.addWidget(self._dot)
+
+        # Status text container
+        text_container = QWidget()
+        text_container.setStyleSheet("background-color: transparent; border: none;")
+        text_layout = QVBoxLayout(text_container)
+        text_layout.setContentsMargins(0, 0, 0, 0)
+        text_layout.setSpacing(4)
+
+        self._status_text = QLabel("Stopped")
+        self._status_text.setObjectName("status-text")
+        status_font = QFont("Menlo, Monaco, Courier New, monospace", 18)
+        status_font.setBold(True)
+        self._status_text.setFont(status_font)
+        text_layout.addWidget(self._status_text)
+
+        self._details_text = QLabel("Watcher: stopped | Recorder: idle")
+        self._details_text.setObjectName("status-details")
+        details_font = QFont("Menlo, Monaco, Courier New, monospace", 12)
+        self._details_text.setFont(details_font)
+        self._details_text.setStyleSheet("color: #808080; background-color: transparent;")
+        text_layout.addWidget(self._details_text)
+
+        layout.addWidget(text_container)
+        layout.addStretch()
+
+    def _set_idle_state(self):
+        """Set the idle/stopped state."""
+        self._dot.setStyleSheet(f"color: #5a5a5a; background-color: transparent;")
+        self._status_text.setText("Stopped")
+        self._status_text.setStyleSheet("color: #808080; background-color: transparent;")
+        self._details_text.setText("Watcher: stopped | Recorder: idle")
+
+    def update_status(
+        self, watcher_running: bool, daemon_running: bool, meeting_name: str = ""
+    ):
+        """Update the status display."""
+        if daemon_running:
+            # Recording state - red
+            self._dot.setStyleSheet("color: #f14c4c; background-color: transparent;")
+            self._status_text.setStyleSheet("color: #f14c4c; background-color: transparent;")
+            if meeting_name:
+                self._status_text.setText(f"Recording: {meeting_name}")
+            else:
+                self._status_text.setText("Recording...")
+        elif watcher_running:
+            # Ready state - green
+            self._dot.setStyleSheet("color: #4ec9b0; background-color: transparent;")
+            self._status_text.setStyleSheet("color: #4ec9b0; background-color: transparent;")
+            self._status_text.setText("Ready (watcher active)")
+        else:
+            # Stopped state - gray
+            self._dot.setStyleSheet("color: #5a5a5a; background-color: transparent;")
+            self._status_text.setStyleSheet("color: #808080; background-color: transparent;")
+            self._status_text.setText("Stopped")
+
+        # Update details
+        watcher_status = "running" if watcher_running else "stopped"
+        recorder_status = "recording" if daemon_running else "idle"
+        self._details_text.setText(f"Watcher: {watcher_status} | Recorder: {recorder_status}")
+
+    def set_recording(self, meeting_name: str = ""):
+        """Set recording state."""
+        self.update_status(False, True, meeting_name)
+
+    def set_ready(self):
+        """Set ready (watcher active) state."""
+        self.update_status(True, False)
+
+    def set_stopped(self):
+        """Set stopped state."""
+        self.update_status(False, False)

{meeting_noter-2.0.0.dist-info → meeting_noter-3.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meeting-noter
-Version: 2.0.0
+Version: 3.0.0
 Summary: Offline meeting transcription for macOS with automatic meeting detection
 Author: Victor
 License: MIT
@@ -36,6 +36,8 @@ Requires-Dist: pyobjc-framework-CoreMedia>=9.0; sys_platform == "darwin"
 Requires-Dist: pyobjc-framework-libdispatch>=9.0; sys_platform == "darwin"
 Provides-Extra: offline
 Requires-Dist: meeting-noter-models>=0.1.0; extra == "offline"
+Provides-Extra: gui
+Requires-Dist: PySide6>=6.5.0; extra == "gui"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"

{meeting_noter-2.0.0.dist-info → meeting_noter-3.0.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
-meeting_noter/__init__.py,sha256=UpvJiLNpsDsoEbxhb6uqsVi1Sa0aUY4BvxWHfaYcBXg,103
+meeting_noter/__init__.py,sha256=IUXWaiwZS1L2077809O-HLyrSjQQUYQ30Xjw7j_HDiI,103
 meeting_noter/__main__.py,sha256=6sSOqH1o3jvgvkVzsVKmF6-xVGcUAbNVQkRl2CrygdE,120
-meeting_noter/cli.py,sha256=m9oHXqRLM8nilFRNaPcVgNOyflmBV9qQ6YHQZmGMG0I,36790
+meeting_noter/cli.py,sha256=_nAbOnqO1eZprWO74zvHKrCfKDqn7YoFs1SsdEOY-WQ,38200
 meeting_noter/config.py,sha256=vdnTh6W6-DUPJCj0ekFu1Q1m87O7gx0QD3E5DrRGpXk,7537
 meeting_noter/daemon.py,sha256=i81IXgEnsoAoMewknySO5_ECa1nCGOsVLfXtJXJf0rw,21611
 meeting_noter/meeting_detector.py,sha256=St0qoMkvUERP4BaxnXO1M6fZDJpWqBf9In7z2SgWcWg,10564
@@ -10,6 +10,25 @@ meeting_noter/audio/__init__.py,sha256=O7PU8CxHSHxMeHbc9Jdwt9kePLQzsPh81GQU7VHCt
 meeting_noter/audio/capture.py,sha256=fDrT5oXfva8vdFlht9cv60NviKbksw2QeJ8eOtI19uE,6469
 meeting_noter/audio/encoder.py,sha256=OBsgUmlZPz-YZQZ7Rp8MAlMRaQxTsccjuTgCtvRebmc,6573
 meeting_noter/audio/system_audio.py,sha256=jbHGjNCerI19weXap0a90Ik17lVTCT1hCEgRKYke-p8,13016
+meeting_noter/gui/__init__.py,sha256=XdjSYNGeiLyGb4wRfDk9mnJuYD_PC-a-tw096Zf0DNk,1401
+meeting_noter/gui/main_window.py,sha256=NXl4JgPbF7MvuLrwmId6i6speYUoiwhMwubYX3C1MLA,6902
+meeting_noter/gui/menubar.py,sha256=hyqm74Vp1I0eB57yzvYEvtzk4y-Y5GRCZau-erGYr_I,8261
+meeting_noter/gui/screens/__init__.py,sha256=_ETRs61OD0xm_FkKTvhv286hpSEsmeZ8v15bKUSUs8Y,549
+meeting_noter/gui/screens/dashboard.py,sha256=_5VzZuh4lUDKoW9iGdM9YZZAqliZtK8azYagI6zFimg,9492
+meeting_noter/gui/screens/logs.py,sha256=acqNhx0H2emVDQ4uCrhkVxbExG58Z99mUrMySF321xI,5746
+meeting_noter/gui/screens/recordings.py,sha256=rQ7_hLv2uq-qyFTlmnR1NuH9h0Yp5u7rh0o6Gv1Vfw8,9500
+meeting_noter/gui/screens/search.py,sha256=emdfAGQR3rhtrbj5rfCYjgqPY8i6gzUO4z1wZ6naFsA,7345
+meeting_noter/gui/screens/settings.py,sha256=u-L0l6I6h25Tp2PIBQW8KipKEBc2VYGsxrXwEENLJxU,8016
+meeting_noter/gui/screens/viewer.py,sha256=TEVCO1tcYVO1li1pt846fKx5VxTxk-lWywnoBV2XuUc,4383
+meeting_noter/gui/theme/__init__.py,sha256=UMcYNuIxJSuLH9iFerklxShJd9BGqyFdeEHYwzWYk8E,148
+meeting_noter/gui/theme/dark_theme.py,sha256=UAgrJDjPgzkjBg7ucg1NC0jOUylh1-n0BcQL9mBZNMA,1795
+meeting_noter/gui/theme/styles.qss,sha256=zY0bYZALFE5Mu93oKYix1s0IzhQCk9AQbu1ChWe-NSQ,9299
+meeting_noter/gui/utils/__init__.py,sha256=IG3pknZCt9P3vEM-1NbARiwoeLN8vT0B5gLOL2Aecik,338
+meeting_noter/gui/utils/signals.py,sha256=voOqXteRWGbrgnltrz_Q4_hjwtUK71r9n16ojAhQLAU,2362
+meeting_noter/gui/utils/workers.py,sha256=xYdpdgUHJcYJkThWoluT0QKKyfTXKzscyi_u3a91GuE,8283
+meeting_noter/gui/widgets/__init__.py,sha256=lbcVJ23SYzVro0VLucsXaBn_X9L1vviUtuwS-H_0YPA,214
+meeting_noter/gui/widgets/sidebar.py,sha256=-VDnWMk5gSonjHmpSIv4MgcVDmsrmPAbnafLk5AHHK0,7232
+meeting_noter/gui/widgets/status_indicator.py,sha256=4gHhOrX1gmP_00V3dXRCg5EkR_k8r_MP_BHNll25ido,4347
 meeting_noter/install/__init__.py,sha256=SX5vLFMrV8aBDEGW18jhaqBqJqnRXaeo0Ct7QVGDgvE,38
 meeting_noter/install/macos.py,sha256=dO-86zbNKRtt0l4D8naVn7kFWjzI8TufWLWE3FRLHQ8,3400
 meeting_noter/output/__init__.py,sha256=F7xPlOrqweZcPbZtDrhved1stBI59vnWnLYfGwdu6oY,31
@@ -39,8 +58,8 @@ meeting_noter/ui/screens/settings.py,sha256=Zb9-1rkPap1oUNcu4SJcOIemI8DmVC_5uqMd
 meeting_noter/ui/screens/viewer.py,sha256=5LVhghDcpshlisCrygk9H3uwOh48vmonMd8d4NH77hU,3991
 meeting_noter/ui/styles/app.tcss,sha256=-uE-1mE3oqKBZW1-pySmOZhK9oxjEQqcG7LDprwxBg4,3396
 meeting_noter/ui/widgets/__init__.py,sha256=6aVXLDGFXL9PnX5bCnMAqRqOvsv4VuzK_T2UTySQlTg,36
-meeting_noter-2.0.0.dist-info/METADATA,sha256=_t77Osf039ZI_VOKMgOsk-OGcBe0SX950SUpsHvVzmY,6970
-meeting_noter-2.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-meeting_noter-2.0.0.dist-info/entry_points.txt,sha256=osZoOmm-UBPCJ4b6DGH6JOAm7mofM2fK06eK6blplmg,83
-meeting_noter-2.0.0.dist-info/top_level.txt,sha256=9Tuq04_0SXM0OXOHVbOHkHkB5tG3fqkrMrfzCMpbLpY,14
-meeting_noter-2.0.0.dist-info/RECORD,,
+meeting_noter-3.0.0.dist-info/METADATA,sha256=sROgsYboliy4ehnWYiZ54Jzs-tWePYweba1EoP8Z-90,7036
+meeting_noter-3.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+meeting_noter-3.0.0.dist-info/entry_points.txt,sha256=osZoOmm-UBPCJ4b6DGH6JOAm7mofM2fK06eK6blplmg,83
+meeting_noter-3.0.0.dist-info/top_level.txt,sha256=9Tuq04_0SXM0OXOHVbOHkHkB5tG3fqkrMrfzCMpbLpY,14
+meeting_noter-3.0.0.dist-info/RECORD,,