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

meeting_noter/__init__.py

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

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,30 @@ 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("--shell", type=click.Choice(["zsh", "bash", "fish"]), default="zsh")
 def completion(shell: str):

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/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"]

meeting_noter/ui/app.py

@@ -0,0 +1,68 @@
+"""Main Textual application for Meeting Noter."""
+
+from __future__ import annotations
+
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.widgets import Footer, Header
+
+from meeting_noter.ui.screens.main import MainScreen
+from meeting_noter.ui.screens.recordings import RecordingsScreen
+from meeting_noter.ui.screens.search import SearchScreen
+from meeting_noter.ui.screens.settings import SettingsScreen
+from meeting_noter.ui.screens.logs import LogsScreen
+
+
+class MeetingNoterApp(App):
+    """Meeting Noter Terminal UI Application."""
+
+    TITLE = "Meeting Noter"
+    CSS_PATH = "styles/app.tcss"
+
+    BINDINGS = [
+        Binding("q", "quit", "Quit"),
+        Binding("question_mark", "help", "Help", key_display="?"),
+        Binding("1", "switch_screen('main')", "Dashboard", show=True),
+        Binding("2", "switch_screen('recordings')", "Recordings", show=True),
+        Binding("3", "switch_screen('search')", "Search", show=True),
+        Binding("4", "switch_screen('settings')", "Settings", show=True),
+        Binding("5", "switch_screen('logs')", "Logs", show=True),
+        Binding("escape", "go_back", "Back", show=False),
+    ]
+
+    SCREENS = {
+        "main": MainScreen,
+        "recordings": RecordingsScreen,
+        "search": SearchScreen,
+        "settings": SettingsScreen,
+        "logs": LogsScreen,
+    }
+
+    def compose(self) -> ComposeResult:
+        """Compose the app layout."""
+        yield Header()
+        yield Footer()
+
+    def on_mount(self) -> None:
+        """Handle app mount - show the main screen."""
+        self.push_screen("main")
+
+    def action_switch_screen(self, screen_name: str) -> None:
+        """Switch to a named screen."""
+        # Pop all screens except the base and push the new one
+        while len(self.screen_stack) > 1:
+            self.pop_screen()
+        self.push_screen(screen_name)
+
+    def action_go_back(self) -> None:
+        """Go back to the previous screen."""
+        if len(self.screen_stack) > 1:
+            self.pop_screen()
+
+    def action_help(self) -> None:
+        """Show help information."""
+        self.notify(
+            "Keys: 1-5 switch screens, q quit, ? help",
+            title="Meeting Noter Help",
+            timeout=5,
+        )

meeting_noter/ui/screens/__init__.py

@@ -0,0 +1,17 @@
+"""UI Screens for Meeting Noter."""
+
+from meeting_noter.ui.screens.main import MainScreen
+from meeting_noter.ui.screens.recordings import RecordingsScreen
+from meeting_noter.ui.screens.search import SearchScreen
+from meeting_noter.ui.screens.viewer import ViewerScreen
+from meeting_noter.ui.screens.settings import SettingsScreen
+from meeting_noter.ui.screens.logs import LogsScreen
+
+__all__ = [
+    "MainScreen",
+    "RecordingsScreen",
+    "SearchScreen",
+    "ViewerScreen",
+    "SettingsScreen",
+    "LogsScreen",
+]

meeting_noter/ui/screens/logs.py

@@ -0,0 +1,166 @@
+"""Logs viewer screen for Meeting Noter."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from textual.app import ComposeResult
+from textual.containers import Container, Horizontal
+from textual.screen import Screen
+from textual.widgets import Button, Label, RichLog, Static, Switch
+
+
+LOG_FILE = Path.home() / ".meeting-noter.log"
+
+
+class LogsScreen(Screen):
+    """Logs viewer screen."""
+
+    BINDINGS = [
+        ("l", "toggle_follow", "Follow"),
+        ("c", "clear_display", "Clear"),
+        ("r", "refresh", "Refresh"),
+        ("escape", "go_back", "Back"),
+    ]
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._follow_mode = True
+        self._last_size = 0
+
+    def compose(self) -> ComposeResult:
+        """Compose the logs screen layout."""
+        yield Container(
+            Static("[bold]Logs[/bold]", classes="title"),
+            Label(f"[dim]{LOG_FILE}[/dim]", id="log-path"),
+            Static("", classes="spacer"),
+            RichLog(id="log-content", highlight=True, markup=True),
+            Static("", classes="spacer"),
+            Horizontal(
+                Label("Follow: "),
+                Switch(value=True, id="follow-switch"),
+                Button("Refresh", id="refresh-btn"),
+                Button("Clear", id="clear-btn"),
+                Button("Back", id="back-btn"),
+                classes="button-row",
+            ),
+            id="logs-container",
+        )
+
+    def on_mount(self) -> None:
+        """Start log refresh on mount."""
+        self._load_logs()
+        self.set_interval(1.0, self._check_for_updates)
+
+    def _load_logs(self, lines: int = 100) -> None:
+        """Load the last N lines from the log file."""
+        log_content = self.query_one("#log-content", RichLog)
+
+        if not LOG_FILE.exists():
+            log_content.write("[yellow]No log file found[/yellow]")
+            return
+
+        try:
+            content = LOG_FILE.read_text()
+            all_lines = content.splitlines()
+            recent_lines = all_lines[-lines:] if len(all_lines) > lines else all_lines
+
+            log_content.clear()
+            for line in recent_lines:
+                # Color-code different log levels
+                if "Error" in line or "error" in line:
+                    log_content.write(f"[red]{line}[/red]")
+                elif "Warning" in line or "warning" in line:
+                    log_content.write(f"[yellow]{line}[/yellow]")
+                elif "Recording started" in line:
+                    log_content.write(f"[green]{line}[/green]")
+                elif "Recording saved" in line:
+                    log_content.write(f"[cyan]{line}[/cyan]")
+                else:
+                    log_content.write(line)
+
+            self._last_size = LOG_FILE.stat().st_size
+
+        except Exception as e:
+            log_content.write(f"[red]Error reading log: {e}[/red]")
+
+    def _check_for_updates(self) -> None:
+        """Check for new log content if in follow mode."""
+        if not self._follow_mode:
+            return
+
+        follow_switch = self.query_one("#follow-switch", Switch)
+        self._follow_mode = follow_switch.value
+
+        if not self._follow_mode:
+            return
+
+        if not LOG_FILE.exists():
+            return
+
+        try:
+            current_size = LOG_FILE.stat().st_size
+            if current_size > self._last_size:
+                # Read new content
+                with open(LOG_FILE, "r") as f:
+                    f.seek(self._last_size)
+                    new_content = f.read()
+
+                log_content = self.query_one("#log-content", RichLog)
+                for line in new_content.splitlines():
+                    if line.strip():
+                        if "Error" in line or "error" in line:
+                            log_content.write(f"[red]{line}[/red]")
+                        elif "Warning" in line or "warning" in line:
+                            log_content.write(f"[yellow]{line}[/yellow]")
+                        elif "Recording started" in line:
+                            log_content.write(f"[green]{line}[/green]")
+                        elif "Recording saved" in line:
+                            log_content.write(f"[cyan]{line}[/cyan]")
+                        else:
+                            log_content.write(line)
+
+                self._last_size = current_size
+
+        except Exception:
+            pass
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handle button presses."""
+        button_id = event.button.id
+
+        if button_id == "refresh-btn":
+            self.action_refresh()
+        elif button_id == "clear-btn":
+            self.action_clear_display()
+        elif button_id == "back-btn":
+            self.action_go_back()
+
+    def on_switch_changed(self, event: Switch.Changed) -> None:
+        """Handle follow switch changes."""
+        if event.switch.id == "follow-switch":
+            self._follow_mode = event.value
+            if event.value:
+                self.notify("Follow mode enabled")
+            else:
+                self.notify("Follow mode disabled")
+
+    def action_toggle_follow(self) -> None:
+        """Toggle follow mode."""
+        switch = self.query_one("#follow-switch", Switch)
+        switch.value = not switch.value
+
+    def action_clear_display(self) -> None:
+        """Clear the log display."""
+        log_content = self.query_one("#log-content", RichLog)
+        log_content.clear()
+        self.notify("Display cleared")
+
+    def action_refresh(self) -> None:
+        """Refresh the log display."""
+        self._load_logs()
+        self.notify("Refreshed")
+
+    def action_go_back(self) -> None:
+        """Go back to the previous screen."""
+        self.app.pop_screen()