meeting-noter 1.3.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/mic_monitor.py

@@ -36,11 +36,21 @@ class _AudioObjectPropertyAddress(Structure):
 _core_audio = None
 _AudioObjectGetPropertyDataSize = None
 _AudioObjectGetPropertyData = None
+_coreaudio_init_time = 0  # Track when CoreAudio was initialized
+
+
+def _reset_coreaudio():
+    """Reset CoreAudio framework (for reinitializing after long idle)."""
+    global _core_audio, _AudioObjectGetPropertyDataSize, _AudioObjectGetPropertyData, _coreaudio_init_time
+    _core_audio = None
+    _AudioObjectGetPropertyDataSize = None
+    _AudioObjectGetPropertyData = None
+    _coreaudio_init_time = 0
 
 
 def _init_coreaudio():
     """Initialize CoreAudio framework."""
-    global _core_audio, _AudioObjectGetPropertyDataSize, _AudioObjectGetPropertyData
+    global _core_audio, _AudioObjectGetPropertyDataSize, _AudioObjectGetPropertyData, _coreaudio_init_time
 
     if _core_audio is not None:
         return True
@@ -60,11 +70,26 @@ def _init_coreaudio():
         ]
         _AudioObjectGetPropertyData.restype = c_int32
 
+        _coreaudio_init_time = time.time()
         return True
     except Exception:
         return False
 
 
+# Reinitialize CoreAudio every 30 minutes to prevent stale handles
+_COREAUDIO_REFRESH_INTERVAL = 30 * 60
+
+
+def _maybe_refresh_coreaudio():
+    """Reinitialize CoreAudio if it's been too long since last init.
+
+    This prevents stale CoreAudio handles after system sleep or long idle.
+    """
+    global _coreaudio_init_time
+    if _core_audio is not None and time.time() - _coreaudio_init_time > _COREAUDIO_REFRESH_INTERVAL:
+        _reset_coreaudio()
+
+
 def is_mic_in_use_by_another_app() -> bool:
     """Check if the microphone is being used by another application.
 
@@ -74,6 +99,9 @@ def is_mic_in_use_by_another_app() -> bool:
     Returns:
         True if another app is using the microphone
     """
+    # Refresh CoreAudio if it's been too long (prevents stale handles)
+    _maybe_refresh_coreaudio()
+
     if not _init_coreaudio():
         return False
 

meeting_noter/ui/__init__.py

@@ -0,0 +1,5 @@
+"""Terminal User Interface for Meeting Noter."""
+
+from meeting_noter.ui.app import MeetingNoterApp
+
+__all__ = ["MeetingNoterApp"]