meeting-noter 1.3.0__tar.gz → 3.0.0__tar.gz

{meeting_noter-1.3.0 → meeting_noter-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meeting-noter
-Version: 1.3.0
+Version: 3.0.0
 Summary: Offline meeting transcription for macOS with automatic meeting detection
 Author: Victor
 License: MIT
@@ -27,6 +27,7 @@ Requires-Dist: sounddevice>=0.4.6
 Requires-Dist: numpy>=1.24
 Requires-Dist: faster-whisper>=1.0.0
 Requires-Dist: imageio-ffmpeg>=0.4.9
+Requires-Dist: textual>=0.47.0
 Requires-Dist: pyobjc-framework-Cocoa>=9.0; sys_platform == "darwin"
 Requires-Dist: pyobjc-framework-Quartz>=9.0; sys_platform == "darwin"
 Requires-Dist: pyobjc-framework-ScreenCaptureKit>=9.0; sys_platform == "darwin"
@@ -35,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-1.3.0 → meeting_noter-3.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "meeting-noter"
-version = "1.3.0"
+version = "3.0.0"
 description = "Offline meeting transcription for macOS with automatic meeting detection"
 readme = "README.md"
 license = {text = "MIT"}
@@ -34,6 +34,7 @@ dependencies = [
     "numpy>=1.24",
     "faster-whisper>=1.0.0",
     "imageio-ffmpeg>=0.4.9",  # Bundles ffmpeg binary for MP3 encoding
+    "textual>=0.47.0",  # Terminal UI framework
     "pyobjc-framework-Cocoa>=9.0; sys_platform == 'darwin'",
     "pyobjc-framework-Quartz>=9.0; sys_platform == 'darwin'",
     "pyobjc-framework-ScreenCaptureKit>=9.0; sys_platform == 'darwin'",
@@ -46,6 +47,9 @@ dependencies = [
 offline = [
     "meeting-noter-models>=0.1.0",
 ]
+gui = [
+    "PySide6>=6.5.0",
+]
 dev = [
     "pytest>=7.0",
     "pytest-cov",
@@ -68,7 +72,7 @@ Issues = "https://github.com/tech4vision/meeting-noter/issues"
 where = ["src"]
 
 [tool.setuptools.package-data]
-meeting_noter = ["resources/*.png", "resources/*.icns"]
+meeting_noter = ["resources/*.png", "resources/*.icns", "ui/styles/*.tcss", "gui/theme/*.qss"]
 
 [tool.black]
 line-length = 100
@@ -98,6 +102,8 @@ branch = true
 omit = [
     "*/__main__.py",
     "*/audio/system_audio.py",  # ScreenCaptureKit-based, requires macOS runtime
+    "*/ui/screens/*.py",  # Textual UI screens require async testing
+    "*/ui/app.py",  # Textual app requires async testing
 ]
 
 [tool.coverage.report]

{meeting_noter-1.3.0 → meeting_noter-3.0.0}/src/meeting_noter/__init__.py

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

{meeting_noter-1.3.0 → meeting_noter-3.0.0}/src/meeting_noter/cli.py

@@ -804,6 +804,25 @@ def watcher(foreground: bool):
         click.echo("Use 'meeting-noter shutdown' to stop.")
 
 
+def _disable_app_nap():
+    """Disable App Nap for this process to prevent macOS from throttling it.
+
+    App Nap can suspend background processes, causing meeting detection to fail
+    after long idle periods.
+    """
+    try:
+        from Foundation import NSProcessInfo
+        info = NSProcessInfo.processInfo()
+        # Disable App Nap and sudden termination
+        # NSActivityUserInitiated keeps the process responsive
+        info.beginActivityWithOptions_reason_(
+            0x00FFFFFF,  # NSActivityUserInitiatedAllowingIdleSystemSleep
+            "Meeting detection watcher"
+        )
+    except Exception:
+        pass  # Not critical if this fails
+
+
 def _run_watcher_loop():
     """Run the watcher loop (foreground)."""
     import time
@@ -813,6 +832,9 @@ def _run_watcher_loop():
     from meeting_noter.mic_monitor import MicrophoneMonitor, get_meeting_window_title, is_meeting_app_active
     from meeting_noter.daemon import is_process_running, read_pid_file, stop_daemon
 
+    # Disable App Nap to prevent macOS from throttling this process
+    _disable_app_nap()
+
     # Write PID file
     WATCHER_PID_FILE.write_text(str(os.getpid()))
     atexit.register(lambda: WATCHER_PID_FILE.unlink(missing_ok=True))
@@ -824,8 +846,23 @@ def _run_watcher_loop():
     mic_monitor = MicrophoneMonitor()
     current_meeting_name = None
 
+    # Heartbeat tracking - log every 30 minutes to confirm watcher is alive
+    last_heartbeat = time.time()
+    heartbeat_interval = 30 * 60  # 30 minutes
+
     try:
         while True:
+            # Periodic heartbeat to confirm watcher is running
+            now = time.time()
+            if now - last_heartbeat >= heartbeat_interval:
+                # Write to log file so user can verify watcher is alive
+                log_path = Path.home() / ".meeting-noter.log"
+                with open(log_path, "a") as f:
+                    from datetime import datetime
+                    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                    f.write(f"{timestamp} Watcher heartbeat - still monitoring for meetings\n")
+                last_heartbeat = now
+
             mic_started, mic_stopped, app_name = mic_monitor.check()
 
             is_recording = read_pid_file(DEFAULT_PID_FILE) is not None and \
@@ -990,6 +1027,72 @@ def open_folder(what: str):
     click.echo(f"Opened: {path}")
 
 
+@cli.command()
+def ui():
+    """Launch the Terminal User Interface.
+
+    Opens an interactive TUI for managing recordings, searching transcripts,
+    and configuring settings.
+
+    \b
+    Examples:
+        meeting-noter ui    # Launch the TUI
+
+    \b
+    Keyboard shortcuts:
+        1-5     Switch between screens
+        q       Quit
+        ?       Help
+        r       Start/stop recording (on dashboard)
+    """
+    from meeting_noter.ui import MeetingNoterApp
+
+    app = MeetingNoterApp()
+    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-1.3.0 → meeting_noter-3.0.0}/src/meeting_noter/daemon.py

@@ -174,6 +174,7 @@ def _run_capture_loop(
     from meeting_noter.audio.encoder import RecordingSession
 
     config = get_config()
+    saved_filepath = None  # Track saved file for auto-transcription
 
     # Live transcription (imported here to avoid loading Whisper before fork)
     live_transcriber = None
@@ -306,6 +307,23 @@ def _run_capture_loop(
                     filepath, duration = session.stop()
                     if filepath:
                         print(f"Recording saved: {filepath.name} ({duration:.1f}s)")
+                        saved_filepath = filepath
+                        # Auto-transcribe if enabled
+                        if config.auto_transcribe:
+                            print("Auto-transcribing...")
+                            sys.stdout.flush()
+                            try:
+                                from meeting_noter.transcription.engine import transcribe_file
+                                transcribe_file(
+                                    str(filepath),
+                                    output_dir,
+                                    config.whisper_model,
+                                    config.transcripts_dir,
+                                )
+                                print("Transcription complete.")
+                            except Exception as e:
+                                print(f"Transcription error: {e}")
+                            sys.stdout.flush()
                     else:
                         print("Recording discarded (too short)")
                     silence_detector.reset()
@@ -313,6 +331,8 @@ def _run_capture_loop(
 
     except Exception as e:
         print(f"Error in capture loop: {e}")
+        import sys
+        sys.stdout.flush()
     finally:
         capture.stop()
 
@@ -325,6 +345,24 @@ def _run_capture_loop(
             filepath, duration = session.stop()
             if filepath:
                 print(f"Recording saved: {filepath.name} ({duration:.1f}s)")
+                saved_filepath = filepath
+                # Auto-transcribe if enabled
+                if config.auto_transcribe:
+                    print("Auto-transcribing...")
+                    import sys
+                    sys.stdout.flush()
+                    try:
+                        from meeting_noter.transcription.engine import transcribe_file
+                        transcribe_file(
+                            str(filepath),
+                            output_dir,
+                            config.whisper_model,
+                            config.transcripts_dir,
+                        )
+                        print("Transcription complete.")
+                    except Exception as e:
+                        print(f"Transcription error: {e}")
+                    sys.stdout.flush()
 
         print("Daemon stopped.")
 

meeting_noter-3.0.0/src/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-3.0.0/src/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)