meeting-noter 0.7.0__py3-none-any.whl

meeting_noter/cli.py

@@ -0,0 +1,837 @@
+"""CLI commands for Meeting Noter."""
+
+from __future__ import annotations
+
+import difflib
+import click
+from pathlib import Path
+from typing import Optional
+
+from meeting_noter import __version__
+from meeting_noter.config import (
+    get_config,
+    require_setup,
+    is_setup_complete,
+    generate_meeting_name,
+)
+
+
+# Default paths
+DEFAULT_PID_FILE = Path.home() / ".meeting-noter.pid"
+
+
+class SuggestGroup(click.Group):
+    """Custom Click group that suggests similar commands on typos."""
+
+    # Use SuggestCommand for all commands in this group
+    command_class = None  # Will be set after SuggestCommand is defined
+
+    def resolve_command(self, ctx, args):
+        """Override to suggest similar commands on error."""
+        try:
+            return super().resolve_command(ctx, args)
+        except click.UsageError as e:
+            if args:
+                cmd_name = args[0]
+                # Find similar commands
+                matches = difflib.get_close_matches(
+                    cmd_name, self.list_commands(ctx), n=3, cutoff=0.5
+                )
+                if matches:
+                    suggestion = f"\n\nDid you mean: {', '.join(matches)}?"
+                    raise click.UsageError(str(e) + suggestion)
+            raise
+
+    def get_command(self, ctx, cmd_name):
+        """Override to handle partial command matching."""
+        # Try exact match first
+        rv = super().get_command(ctx, cmd_name)
+        if rv is not None:
+            return rv
+
+        # Try prefix match
+        matches = [cmd for cmd in self.list_commands(ctx) if cmd.startswith(cmd_name)]
+        if len(matches) == 1:
+            return super().get_command(ctx, matches[0])
+
+        return None
+
+
+class SuggestCommand(click.Command):
+    """Custom Click command that suggests similar options on typos."""
+
+    def make_context(self, info_name, args, parent=None, **extra):
+        """Override to catch and improve option errors."""
+        try:
+            return super().make_context(info_name, args, parent, **extra)
+        except click.UsageError as e:
+            error_msg = str(e)
+            if "No such option:" in error_msg:
+                # Extract the bad option
+                bad_opt = error_msg.split("No such option:")[-1].strip()
+                # Get available options
+                all_opts = []
+                for param in self.params:
+                    all_opts.extend(param.opts)
+
+                matches = difflib.get_close_matches(bad_opt, all_opts, n=3, cutoff=0.4)
+                if matches:
+                    suggestion = f"\n\nDid you mean: {', '.join(matches)}?"
+                    raise click.UsageError(error_msg + suggestion)
+                else:
+                    # Show available options
+                    raise click.UsageError(
+                        error_msg + f"\n\nAvailable options: {', '.join(sorted(all_opts))}"
+                    )
+            raise
+
+
+# Set the default command class for SuggestGroup
+SuggestGroup.command_class = SuggestCommand
+
+
+def _launch_gui_background():
+    """Launch the GUI in background and return immediately."""
+    import subprocess
+    import sys
+
+    subprocess.Popen(
+        [sys.executable, "-m", "meeting_noter.gui"],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        start_new_session=True,
+    )
+    click.echo("Meeting Noter GUI launched.")
+
+
+@click.group(cls=SuggestGroup, invoke_without_command=True)
+@click.version_option(version=__version__)
+@click.pass_context
+def cli(ctx):
+    """Meeting Noter - Offline meeting transcription.
+
+    \b
+    Quick start:
+      meeting-noter           Start watching for meetings (background)
+      meeting-noter status    Show current status
+      meeting-noter shutdown  Stop all processes
+      meeting-noter open      Open recordings in Finder
+
+    \b
+    Configuration:
+      meeting-noter config                        Show all settings
+      meeting-noter config recordings-dir ~/path  Set recordings directory
+      meeting-noter config whisper-model base.en  Set transcription model
+      meeting-noter config auto-transcribe false  Disable auto-transcribe
+    """
+    if ctx.invoked_subcommand is None:
+        # No subcommand - start background watcher
+        ctx.invoke(watcher)
+
+
+@cli.command()
+@click.argument("name", required=False)
+@require_setup
+def start(name: Optional[str]):
+    """Start an interactive foreground recording session.
+
+    NAME is the meeting name (optional). If not provided, uses a timestamp
+    like "29_Jan_2026_1430".
+
+    Examples:
+        meeting-noter start                    # Uses timestamp name
+        meeting-noter start "Weekly Standup"   # Uses custom name
+
+    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
+
+    config = get_config()
+    output_dir = config.recordings_dir
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # 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,
+    )
+
+
+@cli.command(hidden=True)  # Internal command used by watcher
+@click.option("--output-dir", "-o", type=click.Path(), default=None)
+@click.option("--foreground", "-f", is_flag=True)
+@click.option("--name", "-n", default=None)
+@require_setup
+def daemon(output_dir: Optional[str], foreground: bool, name: Optional[str]):
+    """Internal: Start recording daemon."""
+    from meeting_noter.daemon import run_daemon
+
+    config = get_config()
+    output_path = Path(output_dir) if output_dir else config.recordings_dir
+    output_path.mkdir(parents=True, exist_ok=True)
+
+    run_daemon(
+        output_path,
+        foreground=foreground,
+        pid_file=DEFAULT_PID_FILE,
+        meeting_name=name,
+    )
+
+
+@cli.command()
+def status():
+    """Show Meeting Noter status."""
+    import os
+    from meeting_noter.daemon import read_pid_file, is_process_running
+
+    # Check watcher
+    watcher_running = False
+    if WATCHER_PID_FILE.exists():
+        try:
+            pid = int(WATCHER_PID_FILE.read_text().strip())
+            os.kill(pid, 0)
+            watcher_running = True
+        except (ProcessLookupError, ValueError, FileNotFoundError):
+            pass
+
+    # Check menubar
+    menubar_running = False
+    menubar_pid_file = Path.home() / ".meeting-noter-menubar.pid"
+    if menubar_pid_file.exists():
+        try:
+            pid = int(menubar_pid_file.read_text().strip())
+            os.kill(pid, 0)
+            menubar_running = True
+        except (ProcessLookupError, ValueError, FileNotFoundError):
+            pass
+
+    # Check daemon (recording)
+    daemon_running = False
+    daemon_pid = read_pid_file(DEFAULT_PID_FILE)
+    if daemon_pid and is_process_running(daemon_pid):
+        daemon_running = True
+
+    # Determine status
+    click.echo()
+    if daemon_running:
+        # Get current recording name from log
+        recording_name = _get_current_recording_name()
+        click.echo(f"🔴 Recording: {recording_name or 'In progress'}")
+    elif watcher_running or menubar_running:
+        mode = "watcher" if watcher_running else "menubar"
+        click.echo(f"👀 Ready to record ({mode} active)")
+    else:
+        click.echo("⏹️  Stopped (run 'meeting-noter' to start)")
+
+    click.echo()
+
+    # Show details
+    click.echo("Components:")
+    click.echo(f"  Watcher:  {'running' if watcher_running else 'stopped'}")
+    click.echo(f"  Menubar:  {'running' if menubar_running else 'stopped'}")
+    click.echo(f"  Recorder: {'recording' if daemon_running else 'idle'}")
+    click.echo()
+
+
+def _get_current_recording_name() -> str | None:
+    """Get the name of the current recording from the log file."""
+    log_path = Path.home() / ".meeting-noter.log"
+    if not log_path.exists():
+        return None
+
+    try:
+        with open(log_path, "r") as f:
+            lines = f.readlines()
+
+        for line in reversed(lines[-50:]):
+            if "Recording started:" in line:
+                parts = line.split("Recording started:")
+                if len(parts) > 1:
+                    filename = parts[1].strip().replace(".mp3", "")
+                    # Extract name from timestamp_name format
+                    name_parts = filename.split("_", 2)
+                    if len(name_parts) >= 3:
+                        return name_parts[2]
+                    return filename
+            elif "Recording saved:" in line or "Recording discarded" in line:
+                break
+        return None
+    except Exception:
+        return None
+
+
+@cli.command()
+def shutdown():
+    """Stop all Meeting Noter processes (daemon, watcher, menubar, GUI)."""
+    import subprocess
+    import os
+    import signal
+    from meeting_noter.daemon import stop_daemon
+
+    stopped = []
+
+    # Stop daemon
+    if DEFAULT_PID_FILE.exists():
+        stop_daemon(DEFAULT_PID_FILE)
+        stopped.append("daemon")
+
+    # Stop watcher
+    if WATCHER_PID_FILE.exists():
+        try:
+            pid = int(WATCHER_PID_FILE.read_text().strip())
+            os.kill(pid, signal.SIGTERM)
+            WATCHER_PID_FILE.unlink()
+            stopped.append("watcher")
+        except (ProcessLookupError, ValueError):
+            WATCHER_PID_FILE.unlink(missing_ok=True)
+
+    # Stop menubar
+    menubar_pid_file = Path.home() / ".meeting-noter-menubar.pid"
+    if menubar_pid_file.exists():
+        try:
+            pid = int(menubar_pid_file.read_text().strip())
+            os.kill(pid, signal.SIGTERM)
+            menubar_pid_file.unlink()
+            stopped.append("menubar")
+        except (ProcessLookupError, ValueError):
+            menubar_pid_file.unlink(missing_ok=True)
+
+    # Kill any remaining meeting-noter processes
+    result = subprocess.run(
+        ["pkill", "-f", "meeting_noter"],
+        capture_output=True
+    )
+    if result.returncode == 0:
+        stopped.append("other processes")
+
+    if stopped:
+        click.echo(f"Stopped: {', '.join(stopped)}")
+    else:
+        click.echo("No Meeting Noter processes were running.")
+
+
+@cli.command()
+@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."""
+    import subprocess
+
+    log_file = Path.home() / ".meeting-noter.log"
+
+    if not log_file.exists():
+        click.echo("No log file found.")
+        return
+
+    if follow:
+        click.echo(f"Following {log_file} (Ctrl+C to stop)...")
+        try:
+            subprocess.run(["tail", "-f", str(log_file)])
+        except KeyboardInterrupt:
+            pass
+    else:
+        subprocess.run(["tail", f"-{lines}", str(log_file)])
+
+
+@cli.command("list")
+@click.option(
+    "--output-dir", "-o",
+    type=click.Path(exists=True),
+    default=None,
+    help="Directory containing recordings (overrides config)",
+)
+@click.option(
+    "--limit", "-n",
+    type=int,
+    default=10,
+    help="Number of recordings to show",
+)
+@require_setup
+def list_recordings(output_dir: Optional[str], limit: int):
+    """List recent meeting recordings."""
+    from meeting_noter.output.writer import list_recordings as _list_recordings
+
+    config = get_config()
+    path = Path(output_dir) if output_dir else config.recordings_dir
+    _list_recordings(path, limit)
+
+
+@cli.command()
+@click.argument("file", required=False)
+@click.option(
+    "--output-dir", "-o",
+    type=click.Path(exists=True),
+    default=None,
+    help="Directory containing recordings (overrides config)",
+)
+@click.option(
+    "--model", "-m",
+    type=click.Choice(["tiny.en", "base.en", "small.en", "medium.en", "large-v3"]),
+    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):
+    """Transcribe a meeting recording.
+
+    If no FILE is specified, transcribes the most recent recording.
+    Use --live for real-time transcription of an ongoing meeting.
+    """
+    from meeting_noter.transcription.engine import transcribe_file, transcribe_live
+
+    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)
+
+
+@cli.command()
+@click.option(
+    "--foreground", "-f",
+    is_flag=True,
+    help="Run in foreground instead of background",
+)
+@require_setup
+def menubar(foreground: bool):
+    """Launch menu bar app for daemon control.
+
+    Adds a menu bar icon for one-click start/stop of the recording daemon.
+    The icon shows "MN" when idle and "MN [filename]" when recording.
+
+    By default, runs in background. Use -f for foreground (debugging).
+    """
+    import subprocess
+    import sys
+
+    if foreground:
+        from meeting_noter.menubar import run_menubar
+        run_menubar()
+    else:
+        # Spawn as background process
+        subprocess.Popen(
+            [sys.executable, "-m", "meeting_noter.menubar"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            start_new_session=True,
+        )
+        click.echo("Menu bar app started in background.")
+
+
+@cli.command()
+@click.option(
+    "--foreground", "-f",
+    is_flag=True,
+    help="Run in foreground instead of background",
+)
+@require_setup
+def gui(foreground: bool):
+    """Launch the desktop GUI application.
+
+    Opens a window with tabs for:
+    - Recording: Start/stop recordings with meeting names
+    - Meetings: Browse, play, and manage recordings
+    - Settings: Configure directories, models, and preferences
+
+    By default runs in background. Use -f for foreground.
+    """
+    if foreground:
+        from meeting_noter.gui import run_gui
+        run_gui()
+    else:
+        _launch_gui_background()
+
+
+# Config key mappings (CLI name -> config attribute)
+CONFIG_KEYS = {
+    "recordings-dir": ("recordings_dir", "path", "Directory for audio recordings"),
+    "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"),
+    "silence-timeout": ("silence_timeout", "int", "Minutes of silence before auto-stop"),
+    "capture-system-audio": ("capture_system_audio", "bool", "Capture meeting participants via ScreenCaptureKit"),
+}
+
+
+@cli.command()
+@click.argument("key", required=False)
+@click.argument("value", required=False)
+def config(key: Optional[str], value: Optional[str]):
+    """View or set configuration options.
+
+    \b
+    Examples:
+        meeting-noter config                     # Show all settings
+        meeting-noter config recordings-dir      # Get specific setting
+        meeting-noter config recordings-dir ~/meetings  # Set setting
+
+    \b
+    Available settings:
+        recordings-dir       Directory for audio recordings
+        transcripts-dir      Directory for transcripts
+        whisper-model        Model: tiny.en, base.en, small.en, medium.en, large-v3
+        auto-transcribe      Auto-transcribe after recording (true/false)
+        silence-timeout      Minutes of silence before auto-stop
+        capture-system-audio Capture system audio (true/false)
+    """
+    cfg = get_config()
+
+    if key is None:
+        # Show all settings
+        click.echo()
+        click.echo("Meeting Noter Configuration")
+        click.echo("=" * 40)
+        for cli_key, (attr, _, desc) in CONFIG_KEYS.items():
+            val = getattr(cfg, attr)
+            click.echo(f"  {cli_key}: {val}")
+        click.echo()
+        click.echo(f"Config file: {cfg.config_path}")
+        click.echo()
+        return
+
+    # Normalize key (allow underscores too)
+    key = key.replace("_", "-").lower()
+
+    if key not in CONFIG_KEYS:
+        click.echo(f"Unknown config key: {key}")
+        click.echo(f"Available keys: {', '.join(CONFIG_KEYS.keys())}")
+        return
+
+    attr, val_type, desc = CONFIG_KEYS[key]
+
+    if value is None:
+        # Get setting
+        click.echo(getattr(cfg, attr))
+        return
+
+    # Set setting
+    try:
+        if val_type == "bool":
+            if value.lower() in ("true", "1", "yes", "on"):
+                parsed = True
+            elif value.lower() in ("false", "0", "no", "off"):
+                parsed = False
+            else:
+                raise ValueError(f"Invalid boolean: {value}")
+        elif val_type == "int":
+            parsed = int(value)
+        elif val_type == "path":
+            parsed = Path(value).expanduser()
+            # Create directory if it doesn't exist
+            parsed.mkdir(parents=True, exist_ok=True)
+        elif val_type.startswith("choice:"):
+            choices = val_type.split(":")[1].split(",")
+            if value not in choices:
+                raise ValueError(f"Must be one of: {', '.join(choices)}")
+            parsed = value
+        else:
+            parsed = value
+
+        setattr(cfg, attr, parsed)
+        cfg.save()
+        click.echo(f"Set {key} = {parsed}")
+
+    except ValueError as e:
+        click.echo(f"Invalid value: {e}")
+
+
+WATCHER_PID_FILE = Path.home() / ".meeting-noter-watcher.pid"
+
+
+@cli.command()
+@click.option(
+    "--foreground", "-f",
+    is_flag=True,
+    help="Run in foreground instead of background",
+)
+@require_setup
+def watcher(foreground: bool):
+    """Start background watcher that auto-detects and records meetings.
+
+    This is the default command when running 'meeting-noter' without arguments.
+    Runs in background by default. Use 'meeting-noter shutdown' to stop.
+
+    Use -f/--foreground for interactive mode (shows prompts in terminal).
+    """
+    import subprocess
+    import sys
+    import os
+
+    if foreground:
+        _run_watcher_loop()
+    else:
+        # Check if already running
+        if WATCHER_PID_FILE.exists():
+            try:
+                pid = int(WATCHER_PID_FILE.read_text().strip())
+                os.kill(pid, 0)  # Check if process exists
+                click.echo(f"Watcher already running (PID {pid}). Use 'meeting-noter shutdown' to stop.")
+                return
+            except (ProcessLookupError, ValueError):
+                WATCHER_PID_FILE.unlink(missing_ok=True)
+
+        # Start in background
+        subprocess.Popen(
+            [sys.executable, "-m", "meeting_noter.cli", "watcher", "-f"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            start_new_session=True,
+        )
+        click.echo("Meeting Noter watcher started in background.")
+        click.echo("Use 'meeting-noter shutdown' to stop.")
+
+
+def _run_watcher_loop():
+    """Run the watcher loop (foreground)."""
+    import time
+    import sys
+    import os
+    import atexit
+    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
+
+    # Write PID file
+    WATCHER_PID_FILE.write_text(str(os.getpid()))
+    atexit.register(lambda: WATCHER_PID_FILE.unlink(missing_ok=True))
+
+    config = get_config()
+    output_dir = config.recordings_dir
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    mic_monitor = MicrophoneMonitor()
+    current_meeting_name = None
+
+    try:
+        while True:
+            mic_started, mic_stopped, app_name = mic_monitor.check()
+
+            is_recording = read_pid_file(DEFAULT_PID_FILE) is not None and \
+                           is_process_running(read_pid_file(DEFAULT_PID_FILE))
+
+            if mic_started and not is_recording:
+                # Meeting detected - auto-start recording silently
+                app_name = app_name or is_meeting_app_active() or "Unknown"
+                meeting_name = get_meeting_window_title() or generate_meeting_name()
+                current_meeting_name = meeting_name
+
+                # Start daemon
+                import subprocess
+                subprocess.Popen(
+                    [sys.executable, "-m", "meeting_noter.cli", "daemon", "--name", meeting_name],
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                )
+                mic_monitor.set_recording(True, app_name)
+
+            elif mic_stopped and is_recording:
+                # Meeting ended - stop silently
+                stop_daemon(DEFAULT_PID_FILE)
+                mic_monitor.set_recording(False)
+
+                # Auto-transcribe
+                if config.auto_transcribe:
+                    time.sleep(2)
+                    mp3_files = sorted(output_dir.glob("*.mp3"), key=lambda p: p.stat().st_mtime)
+                    if mp3_files:
+                        latest = mp3_files[-1]
+                        import subprocess
+                        subprocess.Popen(
+                            [sys.executable, "-m", "meeting_noter.cli", "transcribe", str(latest)],
+                            stdout=subprocess.DEVNULL,
+                            stderr=subprocess.DEVNULL,
+                        )
+
+                current_meeting_name = None
+
+            time.sleep(2)
+
+    except KeyboardInterrupt:
+        if is_recording:
+            stop_daemon(DEFAULT_PID_FILE)
+
+
+@cli.command()
+@require_setup
+def watch():
+    """Watch for meetings interactively (foreground with prompts).
+
+    Like 'meeting-noter' but runs in foreground and prompts before recording.
+    Press Ctrl+C to exit.
+    """
+    import time
+    import sys
+    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
+
+    config = get_config()
+    output_dir = config.recordings_dir
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    mic_monitor = MicrophoneMonitor()
+    current_meeting_name = None
+
+    click.echo("👀 Watching for meetings... (Ctrl+C to exit)")
+    click.echo()
+
+    try:
+        while True:
+            mic_started, mic_stopped, app_name = mic_monitor.check()
+
+            is_recording = read_pid_file(DEFAULT_PID_FILE) is not None and \
+                           is_process_running(read_pid_file(DEFAULT_PID_FILE))
+
+            if mic_started and not is_recording:
+                app_name = app_name or is_meeting_app_active() or "Unknown"
+                meeting_name = get_meeting_window_title() or generate_meeting_name()
+
+                click.echo(f"🎤 Meeting detected: {app_name}")
+                click.echo(f"   Name: {meeting_name}")
+
+                if click.confirm("   Start recording?", default=True):
+                    current_meeting_name = meeting_name
+                    click.echo(f"🔴 Recording: {meeting_name}")
+
+                    import subprocess
+                    subprocess.Popen(
+                        [sys.executable, "-m", "meeting_noter.cli", "daemon", "--name", meeting_name],
+                        stdout=subprocess.DEVNULL,
+                        stderr=subprocess.DEVNULL,
+                    )
+                    mic_monitor.set_recording(True, app_name)
+                else:
+                    click.echo("   Skipped.")
+                    mic_monitor._was_mic_in_use = True
+
+                click.echo()
+
+            elif mic_stopped and is_recording:
+                click.echo(f"📴 Meeting ended: {current_meeting_name or 'Unknown'}")
+                stop_daemon(DEFAULT_PID_FILE)
+                mic_monitor.set_recording(False)
+                current_meeting_name = None
+
+                if config.auto_transcribe:
+                    click.echo("📝 Auto-transcribing...")
+                    time.sleep(2)
+                    mp3_files = sorted(output_dir.glob("*.mp3"), key=lambda p: p.stat().st_mtime)
+                    if mp3_files:
+                        latest = mp3_files[-1]
+                        click.echo(f"   Transcribing: {latest.name}")
+                        import subprocess
+                        subprocess.Popen(
+                            [sys.executable, "-m", "meeting_noter.cli", "transcribe", str(latest)],
+                            stdout=subprocess.DEVNULL,
+                            stderr=subprocess.DEVNULL,
+                        )
+
+                click.echo()
+                click.echo("👀 Watching for meetings... (Ctrl+C to exit)")
+                click.echo()
+
+            time.sleep(2)
+
+    except KeyboardInterrupt:
+        click.echo()
+        if is_recording:
+            click.echo("Stopping recording...")
+            stop_daemon(DEFAULT_PID_FILE)
+        click.echo("Stopped watching.")
+
+
+@cli.command("open")
+@click.argument("what", type=click.Choice(["recordings", "transcripts", "config"]), default="recordings")
+def open_folder(what: str):
+    """Open recordings, transcripts, or config folder in Finder.
+
+    \b
+    Examples:
+        meeting-noter open              # Open recordings folder
+        meeting-noter open recordings   # Open recordings folder
+        meeting-noter open transcripts  # Open transcripts folder
+        meeting-noter open config       # Open config folder
+    """
+    import subprocess
+
+    config = get_config()
+
+    paths = {
+        "recordings": config.recordings_dir,
+        "transcripts": config.transcripts_dir,
+        "config": config.config_path.parent,
+    }
+
+    path = paths[what]
+    path.mkdir(parents=True, exist_ok=True)
+
+    subprocess.run(["open", str(path)])
+    click.echo(f"Opened: {path}")
+
+
+@cli.command()
+@click.option("--shell", type=click.Choice(["zsh", "bash", "fish"]), default="zsh")
+def completion(shell: str):
+    """Install shell tab completion.
+
+    \b
+    For zsh (default on macOS):
+        eval "$(_MEETING_NOTER_COMPLETE=zsh_source meeting-noter)"
+
+    Add to your ~/.zshrc for permanent completion.
+    """
+    import os
+
+    shell_configs = {
+        "zsh": ("~/.zshrc", '_MEETING_NOTER_COMPLETE=zsh_source meeting-noter'),
+        "bash": ("~/.bashrc", '_MEETING_NOTER_COMPLETE=bash_source meeting-noter'),
+        "fish": ("~/.config/fish/completions/meeting-noter.fish", '_MEETING_NOTER_COMPLETE=fish_source meeting-noter'),
+    }
+
+    config_file, env_cmd = shell_configs[shell]
+    config_path = Path(config_file).expanduser()
+
+    completion_line = f'eval "$({env_cmd})"'
+
+    # Check if already installed
+    if config_path.exists():
+        content = config_path.read_text()
+        if "MEETING_NOTER_COMPLETE" in content:
+            click.echo(f"Completion already installed in {config_file}")
+            return
+
+    # Install
+    click.echo(f"Installing {shell} completion...")
+
+    if shell == "fish":
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        import subprocess
+        result = subprocess.run(
+            ["sh", "-c", f"{env_cmd}"],
+            capture_output=True, text=True
+        )
+        config_path.write_text(result.stdout)
+    else:
+        with open(config_path, "a") as f:
+            f.write(f"\n# Meeting Noter tab completion\n{completion_line}\n")
+
+    click.echo(f"Added to {config_file}")
+    click.echo(f"Run: source {config_file}")
+    click.echo("Or restart your terminal.")
+
+
+if __name__ == "__main__":
+    cli()