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

voice_mode/frontend/.next/types/app/api/connection-details/route.ts

@@ -1,4 +1,4 @@
-// File: /tmp/build-via-sdist-4wig7c1g/voice_mode-2.26.0/voice_mode/frontend/app/api/connection-details/route.ts
+// File: /tmp/build-via-sdist-qw720py5/voice_mode-2.27.0/voice_mode/frontend/app/api/connection-details/route.ts
 import * as entry from '../../../../../app/api/connection-details/route.js'
 import type { NextRequest } from 'next/server.js'
 

voice_mode/frontend/.next/types/app/layout.ts

@@ -1,4 +1,4 @@
-// File: /tmp/build-via-sdist-4wig7c1g/voice_mode-2.26.0/voice_mode/frontend/app/layout.tsx
+// File: /tmp/build-via-sdist-qw720py5/voice_mode-2.27.0/voice_mode/frontend/app/layout.tsx
 import * as entry from '../../../app/layout.js'
 import type { ResolvingMetadata, ResolvingViewport } from 'next/dist/lib/metadata/types/metadata-interface.js'
 

voice_mode/frontend/.next/types/app/page.ts

@@ -1,4 +1,4 @@
-// File: /tmp/build-via-sdist-4wig7c1g/voice_mode-2.26.0/voice_mode/frontend/app/page.tsx
+// File: /tmp/build-via-sdist-qw720py5/voice_mode-2.27.0/voice_mode/frontend/app/page.tsx
 import * as entry from '../../../app/page.js'
 import type { ResolvingMetadata, ResolvingViewport } from 'next/dist/lib/metadata/types/metadata-interface.js'
 

voice_mode/frontend/package-lock.json

@@ -1360,9 +1360,9 @@
       }
     },
     "node_modules/browserslist": {
-      "version": "4.25.2",
-      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.25.2.tgz",
-      "integrity": "sha512-0si2SJK3ooGzIawRu61ZdPCO1IncZwS8IzuX73sPZsXW6EQ/w/DAfPyKI8l1ETTCr2MnvqWitmlCUxgdul45jA==",
+      "version": "4.25.3",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.25.3.tgz",
+      "integrity": "sha512-cDGv1kkDI4/0e5yON9yM5G/0A5u8sf5TnmdX5C9qHzI9PPu++sQ9zjm1k9NiOrf3riY4OkK0zSGqfvJyJsgCBQ==",
       "dev": true,
       "funding": [
         {
@@ -1380,8 +1380,8 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "caniuse-lite": "^1.0.30001733",
-        "electron-to-chromium": "^1.5.199",
+        "caniuse-lite": "^1.0.30001735",
+        "electron-to-chromium": "^1.5.204",
         "node-releases": "^2.0.19",
         "update-browserslist-db": "^1.1.3"
       },
@@ -1774,9 +1774,9 @@
       "license": "MIT"
     },
     "node_modules/electron-to-chromium": {
-      "version": "1.5.203",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.203.tgz",
-      "integrity": "sha512-uz4i0vLhfm6dLZWbz/iH88KNDV+ivj5+2SA+utpgjKaj9Q0iDLuwk6Idhe9BTxciHudyx6IvTvijhkPvFGUQ0g==",
+      "version": "1.5.207",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.207.tgz",
+      "integrity": "sha512-mryFrrL/GXDTmAtIVMVf+eIXM09BBPlO5IQ7lUyKmK8d+A4VpRGG+M3ofoVef6qyF8s60rJei8ymlJxjUA8Faw==",
       "dev": true,
       "license": "ISC"
     },

voice_mode/resources/configuration.py

@@ -238,13 +238,17 @@ async def environment_variables() -> str:
     Shows each configuration variable with:
     - Name: The environment variable name
     - Environment Value: Current value from environment
-    - Config File Value: Value from ~/.voicemode.env (if exists)
+    - Config File Value: Value from ~/.voicemode/voicemode.env (if exists)
     - Description: What the variable controls
     
     This helps identify configuration sources and troubleshoot settings.
     """
-    # Parse config file
-    user_config_path = Path.home() / ".voicemode.env"
+    # Parse config file - try new path first, fall back to old
+    user_config_path = Path.home() / ".voicemode" / "voicemode.env"
+    if not user_config_path.exists():
+        old_path = Path.home() / ".voicemode" / ".voicemode.env"
+        if old_path.exists():
+            user_config_path = old_path
     file_config = parse_env_file(user_config_path)
     
     # Define all configuration variables with descriptions
@@ -330,7 +334,7 @@ async def environment_template() -> str:
     Environment variable template for voice mode configuration.
     
     Provides a ready-to-use template of all available environment variables
-    with their current values. This can be saved to ~/.voicemode.env and
+    with their current values. This can be saved to ~/.voicemode/voicemode.env and
     customized as needed.
     
     Sensitive values like API keys are masked for security.

voice_mode/resources/whisper_models.py

@@ -6,7 +6,7 @@ from pathlib import Path
 from typing import Dict, Any, List
 
 from ..server import mcp
-from ..config import logger
+from ..config import logger, WHISPER_MODEL_PATH, WHISPER_MODEL
 
 
 @mcp.resource("whisper://models")
@@ -24,17 +24,14 @@ async def list_whisper_models() -> str:
     and which one is currently being used by the whisper server.
     """
     try:
-        # Get whisper models directory - check both locations
-        models_dirs = [
-            Path.home() / ".voicemode/services/whisper/models",
-            Path.home() / ".voicemode/whisper.cpp/models"  # legacy
-        ]
+        # Get whisper models directory from config
+        models_dir = Path(WHISPER_MODEL_PATH)
         
-        models_dir = None
-        for dir_path in models_dirs:
-            if dir_path.exists():
-                models_dir = dir_path
-                break
+        # If config path doesn't exist, check service installation
+        if not models_dir.exists():
+            service_models = Path.home() / ".voicemode/services/whisper/models"
+            if service_models.exists():
+                models_dir = service_models
         
         # List all model files
         models: List[Dict[str, Any]] = []
@@ -55,8 +52,8 @@ async def list_whisper_models() -> str:
         # Sort models by name
         models.sort(key=lambda x: x["name"])
         
-        # Get current configuration
-        current_model = os.environ.get("VOICEMODE_WHISPER_MODEL", "large-v2")
+        # Get current configuration from config
+        current_model = WHISPER_MODEL
         
         # Build response
         data = {

voice_mode/templates/systemd/voicemode-frontend.service

@@ -7,7 +7,7 @@ Wants=network.target
 [Service]
 Type=simple
 WorkingDirectory={FRONTEND_DIR}
-EnvironmentFile=%h/.voicemode/.voicemode.env
+EnvironmentFile=%h/.voicemode/voicemode.env
 Environment=NODE_ENV=development
 Environment=PORT={PORT}
 Environment=HOST={HOST}

voice_mode/tools/configuration_management.py

@@ -11,7 +11,9 @@ import logging
 logger = logging.getLogger("voice-mode")
 
 # Configuration file path (user-level only for security)
-USER_CONFIG_PATH = Path.home() / ".voicemode" / ".voicemode.env"
+USER_CONFIG_PATH = Path.home() / ".voicemode" / "voicemode.env"
+# Legacy path for backwards compatibility
+LEGACY_CONFIG_PATH = Path.home() / ".voicemode" / ".voicemode.env"
 
 
 def parse_env_file(file_path: Path) -> Dict[str, str]:
@@ -117,8 +119,11 @@ async def update_config(key: str, value: str) -> str:
     if not re.match(r'^[A-Z_]+$', key):
         return f"❌ Invalid key format: {key}. Keys must be uppercase with underscores only."
     
-    # Use user config path
+    # Use user config path, check for legacy if new doesn't exist
     config_path = USER_CONFIG_PATH
+    if not config_path.exists() and LEGACY_CONFIG_PATH.exists():
+        config_path = LEGACY_CONFIG_PATH
+        logger.warning(f"Using deprecated .voicemode.env - please rename to voicemode.env")
     
     try:
         # Read existing configuration

voice_mode/tools/converse.py

@@ -1412,6 +1412,37 @@ async def converse(
         Remember: Lower values (0-1) = more permissive, may detect non-speech as speech
                  Higher values (2-3) = more strict, may miss soft speech or whispers
     
+    Parallel Operations Pattern (RECOMMENDED):
+        When performing actions that don't require user confirmation, use wait_for_response=False
+        to speak while simultaneously executing other tools. This creates natural, flowing conversations.
+        
+        Pattern: converse("Status update", wait_for_response=False) then immediately run other tools.
+        The speech plays while your actions execute in parallel.
+        
+        Examples:
+        - Search narration: converse("Searching for that file", wait_for_response=False) + Grep(...)
+        - Processing update: converse("Analyzing the screenshot", wait_for_response=False) + analyze_screenshot(...)
+        - Creation status: converse("Creating that document now", wait_for_response=False) + Write(...)
+        - Quick confirmation: converse("Done! The file is saved", wait_for_response=False)
+        
+        Benefits:
+        - No dead air during operations
+        - User knows what's happening
+        - More natural conversation flow
+        - Better user experience
+        
+        When to use parallel pattern:
+        - File operations (reading, writing, searching)
+        - Data processing (analysis, computation)
+        - Status updates during long operations
+        - Confirmations that don't need response
+        
+        When NOT to use parallel pattern:
+        - Questions requiring answers
+        - Confirmations needing user approval
+        - Error messages needing acknowledgment
+        - End of conversation farewells (unless doing cleanup)
+    
     Skip TTS Examples:
         - Fast iteration mode: converse("Processing your request", skip_tts=True)  # Text only, no voice
         - Important announcement: converse("Warning: System will restart", skip_tts=False)  # Always use voice

voice_mode/tools/services/kokoro/install.py

@@ -251,13 +251,14 @@ async def kokoro_install(
             with open(plist_path, 'w') as f:
                 f.write(plist_content)
             
-            # Load the launchagent
+            # Unload if already loaded (ignore errors)
             try:
                 subprocess.run(["launchctl", "unload", plist_path], capture_output=True)
             except:
                 pass  # Ignore if not loaded
             
-            subprocess.run(["launchctl", "load", plist_path], check=True)
+            # Don't load here - let enable_service handle it with the -w flag
+            # This prevents the "already loaded" error when enable_service runs
             result["launchagent"] = plist_path
             result["message"] += f"\nLaunchAgent installed: {plist_name}"
             

voice_mode/tools/services/whisper/__init__.py

@@ -0,0 +1,13 @@
+"""Whisper service tools."""
+
+from voice_mode.tools.services.whisper.install import whisper_install
+from voice_mode.tools.services.whisper.uninstall import whisper_uninstall
+from voice_mode.tools.services.whisper.download_model import download_model
+from voice_mode.tools.services.whisper.list_models_tool import whisper_list_models
+
+__all__ = [
+    'whisper_install',
+    'whisper_uninstall', 
+    'download_model',
+    'whisper_list_models'
+]

voice_mode/tools/services/whisper/install.py

@@ -369,13 +369,14 @@ exec "$SERVER_BIN" \\
             with open(plist_path, 'w') as f:
                 f.write(plist_content)
             
-            # Load the launchagent
+            # Unload if already loaded (ignore errors)
             try:
                 subprocess.run(["launchctl", "unload", plist_path], capture_output=True)
             except:
                 pass  # Ignore if not loaded
             
-            subprocess.run(["launchctl", "load", plist_path], check=True)
+            # Don't load here - let enable_service handle it with the -w flag
+            # This prevents the "already loaded" error when enable_service runs
             
             # Handle auto_enable
             enable_message = ""

voice_mode/tools/services/whisper/list_models.py

@@ -0,0 +1,70 @@
+"""MCP tool for listing Whisper models and their status."""
+
+from typing import Dict, Any
+from voice_mode.tools.services.whisper.models import (
+    WHISPER_MODELS,
+    get_model_directory,
+    get_current_model,
+    is_model_installed,
+    get_installed_models,
+    format_size,
+    has_coreml_model,
+    is_apple_silicon
+)
+
+
+async def list_whisper_models() -> Dict[str, Any]:
+    """List available Whisper models and their installation status.
+    
+    Returns:
+        Dictionary containing model information and status
+    """
+    try:
+        model_dir = get_model_directory()
+        current_model = get_current_model()
+        installed_models = get_installed_models()
+        
+        # Build models list with status
+        models = []
+        show_coreml = is_apple_silicon()  # Only show Core ML on Apple Silicon
+        
+        for model_name, info in WHISPER_MODELS.items():
+            model_status = {
+                "name": model_name,
+                "size_mb": info["size_mb"],
+                "size": format_size(info["size_mb"]),
+                "languages": info["languages"],
+                "description": info["description"],
+                "installed": is_model_installed(model_name),
+                "current": model_name == current_model,
+                "has_coreml": has_coreml_model(model_name) if show_coreml else False
+            }
+            models.append(model_status)
+        
+        # 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()
+        )
+        
+        return {
+            "success": True,
+            "models": models,
+            "current_model": current_model,
+            "model_directory": str(model_dir),
+            "installed_count": len(installed_models),
+            "total_count": len(WHISPER_MODELS),
+            "installed_size_mb": total_installed_size,
+            "installed_size": format_size(total_installed_size),
+            "available_size_mb": total_available_size,
+            "available_size": format_size(total_available_size)
+        }
+        
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e),
+            "models": []
+        }

voice_mode/tools/services/whisper/list_models_tool.py

@@ -0,0 +1,65 @@
+"""MCP tool for listing Whisper models."""
+
+from voice_mode.server import mcp
+from voice_mode.tools.services.whisper.list_models import list_whisper_models
+
+
+@mcp.tool()
+async def whisper_list_models() -> str:
+    """List available Whisper models and their installation status.
+    
+    Shows all available Whisper models with:
+    - Installation status (installed/not installed)
+    - Model sizes
+    - Language support
+    - Currently selected model
+    
+    Returns:
+        Formatted string showing model status and information
+    """
+    result = await list_whisper_models()
+    
+    if not result["success"]:
+        return f"Error listing models: {result.get('error', 'Unknown error')}"
+    
+    # Format output
+    output = ["Whisper Models:", ""]
+    
+    # Check if we should show Core ML column
+    show_coreml = any(model.get("has_coreml", False) for model in result["models"])
+    
+    for model in result["models"]:
+        # Format status indicators
+        current = "→ " if model["current"] else "  "
+        installed = "[✓ Installed]" if model["installed"] else "[ Download ]"
+        
+        # Add Core ML indicator if on macOS
+        coreml = ""
+        if show_coreml:
+            coreml = "[ML]" if model.get("has_coreml", False) else "    "
+        
+        # Format model line
+        line = f"{current}{model['name']:15} {installed:14} {coreml} {model['size']:>8}  {model['languages']:20}"
+        if model["current"]:
+            line += " (Currently selected)"
+        
+        output.append(line)
+    
+    # Add footer
+    footer = [
+        "",
+        f"Models directory: {result['model_directory']}",
+        f"Total size: {result['installed_size']} installed / {result['available_size']} available",
+        "",
+        f"Installed models: {result['installed_count']}/{result['total_count']}",
+        f"Current model: {result['current_model']}"
+    ]
+    
+    # Add Core ML note if on macOS
+    if show_coreml:
+        footer.append("")
+        footer.append("[ML] = Core ML model available for faster inference on Apple Silicon")
+    
+    output.extend(footer)
+    
+    return "\n".join(output)

voice_mode/tools/services/whisper/models.py

@@ -0,0 +1,274 @@
+"""Whisper model registry and utilities."""
+
+import os
+from pathlib import Path
+from typing import Dict, List, Optional, TypedDict
+from voice_mode.config import WHISPER_MODEL_PATH, WHISPER_MODEL
+
+
+class ModelInfo(TypedDict):
+    """Information about a Whisper model."""
+    size_mb: int  # Download size in MB
+    languages: str  # Language support description
+    description: str  # Brief description
+    filename: str  # Expected filename when downloaded
+
+
+# Registry of all available Whisper models
+WHISPER_MODELS: Dict[str, ModelInfo] = {
+    "tiny": {
+        "size_mb": 39,
+        "languages": "Multilingual",
+        "description": "Fastest, least accurate",
+        "filename": "ggml-tiny.bin"
+    },
+    "tiny.en": {
+        "size_mb": 39,
+        "languages": "English only",
+        "description": "Fastest English model",
+        "filename": "ggml-tiny.en.bin"
+    },
+    "base": {
+        "size_mb": 142,
+        "languages": "Multilingual",
+        "description": "Good balance of speed and accuracy",
+        "filename": "ggml-base.bin"
+    },
+    "base.en": {
+        "size_mb": 142,
+        "languages": "English only",
+        "description": "Good English model",
+        "filename": "ggml-base.en.bin"
+    },
+    "small": {
+        "size_mb": 466,
+        "languages": "Multilingual",
+        "description": "Better accuracy, slower",
+        "filename": "ggml-small.bin"
+    },
+    "small.en": {
+        "size_mb": 466,
+        "languages": "English only",
+        "description": "Better English accuracy",
+        "filename": "ggml-small.en.bin"
+    },
+    "medium": {
+        "size_mb": 1500,
+        "languages": "Multilingual",
+        "description": "High accuracy, slow",
+        "filename": "ggml-medium.bin"
+    },
+    "medium.en": {
+        "size_mb": 1500,
+        "languages": "English only",
+        "description": "High English accuracy",
+        "filename": "ggml-medium.en.bin"
+    },
+    "large-v1": {
+        "size_mb": 2900,
+        "languages": "Multilingual",
+        "description": "Original large model",
+        "filename": "ggml-large-v1.bin"
+    },
+    "large-v2": {
+        "size_mb": 2900,
+        "languages": "Multilingual",
+        "description": "Improved large model (recommended)",
+        "filename": "ggml-large-v2.bin"
+    },
+    "large-v3": {
+        "size_mb": 3100,
+        "languages": "Multilingual",
+        "description": "Latest large model",
+        "filename": "ggml-large-v3.bin"
+    },
+    "large-v3-turbo": {
+        "size_mb": 1600,
+        "languages": "Multilingual",
+        "description": "Faster large model with good accuracy",
+        "filename": "ggml-large-v3-turbo.bin"
+    }
+}
+
+
+def get_model_directory() -> Path:
+    """Get the directory where Whisper models are stored."""
+    # Use the configured path from config.py
+    model_dir = Path(WHISPER_MODEL_PATH)
+    
+    # If config path doesn't exist, check service installation
+    if not model_dir.exists():
+        service_models = Path.home() / ".voicemode" / "services" / "whisper" / "models"
+        if service_models.exists():
+            return service_models
+    
+    return model_dir
+
+
+def get_current_model() -> str:
+    """Get the currently selected Whisper model."""
+    # Use the configured model from config.py
+    model = WHISPER_MODEL
+    
+    # Validate it's a known model
+    if model not in WHISPER_MODELS:
+        return "large-v2"  # Default fallback
+    
+    return model
+
+
+def is_model_installed(model_name: str) -> bool:
+    """Check if a model is installed."""
+    if model_name not in WHISPER_MODELS:
+        return False
+    
+    model_dir = get_model_directory()
+    model_info = WHISPER_MODELS[model_name]
+    model_path = model_dir / model_info["filename"]
+    
+    return model_path.exists()
+
+
+def has_coreml_model(model_name: str) -> bool:
+    """Check if a Core ML model is available for the given model.
+    
+    Core ML models are only used on macOS with Apple Silicon.
+    They have the extension .mlmodelc and provide faster inference.
+    """
+    import platform
+    
+    # Core ML is only relevant on macOS
+    if platform.system() != "Darwin":
+        return False
+    
+    if model_name not in WHISPER_MODELS:
+        return False
+    
+    model_dir = get_model_directory()
+    model_info = WHISPER_MODELS[model_name]
+    
+    # Core ML model would be named like ggml-large-v2-encoder.mlmodelc
+    coreml_path = model_dir / f"ggml-{model_name}-encoder.mlmodelc"
+    
+    return coreml_path.exists()
+
+
+def get_installed_models() -> List[str]:
+    """Get list of installed models."""
+    installed = []
+    for model_name in WHISPER_MODELS:
+        if is_model_installed(model_name):
+            installed.append(model_name)
+    return installed
+
+
+def get_total_size(models: Optional[List[str]] = None) -> int:
+    """Get total size of models in MB.
+    
+    Args:
+        models: List of model names. If None, uses all models.
+    
+    Returns:
+        Total size in MB
+    """
+    if models is None:
+        models = list(WHISPER_MODELS.keys())
+    
+    total = 0
+    for model in models:
+        if model in WHISPER_MODELS:
+            total += WHISPER_MODELS[model]["size_mb"]
+    
+    return total
+
+
+def format_size(size_mb: int) -> str:
+    """Format size in MB to human-readable string."""
+    if size_mb < 1000:
+        return f"{size_mb} MB"
+    else:
+        size_gb = size_mb / 1000
+        return f"{size_gb:.1f} GB"
+
+
+def is_macos() -> bool:
+    """Check if running on macOS."""
+    import platform
+    return platform.system() == "Darwin"
+
+
+def is_apple_silicon() -> bool:
+    """Check if running on Apple Silicon (M1/M2/M3/M4)."""
+    import platform
+    return platform.system() == "Darwin" and platform.machine() == "arm64"
+
+
+def set_current_model(model_name: str) -> None:
+    """Set the current active Whisper model.
+    
+    Args:
+        model_name: Name of the model to set as active
+    
+    Updates the voicemode.env configuration file for persistence.
+    """
+    from pathlib import Path
+    import re
+    
+    # Configuration file path
+    config_path = Path.home() / ".voicemode" / ".voicemode.env"
+    
+    # Ensure directory exists
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    # Read existing configuration
+    config = {}
+    if config_path.exists():
+        with open(config_path, 'r') as f:
+            for line in f:
+                line = line.strip()
+                if not line or line.startswith('#'):
+                    continue
+                match = re.match(r'^([A-Z_]+)=(.*)$', line)
+                if match:
+                    key, value = match.groups()
+                    value = value.strip('"').strip("'")
+                    config[key] = value
+    
+    # Update the model
+    config['VOICEMODE_WHISPER_MODEL'] = model_name
+    
+    # Write back to file, preserving structure
+    lines = []
+    updated_keys = set()
+    
+    if config_path.exists():
+        with open(config_path, 'r') as f:
+            for line in f:
+                stripped = line.strip()
+                if stripped and not stripped.startswith('#'):
+                    match = re.match(r'^([A-Z_]+)=', stripped)
+                    if match:
+                        key = match.group(1)
+                        if key == 'VOICEMODE_WHISPER_MODEL':
+                            lines.append(f"VOICEMODE_WHISPER_MODEL={model_name}\n")
+                            updated_keys.add(key)
+                        elif key in config:
+                            lines.append(f"{key}={config[key]}\n")
+                            updated_keys.add(key)
+                        else:
+                            lines.append(line)
+                    else:
+                        lines.append(line)
+                else:
+                    lines.append(line)
+    
+    # Add VOICEMODE_WHISPER_MODEL if it wasn't in the file
+    if 'VOICEMODE_WHISPER_MODEL' not in updated_keys:
+        if lines and not lines[-1].strip() == '':
+            lines.append('\n')
+        lines.append("# Whisper Configuration\n")
+        lines.append(f"VOICEMODE_WHISPER_MODEL={model_name}\n")
+    
+    # Write the updated configuration
+    with open(config_path, 'w') as f:
+        f.writelines(lines)