meeting-noter 0.7.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

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

meeting_noter/transcription/live_transcription.py

@@ -0,0 +1,250 @@
+"""Live transcription during recording.
+
+Buffers audio chunks and transcribes them in a background thread,
+writing segments to a .live.txt file that can be tailed by the CLI.
+
+Uses overlapping windows for lower latency: keeps a 5-second context window
+but transcribes every 2 seconds, only outputting new content.
+"""
+
+from __future__ import annotations
+
+import sys
+import numpy as np
+from collections import deque
+from pathlib import Path
+from queue import Queue, Empty
+from threading import Thread, Event
+from typing import Optional
+from datetime import datetime
+
+
+class LiveTranscriber:
+    """Transcribes audio in real-time during recording.
+
+    Uses overlapping windows approach:
+    - Maintains a rolling window of audio (default 5 seconds)
+    - Transcribes every `slide_seconds` (default 2 seconds)
+    - Only outputs new segments to avoid duplicates
+    """
+
+    def __init__(
+        self,
+        output_path: Path,
+        sample_rate: int = 48000,
+        channels: int = 2,
+        window_seconds: float = 5.0,
+        slide_seconds: float = 2.0,
+        model_size: str = "tiny.en",
+    ):
+        """Initialize the live transcriber.
+
+        Args:
+            output_path: Path to write live transcript (will use .live.txt suffix in live/ subfolder)
+            sample_rate: Audio sample rate
+            channels: Number of audio channels
+            window_seconds: Size of the context window for transcription
+            slide_seconds: How often to transcribe (lower = more responsive, higher CPU)
+            model_size: Whisper model to use (tiny.en recommended for speed)
+        """
+        # Put live transcripts in a 'live/' subfolder to keep recordings folder clean
+        live_dir = output_path.parent / "live"
+        live_dir.mkdir(exist_ok=True)
+        self.output_path = live_dir / (output_path.stem + ".live.txt")
+        self.sample_rate = sample_rate
+        self.channels = channels
+        self.window_seconds = window_seconds
+        self.slide_seconds = slide_seconds
+        self.model_size = model_size
+
+        self._audio_queue: Queue[np.ndarray] = Queue()
+        self._stop_event = Event()
+        self._thread: Optional[Thread] = None
+        self._model = None
+        self._start_time: Optional[datetime] = None
+        self._recording_offset = 0.0  # Current position in recording (seconds)
+        self._last_output_end = 0.0  # End time of last outputted segment
+
+    def start(self):
+        """Start the live transcription thread."""
+        self._stop_event.clear()
+        self._start_time = datetime.now()
+        self._recording_offset = 0.0
+        self._last_output_end = 0.0
+
+        # Create/clear the output file
+        with open(self.output_path, "w") as f:
+            f.write(f"Live Transcription - {self._start_time.strftime('%Y-%m-%d %H:%M:%S')}\n")
+            f.write("-" * 40 + "\n\n")
+
+        self._thread = Thread(target=self._transcribe_loop, daemon=True)
+        self._thread.start()
+
+    def write(self, audio: np.ndarray):
+        """Add audio chunk to the transcription queue.
+
+        Args:
+            audio: Audio data (float32, -1 to 1)
+        """
+        if not self._stop_event.is_set():
+            self._audio_queue.put(audio.copy())
+
+    def stop(self):
+        """Stop the live transcription thread."""
+        self._stop_event.set()
+        if self._thread is not None:
+            self._thread.join(timeout=10.0)
+            self._thread = None
+        self._model = None
+
+    def _load_model(self):
+        """Load the Whisper model (lazy loading)."""
+        if self._model is not None:
+            return
+
+        try:
+            from faster_whisper import WhisperModel
+
+            # Check for bundled model
+            bundled_path = None
+            try:
+                from meeting_noter_models import get_model_path
+                bundled_path = get_model_path()
+                if not (bundled_path.exists() and (bundled_path / "model.bin").exists()):
+                    bundled_path = None
+            except ImportError:
+                pass
+
+            if bundled_path and self.model_size == "tiny.en":
+                self._model = WhisperModel(
+                    str(bundled_path),
+                    device="cpu",
+                    compute_type="int8",
+                )
+            else:
+                self._model = WhisperModel(
+                    self.model_size,
+                    device="cpu",
+                    compute_type="int8",
+                )
+        except Exception as e:
+            print(f"Failed to load Whisper model: {e}", file=sys.stderr)
+            self._model = None
+
+    def _transcribe_loop(self):
+        """Main transcription loop with overlapping windows."""
+        # Rolling buffer using deque for efficient sliding
+        window_samples = int(self.window_seconds * self.sample_rate)
+        slide_samples = int(self.slide_seconds * self.sample_rate)
+
+        # Buffer holds raw audio samples
+        rolling_buffer: deque[float] = deque(maxlen=window_samples)
+        samples_since_last_transcribe = 0
+
+        # Load model on first use
+        self._load_model()
+        if self._model is None:
+            return
+
+        while not self._stop_event.is_set():
+            try:
+                # Collect audio chunks
+                try:
+                    chunk = self._audio_queue.get(timeout=0.5)
+
+                    # Add samples to rolling buffer
+                    for sample in chunk:
+                        rolling_buffer.append(sample)
+
+                    samples_since_last_transcribe += len(chunk)
+                    self._recording_offset += len(chunk) / self.sample_rate
+
+                except Empty:
+                    if self._stop_event.is_set():
+                        break
+                    continue
+
+                # Transcribe every slide_seconds
+                if samples_since_last_transcribe >= slide_samples and len(rolling_buffer) >= slide_samples:
+                    self._transcribe_window(rolling_buffer)
+                    samples_since_last_transcribe = 0
+
+            except Exception as e:
+                print(f"Live transcription error: {e}", file=sys.stderr)
+
+        # Final transcription on stop
+        if len(rolling_buffer) > 0:
+            self._transcribe_window(rolling_buffer)
+
+    def _transcribe_window(self, rolling_buffer: deque):
+        """Transcribe the current window and output new segments."""
+        if not rolling_buffer or self._model is None:
+            return
+
+        try:
+            # Convert deque to numpy array (ensure float32 for Whisper)
+            audio = np.array(list(rolling_buffer), dtype=np.float32)
+
+            # Convert stereo to mono if needed
+            if self.channels == 2 and len(audio) % 2 == 0:
+                audio = audio.reshape(-1, 2).mean(axis=1).astype(np.float32)
+
+            # Resample to 16kHz if needed (Whisper expects 16kHz)
+            if self.sample_rate != 16000:
+                audio = self._resample(audio, self.sample_rate, 16000).astype(np.float32)
+
+            # Calculate window timing
+            window_duration = len(rolling_buffer) / self.sample_rate
+            window_start = self._recording_offset - window_duration
+
+            # Transcribe using faster-whisper
+            segments, _ = self._model.transcribe(
+                audio,
+                beam_size=1,  # Fastest
+                vad_filter=True,
+                vad_parameters=dict(min_silence_duration_ms=200),
+            )
+
+            # Write only NEW segments to file
+            with open(self.output_path, "a") as f:
+                for segment in segments:
+                    # Calculate absolute timestamp
+                    abs_start = window_start + segment.start
+                    abs_end = window_start + segment.end
+
+                    # Only output if this segment is new (starts after last output)
+                    if abs_start >= self._last_output_end - 0.5:  # 0.5s tolerance for overlap
+                        text = segment.text.strip()
+                        if text:
+                            timestamp = self._format_timestamp(abs_start)
+                            f.write(f"{timestamp} {text}\n")
+                            f.flush()
+                            self._last_output_end = abs_end
+
+        except Exception as e:
+            print(f"Transcription error: {e}", file=sys.stderr)
+
+    @staticmethod
+    def _resample(audio: np.ndarray, orig_sr: int, target_sr: int) -> np.ndarray:
+        """Simple resampling using linear interpolation."""
+        if orig_sr == target_sr:
+            return audio
+
+        duration = len(audio) / orig_sr
+        target_length = int(duration * target_sr)
+
+        # Use numpy interpolation (returns float64, so cast back)
+        indices = np.linspace(0, len(audio) - 1, target_length)
+        return np.interp(indices, np.arange(len(audio)), audio).astype(np.float32)
+
+    @staticmethod
+    def _format_timestamp(seconds: float) -> str:
+        """Format seconds as [MM:SS]."""
+        minutes = int(seconds // 60)
+        secs = int(seconds % 60)
+        return f"[{minutes:02d}:{secs:02d}]"
+
+    @property
+    def live_file_path(self) -> Path:
+        """Get the path to the live transcript file."""
+        return self.output_path

meeting_noter/update_checker.py

@@ -0,0 +1,65 @@
+"""Check for updates from PyPI."""
+
+import threading
+import urllib.request
+import json
+from typing import Optional, Tuple
+
+from meeting_noter import __version__
+
+
+PYPI_URL = "https://pypi.org/pypi/meeting-noter/json"
+
+
+def parse_version(version: str) -> Tuple[int, ...]:
+    """Parse version string into tuple for comparison."""
+    try:
+        return tuple(int(x) for x in version.split("."))
+    except ValueError:
+        return (0, 0, 0)
+
+
+def get_latest_version() -> Optional[str]:
+    """Fetch the latest version from PyPI."""
+    try:
+        req = urllib.request.Request(
+            PYPI_URL,
+            headers={"Accept": "application/json", "User-Agent": "meeting-noter"}
+        )
+        with urllib.request.urlopen(req, timeout=5) as response:
+            data = json.loads(response.read().decode())
+            return data.get("info", {}).get("version")
+    except Exception:
+        return None
+
+
+def check_for_update() -> Optional[str]:
+    """Check if an update is available.
+
+    Returns the new version string if an update is available, None otherwise.
+    """
+    latest = get_latest_version()
+    if not latest:
+        return None
+
+    current = parse_version(__version__)
+    latest_parsed = parse_version(latest)
+
+    if latest_parsed > current:
+        return latest
+    return None
+
+
+def check_for_update_async(callback):
+    """Check for updates in a background thread.
+
+    Args:
+        callback: Function to call with the new version string (or None if no update).
+    """
+    def _check():
+        new_version = check_for_update()
+        if new_version:
+            callback(new_version)
+
+    thread = threading.Thread(target=_check, daemon=True)
+    thread.start()

{meeting_noter-0.7.0.dist-info → meeting_noter-1.1.0.dist-info}/METADATA

@@ -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.dist-info → meeting_noter-1.1.0.dist-info}/RECORD

@@ -1,14 +1,15 @@
-meeting_noter/__init__.py,sha256=bLOErRC3sfnQ4a4RyZUzUljZEikXy7zOiYYUz5GytPg,103
+meeting_noter/__init__.py,sha256=OuitWUFUeSb7eg41mnnDD6QiJrcGVpXpdhDzyxtCmmU,103
 meeting_noter/__main__.py,sha256=6sSOqH1o3jvgvkVzsVKmF6-xVGcUAbNVQkRl2CrygdE,120
-meeting_noter/cli.py,sha256=OAlLc7CEgov3akDo89I0JUMl9wCXs81x3QO2mBcqLvE,27769
-meeting_noter/config.py,sha256=41LFBNp5o0IojYS5Hf0FJVIr7GNn7B5O1TJDE8SQkkk,5977
-meeting_noter/daemon.py,sha256=BYMc-sAz8zo9ZFMRr_Th8iw_l7rc71ldEf1mwsJJgaw,16502
+meeting_noter/cli.py,sha256=BAoUnQ-FPgwTp6-ON6WQkO-7Biwk1mYhwFaGdchHGHQ,34267
+meeting_noter/config.py,sha256=_Jy-gZDTCN3TwH5fiLEWk-qFhoSGISO2xDQmACV_zRc,6334
+meeting_noter/daemon.py,sha256=u9VrYe94o3lxabuIS9MDVPHSH7MqKqzTqGTuA7TNAIc,19767
 meeting_noter/meeting_detector.py,sha256=St0qoMkvUERP4BaxnXO1M6fZDJpWqBf9In7z2SgWcWg,10564
 meeting_noter/menubar.py,sha256=Gn6p8y5jA_HCWf1T3ademxH-vndpONHkf9vUlKs6XEo,14379
-meeting_noter/mic_monitor.py,sha256=zgcNypn29gWTyslalu5-JFseG47DVHEtcHCGiEUugAs,16021
+meeting_noter/mic_monitor.py,sha256=P8vF4qaZcGrEzzJyVos78Vuf38NXHGNRREDsD-HyBHc,16211
+meeting_noter/update_checker.py,sha256=sMmIiiZJL6K7wqLWE64Aj4hS8uspjUOirr6BG_IlL1I,1701
 meeting_noter/audio/__init__.py,sha256=O7PU8CxHSHxMeHbc9Jdwt9kePLQzsPh81GQU7VHCtBY,44
 meeting_noter/audio/capture.py,sha256=fDrT5oXfva8vdFlht9cv60NviKbksw2QeJ8eOtI19uE,6469
-meeting_noter/audio/encoder.py,sha256=6UgEYLFACSQEIx2nhH1Qq-cBh3qPJziMGkrm39k6Nz8,6401
+meeting_noter/audio/encoder.py,sha256=OBsgUmlZPz-YZQZ7Rp8MAlMRaQxTsccjuTgCtvRebmc,6573
 meeting_noter/audio/system_audio.py,sha256=jbHGjNCerI19weXap0a90Ik17lVTCT1hCEgRKYke-p8,13016
 meeting_noter/gui/__init__.py,sha256=z5GxxaeXyjqyEa9ox0dQxuL5u_BART0bi7cI6rfntEI,103
 meeting_noter/gui/__main__.py,sha256=A2HWdYod0bTgjQQIi21O7XpmgxLH36e_X0aygEUZLls,146
@@ -32,8 +33,9 @@ meeting_noter/resources/icon_512.png,sha256=o7X3ngYcppcIAAk9AcfPx94MUmrsPRp0qBTp
 meeting_noter/resources/icon_64.png,sha256=TqG7Awx3kK8YdiX1e_z1odZonosZyQI2trlkNZCzUoI,607
 meeting_noter/transcription/__init__.py,sha256=7GY9diP06DzFyoli41wddbrPv5bVDzH35bmnWlIJev4,29
 meeting_noter/transcription/engine.py,sha256=G9NcSS6Q-UhW7PlQ0E85hQXn6BWao64nIvyw4NR2yxI,7208
-meeting_noter-0.7.0.dist-info/METADATA,sha256=8V-ZO5eL8tFm3PauQU9dCZVw0ZbkyCWl6xklfcH3a-c,6952
-meeting_noter-0.7.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-meeting_noter-0.7.0.dist-info/entry_points.txt,sha256=rKNhzjSF5-e3bLRr8LVe22FeiwcacXabCvNpoEXfu4I,56
-meeting_noter-0.7.0.dist-info/top_level.txt,sha256=9Tuq04_0SXM0OXOHVbOHkHkB5tG3fqkrMrfzCMpbLpY,14
-meeting_noter-0.7.0.dist-info/RECORD,,
+meeting_noter/transcription/live_transcription.py,sha256=AslB1T1_gxu7eSp7xc79_2SdfGrNJq7L_8bA1t6YoU4,9277
+meeting_noter-1.1.0.dist-info/METADATA,sha256=bGwwBq9AeFcxYKf0vpD3WtENmibBNLl4mzf1fLDyiVs,6995
+meeting_noter-1.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+meeting_noter-1.1.0.dist-info/entry_points.txt,sha256=osZoOmm-UBPCJ4b6DGH6JOAm7mofM2fK06eK6blplmg,83
+meeting_noter-1.1.0.dist-info/top_level.txt,sha256=9Tuq04_0SXM0OXOHVbOHkHkB5tG3fqkrMrfzCMpbLpY,14
+meeting_noter-1.1.0.dist-info/RECORD,,

{meeting_noter-0.7.0.dist-info → meeting_noter-1.1.0.dist-info}/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
 meeting-noter = meeting_noter.cli:cli
+mn = meeting_noter.cli:cli