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

meeting_noter/gui/menubar.py

@@ -0,0 +1,248 @@
+"""Menu bar (system tray) integration for Meeting Noter GUI."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QTimer
+from PySide6.QtGui import QAction, QIcon, QPixmap, QPainter, QColor, QFont
+from PySide6.QtWidgets import QMenu, QSystemTrayIcon
+
+if TYPE_CHECKING:
+    from meeting_noter.gui.main_window import MainWindow
+
+
+class MenuBarIcon(QSystemTrayIcon):
+    """System tray / menu bar icon for Meeting Noter."""
+
+    # Status states
+    STATUS_STOPPED = "stopped"
+    STATUS_READY = "ready"
+    STATUS_RECORDING = "recording"
+
+    def __init__(self, main_window: "MainWindow"):
+        super().__init__()
+        self._main_window = main_window
+        self._current_status = self.STATUS_STOPPED
+        self._recording_name = ""
+
+        self._setup_icons()
+        self._setup_menu()
+        self._setup_polling()
+
+        # Set initial icon
+        self._update_icon()
+
+        # Connect signals
+        self.activated.connect(self._on_activated)
+
+    def _setup_icons(self):
+        """Create status icons programmatically."""
+        self._icons = {}
+
+        # Create icons for each status
+        for status, color in [
+            (self.STATUS_STOPPED, "#5a5a5a"),  # Gray
+            (self.STATUS_READY, "#4ec9b0"),     # Green/Cyan
+            (self.STATUS_RECORDING, "#f14c4c"), # Red
+        ]:
+            self._icons[status] = self._create_icon(color)
+
+    def _create_icon(self, color: str) -> QIcon:
+        """Create a simple colored circle icon."""
+        size = 22
+        pixmap = QPixmap(size, size)
+        pixmap.fill(QColor(0, 0, 0, 0))  # Transparent background
+
+        painter = QPainter(pixmap)
+        painter.setRenderHint(QPainter.Antialiasing)
+
+        # Draw filled circle
+        painter.setBrush(QColor(color))
+        painter.setPen(QColor(color))
+        margin = 3
+        painter.drawEllipse(margin, margin, size - margin * 2, size - margin * 2)
+
+        painter.end()
+        return QIcon(pixmap)
+
+    def _setup_menu(self):
+        """Set up the context menu."""
+        self._menu = QMenu()
+        self._menu.setStyleSheet("""
+            QMenu {
+                background-color: #1a1a1a;
+                border: 1px solid #2a2a2a;
+                border-radius: 6px;
+                padding: 5px;
+            }
+            QMenu::item {
+                color: #d4d4d4;
+                padding: 8px 20px;
+                border-radius: 4px;
+            }
+            QMenu::item:selected {
+                background-color: #2a2a2a;
+            }
+            QMenu::separator {
+                height: 1px;
+                background-color: #2a2a2a;
+                margin: 5px 10px;
+            }
+        """)
+
+        # Status label (non-clickable)
+        self._status_action = QAction("● Stopped")
+        self._status_action.setEnabled(False)
+        self._menu.addAction(self._status_action)
+
+        self._menu.addSeparator()
+
+        # Open GUI
+        self._open_action = QAction("Open Meeting Noter")
+        self._open_action.triggered.connect(self._show_main_window)
+        self._menu.addAction(self._open_action)
+
+        self._menu.addSeparator()
+
+        # Quit
+        self._quit_action = QAction("Quit Meeting Noter")
+        self._quit_action.triggered.connect(self._quit_app)
+        self._menu.addAction(self._quit_action)
+
+        self.setContextMenu(self._menu)
+
+    def _setup_polling(self):
+        """Set up status polling timer."""
+        self._poll_timer = QTimer()
+        self._poll_timer.timeout.connect(self._poll_status)
+        self._poll_timer.start(2000)  # Poll every 2 seconds
+
+    def _poll_status(self):
+        """Poll for status updates."""
+        import os
+        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"
+
+        # Check watcher
+        watcher_running = False
+        if WATCHER_PID_FILE.exists():
+            try:
+                pid = int(WATCHER_PID_FILE.read_text().strip())
+                os.kill(pid, 0)
+                watcher_running = True
+            except (ProcessLookupError, ValueError, FileNotFoundError, PermissionError):
+                pass
+
+        # Check daemon
+        daemon_running = False
+        daemon_pid = read_pid_file(DEFAULT_PID_FILE)
+        if daemon_pid and is_process_running(daemon_pid):
+            daemon_running = True
+
+        # Determine status
+        if daemon_running:
+            new_status = self.STATUS_RECORDING
+            # Get recording name
+            recording_name = self._get_recording_name()
+            self._recording_name = recording_name or "Recording..."
+        elif watcher_running:
+            new_status = self.STATUS_READY
+            self._recording_name = ""
+        else:
+            new_status = self.STATUS_STOPPED
+            self._recording_name = ""
+
+        if new_status != self._current_status:
+            self._current_status = new_status
+            self._update_icon()
+            self._update_status_text()
+
+    def _get_recording_name(self) -> str:
+        """Get the current recording name from logs."""
+        log_path = Path.home() / ".meeting-noter.log"
+        if not log_path.exists():
+            return ""
+
+        try:
+            with open(log_path, "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 ""
+        except Exception:
+            return ""
+
+    def _update_icon(self):
+        """Update the tray icon based on status."""
+        self.setIcon(self._icons[self._current_status])
+
+    def _update_status_text(self):
+        """Update the status text in menu."""
+        if self._current_status == self.STATUS_RECORDING:
+            text = f"● Recording: {self._recording_name}"
+        elif self._current_status == self.STATUS_READY:
+            text = "● Ready"
+        else:
+            text = "● Stopped"
+
+        self._status_action.setText(text)
+
+        # Update tooltip
+        self.setToolTip(f"Meeting Noter - {text}")
+
+    def _on_activated(self, reason):
+        """Handle tray icon activation."""
+        if reason == QSystemTrayIcon.ActivationReason.Trigger:
+            # Single click - toggle window visibility
+            self._toggle_main_window()
+        elif reason == QSystemTrayIcon.ActivationReason.DoubleClick:
+            # Double click - show window
+            self._show_main_window()
+
+    def _toggle_main_window(self):
+        """Toggle main window visibility."""
+        if self._main_window.isVisible():
+            self._main_window.hide()
+        else:
+            self._show_main_window()
+
+    def _show_main_window(self):
+        """Show and raise the main window."""
+        self._main_window.show()  # This also shows in dock
+        self._main_window.raise_()
+        self._main_window.activateWindow()
+
+    def _quit_app(self):
+        """Quit the application completely."""
+        self._poll_timer.stop()
+        from PySide6.QtWidgets import QApplication
+        QApplication.instance().quit()
+
+    def update_status(self, watcher_running: bool, daemon_running: bool, meeting_name: str):
+        """Update status from external source."""
+        if daemon_running:
+            self._current_status = self.STATUS_RECORDING
+            self._recording_name = meeting_name or "Recording..."
+        elif watcher_running:
+            self._current_status = self.STATUS_READY
+            self._recording_name = ""
+        else:
+            self._current_status = self.STATUS_STOPPED
+            self._recording_name = ""
+
+        self._update_icon()
+        self._update_status_text()

meeting_noter/gui/screens/__init__.py

@@ -0,0 +1,17 @@
+"""Screen modules for Meeting Noter GUI."""
+
+from meeting_noter.gui.screens.dashboard import DashboardScreen
+from meeting_noter.gui.screens.logs import LogsScreen
+from meeting_noter.gui.screens.recordings import RecordingsScreen
+from meeting_noter.gui.screens.search import SearchScreen
+from meeting_noter.gui.screens.settings import SettingsScreen
+from meeting_noter.gui.screens.viewer import ViewerScreen
+
+__all__ = [
+    "DashboardScreen",
+    "RecordingsScreen",
+    "SearchScreen",
+    "ViewerScreen",
+    "SettingsScreen",
+    "LogsScreen",
+]

meeting_noter/gui/screens/dashboard.py

@@ -0,0 +1,262 @@
+"""Dashboard screen for Meeting Noter GUI."""
+
+from __future__ import annotations
+
+import os
+import signal
+import subprocess
+import sys
+from pathlib import Path
+
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QFont
+from PySide6.QtWidgets import (
+    QCheckBox,
+    QFrame,
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QPushButton,
+    QTextEdit,
+    QVBoxLayout,
+    QWidget,
+)
+
+from meeting_noter.config import generate_meeting_name, get_config
+from meeting_noter.daemon import is_process_running, read_pid_file
+from meeting_noter.gui.utils.workers import LiveTranscriptWatcher
+from meeting_noter.gui.widgets.status_indicator import StatusIndicator
+
+
+DEFAULT_PID_FILE = Path.home() / ".meeting-noter.pid"
+WATCHER_PID_FILE = Path.home() / ".meeting-noter-watcher.pid"
+
+
+class DashboardScreen(QWidget):
+    """Main dashboard screen with recording controls."""
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._setup_ui()
+        self._setup_workers()
+        self._connect_signals()
+
+    def _setup_ui(self):
+        """Set up the dashboard UI."""
+        mono_font = QFont("Menlo, Monaco, Courier New, monospace")
+
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(30, 30, 30, 30)
+        layout.setSpacing(20)
+
+        # Title
+        title = QLabel("Dashboard")
+        title.setProperty("class", "heading")
+        title_font = QFont("Menlo, Monaco, Courier New, monospace", 22)
+        title_font.setBold(True)
+        title.setFont(title_font)
+        title.setStyleSheet("color: #ffffff;")
+        layout.addWidget(title)
+
+        # Status indicator
+        self._status_indicator = StatusIndicator()
+        layout.addWidget(self._status_indicator)
+
+        # Recording controls panel
+        controls_panel = QFrame()
+        controls_panel.setProperty("class", "panel")
+        controls_panel.setStyleSheet(
+            "background-color: #0d0d0d; border: 1px solid #2a2a2a; border-radius: 8px; padding: 20px;"
+        )
+        controls_layout = QVBoxLayout(controls_panel)
+        controls_layout.setSpacing(15)
+
+        # Meeting name input
+        name_row = QHBoxLayout()
+        name_label = QLabel("Meeting name:")
+        name_label.setFont(mono_font)
+        name_label.setFixedWidth(140)
+        self._name_input = QLineEdit()
+        self._name_input.setPlaceholderText(generate_meeting_name())
+        self._name_input.setFont(mono_font)
+        name_row.addWidget(name_label)
+        name_row.addWidget(self._name_input)
+        controls_layout.addLayout(name_row)
+
+        # Live transcription toggle
+        toggle_row = QHBoxLayout()
+        toggle_label = QLabel("Live transcription:")
+        toggle_label.setFont(mono_font)
+        toggle_label.setFixedWidth(140)
+        self._live_toggle = QCheckBox("Show live transcript")
+        self._live_toggle.setFont(mono_font)
+        self._live_toggle.setChecked(True)
+        toggle_row.addWidget(toggle_label)
+        toggle_row.addWidget(self._live_toggle)
+        toggle_row.addStretch()
+        controls_layout.addLayout(toggle_row)
+
+        # Buttons
+        button_row = QHBoxLayout()
+        button_row.setSpacing(12)
+
+        self._start_btn = QPushButton("▶ Start Recording")
+        self._start_btn.setProperty("class", "success")
+        self._start_btn.setFont(mono_font)
+        self._start_btn.setStyleSheet(
+            "background-color: #4ec9b0; color: #0d0d0d; min-width: 160px; padding: 12px 24px; font-weight: 600;"
+        )
+
+        self._stop_btn = QPushButton("■ Stop")
+        self._stop_btn.setProperty("class", "danger")
+        self._stop_btn.setFont(mono_font)
+        self._stop_btn.setStyleSheet(
+            "background-color: #f14c4c; color: #ffffff; min-width: 100px; padding: 12px 24px; font-weight: 600;"
+        )
+
+        button_row.addWidget(self._start_btn)
+        button_row.addWidget(self._stop_btn)
+        button_row.addStretch()
+        controls_layout.addLayout(button_row)
+
+        layout.addWidget(controls_panel)
+
+        # Live transcription display
+        transcript_label = QLabel("LIVE TRANSCRIPTION")
+        transcript_label.setFont(mono_font)
+        transcript_label.setStyleSheet("font-size: 11px; font-weight: 600; color: #5a5a5a; letter-spacing: 2px;")
+        layout.addWidget(transcript_label)
+
+        self._transcript_display = QTextEdit()
+        self._transcript_display.setReadOnly(True)
+        self._transcript_display.setPlaceholderText("Waiting for transcription...")
+        self._transcript_display.setMinimumHeight(200)
+        self._transcript_display.setFont(mono_font)
+        self._transcript_display.setStyleSheet(
+            "background-color: #0d0d0d; border: 1px solid #2a2a2a; border-radius: 6px; "
+            "color: #4ec9b0; padding: 12px; font-size: 13px;"
+        )
+        layout.addWidget(self._transcript_display, 1)  # Stretch factor
+
+    def _setup_workers(self):
+        """Set up background workers."""
+        self._transcript_watcher = LiveTranscriptWatcher()
+        self._transcript_watcher.new_content.connect(self._on_new_transcript)
+        self._transcript_watcher.file_changed.connect(self._on_transcript_file_changed)
+        self._transcript_watcher.recording_ended.connect(self._on_recording_ended)
+        self._transcript_watcher.start()
+
+    def _connect_signals(self):
+        """Connect button signals."""
+        self._start_btn.clicked.connect(self._start_recording)
+        self._stop_btn.clicked.connect(self._stop_recording)
+        self._live_toggle.toggled.connect(self._on_live_toggle)
+
+    def _start_recording(self):
+        """Start a new recording."""
+        # Check if already recording
+        daemon_pid = read_pid_file(DEFAULT_PID_FILE)
+        if daemon_pid and is_process_running(daemon_pid):
+            self._show_message("Already recording. Stop first.")
+            return
+
+        # Get meeting name
+        meeting_name = self._name_input.text().strip() or generate_meeting_name()
+
+        # Start recording daemon
+        subprocess.Popen(
+            [sys.executable, "-m", "meeting_noter.cli", "daemon", "--name", meeting_name],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+
+        # Clear input and transcript
+        self._name_input.clear()
+        self._name_input.setPlaceholderText(generate_meeting_name())
+        self._transcript_display.clear()
+        self._transcript_display.append(f"Starting recording: {meeting_name}\n")
+
+    def _stop_recording(self):
+        """Stop recording."""
+        daemon_pid = read_pid_file(DEFAULT_PID_FILE)
+        watcher_pid = None
+
+        if WATCHER_PID_FILE.exists():
+            try:
+                watcher_pid = int(WATCHER_PID_FILE.read_text().strip())
+            except (ValueError, FileNotFoundError):
+                pass
+
+        stopped = []
+
+        # Stop daemon gracefully
+        if daemon_pid and is_process_running(daemon_pid):
+            try:
+                os.kill(daemon_pid, signal.SIGTERM)
+                stopped.append("recording")
+            except ProcessLookupError:
+                pass
+
+        # Stop watcher
+        if watcher_pid:
+            try:
+                os.kill(watcher_pid, signal.SIGTERM)
+                stopped.append("watcher")
+            except ProcessLookupError:
+                pass
+            WATCHER_PID_FILE.unlink(missing_ok=True)
+
+        if not stopped:
+            self._show_message("Nothing running")
+        else:
+            self._show_message(f"Stopped: {', '.join(stopped)}")
+
+    def _on_live_toggle(self, checked: bool):
+        """Handle live transcription toggle."""
+        if checked:
+            self._transcript_watcher.start()
+        else:
+            self._transcript_watcher.stop()
+
+    def _on_new_transcript(self, text: str):
+        """Handle new transcript content."""
+        if self._live_toggle.isChecked():
+            # Format timestamps in cyan
+            lines = text.splitlines()
+            for line in lines:
+                if line.strip() and line.startswith("["):
+                    self._transcript_display.append(line)
+            # Auto-scroll to bottom
+            scrollbar = self._transcript_display.verticalScrollBar()
+            scrollbar.setValue(scrollbar.maximum())
+
+    def _on_transcript_file_changed(self, meeting_name: str):
+        """Handle new transcript file."""
+        self._transcript_display.clear()
+        self._transcript_display.append(f"Transcribing: {meeting_name}\n")
+
+    def _on_recording_ended(self):
+        """Handle recording end."""
+        self._transcript_display.append("\n--- Recording ended ---")
+
+    def _show_message(self, message: str):
+        """Show a message in the transcript area."""
+        self._transcript_display.append(f"\n{message}")
+
+    def update_status(self, watcher_running: bool, daemon_running: bool, meeting_name: str):
+        """Update status indicator."""
+        self._status_indicator.update_status(watcher_running, daemon_running, meeting_name)
+
+        # Update button states
+        self._start_btn.setEnabled(not daemon_running)
+        self._stop_btn.setEnabled(daemon_running or watcher_running)
+
+    def refresh(self):
+        """Refresh the dashboard."""
+        # Update placeholder with new timestamp
+        self._name_input.setPlaceholderText(generate_meeting_name())
+
+    def stop_workers(self):
+        """Stop background workers."""
+        if hasattr(self, "_transcript_watcher"):
+            self._transcript_watcher.stop()