voice-mode 2.25.1__py3-none-any.whl → 2.27.0__py3-none-any.whl

voice_mode/cli.py

@@ -7,6 +7,7 @@ import os
 import warnings
 import click
 
+
 # Suppress known deprecation warnings for better user experience
 # These apply to both CLI commands and MCP server operation
 # They can be shown with VOICEMODE_DEBUG=true or --debug flag
@@ -420,12 +421,183 @@ def uninstall(remove_models, remove_all_data):
             click.echo(f"   Details: {result['details']}")
 
 
-@whisper.command("download-model")
+@whisper.group("model")
+def whisper_model():
+    """Manage Whisper models.
+    
+    Subcommands:
+      active   - Show or set the active model
+      install  - Download and install models
+      remove   - Remove installed models
+    """
+    pass
+
+
+@whisper_model.command("active")
+@click.argument('model_name', required=False)
+def whisper_model_active(model_name):
+    """Show or set the active Whisper model.
+    
+    Without arguments: Shows the current active model
+    With MODEL_NAME: Sets the active model (updates VOICEMODE_WHISPER_MODEL)
+    """
+    from voice_mode.tools.services.whisper.models import (
+        get_current_model,
+        WHISPER_MODELS,
+        is_model_installed,
+        set_current_model
+    )
+    import os
+    import subprocess
+    
+    if model_name:
+        # Set model mode
+        if model_name not in WHISPER_MODELS:
+            click.echo(f"Error: '{model_name}' is not a valid model.", err=True)
+            click.echo("\nAvailable models:", err=True)
+            for name in WHISPER_MODELS.keys():
+                click.echo(f"  - {name}", err=True)
+            return
+        
+        # Check if model is installed
+        if not is_model_installed(model_name):
+            click.echo(f"Error: Model '{model_name}' is not installed.", err=True)
+            click.echo(f"Install it with: voice-mode whisper model install {model_name}", err=True)
+            raise click.Abort()
+        
+        # Get previous model
+        previous_model = get_current_model()
+        
+        # Update the configuration file
+        set_current_model(model_name)
+        
+        click.echo(f"✓ Active model set to: {model_name}")
+        if previous_model != model_name:
+            click.echo(f"  (was: {previous_model})")
+        
+        # Check if whisper service is running
+        try:
+            result = subprocess.run(['pgrep', '-f', 'whisper-server'], capture_output=True)
+            if result.returncode == 0:
+                # Service is running
+                click.echo(f"\n⚠️  Please restart the whisper service for changes to take effect:")
+                click.echo(f"  {click.style('voice-mode whisper restart', fg='yellow', bold=True)}")
+            else:
+                click.echo(f"\nWhisper service is not running. Start it with:")
+                click.echo(f"  voice-mode whisper start")
+                click.echo(f"(or restart the whisper service if it's managed by systemd/launchd)")
+        except:
+            click.echo(f"\nPlease restart the whisper service for changes to take effect:")
+            click.echo(f"  voice-mode whisper restart")
+    
+    else:
+        # Show current model
+        current = get_current_model()
+        
+        # Check if current model is installed
+        installed = is_model_installed(current)
+        status = click.style("[✓ Installed]", fg="green") if installed else click.style("[Not installed]", fg="red")
+        
+        # Get model info
+        model_info = WHISPER_MODELS.get(current, {})
+        
+        click.echo(f"\nActive Whisper model: {click.style(current, fg='yellow', bold=True)} {status}")
+        if model_info:
+            click.echo(f"  Size: {model_info.get('size_mb', 'Unknown')} MB")
+            click.echo(f"  Languages: {model_info.get('languages', 'Unknown')}")
+            click.echo(f"  Description: {model_info.get('description', 'Unknown')}")
+        
+        # Check what model the service is actually using
+        try:
+            result = subprocess.run(['pgrep', '-f', 'whisper-server'], capture_output=True)
+            if result.returncode == 0:
+                # Service is running, could check its actual model here
+                click.echo(f"\nWhisper service status: {click.style('Running', fg='green')}")
+        except:
+            pass
+        
+        click.echo(f"\nTo change: voice-mode whisper model active <model-name>")
+        click.echo(f"To list all models: voice-mode whisper models")
+
+
+@whisper.command("models")
+def whisper_models():
+    """List available Whisper models and their installation status."""
+    from voice_mode.tools.services.whisper.models import (
+        WHISPER_MODELS, 
+        get_model_directory,
+        get_current_model,
+        is_model_installed,
+        get_installed_models,
+        format_size
+    )
+    
+    model_dir = get_model_directory()
+    current_model = get_current_model()
+    installed_models = get_installed_models()
+    
+    # Calculate totals
+    total_installed_size = sum(
+        WHISPER_MODELS[m]["size_mb"] for m in installed_models
+    )
+    total_available_size = sum(
+        m["size_mb"] for m in WHISPER_MODELS.values()
+    )
+    
+    # Print header
+    click.echo("\nWhisper Models:")
+    click.echo("")
+    
+    # Print models table
+    for model_name, info in WHISPER_MODELS.items():
+        # Check status
+        is_installed = is_model_installed(model_name)
+        is_current = model_name == current_model
+        
+        # Format status
+        if is_current:
+            status = click.style("→", fg="yellow", bold=True)
+            model_display = click.style(f"{model_name:15}", fg="yellow", bold=True)
+        else:
+            status = " "
+            model_display = f"{model_name:15}"
+        
+        # Format installation status
+        if is_installed:
+            install_status = click.style("[✓ Installed]", fg="green")
+        else:
+            install_status = click.style("[ Download ]", fg="bright_black")
+        
+        # Format size
+        size_str = format_size(info["size_mb"]).rjust(8)
+        
+        # Format languages
+        lang_str = f"{info['languages']:20}"
+        
+        # Format description
+        desc = info['description']
+        if is_current:
+            desc += " (Currently selected)"
+            desc = click.style(desc, fg="yellow")
+        
+        # Print row
+        click.echo(f"{status} {model_display} {install_status:14} {size_str}  {lang_str} {desc}")
+    
+    # Print footer
+    click.echo("")
+    click.echo(f"Models directory: {model_dir}")
+    click.echo(f"Total size: {format_size(total_installed_size)} installed / {format_size(total_available_size)} available")
+    click.echo("")
+    click.echo("To download a model: voice-mode whisper model install <model-name>")
+    click.echo("To set default model: voice-mode whisper model <model-name>")
+
+
+@whisper_model.command("install")
 @click.argument('model', default='large-v2')
 @click.option('--force', '-f', is_flag=True, help='Re-download even if model exists')
 @click.option('--skip-core-ml', is_flag=True, help='Skip Core ML conversion on Apple Silicon')
-def download_model_cmd(model, force, skip_core_ml):
-    """Download Whisper model(s) with optional Core ML conversion.
+def whisper_model_install(model, force, skip_core_ml):
+    """Install Whisper model(s) with optional Core ML conversion.
     
     MODEL can be a model name (e.g., 'large-v2'), 'all' to download all models,
     or omitted to use the default (large-v2).
@@ -472,6 +644,74 @@ def download_model_cmd(model, force, skip_core_ml):
         click.echo(result)
 
 
+@whisper_model.command("remove")
+@click.argument('model')
+@click.option('--force', '-f', is_flag=True, help='Remove without confirmation')
+def whisper_model_remove(model, force):
+    """Remove an installed Whisper model.
+    
+    MODEL is the name of the model to remove (e.g., 'large-v2').
+    """
+    from voice_mode.tools.services.whisper.models import (
+        WHISPER_MODELS,
+        is_model_installed,
+        get_model_directory,
+        get_current_model
+    )
+    import os
+    
+    # Validate model name
+    if model not in WHISPER_MODELS:
+        click.echo(f"Error: '{model}' is not a valid model.", err=True)
+        click.echo("\nAvailable models:", err=True)
+        for name in WHISPER_MODELS.keys():
+            click.echo(f"  - {name}", err=True)
+        ctx.exit(1)
+    
+    # Check if model is installed
+    if not is_model_installed(model):
+        click.echo(f"Model '{model}' is not installed.")
+        return
+    
+    # Check if it's the current model
+    current = get_current_model()
+    if model == current:
+        click.echo(f"Warning: '{model}' is the currently selected model.", err=True)
+        if not force:
+            if not click.confirm("Do you still want to remove it?"):
+                return
+    
+    # Get model path
+    model_dir = get_model_directory()
+    model_info = WHISPER_MODELS[model]
+    model_path = model_dir / model_info["filename"]
+    
+    # Also check for Core ML models
+    coreml_path = model_dir / f"ggml-{model}-encoder.mlmodelc"
+    
+    # Confirm removal if not forced
+    if not force:
+        size_mb = model_info["size_mb"]
+        if not click.confirm(f"Remove {model} ({size_mb} MB)?"):
+            return
+    
+    # Remove the model file
+    try:
+        if model_path.exists():
+            os.remove(model_path)
+            click.echo(f"✓ Removed model: {model}")
+        
+        # Remove Core ML model if exists
+        if coreml_path.exists():
+            import shutil
+            shutil.rmtree(coreml_path)
+            click.echo(f"✓ Removed Core ML model: {model}")
+        
+        click.echo(f"\nModel '{model}' has been removed.")
+    except Exception as e:
+        click.echo(f"Error removing model: {e}", err=True)
+
+
 # LiveKit service commands
 @livekit.command()
 def status():
@@ -897,6 +1137,150 @@ def config_set(key, value):
     click.echo(result)
 
 
+# Shell completion group
+@voice_mode_main_cli.group()
+def completion():
+    """Generate shell completion scripts for voice-mode."""
+    pass
+
+
+@completion.command("bash")
+def completion_bash():
+    """Generate bash completion script.
+    
+    Add this to your ~/.bashrc:
+    
+        eval "$(_VOICE_MODE_COMPLETE=bash_source voice-mode)"
+    
+    Or for better performance, generate the script once:
+    
+        _VOICE_MODE_COMPLETE=bash_source voice-mode > ~/.voice-mode-complete.bash
+        echo '. ~/.voice-mode-complete.bash' >> ~/.bashrc
+    """
+    # Output the instructions directly since the environment variable method
+    # needs to be run from the shell itself
+    click.echo("# Bash completion for voice-mode")
+    click.echo("# Add this to your ~/.bashrc:")
+    click.echo("")
+    click.echo('eval "$(_VOICE_MODE_COMPLETE=bash_source voice-mode)"')
+    click.echo("")
+    click.echo("# Or for better performance, generate and save the script:")
+    click.echo("# _VOICE_MODE_COMPLETE=bash_source voice-mode > ~/.voice-mode-complete.bash")
+    click.echo("# Then add to ~/.bashrc:")
+    click.echo("# . ~/.voice-mode-complete.bash")
+
+
+@completion.command("zsh")
+def completion_zsh():
+    """Generate zsh completion script.
+    
+    Add this to your ~/.zshrc:
+    
+        eval "$(_VOICE_MODE_COMPLETE=zsh_source voice-mode)"
+    
+    Or for better performance, generate the script once:
+    
+        _VOICE_MODE_COMPLETE=zsh_source voice-mode > ~/.voice-mode-complete.zsh
+        echo '. ~/.voice-mode-complete.zsh' >> ~/.zshrc
+    """
+    # Output the instructions directly
+    click.echo("# Zsh completion for voice-mode")
+    click.echo("# Add this to your ~/.zshrc:")
+    click.echo("")
+    click.echo('eval "$(_VOICE_MODE_COMPLETE=zsh_source voice-mode)"')
+    click.echo("")
+    click.echo("# Or for better performance, generate and save the script:")
+    click.echo("# _VOICE_MODE_COMPLETE=zsh_source voice-mode > ~/.voice-mode-complete.zsh")
+    click.echo("# Then add to ~/.zshrc:")
+    click.echo("# . ~/.voice-mode-complete.zsh")
+
+
+@completion.command("fish")
+def completion_fish():
+    """Generate fish completion script.
+    
+    Add this to ~/.config/fish/completions/voice-mode.fish:
+    
+        _VOICE_MODE_COMPLETE=fish_source voice-mode | source
+    
+    Or save it to a file:
+    
+        _VOICE_MODE_COMPLETE=fish_source voice-mode > ~/.config/fish/completions/voice-mode.fish
+    """
+    # Output the instructions directly
+    click.echo("# Fish completion for voice-mode")
+    click.echo("# Save this to ~/.config/fish/completions/voice-mode.fish:")
+    click.echo("")
+    click.echo("_VOICE_MODE_COMPLETE=fish_source voice-mode | source")
+    click.echo("")
+    click.echo("# Or run this command to save it:")
+    click.echo("# _VOICE_MODE_COMPLETE=fish_source voice-mode > ~/.config/fish/completions/voice-mode.fish")
+
+
+@completion.command("install")
+@click.option('--shell', type=click.Choice(['bash', 'zsh', 'fish', 'auto']), default='auto', help='Shell type to install for')
+def completion_install(shell):
+    """Show installation instructions for shell completion.
+    
+    This command displays the steps to enable tab completion
+    for voice-mode in your shell.
+    """
+    # Detect shell if auto
+    if shell == 'auto':
+        shell_env = os.environ.get('SHELL', '')
+        if 'bash' in shell_env:
+            shell = 'bash'
+        elif 'zsh' in shell_env:
+            shell = 'zsh'
+        elif 'fish' in shell_env:
+            shell = 'fish'
+        else:
+            click.echo("Could not detect shell type. Showing instructions for all shells.")
+            click.echo("")
+            
+            # Show all instructions
+            click.echo("=== Bash ===")
+            click.echo("Add to ~/.bashrc:")
+            click.echo('  eval "$(_VOICE_MODE_COMPLETE=bash_source voice-mode)"')
+            click.echo("")
+            
+            click.echo("=== Zsh ===")
+            click.echo("Add to ~/.zshrc:")
+            click.echo('  eval "$(_VOICE_MODE_COMPLETE=zsh_source voice-mode)"')
+            click.echo("")
+            
+            click.echo("=== Fish ===")
+            click.echo("Run this command:")
+            click.echo('  _VOICE_MODE_COMPLETE=fish_source voice-mode > ~/.config/fish/completions/voice-mode.fish')
+            return
+    
+    click.echo(f"To enable tab completion for voice-mode in {shell}:")
+    click.echo("")
+    
+    if shell == 'bash':
+        click.echo("Add this line to your ~/.bashrc:")
+        click.echo('  eval "$(_VOICE_MODE_COMPLETE=bash_source voice-mode)"')
+        click.echo("")
+        click.echo("Or for better performance, generate the script once:")
+        click.echo("  _VOICE_MODE_COMPLETE=bash_source voice-mode > ~/.voice-mode-complete.bash")
+        click.echo("  echo '. ~/.voice-mode-complete.bash' >> ~/.bashrc")
+    elif shell == 'zsh':
+        click.echo("Add this line to your ~/.zshrc:")
+        click.echo('  eval "$(_VOICE_MODE_COMPLETE=zsh_source voice-mode)"')
+        click.echo("")
+        click.echo("Or for better performance, generate the script once:")
+        click.echo("  _VOICE_MODE_COMPLETE=zsh_source voice-mode > ~/.voice-mode-complete.zsh")
+        click.echo("  echo '. ~/.voice-mode-complete.zsh' >> ~/.zshrc")
+    elif shell == 'fish':
+        click.echo("Run this command:")
+        click.echo('  _VOICE_MODE_COMPLETE=fish_source voice-mode > ~/.config/fish/completions/voice-mode.fish')
+        click.echo("")
+        click.echo("Fish will automatically load the completion from this location.")
+    
+    click.echo("")
+    click.echo("After making these changes, restart your shell or source the config file.")
+
+
 # Diagnostics group
 @voice_mode_main_cli.group()
 def diag():
@@ -994,3 +1378,389 @@ cli.add_command(exchanges_cmd.exchanges)
 voice_mode_main_cli.add_command(exchanges_cmd.exchanges)
 
 
+# Converse command - direct voice conversation from CLI
+@voice_mode_main_cli.command()
+@click.option('--message', '-m', default="Hello! How can I help you today?", help='Initial message to speak')
+@click.option('--wait/--no-wait', default=True, help='Wait for response after speaking')
+@click.option('--duration', '-d', type=float, default=30.0, help='Listen duration in seconds')
+@click.option('--min-duration', type=float, default=2.0, help='Minimum listen duration before silence detection')
+@click.option('--transport', type=click.Choice(['auto', 'local', 'livekit']), default='auto', help='Transport method')
+@click.option('--room-name', default='', help='LiveKit room name (for livekit transport)')
+@click.option('--voice', help='TTS voice to use (e.g., nova, shimmer, af_sky)')
+@click.option('--tts-provider', type=click.Choice(['openai', 'kokoro']), help='TTS provider')
+@click.option('--tts-model', help='TTS model (e.g., tts-1, tts-1-hd)')
+@click.option('--tts-instructions', help='Tone/style instructions for gpt-4o-mini-tts')
+@click.option('--audio-feedback/--no-audio-feedback', default=None, help='Enable/disable audio feedback')
+@click.option('--audio-format', help='Audio format (pcm, mp3, wav, flac, aac, opus)')
+@click.option('--disable-silence-detection', is_flag=True, help='Disable silence detection')
+@click.option('--speed', type=float, help='Speech rate (0.25 to 4.0)')
+@click.option('--vad-aggressiveness', type=int, help='VAD aggressiveness (0-3)')
+@click.option('--skip-tts/--no-skip-tts', default=None, help='Skip TTS and only show text')
+@click.option('--continuous', '-c', is_flag=True, help='Continuous conversation mode')
+def converse(message, wait, duration, min_duration, transport, room_name, voice, tts_provider, 
+            tts_model, tts_instructions, audio_feedback, audio_format, disable_silence_detection,
+            speed, vad_aggressiveness, skip_tts, continuous):
+    """Have a voice conversation directly from the command line.
+    
+    Examples:
+    
+        # Simple conversation
+        voice-mode converse
+        
+        # Speak a message without waiting
+        voice-mode converse -m "Hello there!" --no-wait
+        
+        # Continuous conversation mode
+        voice-mode converse --continuous
+        
+        # Use specific voice
+        voice-mode converse --voice nova
+    """
+    from voice_mode.tools.converse import converse as converse_fn
+    
+    async def run_conversation():
+        """Run the conversation asynchronously."""
+        try:
+            if continuous:
+                # Continuous conversation mode
+                click.echo("🎤 Starting continuous conversation mode...")
+                click.echo("   Press Ctrl+C to exit\n")
+                
+                # First message
+                result = await converse_fn.fn(
+                    message=message,
+                    wait_for_response=True,
+                    listen_duration=duration,
+                    min_listen_duration=min_duration,
+                    transport=transport,
+                    room_name=room_name,
+                    voice=voice,
+                    tts_provider=tts_provider,
+                    tts_model=tts_model,
+                    tts_instructions=tts_instructions,
+                    audio_feedback=audio_feedback,
+                    audio_feedback_style=None,
+                    audio_format=audio_format,
+                    disable_silence_detection=disable_silence_detection,
+                    speed=speed,
+                    vad_aggressiveness=vad_aggressiveness,
+                    skip_tts=skip_tts
+                )
+                
+                if result and "Voice response:" in result:
+                    click.echo(f"You: {result.split('Voice response:')[1].split('|')[0].strip()}")
+                
+                # Continue conversation
+                while True:
+                    # Wait for user's next input
+                    result = await converse_fn.fn(
+                        message="",  # Empty message for listening only
+                        wait_for_response=True,
+                        listen_duration=duration,
+                        min_listen_duration=min_duration,
+                        transport=transport,
+                        room_name=room_name,
+                        voice=voice,
+                        tts_provider=tts_provider,
+                        tts_model=tts_model,
+                        tts_instructions=tts_instructions,
+                        audio_feedback=audio_feedback,
+                        audio_feedback_style=None,
+                        audio_format=audio_format,
+                        disable_silence_detection=disable_silence_detection,
+                        speed=speed,
+                        vad_aggressiveness=vad_aggressiveness,
+                        skip_tts=skip_tts
+                    )
+                    
+                    if result and "Voice response:" in result:
+                        user_text = result.split('Voice response:')[1].split('|')[0].strip()
+                        click.echo(f"You: {user_text}")
+                        
+                        # Check for exit commands
+                        if user_text.lower() in ['exit', 'quit', 'goodbye', 'bye']:
+                            await converse_fn.fn(
+                                message="Goodbye!",
+                                wait_for_response=False,
+                                voice=voice,
+                                tts_provider=tts_provider,
+                                tts_model=tts_model,
+                                audio_format=audio_format,
+                                speed=speed,
+                                skip_tts=skip_tts
+                            )
+                            break
+            else:
+                # Single conversation
+                result = await converse_fn.fn(
+                    message=message,
+                    wait_for_response=wait,
+                    listen_duration=duration,
+                    min_listen_duration=min_duration,
+                    transport=transport,
+                    room_name=room_name,
+                    voice=voice,
+                    tts_provider=tts_provider,
+                    tts_model=tts_model,
+                    tts_instructions=tts_instructions,
+                    audio_feedback=audio_feedback,
+                    audio_feedback_style=None,
+                    audio_format=audio_format,
+                    disable_silence_detection=disable_silence_detection,
+                    speed=speed,
+                    vad_aggressiveness=vad_aggressiveness,
+                    skip_tts=skip_tts
+                )
+                
+                # Display result
+                if result:
+                    if "Voice response:" in result:
+                        # Extract the response text and timing info
+                        parts = result.split('|')
+                        response_text = result.split('Voice response:')[1].split('|')[0].strip()
+                        timing_info = parts[1].strip() if len(parts) > 1 else ""
+                        
+                        click.echo(f"\n📢 Spoke: {message}")
+                        if wait:
+                            click.echo(f"🎤 Heard: {response_text}")
+                        if timing_info:
+                            click.echo(f"⏱️  {timing_info}")
+                    else:
+                        click.echo(result)
+                        
+        except KeyboardInterrupt:
+            click.echo("\n\n👋 Conversation ended")
+        except Exception as e:
+            click.echo(f"❌ Error: {e}", err=True)
+            import traceback
+            if os.environ.get('VOICEMODE_DEBUG'):
+                traceback.print_exc()
+    
+    # Run the async function
+    asyncio.run(run_conversation())
+
+
+# Version command
+@voice_mode_main_cli.command()
+def version():
+    """Show Voice Mode version and check for updates."""
+    import requests
+    from importlib.metadata import version as get_version, PackageNotFoundError
+    
+    try:
+        current_version = get_version("voice-mode")
+    except PackageNotFoundError:
+        # Fallback for development installations
+        current_version = "development"
+    
+    click.echo(f"Voice Mode version: {current_version}")
+    
+    # Check for updates if not in development mode
+    if current_version != "development":
+        try:
+            response = requests.get(
+                "https://pypi.org/pypi/voice-mode/json",
+                timeout=2
+            )
+            if response.status_code == 200:
+                latest_version = response.json()["info"]["version"]
+                
+                # Simple version comparison (works for semantic versioning)
+                if latest_version != current_version:
+                    click.echo(f"Latest version: {latest_version} available")
+                    click.echo("Run 'voicemode update' to update")
+                else:
+                    click.echo("You are running the latest version")
+        except (requests.RequestException, KeyError, ValueError):
+            # Fail silently if we can't check for updates
+            pass
+
+
+# Update command
+@voice_mode_main_cli.command()
+@click.option('--force', is_flag=True, help='Force reinstall even if already up to date')
+def update(force):
+    """Update Voice Mode to the latest version."""
+    import subprocess
+    import requests
+    from importlib.metadata import version as get_version, PackageNotFoundError
+    
+    try:
+        current_version = get_version("voice-mode")
+    except PackageNotFoundError:
+        current_version = "development"
+    
+    if not force and current_version != "development":
+        # Check if update is needed
+        try:
+            response = requests.get(
+                "https://pypi.org/pypi/voice-mode/json",
+                timeout=2
+            )
+            if response.status_code == 200:
+                latest_version = response.json()["info"]["version"]
+                if latest_version == current_version:
+                    click.echo(f"Already running the latest version ({current_version})")
+                    return
+        except (requests.RequestException, KeyError, ValueError):
+            # Continue with update if we can't check
+            pass
+    
+    click.echo("Updating Voice Mode to the latest version...")
+    
+    # Try UV first, fall back to pip
+    try:
+        # Check if UV is available
+        result = subprocess.run(
+            ["uv", "--version"],
+            capture_output=True,
+            text=True,
+            check=False
+        )
+        
+        if result.returncode == 0:
+            # Use UV for update
+            result = subprocess.run(
+                ["uv", "pip", "install", "--upgrade", "voice-mode"],
+                capture_output=True,
+                text=True
+            )
+            if result.returncode == 0:
+                # Get new version
+                try:
+                    new_version = get_version("voice-mode")
+                    click.echo(f"✅ Successfully updated to version {new_version}")
+                except PackageNotFoundError:
+                    click.echo("✅ Successfully updated Voice Mode")
+            else:
+                click.echo(f"❌ Update failed: {result.stderr}")
+                click.echo("Try running: uv pip install --upgrade voice-mode")
+        else:
+            # Fall back to pip
+            result = subprocess.run(
+                [sys.executable, "-m", "pip", "install", "--upgrade", "voice-mode"],
+                capture_output=True,
+                text=True
+            )
+            if result.returncode == 0:
+                try:
+                    new_version = get_version("voice-mode")
+                    click.echo(f"✅ Successfully updated to version {new_version}")
+                except PackageNotFoundError:
+                    click.echo("✅ Successfully updated Voice Mode")
+            else:
+                click.echo(f"❌ Update failed: {result.stderr}")
+                click.echo("Try running: pip install --upgrade voice-mode")
+    
+    except FileNotFoundError as e:
+        click.echo(f"❌ Update failed: {e}")
+        click.echo("Please install UV or pip and try again")
+
+
+# Completions command
+@voice_mode_main_cli.command()
+@click.argument('shell', type=click.Choice(['bash', 'zsh', 'fish']))
+@click.option('--install', is_flag=True, help='Install completion script to the appropriate location')
+def completions(shell, install):
+    """Generate or install shell completion scripts.
+    
+    Examples:
+        voicemode completions bash              # Output bash completion to stdout
+        voicemode completions bash --install    # Install to ~/.bash_completion.d/
+        voicemode completions zsh --install     # Install to ~/.zfunc/
+        voicemode completions fish --install    # Install to ~/.config/fish/completions/
+    """
+    from pathlib import Path
+    
+    # Generate completion scripts based on shell type
+    if shell == 'bash':
+        completion_script = '''# bash completion for voicemode
+_voicemode_completion() {
+    local IFS=$'\\n'
+    local response
+    
+    response=$(env _VOICEMODE_COMPLETE=bash_complete COMP_WORDS="${COMP_WORDS[*]}" COMP_CWORD=$COMP_CWORD voicemode 2>/dev/null)
+    
+    for completion in $response; do
+        IFS=',' read type value <<< "$completion"
+        
+        if [[ $type == 'plain' ]]; then
+            COMPREPLY+=("$value")
+        elif [[ $type == 'file' ]]; then
+            COMPREPLY+=("$value")
+        elif [[ $type == 'dir' ]]; then
+            COMPREPLY+=("$value")
+        fi
+    done
+    
+    return 0
+}
+
+complete -o default -F _voicemode_completion voicemode
+'''
+    
+    elif shell == 'zsh':
+        completion_script = '''#compdef voicemode
+# zsh completion for voicemode
+
+_voicemode() {
+    local -a response
+    response=(${(f)"$(env _VOICEMODE_COMPLETE=zsh_complete COMP_WORDS="${words[*]}" COMP_CWORD=$((CURRENT-1)) voicemode 2>/dev/null)"})
+    
+    for completion in $response; do
+        IFS=',' read type value <<< "$completion"
+        compadd -U -- "$value"
+    done
+}
+
+compdef _voicemode voicemode
+'''
+    
+    elif shell == 'fish':
+        completion_script = '''# fish completion for voicemode
+function __fish_voicemode_complete
+    set -l response (env _VOICEMODE_COMPLETE=fish_complete COMP_WORDS=(commandline -cp) COMP_CWORD=(commandline -t) voicemode 2>/dev/null)
+    
+    for completion in $response
+        echo $completion
+    end
+end
+
+complete -c voicemode -f -a '(__fish_voicemode_complete)'
+'''
+    
+    if install:
+        # Define installation locations for each shell
+        locations = {
+            'bash': '~/.bash_completion.d/voicemode',
+            'zsh': '~/.zfunc/_voicemode',
+            'fish': '~/.config/fish/completions/voicemode.fish'
+        }
+        
+        install_path = Path(locations[shell]).expanduser()
+        install_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Write completion script to file
+        install_path.write_text(completion_script)
+        click.echo(f"✅ Installed {shell} completions to {install_path}")
+        
+        # Provide shell-specific instructions
+        if shell == 'bash':
+            click.echo("\nTo activate now, run:")
+            click.echo(f"  source {install_path}")
+            click.echo("\nTo activate permanently, add to ~/.bashrc:")
+            click.echo(f"  source {install_path}")
+        elif shell == 'zsh':
+            click.echo("\nTo activate now, run:")
+            click.echo("  autoload -U compinit && compinit")
+            click.echo("\nMake sure ~/.zfunc is in your fpath (add to ~/.zshrc):")
+            click.echo("  fpath=(~/.zfunc $fpath)")
+        elif shell == 'fish':
+            click.echo("\nCompletions will be active in new fish sessions.")
+            click.echo("To activate now, run:")
+            click.echo(f"  source {install_path}")
+    else:
+        # Output completion script to stdout
+        click.echo(completion_script)
+
+