meeting-noter 0.7.0__tar.gz → 1.1.0__tar.gz

{meeting_noter-0.7.0 → meeting_noter-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meeting-noter
-Version: 0.7.0
+Version: 1.1.0
 Summary: Offline meeting transcription for macOS with automatic meeting detection
 Author: Victor
 License: MIT
@@ -40,6 +40,7 @@ Requires-Dist: meeting-noter-models>=0.1.0; extra == "offline"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-mock; extra == "dev"
 Requires-Dist: black; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
 Requires-Dist: mypy; extra == "dev"

{meeting_noter-0.7.0 → meeting_noter-1.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "meeting-noter"
-version = "0.7.0"
+version = "1.1.0"
 description = "Offline meeting transcription for macOS with automatic meeting detection"
 readme = "README.md"
 license = {text = "MIT"}
@@ -51,6 +51,7 @@ offline = [
 dev = [
     "pytest>=7.0",
     "pytest-cov",
+    "pytest-mock",
     "black",
     "ruff",
     "mypy",
@@ -58,6 +59,7 @@ dev = [
 
 [project.scripts]
 meeting-noter = "meeting_noter.cli:cli"
+mn = "meeting_noter.cli:cli"
 
 [project.urls]
 Homepage = "https://github.com/tech4vision/meeting-noter"
@@ -77,3 +79,57 @@ target-version = ["py39", "py310", "py311", "py312"]
 [tool.ruff]
 line-length = 100
 select = ["E", "F", "I", "N", "W"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_functions = ["test_*"]
+addopts = [
+    "--cov=meeting_noter",
+    "--cov-report=term-missing",
+    "--cov-report=html",
+    "-v",
+]
+filterwarnings = [
+    "ignore::DeprecationWarning",
+]
+
+[tool.coverage.run]
+source = ["src/meeting_noter"]
+branch = true
+omit = [
+    "*/gui/*",
+    "*/menubar.py",
+    "*/__main__.py",
+    "*/audio/system_audio.py",  # ScreenCaptureKit-based, requires macOS runtime
+]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "raise NotImplementedError",
+    "if TYPE_CHECKING:",
+    "if __name__ == .__main__.:",
+    # Exclude macOS-specific framework code that can't be unit tested
+    "import ScreenCaptureKit",
+    "import CoreMedia",
+    "import AppKit",
+    "from AppKit import",
+    "from EventKit import",
+    "from Foundation import NSObject",
+    "from libdispatch import",
+    "from dispatch import",
+    "class StreamOutput",
+    "def stream_didOutputSampleBuffer_ofType_",
+    "def stream_didStopWithError_",
+    "except ImportError:",
+    # Exclude daemon fork code (requires OS process fork)
+    "def daemonize",
+    "os.fork()",
+    "os.setsid()",
+    "os.chdir",
+    "os.dup2",
+    "sys.exit(0)",
+    "sys.exit(1)",
+]

{meeting_noter-0.7.0 → meeting_noter-1.1.0}/src/meeting_noter/__init__.py

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

{meeting_noter-0.7.0 → meeting_noter-1.1.0}/src/meeting_noter/audio/encoder.py

@@ -105,12 +105,17 @@ class MP3Encoder:
 
     def finalize(self) -> bytes:
         """Finalize encoding."""
-        if self._process is not None and self._process.stdin is not None:
+        if self._process is not None:
             try:
-                self._process.stdin.close()
+                if self._process.stdin is not None:
+                    self._process.stdin.close()
             except Exception:
                 pass
-            self._process.wait()
+            try:
+                self._process.wait(timeout=5.0)
+            except subprocess.TimeoutExpired:
+                self._process.kill()
+                self._process.wait()
             self._process = None
         return b""
 

{meeting_noter-0.7.0 → meeting_noter-1.1.0}/src/meeting_noter/cli.py

@@ -104,10 +104,46 @@ def _launch_gui_background():
     click.echo("Meeting Noter GUI launched.")
 
 
+def _handle_version():
+    """Handle --version: show version, check for updates, auto-update if enabled."""
+    import subprocess
+
+    from meeting_noter.update_checker import check_for_update
+
+    config = get_config()
+
+    click.echo(f"meeting-noter {__version__}")
+
+    # Check for updates
+    click.echo("Checking for updates...", nl=False)
+    new_version = check_for_update()
+
+    if new_version:
+        click.echo(f" update available: {new_version}")
+
+        if config.auto_update:
+            click.echo(f"Auto-updating to {new_version}...")
+            result = subprocess.run(
+                ["pipx", "upgrade", "meeting-noter"],
+                capture_output=True,
+                text=True,
+            )
+            if result.returncode == 0:
+                click.echo(click.style(f"Updated to {new_version}", fg="green"))
+            else:
+                click.echo(click.style("Update failed. Run manually:", fg="yellow"))
+                click.echo("  pipx upgrade meeting-noter")
+        else:
+            click.echo("Run to update: pipx upgrade meeting-noter")
+            click.echo("Or enable auto-update: mn config auto-update true")
+    else:
+        click.echo(" up to date")
+
+
 @click.group(cls=SuggestGroup, invoke_without_command=True)
-@click.version_option(version=__version__)
+@click.option("--version", "-V", is_flag=True, help="Show version and check for updates")
 @click.pass_context
-def cli(ctx):
+def cli(ctx, version):
     """Meeting Noter - Offline meeting transcription.
 
     \b
@@ -124,6 +160,10 @@ def cli(ctx):
       meeting-noter config whisper-model base.en  Set transcription model
       meeting-noter config auto-transcribe false  Disable auto-transcribe
     """
+    if version:
+        _handle_version()
+        ctx.exit(0)
+
     if ctx.invoked_subcommand is None:
         # No subcommand - start background watcher
         ctx.invoke(watcher)
@@ -131,8 +171,9 @@ def cli(ctx):
 
 @cli.command()
 @click.argument("name", required=False)
+@click.option("--live", "-l", is_flag=True, help="Show live transcription in terminal")
 @require_setup
-def start(name: Optional[str]):
+def start(name: Optional[str], live: bool):
     """Start an interactive foreground recording session.
 
     NAME is the meeting name (optional). If not provided, uses a timestamp
@@ -141,11 +182,14 @@ def start(name: Optional[str]):
     Examples:
         meeting-noter start                    # Uses timestamp name
         meeting-noter start "Weekly Standup"   # Uses custom name
+        meeting-noter start "Meeting" --live   # With live transcription
 
     Press Ctrl+C to stop recording. The recording will be automatically
     transcribed if auto_transcribe is enabled in settings.
     """
     from meeting_noter.daemon import run_foreground_capture
+    import threading
+    import time
 
     config = get_config()
     output_dir = config.recordings_dir
@@ -154,14 +198,59 @@ def start(name: Optional[str]):
     # Use default timestamp name if not provided
     meeting_name = name if name else generate_meeting_name()
 
-    run_foreground_capture(
-        output_dir=output_dir,
-        meeting_name=meeting_name,
-        auto_transcribe=config.auto_transcribe,
-        whisper_model=config.whisper_model,
-        transcripts_dir=config.transcripts_dir,
-        silence_timeout_minutes=config.silence_timeout,
-    )
+    # Live transcription display thread
+    stop_live_display = threading.Event()
+
+    def display_live_transcript():
+        """Background thread to display live transcription."""
+        live_dir = output_dir / "live"
+        last_content = ""
+
+        # Wait for live file to appear
+        while not stop_live_display.is_set():
+            live_files = list(live_dir.glob("*.live.txt")) if live_dir.exists() else []
+            if live_files:
+                live_file = max(live_files, key=lambda p: p.stat().st_mtime)
+                break
+            time.sleep(0.5)
+        else:
+            return
+
+        # Tail the file
+        while not stop_live_display.is_set():
+            try:
+                content = live_file.read_text()
+                if len(content) > len(last_content):
+                    new_content = content[len(last_content):]
+                    for line in new_content.splitlines():
+                        # Only show timestamp lines (transcriptions)
+                        if line.strip() and line.startswith("["):
+                            click.echo(click.style(line, fg="cyan"))
+                    last_content = content
+            except Exception:
+                pass
+            time.sleep(0.5)
+
+    # Start live display thread if requested
+    live_thread = None
+    if live:
+        click.echo(click.style("Live transcription enabled", fg="cyan"))
+        live_thread = threading.Thread(target=display_live_transcript, daemon=True)
+        live_thread.start()
+
+    try:
+        run_foreground_capture(
+            output_dir=output_dir,
+            meeting_name=meeting_name,
+            auto_transcribe=config.auto_transcribe,
+            whisper_model=config.whisper_model,
+            transcripts_dir=config.transcripts_dir,
+            silence_timeout_minutes=config.silence_timeout,
+        )
+    finally:
+        stop_live_display.set()
+        if live_thread:
+            live_thread.join(timeout=1.0)
 
 
 @cli.command(hidden=True)  # Internal command used by watcher
@@ -355,7 +444,13 @@ def logs(follow: bool, lines: int):
 )
 @require_setup
 def list_recordings(output_dir: Optional[str], limit: int):
-    """List recent meeting recordings."""
+    """List recent meeting recordings.
+
+    \b
+    Examples:
+        meeting-noter list          # Show last 10 recordings
+        meeting-noter list -n 20    # Show last 20 recordings
+    """
     from meeting_noter.output.writer import list_recordings as _list_recordings
 
     config = get_config()
@@ -377,28 +472,116 @@ def list_recordings(output_dir: Optional[str], limit: int):
     default=None,
     help="Whisper model size (overrides config)",
 )
-@click.option(
-    "--live", "-l",
-    is_flag=True,
-    help="Real-time transcription of current recording",
-)
 @require_setup
-def transcribe(file: Optional[str], output_dir: Optional[str], model: Optional[str], live: bool):
+def transcribe(file: Optional[str], output_dir: Optional[str], model: Optional[str]):
     """Transcribe a meeting recording.
 
-    If no FILE is specified, transcribes the most recent recording.
-    Use --live for real-time transcription of an ongoing meeting.
+    \b
+    Examples:
+        meeting-noter transcribe                    # Transcribe latest recording
+        meeting-noter transcribe recording.mp3      # Transcribe specific file
+        meeting-noter transcribe -m base.en         # Use larger model for accuracy
     """
-    from meeting_noter.transcription.engine import transcribe_file, transcribe_live
+    from meeting_noter.transcription.engine import transcribe_file
 
     config = get_config()
     output_path = Path(output_dir) if output_dir else config.recordings_dir
     whisper_model = model or config.whisper_model
 
-    if live:
-        transcribe_live(output_path, whisper_model)
-    else:
-        transcribe_file(file, output_path, whisper_model, config.transcripts_dir)
+    transcribe_file(file, output_path, whisper_model, config.transcripts_dir)
+
+
+@cli.command()
+@require_setup
+def live():
+    """Show live transcription of an active recording.
+
+    Displays the real-time transcript as it's being generated.
+    Use in a separate terminal while recording with 'meeting-noter start'.
+
+    \b
+    Examples:
+        # Terminal 1: Start recording
+        meeting-noter start "Team Meeting"
+
+        # Terminal 2: Watch live transcript
+        meeting-noter live
+
+    Or use 'meeting-noter start "name" --live' to see both in one terminal.
+    """
+    import time
+
+    config = get_config()
+    live_dir = config.recordings_dir / "live"
+
+    # Find the most recent .live.txt file in the live/ subfolder
+    if not live_dir.exists():
+        click.echo(click.style("No live transcript found.", fg="yellow"))
+        click.echo("Start a recording with: meeting-noter start")
+        return
+
+    live_files = sorted(
+        live_dir.glob("*.live.txt"),
+        key=lambda p: p.stat().st_mtime,
+        reverse=True,
+    )
+
+    if not live_files:
+        click.echo(click.style("No live transcript found.", fg="yellow"))
+        click.echo("Start a recording with: meeting-noter start")
+        return
+
+    live_file = live_files[0]
+
+    # Check if file is actively being written (modified in last 30 seconds)
+    file_age = time.time() - live_file.stat().st_mtime
+    if file_age > 30:
+        click.echo(click.style("No active recording found.", fg="yellow"))
+        click.echo(f"Most recent transcript ({live_file.name}) is {int(file_age)}s old.")
+        click.echo("Start a recording with: meeting-noter start")
+        return
+
+    click.echo(click.style("Live Transcription", fg="cyan", bold=True))
+    click.echo(f"Source: {live_file.name.replace('.live.txt', '.mp3')}")
+    click.echo("Press Ctrl+C to stop watching.\n")
+    click.echo("-" * 40)
+
+    # Tail the file
+    try:
+        last_content = ""
+        no_update_count = 0
+
+        while True:
+            try:
+                with open(live_file, "r") as f:
+                    content = f.read()
+
+                # Print only new content
+                if len(content) > len(last_content):
+                    new_content = content[len(last_content):]
+                    # Print line by line for better formatting
+                    for line in new_content.splitlines():
+                        if line.strip():
+                            click.echo(line)
+                    last_content = content
+                    no_update_count = 0
+                else:
+                    no_update_count += 1
+
+                # Check if file hasn't been updated for 30+ seconds (recording likely ended)
+                file_age = time.time() - live_file.stat().st_mtime
+                if file_age > 30 and no_update_count > 5:
+                    click.echo("\n" + click.style("Recording ended.", fg="yellow"))
+                    break
+
+            except FileNotFoundError:
+                click.echo("\n" + click.style("Live transcript file removed.", fg="yellow"))
+                break
+
+            time.sleep(1)
+
+    except KeyboardInterrupt:
+        click.echo("\n" + click.style("Stopped watching.", fg="cyan"))
 
 
 @cli.command()
@@ -463,6 +646,7 @@ CONFIG_KEYS = {
     "transcripts-dir": ("transcripts_dir", "path", "Directory for transcripts"),
     "whisper-model": ("whisper_model", "choice:tiny.en,base.en,small.en,medium.en,large-v3", "Whisper model for transcription"),
     "auto-transcribe": ("auto_transcribe", "bool", "Auto-transcribe after recording"),
+    "auto-update": ("auto_update", "bool", "Auto-update when running --version"),
     "silence-timeout": ("silence_timeout", "int", "Minutes of silence before auto-stop"),
     "capture-system-audio": ("capture_system_audio", "bool", "Capture meeting participants via ScreenCaptureKit"),
 }
@@ -553,7 +737,7 @@ def config(key: Optional[str], value: Optional[str]):
 WATCHER_PID_FILE = Path.home() / ".meeting-noter-watcher.pid"
 
 
-@cli.command()
+@cli.command(hidden=True)
 @click.option(
     "--foreground", "-f",
     is_flag=True,
@@ -665,7 +849,7 @@ def _run_watcher_loop():
             stop_daemon(DEFAULT_PID_FILE)
 
 
-@cli.command()
+@cli.command(hidden=True)
 @require_setup
 def watch():
     """Watch for meetings interactively (foreground with prompts).

{meeting_noter-0.7.0 → meeting_noter-1.1.0}/src/meeting_noter/config.py

@@ -32,6 +32,7 @@ DEFAULT_CONFIG = {
     "transcripts_dir": str(Path.home() / "meetings"),
     "whisper_model": "tiny.en",
     "auto_transcribe": True,
+    "auto_update": True,  # Auto-update when running --version
     "silence_timeout": 5,  # Minutes of silence before stopping recording
     "capture_system_audio": True,  # Capture other participants via ScreenCaptureKit
     "show_menubar": False,
@@ -139,6 +140,16 @@ class Config:
         """Set show menubar setting."""
         self._data["show_menubar"] = value
 
+    @property
+    def auto_update(self) -> bool:
+        """Get auto-update setting."""
+        return self._data.get("auto_update", True)
+
+    @auto_update.setter
+    def auto_update(self, value: bool) -> None:
+        """Set auto-update setting."""
+        self._data["auto_update"] = value
+
     @property
     def setup_complete(self) -> bool:
         """Check if setup has been completed."""

{meeting_noter-0.7.0 → meeting_noter-1.1.0}/src/meeting_noter/daemon.py

@@ -157,7 +157,11 @@ def run_daemon(
             remove_pid_file(pid_file)
 
 
-def _run_capture_loop(output_dir: Path, meeting_name: Optional[str] = None):
+def _run_capture_loop(
+    output_dir: Path,
+    meeting_name: Optional[str] = None,
+    enable_live_transcription: bool = True,
+):
     """Main capture loop.
 
     Audio imports happen HERE, safely AFTER the fork.
@@ -171,6 +175,16 @@ def _run_capture_loop(output_dir: Path, meeting_name: Optional[str] = None):
 
     config = get_config()
 
+    # Live transcription (imported here to avoid loading Whisper before fork)
+    live_transcriber = None
+    if enable_live_transcription:
+        try:
+            from meeting_noter.transcription.live_transcription import LiveTranscriber
+            LiveTranscriber  # Just verify import works, create later
+        except ImportError as e:
+            print(f"Live transcription not available: {e}")
+            enable_live_transcription = False
+
     print(f"Meeting Noter daemon started. Saving to {output_dir}")
     sys.stdout.flush()
     if meeting_name:
@@ -253,15 +267,42 @@ def _run_capture_loop(output_dir: Path, meeting_name: Optional[str] = None):
                     print(f"Recording started: {filepath.name}")
                     recording_started = True
                     audio_detected = True
+
+                    # Start live transcription
+                    if enable_live_transcription:
+                        try:
+                            from meeting_noter.transcription.live_transcription import LiveTranscriber
+                            live_transcriber = LiveTranscriber(
+                                output_path=filepath,
+                                sample_rate=sample_rate,
+                                channels=channels,
+                                window_seconds=5.0,
+                                slide_seconds=2.0,
+                                model_size=config.whisper_model,
+                            )
+                            live_transcriber.start()
+                            print(f"Live transcription: {live_transcriber.live_file_path.name}")
+                        except Exception as e:
+                            print(f"Failed to start live transcription: {e}")
+                            live_transcriber = None
             else:
                 # Currently recording
                 session.write(audio)
 
+                # Feed audio to live transcriber
+                if live_transcriber is not None:
+                    live_transcriber.write(audio)
+
                 if has_audio:
                     audio_detected = True
 
                 # Check for extended silence (meeting ended)
                 if is_silence and audio_detected:
+                    # Stop live transcription first
+                    if live_transcriber is not None:
+                        live_transcriber.stop()
+                        live_transcriber = None
+
                     filepath, duration = session.stop()
                     if filepath:
                         print(f"Recording saved: {filepath.name} ({duration:.1f}s)")
@@ -275,6 +316,10 @@ def _run_capture_loop(output_dir: Path, meeting_name: Optional[str] = None):
     finally:
         capture.stop()
 
+        # Stop live transcription
+        if live_transcriber is not None:
+            live_transcriber.stop()
+
         # Save any ongoing recording
         if 'session' in locals() and session.is_active:
             filepath, duration = session.stop()
@@ -377,6 +422,7 @@ def run_foreground_capture(
     whisper_model: str = "tiny.en",
     transcripts_dir: Optional[Path] = None,
     silence_timeout_minutes: int = 5,
+    enable_live_transcription: bool = True,
 ) -> Optional[Path]:
     """Run audio capture in foreground with a named meeting.
 
@@ -390,6 +436,7 @@ def run_foreground_capture(
         whisper_model: Whisper model to use for transcription
         transcripts_dir: Directory for transcripts
         silence_timeout_minutes: Stop after this many minutes of silence
+        enable_live_transcription: Whether to enable real-time transcription
 
     Returns:
         Path to the saved recording, or None if recording was too short
@@ -401,6 +448,9 @@ def run_foreground_capture(
 
     config = get_config()
 
+    # Initialize live transcriber
+    live_transcriber = None
+
     # Check audio device
     if not check_audio_available():
         click.echo(click.style("Error: ", fg="red") + "No audio input device found.")
@@ -461,6 +511,27 @@ def run_foreground_capture(
         filepath = session.start()
         click.echo(click.style("Recording: ", fg="green") + filepath.name)
 
+        # Start live transcription
+        if enable_live_transcription:
+            try:
+                from meeting_noter.transcription.live_transcription import LiveTranscriber
+                live_transcriber = LiveTranscriber(
+                    output_path=filepath,
+                    sample_rate=sample_rate,
+                    channels=channels,
+                    window_seconds=5.0,
+                    slide_seconds=2.0,
+                    model_size=whisper_model,
+                )
+                live_transcriber.start()
+                click.echo(
+                    click.style("Live transcript: ", fg="cyan") +
+                    str(live_transcriber.live_file_path)
+                )
+            except Exception as e:
+                click.echo(click.style(f"Live transcription not available: {e}", fg="yellow"))
+                live_transcriber = None
+
         while not _stop_event.is_set():
             audio = capture.get_audio(timeout=0.5)
             if audio is None:
@@ -472,6 +543,10 @@ def run_foreground_capture(
 
             session.write(audio)
 
+            # Feed audio to live transcriber
+            if live_transcriber is not None:
+                live_transcriber.write(audio)
+
             # Check for extended silence
             if silence_detector.update(audio):
                 click.echo("\n" + click.style("Stopped: ", fg="yellow") + "silence timeout reached")
@@ -487,6 +562,10 @@ def run_foreground_capture(
     except Exception as e:
         click.echo(click.style(f"\nError: {e}", fg="red"))
     finally:
+        # Stop live transcription
+        if live_transcriber is not None:
+            live_transcriber.stop()
+
         capture.stop()
 
         # Save recording

{meeting_noter-0.7.0 → meeting_noter-1.1.0}/src/meeting_noter/mic_monitor.py

@@ -169,6 +169,9 @@ def is_meeting_app_active() -> Optional[str]:
 
             # Browser-based meetings (Google Meet, etc.)
             if any(browser in owner_lower for browser in ["chrome", "safari", "firefox", "edge", "brave", "arc"]):
+                # Skip video streaming sites (YouTube, Vimeo, etc.)
+                if any(x in title_lower for x in ["youtube", "vimeo", "twitch", "netflix"]):
+                    continue
                 if title_lower.startswith("meet -") or "meet.google.com" in title_lower:
                     return "Google Meet"
                 if " meeting" in title_lower and any(x in title_lower for x in ["zoom", "teams", "webex"]):