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

meeting_noter/__init__.py

@@ -1,3 +1,3 @@
 """Meeting Noter - Offline meeting transcription with virtual audio devices."""
 
-__version__ = "2.0.0"
+__version__ = "3.0.0"

meeting_noter/cli.py

@@ -1051,6 +1051,48 @@ def ui():
     app.run()
 
 
+@cli.command()
+@click.option("--foreground", "-f", is_flag=True, help="Run in foreground (block terminal)")
+def gui(foreground: bool):
+    """Launch the Desktop GUI.
+
+    Opens the Meeting Noter desktop application with a modern dark theme.
+    Runs in background by default so your terminal stays free.
+    Requires PySide6: pip install meeting-noter[gui]
+
+    \b
+    Examples:
+        meeting-noter gui       # Launch GUI in background
+        meeting-noter gui -f    # Launch GUI in foreground (blocks terminal)
+        mn gui                  # Same with short alias
+    """
+    try:
+        # Check if PySide6 is available
+        import PySide6  # noqa: F401
+    except ImportError:
+        click.echo(click.style("Error: ", fg="red") + "PySide6 not installed.")
+        click.echo("Install with: pip install meeting-noter[gui]")
+        click.echo("Or: pipx install 'meeting-noter[gui]'")
+        raise SystemExit(1)
+
+    if foreground:
+        # Run in foreground (blocks terminal)
+        from meeting_noter.gui import run_gui
+        run_gui()
+    else:
+        # Run in background
+        import subprocess
+        import sys
+
+        subprocess.Popen(
+            [sys.executable, "-m", "meeting_noter.cli", "gui", "-f"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            start_new_session=True,
+        )
+        click.echo("Meeting Noter GUI launched.")
+
+
 @cli.command()
 @click.option("--shell", type=click.Choice(["zsh", "bash", "fish"]), default="zsh")
 def completion(shell: str):

meeting_noter/gui/__init__.py

@@ -0,0 +1,51 @@
+"""Meeting Noter Desktop GUI - Modern PySide6 interface."""
+
+from __future__ import annotations
+
+
+def run_gui():
+    """Launch the GUI application with system tray icon."""
+    import sys
+    from pathlib import Path
+
+    from PySide6.QtCore import Qt
+    from PySide6.QtGui import QIcon
+    from PySide6.QtWidgets import QApplication
+
+    from meeting_noter.gui.main_window import MainWindow
+    from meeting_noter.gui.menubar import MenuBarIcon
+
+    # Enable High DPI scaling
+    QApplication.setHighDpiScaleFactorRoundingPolicy(
+        Qt.HighDpiScaleFactorRoundingPolicy.PassThrough
+    )
+
+    app = QApplication(sys.argv)
+    app.setApplicationName("Meeting Noter")
+    app.setOrganizationName("Meeting Noter")
+
+    # Set application icon (for dock)
+    resources_dir = Path(__file__).parent.parent / "resources"
+    icon_path = resources_dir / "icon.icns"
+    if not icon_path.exists():
+        icon_path = resources_dir / "icon.png"
+    if icon_path.exists():
+        app.setWindowIcon(QIcon(str(icon_path)))
+
+    # Don't quit when last window closes (we have tray icon)
+    app.setQuitOnLastWindowClosed(False)
+
+    # Create main window
+    window = MainWindow()
+
+    # Create system tray icon
+    tray_icon = MenuBarIcon(window)
+    tray_icon.show()
+
+    # Give window reference to tray icon
+    window.set_tray_icon(tray_icon)
+
+    # Show window
+    window.show()
+
+    sys.exit(app.exec())

meeting_noter/gui/main_window.py

@@ -0,0 +1,219 @@
+"""Main window for Meeting Noter GUI."""
+
+from __future__ import annotations
+
+import platform
+
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import (
+    QApplication,
+    QHBoxLayout,
+    QMainWindow,
+    QStackedWidget,
+    QWidget,
+)
+
+# macOS dock visibility control
+if platform.system() == "Darwin":
+    try:
+        from AppKit import NSApp, NSApplicationActivationPolicyAccessory, NSApplicationActivationPolicyRegular
+        HAS_APPKIT = True
+    except ImportError:
+        HAS_APPKIT = False
+else:
+    HAS_APPKIT = False
+
+from meeting_noter.gui.screens import (
+    DashboardScreen,
+    LogsScreen,
+    RecordingsScreen,
+    SearchScreen,
+    SettingsScreen,
+    ViewerScreen,
+)
+from meeting_noter.gui.theme import apply_theme
+from meeting_noter.gui.utils.signals import get_app_state
+from meeting_noter.gui.utils.workers import StatusPollingWorker
+from meeting_noter.gui.widgets import Sidebar
+
+
+class MainWindow(QMainWindow):
+    """Main application window with sidebar navigation."""
+
+    def __init__(self, tray_icon=None):
+        super().__init__()
+        self.setWindowTitle("Meeting Noter")
+        self.setMinimumSize(1000, 700)
+        self.resize(1200, 800)
+
+        self._tray_icon = tray_icon
+        self._force_quit = False
+
+        # Apply dark theme
+        apply_theme(self.app())
+
+        self._setup_ui()
+        self._setup_workers()
+        self._connect_signals()
+
+        # Select dashboard initially
+        self._show_screen("dashboard")
+
+    def app(self):
+        """Get the QApplication instance."""
+        return QApplication.instance()
+
+    def set_tray_icon(self, tray_icon):
+        """Set the tray icon reference."""
+        self._tray_icon = tray_icon
+
+    def _setup_ui(self):
+        """Set up the main UI."""
+        # Central widget
+        central = QWidget()
+        self.setCentralWidget(central)
+
+        # Main layout (horizontal: sidebar + content)
+        layout = QHBoxLayout(central)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(0)
+
+        # Sidebar
+        self._sidebar = Sidebar()
+        self._sidebar.quit_requested.connect(self._quit_app)
+        layout.addWidget(self._sidebar)
+
+        # Content area (stacked widget)
+        self._content = QStackedWidget()
+        self._content.setObjectName("content-area")
+        layout.addWidget(self._content, 1)  # Stretch factor 1
+
+        # Create screens
+        self._screens: dict[str, QWidget] = {}
+        self._create_screens()
+
+    def _create_screens(self):
+        """Create all screen widgets."""
+        # Dashboard
+        self._screens["dashboard"] = DashboardScreen()
+        self._content.addWidget(self._screens["dashboard"])
+
+        # Recordings
+        self._screens["recordings"] = RecordingsScreen()
+        self._content.addWidget(self._screens["recordings"])
+
+        # Search
+        self._screens["search"] = SearchScreen()
+        self._content.addWidget(self._screens["search"])
+
+        # Settings
+        self._screens["settings"] = SettingsScreen()
+        self._content.addWidget(self._screens["settings"])
+
+        # Logs
+        self._screens["logs"] = LogsScreen()
+        self._content.addWidget(self._screens["logs"])
+
+        # Viewer (for transcripts)
+        self._screens["viewer"] = ViewerScreen()
+        self._content.addWidget(self._screens["viewer"])
+
+    def _setup_workers(self):
+        """Set up background workers."""
+        # Status polling
+        self._status_worker = StatusPollingWorker()
+        self._status_worker.status_updated.connect(self._on_status_updated)
+        self._status_worker.start()
+
+    def _connect_signals(self):
+        """Connect signals."""
+        # Sidebar navigation
+        self._sidebar.screen_selected.connect(self._show_screen)
+
+        # App state signals
+        app_state = get_app_state()
+        app_state.navigate_to.connect(self._show_screen)
+        app_state.open_transcript.connect(self._open_transcript)
+
+    def _show_screen(self, screen_id: str):
+        """Show a screen by ID."""
+        if screen_id in self._screens:
+            self._content.setCurrentWidget(self._screens[screen_id])
+            self._sidebar.select_screen(screen_id)
+
+            # Refresh screen if it has a refresh method
+            screen = self._screens[screen_id]
+            if hasattr(screen, "refresh"):
+                screen.refresh()
+
+    def _open_transcript(self, filepath: str):
+        """Open a transcript in the viewer."""
+        viewer = self._screens.get("viewer")
+        if viewer and hasattr(viewer, "load_transcript"):
+            viewer.load_transcript(filepath)
+            self._show_screen("viewer")
+
+    def _on_status_updated(self, watcher_running: bool, daemon_running: bool, meeting_name: str):
+        """Handle status update from worker."""
+        # Update sidebar status
+        self._sidebar.update_status(daemon_running, meeting_name)
+
+        # Update dashboard status indicator
+        dashboard = self._screens.get("dashboard")
+        if dashboard and hasattr(dashboard, "update_status"):
+            dashboard.update_status(watcher_running, daemon_running, meeting_name)
+
+        # Update tray icon
+        if self._tray_icon:
+            self._tray_icon.update_status(watcher_running, daemon_running, meeting_name)
+
+        # Update app state
+        app_state = get_app_state()
+        app_state._is_recording = daemon_running
+        app_state._current_meeting = meeting_name
+        app_state._watcher_running = watcher_running
+
+    def _quit_app(self):
+        """Quit the application completely."""
+        self._force_quit = True
+        self._cleanup()
+        QApplication.instance().quit()
+
+    def _cleanup(self):
+        """Clean up workers and resources."""
+        # Stop workers
+        if hasattr(self, "_status_worker"):
+            self._status_worker.stop()
+
+        # Stop screen workers
+        for screen in self._screens.values():
+            if hasattr(screen, "stop_workers"):
+                screen.stop_workers()
+
+    def closeEvent(self, event):
+        """Handle window close - hide to tray instead of quitting."""
+        if self._force_quit or self._tray_icon is None:
+            # Actually quit
+            self._cleanup()
+            event.accept()
+        else:
+            # Hide to tray instead of closing
+            event.ignore()
+            self.hide()
+            self._hide_from_dock()
+
+    def show(self):
+        """Show window and add to dock."""
+        super().show()
+        self._show_in_dock()
+
+    def _hide_from_dock(self):
+        """Hide app from macOS dock."""
+        if HAS_APPKIT:
+            NSApp.setActivationPolicy_(NSApplicationActivationPolicyAccessory)
+
+    def _show_in_dock(self):
+        """Show app in macOS dock."""
+        if HAS_APPKIT:
+            NSApp.setActivationPolicy_(NSApplicationActivationPolicyRegular)
+            NSApp.activateIgnoringOtherApps_(True)

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",
+]