voice-mode 2.32.0__py3-none-any.whl → 2.33.2__py3-none-any.whl

voice_mode/utils/services/coreml_setup.py

@@ -0,0 +1,234 @@
+"""Setup and manage CoreML Python environment for whisper.cpp."""
+
+import os
+import subprocess
+import logging
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+logger = logging.getLogger("voice-mode")
+
+
+def setup_coreml_venv(whisper_dir: Path, force: bool = False) -> Dict[str, Any]:
+    """
+    Setup a dedicated Python virtual environment for CoreML conversion.
+    
+    Uses whisper.cpp's requirements-coreml.txt to ensure compatibility.
+    
+    Args:
+        whisper_dir: Path to whisper.cpp installation
+        force: Force recreation of venv even if it exists
+        
+    Returns:
+        Dict with 'success' and 'python_path' or 'error'
+    """
+    venv_dir = whisper_dir / "venv-coreml"
+    venv_python = venv_dir / "bin" / "python"
+    requirements_file = whisper_dir / "models" / "requirements-coreml.txt"
+    
+    # Check if requirements file exists
+    if not requirements_file.exists():
+        return {
+            "success": False,
+            "error": f"CoreML requirements file not found at {requirements_file}"
+        }
+    
+    # Check if venv already exists and is valid
+    if venv_python.exists() and not force:
+        # Test if the venv has the required packages
+        try:
+            result = subprocess.run(
+                [str(venv_python), "-c", "import torch, coremltools, whisper, ane_transformers"],
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            if result.returncode == 0:
+                logger.info(f"CoreML venv already exists and is valid at {venv_dir}")
+                return {
+                    "success": True,
+                    "python_path": str(venv_python),
+                    "message": "Using existing CoreML virtual environment"
+                }
+        except (subprocess.TimeoutExpired, subprocess.CalledProcessError):
+            logger.info("Existing CoreML venv is incomplete, will recreate")
+    
+    # Create or recreate venv
+    logger.info(f"Creating CoreML virtual environment at {venv_dir}")
+    
+    try:
+        # Remove existing venv if force or invalid
+        if venv_dir.exists() and (force or not venv_python.exists()):
+            import shutil
+            shutil.rmtree(venv_dir, ignore_errors=True)
+        
+        # Try to use Python 3.11 as recommended by whisper.cpp
+        python_cmd = None
+        for python_version in ["python3.11", "python3.10", "python3.9", "python3"]:
+            if subprocess.run(["which", python_version], capture_output=True).returncode == 0:
+                # Check actual version
+                version_result = subprocess.run(
+                    [python_version, "--version"],
+                    capture_output=True,
+                    text=True
+                )
+                if version_result.returncode == 0:
+                    version = version_result.stdout.strip()
+                    logger.info(f"Found {version}")
+                    # Strongly prefer 3.11 as recommended
+                    if "3.11" in version:
+                        python_cmd = python_version
+                        logger.info("Using Python 3.11 (recommended for CoreML)")
+                        break
+                    elif "3.10" in version or "3.9" in version:
+                        if python_cmd is None:  # Use as fallback if no 3.11
+                            python_cmd = python_version
+                    elif python_cmd is None:
+                        python_cmd = python_version  # Use as last resort
+        
+        if python_cmd is None:
+            return {
+                "success": False,
+                "error": "No suitable Python version found. Python 3.9-3.11 recommended for CoreML."
+            }
+        
+        # Create venv
+        logger.info(f"Creating venv with {python_cmd}")
+        result = subprocess.run(
+            [python_cmd, "-m", "venv", str(venv_dir)],
+            capture_output=True,
+            text=True
+        )
+        
+        if result.returncode != 0:
+            return {
+                "success": False,
+                "error": f"Failed to create venv: {result.stderr}"
+            }
+        
+        # Upgrade pip
+        logger.info("Upgrading pip in CoreML venv")
+        subprocess.run(
+            [str(venv_python), "-m", "pip", "install", "--upgrade", "pip"],
+            capture_output=True,
+            text=True
+        )
+        
+        # Install requirements with proper versions
+        # Based on whisper.cpp documentation and coremltools compatibility
+        # Python 3.11 is recommended, torch 2.5.0 is known to work with coremltools
+        logger.info("Installing CoreML requirements with compatible versions")
+        packages = [
+            "torch==2.5.0",  # Specific version mentioned in whisper.cpp for coremltools compatibility
+            "coremltools>=7.0",
+            "openai-whisper",
+            "ane_transformers"
+        ]
+        
+        # Try installing all at once first
+        result = subprocess.run(
+            [str(venv_python), "-m", "pip", "install"] + packages,
+            capture_output=True,
+            text=True
+        )
+        
+        if result.returncode != 0:
+            # Try installing packages one by one if bulk install fails
+            logger.warning("Bulk install failed, trying packages individually")
+            
+            failed_packages = []
+            for package in packages:
+                logger.info(f"Installing {package}")
+                result = subprocess.run(
+                    [str(venv_python), "-m", "pip", "install", package],
+                    capture_output=True,
+                    text=True
+                )
+                if result.returncode != 0:
+                    logger.warning(f"Failed to install {package}: {result.stderr}")
+                    failed_packages.append(package)
+            
+            if failed_packages:
+                return {
+                    "success": False,
+                    "error": f"Failed to install packages: {', '.join(failed_packages)}",
+                    "partial": True,
+                    "python_path": str(venv_python)
+                }
+        
+        # Verify installation
+        logger.info("Verifying CoreML dependencies")
+        result = subprocess.run(
+            [str(venv_python), "-c", "import torch, coremltools, whisper, ane_transformers; print('All packages imported successfully')"],
+            capture_output=True,
+            text=True
+        )
+        
+        if result.returncode == 0:
+            logger.info("CoreML virtual environment created successfully")
+            return {
+                "success": True,
+                "python_path": str(venv_python),
+                "message": "CoreML virtual environment created with all dependencies"
+            }
+        else:
+            return {
+                "success": True,  # Partial success
+                "python_path": str(venv_python),
+                "warning": "Some packages may be missing but environment was created",
+                "verification_error": result.stderr
+            }
+            
+    except Exception as e:
+        logger.error(f"Error setting up CoreML venv: {e}")
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+
+def get_coreml_python(whisper_dir: Path) -> Optional[str]:
+    """
+    Get the path to Python executable with CoreML dependencies.
+    
+    Checks in order:
+    1. Dedicated venv-coreml environment
+    2. Existing venv environment (if it has CoreML packages)
+    3. None if no suitable environment found
+    
+    Args:
+        whisper_dir: Path to whisper.cpp installation
+        
+    Returns:
+        Path to Python executable or None
+    """
+    # Check dedicated CoreML venv first
+    venv_coreml_python = whisper_dir / "venv-coreml" / "bin" / "python"
+    if venv_coreml_python.exists():
+        # Quick check if it has required packages
+        try:
+            result = subprocess.run(
+                [str(venv_coreml_python), "-c", "import torch, coremltools"],
+                capture_output=True,
+                timeout=5
+            )
+            if result.returncode == 0:
+                return str(venv_coreml_python)
+        except:
+            pass
+    
+    # Check existing venv as fallback
+    venv_python = whisper_dir / "venv" / "bin" / "python"
+    if venv_python.exists():
+        try:
+            result = subprocess.run(
+                [str(venv_python), "-c", "import torch, coremltools, whisper"],
+                capture_output=True,
+                timeout=5
+            )
+            if result.returncode == 0:
+                return str(venv_python)
+        except:
+            pass
+    
+    return None

voice_mode/utils/services/whisper_helpers.py

@@ -9,6 +9,8 @@ import shutil
 from pathlib import Path
 from typing import Optional, List, Dict, Union
 
+from .coreml_setup import setup_coreml_venv, get_coreml_python
+
 logger = logging.getLogger("voice-mode")
 
 def find_whisper_server() -> Optional[str]:
@@ -36,14 +38,23 @@ def find_whisper_server() -> Optional[str]:
 
 
 def find_whisper_model() -> Optional[str]:
-    """Find a whisper model file."""
-    from voice_mode.config import WHISPER_MODEL_PATH
+    """Find the active whisper model file based on VOICEMODE_WHISPER_MODEL setting."""
+    from voice_mode.config import WHISPER_MODEL_PATH, WHISPER_MODEL
+    
+    # First try to find the specific model configured in VOICEMODE_WHISPER_MODEL
+    model_name = WHISPER_MODEL  # This reads from env/config
+    model_filename = f"ggml-{model_name}.bin"
     
     # Check configured model path
     model_dir = Path(WHISPER_MODEL_PATH)
     if model_dir.exists():
-        # Look for ggml model files
+        specific_model = model_dir / model_filename
+        if specific_model.exists():
+            return str(specific_model)
+        
+        # Fall back to any model if configured model not found
         for model_file in model_dir.glob("ggml-*.bin"):
+            logger.warning(f"Configured model {model_name} not found, using {model_file.name}")
             return str(model_file)
     
     # Check default installation paths
@@ -54,7 +65,13 @@ def find_whisper_model() -> Optional[str]:
     
     for default_path in default_paths:
         if default_path.exists():
+            specific_model = default_path / model_filename
+            if specific_model.exists():
+                return str(specific_model)
+            
+            # Fall back to any model
             for model_file in default_path.glob("ggml-*.bin"):
+                logger.warning(f"Configured model {model_name} not found, using {model_file.name}")
                 return str(model_file)
     
     return None
@@ -63,7 +80,8 @@ def find_whisper_model() -> Optional[str]:
 async def download_whisper_model(
     model: str,
     models_dir: Union[str, Path],
-    force_download: bool = False
+    force_download: bool = False,
+    skip_core_ml: bool = False
 ) -> Dict[str, Union[bool, str]]:
     """
     Download a single Whisper model.
@@ -72,6 +90,7 @@ async def download_whisper_model(
         model: Model name (e.g., 'large-v2', 'base.en')
         models_dir: Directory to download models to
         force_download: Re-download even if model exists
+        skip_core_ml: Skip Core ML conversion even on Apple Silicon
         
     Returns:
         Dict with 'success' and optional 'error' or 'path'
@@ -144,8 +163,11 @@ async def download_whisper_model(
                 "error": f"Model file not found after download: {model_path}"
             }
         
-        # Check for Core ML support on Apple Silicon
-        if platform.system() == "Darwin" and platform.machine() == "arm64":
+        # Initialize core_ml_result
+        core_ml_result = None
+        
+        # Check for Core ML support on Apple Silicon (unless explicitly skipped)
+        if platform.system() == "Darwin" and platform.machine() == "arm64" and not skip_core_ml:
             # Check if Core ML dependencies are needed
             requirements_file = Path(models_dir) / "requirements-coreml.txt"
             if requirements_file.exists() and shutil.which("uv"):
@@ -185,15 +207,22 @@ async def download_whisper_model(
                 else:
                     logger.warning(f"Core ML conversion failed ({error_category}): {core_ml_result.get('error', 'Unknown error')}")
         
-        # Always include Core ML status in response
-        return {
+        # Build response with appropriate status
+        response = {
             "success": True,
             "path": str(model_path),
-            "message": f"Model {model} downloaded successfully",
-            "core_ml_status": core_ml_result,
-            "acceleration": "coreml" if core_ml_result.get("success") else "metal"
+            "message": f"Model {model} downloaded successfully"
         }
         
+        # Add Core ML status if attempted
+        if core_ml_result:
+            response["core_ml_status"] = core_ml_result
+            response["acceleration"] = "coreml" if core_ml_result.get("success") else "metal"
+        else:
+            response["acceleration"] = "metal"
+        
+        return response
+        
     except subprocess.CalledProcessError as e:
         logger.error(f"Failed to download model {model}: {e.stderr}")
         return {
@@ -255,28 +284,24 @@ async def convert_to_coreml(
     logger.info(f"Converting {model} to Core ML format...")
     
     try:
-        # Check if we should use uv for Python dependencies
-        # Try to find the voicemode project root for uv
-        voicemode_root = None
-        current = Path(__file__).parent
-        while current != current.parent:
-            if (current / "pyproject.toml").exists():
-                with open(current / "pyproject.toml") as f:
-                    content = f.read()
-                    if 'name = "voice-mode"' in content or 'name = "voicemode"' in content:
-                        voicemode_root = current
-                        break
-            current = current.parent
+        # First, try to get existing CoreML Python environment
+        coreml_python = get_coreml_python(whisper_dir)
+        
+        # If no suitable environment exists, set one up
+        if not coreml_python:
+            logger.info("Setting up CoreML Python environment...")
+            setup_result = setup_coreml_venv(whisper_dir)
+            if setup_result["success"]:
+                coreml_python = setup_result.get("python_path")
+            else:
+                logger.warning(f"Could not setup CoreML environment: {setup_result.get('error')}")
         
-        # If we found voicemode root and uv is available, use it
-        if voicemode_root and shutil.which("uv"):
-            # Run the Python script directly with uv instead of using the bash wrapper
-            logger.info("Using uv for Core ML conversion with Python dependencies")
-            # Run from the whisper models directory
+        if coreml_python:
+            # Use the CoreML-enabled Python environment
+            logger.info(f"Using CoreML Python environment: {coreml_python}")
             script_path = whisper_dir / "models" / "convert-whisper-to-coreml.py"
             result = subprocess.run(
-                ["uv", "run", "--project", str(voicemode_root), "python", 
-                 str(script_path),
+                [coreml_python, str(script_path),
                  "--model", model, "--encoder-only", "True", "--optimize-ane", "True"],
                 cwd=str(whisper_dir / "models"),
                 capture_output=True,
@@ -301,8 +326,8 @@ async def convert_to_coreml(
                     shutil.rmtree(coreml_path, ignore_errors=True)
                     shutil.move(str(compiled_path), str(coreml_path))
         else:
-            # Fallback to original bash script
-            logger.info("Using standard Python for Core ML conversion")
+            # No suitable Python environment available
+            logger.warning("No suitable Python environment for CoreML conversion")
             # Run from the whisper models directory where the script is located
             script_dir = convert_script.parent
             result = subprocess.run(

{voice_mode-2.32.0.dist-info → voice_mode-2.33.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voice-mode
-Version: 2.32.0
+Version: 2.33.2
 Summary: VoiceMode - Voice interaction capabilities for AI assistants (formerly voice-mcp)
 Project-URL: Homepage, https://github.com/mbailey/voicemode
 Project-URL: Repository, https://github.com/mbailey/voicemode
@@ -116,7 +116,15 @@ Natural voice conversations for AI assistants. Voice Mode brings human-like voic
 Install Claude Code with Voice Mode configured and ready to run on Linux, macOS, and Windows WSL:
 
 ```bash
+# Download and run the installer
 curl -O https://getvoicemode.com/install.sh && bash install.sh
+
+# While local voice services can be installed automatically, we recommend
+# providing an OpenAI API key as a fallback in case local services are unavailable
+export OPENAI_API_KEY=your-openai-key  # Optional but recommended
+
+# Start a voice conversation
+claude /voicemode:converse
 ```
 
 This installer will:
@@ -124,16 +132,7 @@ This installer will:
 - Install Claude Code if not already installed
 - Configure Voice Mode as an MCP server
 - Set up your system for voice conversations
-
-After installation, just run:
-```bash
-# With OpenAI API (cloud-based, requires API key)
-export OPENAI_API_KEY=your-openai-key
-claude converse
-
-# Or use free local services (Voice Mode will offer to install them)
-claude converse
-```
+- Offer to install free local STT/TTS services if no API key is provided
 
 ### Manual Installation
 
@@ -693,7 +692,7 @@ To save all audio files (both TTS output and STT input):
 export VOICEMODE_SAVE_AUDIO=true
 ```
 
-Audio files are saved to: `~/voicemode_audio/` with timestamps in the filename.
+Audio files are saved to: `~/.voicemode/audio/YYYY/MM/` with timestamps in the filename.
 
 ## Documentation