meeting-noter 1.2.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.2.0"
+__version__ = "2.0.0"

meeting_noter/cli.py

@@ -262,7 +262,12 @@ def daemon(output_dir: Optional[str], foreground: bool, name: Optional[str]):
 
 @cli.command()
 def status():
-    """Show Meeting Noter status."""
+    """Show Meeting Noter status.
+
+    \b
+    Examples:
+        meeting-noter status    # Check if recording or watching
+    """
     import os
     from meeting_noter.daemon import read_pid_file, is_process_running
 
@@ -331,7 +336,12 @@ def _get_current_recording_name() -> str | None:
 
 @cli.command()
 def shutdown():
-    """Stop all Meeting Noter processes (daemon, watcher)."""
+    """Stop all Meeting Noter processes (daemon, watcher).
+
+    \b
+    Examples:
+        meeting-noter shutdown    # Stop recording and watcher
+    """
     import subprocess
     import os
     import signal
@@ -372,7 +382,14 @@ def shutdown():
 @click.option("--follow", "-f", is_flag=True, help="Follow log output (like tail -f)")
 @click.option("--lines", "-n", default=50, help="Number of lines to show")
 def logs(follow: bool, lines: int):
-    """View Meeting Noter logs."""
+    """View Meeting Noter logs.
+
+    \b
+    Examples:
+        meeting-noter logs           # Show last 50 lines
+        meeting-noter logs -n 100    # Show last 100 lines
+        meeting-noter logs -f        # Follow log output (Ctrl+C to stop)
+    """
     import subprocess
 
     log_file = Path.home() / ".meeting-noter.log"
@@ -392,6 +409,11 @@ def logs(follow: bool, lines: int):
 
 
 @cli.command("list")
+@click.option(
+    "--transcripts", "-t",
+    is_flag=True,
+    help="List transcripts instead of recordings",
+)
 @click.option(
     "--output-dir", "-o",
     type=click.Path(exists=True),
@@ -402,22 +424,118 @@ def logs(follow: bool, lines: int):
     "--limit", "-n",
     type=int,
     default=10,
-    help="Number of recordings to show",
+    help="Number of items to show",
+)
+@require_setup
+def list_recordings(transcripts: bool, output_dir: Optional[str], limit: int):
+    """List recent meeting recordings or transcripts.
+
+    \b
+    Examples:
+        meeting-noter list             # Show last 10 recordings
+        meeting-noter list -t          # Show last 10 transcripts
+        meeting-noter list -t -n 20    # Show last 20 transcripts
+    """
+    config = get_config()
+
+    if transcripts:
+        from meeting_noter.output.favorites import list_transcripts_with_favorites
+        path = Path(output_dir) if output_dir else config.transcripts_dir
+        list_transcripts_with_favorites(path, limit)
+    else:
+        from meeting_noter.output.writer import list_recordings as _list_recordings
+        path = Path(output_dir) if output_dir else config.recordings_dir
+        _list_recordings(path, limit)
+
+
+@cli.command("search")
+@click.argument("query")
+@click.option(
+    "--case-sensitive", "-c",
+    is_flag=True,
+    help="Case-sensitive search",
+)
+@click.option(
+    "--limit", "-n",
+    type=int,
+    default=20,
+    help="Max results to show",
+)
+@click.option(
+    "--transcripts-dir", "-d",
+    type=click.Path(),
+    default=None,
+    help="Override transcripts directory",
 )
 @require_setup
-def list_recordings(output_dir: Optional[str], limit: int):
-    """List recent meeting recordings.
+def search(query: str, case_sensitive: bool, limit: int, transcripts_dir: Optional[str]):
+    """Search across all meeting transcripts.
 
     \b
     Examples:
-        meeting-noter list          # Show last 10 recordings
-        meeting-noter list -n 20    # Show last 20 recordings
+        meeting-noter search "action items"
+        meeting-noter search "API" --case-sensitive
+        meeting-noter search "standup" -n 5
     """
-    from meeting_noter.output.writer import list_recordings as _list_recordings
+    from meeting_noter.output.searcher import search_transcripts
 
     config = get_config()
-    path = Path(output_dir) if output_dir else config.recordings_dir
-    _list_recordings(path, limit)
+    path = Path(transcripts_dir) if transcripts_dir else config.transcripts_dir
+    search_transcripts(path, query, case_sensitive, limit)
+
+
+@cli.group("favorites", invoke_without_command=True)
+@click.pass_context
+@require_setup
+def favorites(ctx):
+    """Manage favorite transcripts.
+
+    \b
+    Examples:
+        meeting-noter favorites              # List all favorites
+        meeting-noter favorites add file.txt # Add to favorites
+        meeting-noter favorites add --latest # Add most recent transcript
+        meeting-noter favorites remove file  # Remove from favorites
+    """
+    if ctx.invoked_subcommand is None:
+        # Default: list favorites
+        from meeting_noter.output.favorites import list_favorites
+
+        config = get_config()
+        list_favorites(config.transcripts_dir)
+
+
+@favorites.command("add")
+@click.argument("filename", required=False)
+@click.option("--latest", "-l", is_flag=True, help="Add the most recent transcript")
+@require_setup
+def favorites_add(filename: Optional[str], latest: bool):
+    """Add a transcript to favorites.
+
+    \b
+    Examples:
+        meeting-noter favorites add meeting.txt
+        meeting-noter favorites add --latest
+    """
+    from meeting_noter.output.favorites import add_favorite
+
+    config = get_config()
+    add_favorite(config.transcripts_dir, filename, latest)
+
+
+@favorites.command("remove")
+@click.argument("filename")
+@require_setup
+def favorites_remove(filename: str):
+    """Remove a transcript from favorites.
+
+    \b
+    Examples:
+        meeting-noter favorites remove meeting.txt
+    """
+    from meeting_noter.output.favorites import remove_favorite
+
+    remove_favorite(filename)
 
 
 @cli.command()
@@ -686,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
@@ -695,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))
@@ -706,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 \
@@ -872,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/config.py

@@ -160,6 +160,40 @@ class Config:
         """Set setup completion status."""
         self._data["setup_complete"] = value
 
+    @property
+    def favorites(self) -> list[str]:
+        """Get list of favorite transcript filenames."""
+        return self._data.get("favorites", [])
+
+    @favorites.setter
+    def favorites(self, value: list[str]) -> None:
+        """Set list of favorite transcript filenames."""
+        self._data["favorites"] = value
+
+    def add_favorite(self, filename: str) -> bool:
+        """Add a transcript to favorites. Returns True if added, False if already exists."""
+        favorites = self.favorites
+        if filename not in favorites:
+            favorites.append(filename)
+            self.favorites = favorites
+            self.save()
+            return True
+        return False
+
+    def remove_favorite(self, filename: str) -> bool:
+        """Remove a transcript from favorites. Returns True if removed, False if not found."""
+        favorites = self.favorites
+        if filename in favorites:
+            favorites.remove(filename)
+            self.favorites = favorites
+            self.save()
+            return True
+        return False
+
+    def is_favorite(self, filename: str) -> bool:
+        """Check if a transcript is a favorite."""
+        return filename in self.favorites
+
     def __getitem__(self, key: str) -> Any:
         """Get config value by key."""
         return self._data.get(key, DEFAULT_CONFIG.get(key))

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/output/favorites.py

@@ -0,0 +1,189 @@
+"""Favorites management for meeting transcripts."""
+
+from __future__ import annotations
+
+import click
+from pathlib import Path
+from datetime import datetime
+from typing import Optional
+
+from meeting_noter.config import get_config
+
+
+def list_favorites(transcripts_dir: Path) -> None:
+    """List all favorite transcripts.
+
+    Args:
+        transcripts_dir: Directory containing transcript files
+    """
+    config = get_config()
+    favorites = config.favorites
+
+    if not favorites:
+        click.echo(click.style("No favorites yet.", fg="yellow"))
+        click.echo("\nAdd favorites with: meeting-noter favorites add <filename>")
+        click.echo("Or use: meeting-noter favorites add --latest")
+        return
+
+    click.echo()
+    click.echo(click.style("Favorite Transcripts", bold=True))
+    click.echo("=" * 50)
+    click.echo()
+
+    found_count = 0
+    missing_count = 0
+
+    for idx, filename in enumerate(favorites, 1):
+        filepath = transcripts_dir / filename
+        if filepath.exists():
+            found_count += 1
+            # Get file info
+            stat = filepath.stat()
+            mod_time = datetime.fromtimestamp(stat.st_mtime)
+            date_str = mod_time.strftime("%Y-%m-%d %H:%M")
+
+            # Display: index, filename prominently, then date
+            click.echo(
+                click.style(f"  {idx}. ", fg="cyan")
+                + click.style(filename, fg="green", bold=True)
+            )
+            click.echo(f"     ★ {date_str}")
+        else:
+            missing_count += 1
+            click.echo(
+                click.style(f"  {idx}. ", fg="cyan")
+                + click.style(filename, fg="red", strikethrough=True)
+            )
+            click.echo(click.style("     (file not found)", fg="red"))
+
+    click.echo()
+    click.echo(f"Total: {found_count} favorites")
+    if missing_count > 0:
+        click.echo(
+            click.style(
+                f"Warning: {missing_count} favorite(s) no longer exist",
+                fg="yellow"
+            )
+        )
+    click.echo()
+
+
+def add_favorite(
+    transcripts_dir: Path,
+    filename: Optional[str] = None,
+    latest: bool = False
+) -> None:
+    """Add a transcript to favorites.
+
+    Args:
+        transcripts_dir: Directory containing transcript files
+        filename: Name of transcript file to add
+        latest: If True, add the most recent transcript
+    """
+    config = get_config()
+
+    if latest:
+        # Find the most recent transcript
+        txt_files = sorted(
+            transcripts_dir.glob("*.txt"),
+            key=lambda p: p.stat().st_mtime,
+            reverse=True,
+        )
+        if not txt_files:
+            click.echo(click.style("No transcripts found.", fg="red"))
+            return
+        filename = txt_files[0].name
+
+    if not filename:
+        click.echo(click.style("Error: Specify a filename or use --latest", fg="red"))
+        return
+
+    # Check if file exists
+    filepath = transcripts_dir / filename
+    if not filepath.exists():
+        # Try adding .txt extension
+        if not filename.endswith(".txt"):
+            filepath = transcripts_dir / f"{filename}.txt"
+            if filepath.exists():
+                filename = f"{filename}.txt"
+            else:
+                click.echo(click.style(f"File not found: {filename}", fg="red"))
+                click.echo(f"Looking in: {transcripts_dir}")
+                return
+        else:
+            click.echo(click.style(f"File not found: {filename}", fg="red"))
+            click.echo(f"Looking in: {transcripts_dir}")
+            return
+
+    if config.add_favorite(filename):
+        click.echo(
+            click.style("★ ", fg="yellow")
+            + f"Added to favorites: "
+            + click.style(filename, fg="green")
+        )
+    else:
+        click.echo(click.style(f"Already a favorite: {filename}", fg="yellow"))
+
+
+def remove_favorite(filename: str) -> None:
+    """Remove a transcript from favorites.
+
+    Args:
+        filename: Name of transcript file to remove
+    """
+    config = get_config()
+
+    # Handle with or without .txt extension
+    if not filename.endswith(".txt"):
+        if f"{filename}.txt" in config.favorites:
+            filename = f"{filename}.txt"
+
+    if config.remove_favorite(filename):
+        click.echo(
+            click.style("☆ ", fg="cyan")
+            + f"Removed from favorites: "
+            + click.style(filename, fg="green")
+        )
+    else:
+        click.echo(click.style(f"Not a favorite: {filename}", fg="yellow"))
+
+
+def list_transcripts_with_favorites(transcripts_dir: Path, limit: int = 10) -> None:
+    """List transcripts with favorite status indicated.
+
+    Args:
+        transcripts_dir: Directory containing transcript files
+        limit: Maximum number of transcripts to show
+    """
+    config = get_config()
+
+    if not transcripts_dir.exists():
+        click.echo(click.style(f"Directory not found: {transcripts_dir}", fg="red"))
+        return
+
+    txt_files = sorted(
+        transcripts_dir.glob("*.txt"),
+        key=lambda p: p.stat().st_mtime,
+        reverse=True,
+    )
+
+    if not txt_files:
+        click.echo(click.style("No transcripts found.", fg="yellow"))
+        return
+
+    click.echo(f"\nTranscripts in {transcripts_dir}:\n")
+
+    for txt_file in txt_files[:limit]:
+        stat = txt_file.stat()
+        mod_time = datetime.fromtimestamp(stat.st_mtime)
+        date_str = mod_time.strftime("%Y-%m-%d %H:%M")
+
+        is_fav = config.is_favorite(txt_file.name)
+        star = click.style("★ ", fg="yellow") if is_fav else "  "
+
+        click.echo(f"{star}{date_str}  {txt_file.name}")
+
+    if len(txt_files) > limit:
+        click.echo(f"\n  ... and {len(txt_files) - limit} more")
+
+    click.echo(f"\nTotal: {len(txt_files)} transcripts")