voice-mode 3.34.3__py3-none-any.whl → 4.1.0__py3-none-any.whl

voice_mode/frontend/package-lock.json

@@ -21,6 +21,7 @@
         "@types/node": "^20.17.13",
         "@types/react": "^18.3.18",
         "@types/react-dom": "^18.3.5",
+        "autoprefixer": "^10.4.21",
         "eslint": "^8.57.1",
         "eslint-config-next": "14.2.29",
         "eslint-config-prettier": "9.1.0",
@@ -1254,6 +1255,44 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/autoprefixer": {
+      "version": "10.4.21",
+      "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.21.tgz",
+      "integrity": "sha512-O+A6LWV5LDHSJD3LjHYoNi4VLsj/Whi7k6zG12xTYaU4cQ8oxQGckXNX8cRHK5yOZ/ppVHe0ZBXGzSV9jXdVbQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/autoprefixer"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "browserslist": "^4.24.4",
+        "caniuse-lite": "^1.0.30001702",
+        "fraction.js": "^4.3.7",
+        "normalize-range": "^0.1.2",
+        "picocolors": "^1.1.1",
+        "postcss-value-parser": "^4.2.0"
+      },
+      "bin": {
+        "autoprefixer": "bin/autoprefixer"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      },
+      "peerDependencies": {
+        "postcss": "^8.1.0"
+      }
+    },
     "node_modules/available-typed-arrays": {
       "version": "1.0.7",
       "dev": true,
@@ -1320,6 +1359,39 @@
         "node": ">=8"
       }
     },
+    "node_modules/browserslist": {
+      "version": "4.25.4",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.25.4.tgz",
+      "integrity": "sha512-4jYpcjabC606xJ3kw2QwGEZKX0Aw7sgQdZCvIK9dhVSPh76BKo+C+btT1RRofH7B+8iNpEbgGNVWiLki5q93yg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "caniuse-lite": "^1.0.30001737",
+        "electron-to-chromium": "^1.5.211",
+        "node-releases": "^2.0.19",
+        "update-browserslist-db": "^1.1.3"
+      },
+      "bin": {
+        "browserslist": "cli.js"
+      },
+      "engines": {
+        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
+      }
+    },
     "node_modules/busboy": {
       "version": "1.6.0",
       "dev": true,
@@ -1417,7 +1489,9 @@
       }
     },
     "node_modules/caniuse-lite": {
-      "version": "1.0.30001726",
+      "version": "1.0.30001739",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001739.tgz",
+      "integrity": "sha512-y+j60d6ulelrNSwpPyrHdl+9mJnQzHBr08xm48Qno0nSk4h3Qojh+ziv2qE6rXf4k3tadF4o1J/1tAbVm1NtnA==",
       "dev": true,
       "funding": [
         {
@@ -1699,6 +1773,13 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/electron-to-chromium": {
+      "version": "1.5.211",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.211.tgz",
+      "integrity": "sha512-IGBvimJkotaLzFnwIVgW9/UD/AOJ2tByUmeOrtqBfACSbAw5b1G0XpvdaieKyc7ULmbwXVx+4e4Be8pOPBrYkw==",
+      "dev": true,
+      "license": "ISC"
+    },
     "node_modules/emoji-regex": {
       "version": "9.2.2",
       "dev": true,
@@ -1865,6 +1946,16 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
     "node_modules/escape-string-regexp": {
       "version": "4.0.0",
       "dev": true,
@@ -2462,6 +2553,20 @@
         "url": "https://github.com/sponsors/isaacs"
       }
     },
+    "node_modules/fraction.js": {
+      "version": "4.3.7",
+      "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-4.3.7.tgz",
+      "integrity": "sha512-ZsDfxO51wGAXREY55a7la9LScWpwv9RxIrYABrlvOFBlH/ShPnrtsXeuUIfXKKOVicNxQ+o8JTbJvjS4M89yew==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "*"
+      },
+      "funding": {
+        "type": "patreon",
+        "url": "https://github.com/sponsors/rawify"
+      }
+    },
     "node_modules/framer-motion": {
       "version": "11.18.2",
       "resolved": "https://registry.npmjs.org/framer-motion/-/framer-motion-11.18.2.tgz",
@@ -3693,6 +3798,13 @@
         "node": "^10 || ^12 || >=14"
       }
     },
+    "node_modules/node-releases": {
+      "version": "2.0.19",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.19.tgz",
+      "integrity": "sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/normalize-path": {
       "version": "3.0.0",
       "dev": true,
@@ -3701,6 +3813,16 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/normalize-range": {
+      "version": "0.1.2",
+      "resolved": "https://registry.npmjs.org/normalize-range/-/normalize-range-0.1.2.tgz",
+      "integrity": "sha512-bdok/XvKII3nUpklnV6P2hxtMNrCboOjAcyBuQnWEhO665FwrSNRxU+AqpsyvO6LgGYPspN+lu5CLtw4jPRKNA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/object-assign": {
       "version": "4.1.1",
       "dev": true,
@@ -5218,6 +5340,37 @@
         "@unrs/resolver-binding-win32-x64-msvc": "1.9.2"
       }
     },
+    "node_modules/update-browserslist-db": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.3.tgz",
+      "integrity": "sha512-UxhIZQ+QInVdunkDAaiazvvT/+fXL5Osr0JZlJulepYu6Jd7qJtDZjlur0emRlT71EN3ScPoE7gvsuIKKNavKw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "escalade": "^3.2.0",
+        "picocolors": "^1.1.1"
+      },
+      "bin": {
+        "update-browserslist-db": "cli.js"
+      },
+      "peerDependencies": {
+        "browserslist": ">= 4.21.0"
+      }
+    },
     "node_modules/uri-js": {
       "version": "4.4.1",
       "dev": true,

voice_mode/pronounce.py

@@ -0,0 +1,397 @@
+"""
+Pronunciation middleware for TTS and STT text processing.
+
+This module provides regex-based text substitutions to improve TTS pronunciation
+and correct STT transcription errors.
+"""
+
+import logging
+import re
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+import yaml
+from dataclasses import dataclass, field
+import os
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class PronounceRule:
+    """A single pronunciation rule."""
+    name: str
+    pattern: str
+    replacement: str
+    order: int = 100
+    enabled: bool = True
+    description: str = ""
+    private: bool = True  # Default to private for security
+    _compiled: Optional[re.Pattern] = field(default=None, init=False, repr=False)
+    
+    def __post_init__(self):
+        """Compile the regex pattern after initialization."""
+        try:
+            self._compiled = re.compile(self.pattern)
+        except re.error as e:
+            logger.error(f"Invalid regex pattern in rule '{self.name}': {e}")
+            self._compiled = None
+    
+    def apply(self, text: str) -> Tuple[str, bool]:
+        """Apply this rule to text. Returns (modified_text, was_applied)."""
+        if not self.enabled or not self._compiled:
+            return text, False
+        
+        original = text
+        try:
+            text = self._compiled.sub(self.replacement, text)
+            return text, text != original
+        except Exception as e:
+            logger.error(f"Error applying rule '{self.name}': {e}")
+            return original, False
+
+
+class PronounceManager:
+    """Manages pronunciation rules for TTS and STT corrections."""
+    
+    def __init__(self, config_paths: Optional[List[Path]] = None):
+        """
+        Initialize the pronunciation rule manager.
+        
+        Args:
+            config_paths: List of config file paths. If None, uses default locations.
+        """
+        self.rules: Dict[str, List[PronounceRule]] = {
+            'tts': [],
+            'stt': []
+        }
+        self.config_paths = config_paths or self._get_default_config_paths()
+        self._load_all_rules()
+    
+    def _get_default_config_paths(self) -> List[Path]:
+        """Get default configuration file paths."""
+        paths = []
+        
+        # System defaults
+        default_path = Path(__file__).parent / 'data' / 'default_pronunciation.yaml'
+        if default_path.exists():
+            paths.append(default_path)
+        
+        # User config
+        user_config = Path.home() / '.voicemode' / 'config' / 'pronunciation.yaml'
+        if user_config.exists():
+            paths.append(user_config)
+        
+        # Project config (like Claude Code hooks)
+        project_config = Path.cwd() / '.pronunciation.yaml'
+        if project_config.exists():
+            paths.append(project_config)
+        
+        # Environment variable paths
+        env_paths = os.environ.get('VOICEMODE_PRONUNCIATION_CONFIG', '')
+        if env_paths:
+            for path_str in env_paths.split(':'):
+                path = Path(path_str).expanduser()
+                if path.exists():
+                    paths.append(path)
+        
+        return paths
+    
+    def _load_all_rules(self):
+        """Load rules from all configured paths."""
+        self.rules = {'tts': [], 'stt': []}
+        
+        for config_path in self.config_paths:
+            try:
+                self._load_rules_from_file(config_path)
+                logger.info(f"Loaded pronunciation rules from {config_path}")
+            except Exception as e:
+                logger.error(f"Failed to load rules from {config_path}: {e}")
+    
+    def _load_rules_from_file(self, config_path: Path):
+        """Load rules from a single YAML file."""
+        with open(config_path, 'r') as f:
+            config = yaml.safe_load(f)
+        
+        if not config:
+            return
+        
+        # Load TTS rules
+        for rule_dict in config.get('tts_rules', []):
+            rule = self._dict_to_rule(rule_dict)
+            if rule:
+                # Check for duplicate names and override
+                self.rules['tts'] = [r for r in self.rules['tts'] if r.name != rule.name]
+                self.rules['tts'].append(rule)
+        
+        # Load STT rules
+        for rule_dict in config.get('stt_rules', []):
+            rule = self._dict_to_rule(rule_dict)
+            if rule:
+                # Check for duplicate names and override
+                self.rules['stt'] = [r for r in self.rules['stt'] if r.name != rule.name]
+                self.rules['stt'].append(rule)
+        
+        # Sort rules by order
+        self.rules['tts'].sort(key=lambda r: r.order)
+        self.rules['stt'].sort(key=lambda r: r.order)
+    
+    def _dict_to_rule(self, rule_dict: dict) -> Optional[PronounceRule]:
+        """Convert a dictionary to a PronounceRule."""
+        try:
+            return PronounceRule(
+                name=rule_dict['name'],
+                pattern=rule_dict['pattern'],
+                replacement=rule_dict['replacement'],
+                order=rule_dict.get('order', 100),
+                enabled=rule_dict.get('enabled', True),
+                description=rule_dict.get('description', ''),
+                private=rule_dict.get('private', True)  # Default to private
+            )
+        except (KeyError, TypeError) as e:
+            logger.error(f"Invalid rule configuration: {e}")
+            return None
+    
+    def process_tts(self, text: str) -> str:
+        """
+        Apply TTS substitutions before speech generation.
+        
+        Args:
+            text: Text to be spoken by TTS
+            
+        Returns:
+            Modified text with pronunciation improvements
+        """
+        log_substitutions = os.environ.get('VOICEMODE_PRONUNCIATION_LOG_SUBSTITUTIONS', '').lower() == 'true'
+        
+        for rule in self.rules['tts']:
+            original = text
+            text, applied = rule.apply(text)
+            if applied and log_substitutions:
+                logger.info(f"Pronunciation TTS: Applied rule '{rule.name}': \"{original}\" → \"{text}\"")
+        
+        return text
+    
+    def process_stt(self, text: str) -> str:
+        """
+        Apply STT corrections after transcription.
+        
+        Args:
+            text: Text transcribed from speech
+            
+        Returns:
+            Corrected text
+        """
+        log_substitutions = os.environ.get('VOICEMODE_PRONUNCIATION_LOG_SUBSTITUTIONS', '').lower() == 'true'
+        
+        for rule in self.rules['stt']:
+            original = text
+            text, applied = rule.apply(text)
+            if applied and log_substitutions:
+                logger.info(f"Pronunciation STT: Applied rule '{rule.name}': \"{original}\" → \"{text}\"")
+        
+        return text
+    
+    # CRUD Operations
+    def add_rule(self, direction: str, pattern: str, replacement: str,
+                 name: Optional[str] = None, description: str = "",
+                 enabled: bool = True, order: int = 100,
+                 private: bool = False) -> bool:
+        """
+        Add a new pronunciation rule.
+        
+        Args:
+            direction: 'tts' or 'stt'
+            pattern: Regex pattern to match
+            replacement: Replacement text
+            name: Rule name (auto-generated if not provided)
+            description: Human-readable description
+            enabled: Whether rule is active
+            order: Processing order
+            private: Whether rule is hidden from LLM
+            
+        Returns:
+            True if rule was added successfully
+        """
+        if direction not in ['tts', 'stt']:
+            logger.error(f"Invalid direction: {direction}")
+            return False
+        
+        # Auto-generate name if not provided
+        if not name:
+            name = f"{direction}_rule_{len(self.rules[direction])}"
+        
+        # Check for duplicate names
+        if any(r.name == name for r in self.rules[direction]):
+            logger.error(f"Rule with name '{name}' already exists")
+            return False
+        
+        rule = PronounceRule(
+            name=name,
+            pattern=pattern,
+            replacement=replacement,
+            order=order,
+            enabled=enabled,
+            description=description,
+            private=private
+        )
+        
+        if not rule._compiled:
+            return False
+        
+        self.rules[direction].append(rule)
+        self.rules[direction].sort(key=lambda r: r.order)
+        
+        # Save to user config
+        self._save_user_rules()
+        return True
+    
+    def remove_rule(self, direction: str, name: str) -> bool:
+        """Remove a pronunciation rule by name."""
+        if direction not in ['tts', 'stt']:
+            return False
+        
+        original_count = len(self.rules[direction])
+        self.rules[direction] = [r for r in self.rules[direction] if r.name != name]
+        
+        if len(self.rules[direction]) < original_count:
+            self._save_user_rules()
+            return True
+        return False
+    
+    def list_rules(self, direction: Optional[str] = None, 
+                   include_private: bool = False) -> List[dict]:
+        """
+        List all rules or rules for specific direction.
+        
+        Args:
+            direction: 'tts', 'stt', or None for all
+            include_private: Whether to include private rules (for CLI, not MCP)
+            
+        Returns:
+            List of rule dictionaries
+        """
+        rules = []
+        
+        directions = [direction] if direction else ['tts', 'stt']
+        
+        for dir in directions:
+            if dir not in self.rules:
+                continue
+            
+            for rule in self.rules[dir]:
+                # Skip private rules unless explicitly requested
+                if rule.private and not include_private:
+                    continue
+                
+                rules.append({
+                    'direction': dir,
+                    'name': rule.name,
+                    'pattern': rule.pattern,
+                    'replacement': rule.replacement,
+                    'order': rule.order,
+                    'enabled': rule.enabled,
+                    'description': rule.description,
+                    'private': rule.private
+                })
+        
+        return rules
+    
+    def enable_rule(self, direction: str, name: str) -> bool:
+        """Enable a specific rule."""
+        if direction not in ['tts', 'stt']:
+            return False
+        
+        for rule in self.rules[direction]:
+            if rule.name == name:
+                if rule.private:
+                    logger.warning(f"Cannot enable private rule '{name}' via API")
+                    return False
+                rule.enabled = True
+                self._save_user_rules()
+                return True
+        return False
+    
+    def disable_rule(self, direction: str, name: str) -> bool:
+        """Disable a specific rule."""
+        if direction not in ['tts', 'stt']:
+            return False
+        
+        for rule in self.rules[direction]:
+            if rule.name == name:
+                if rule.private:
+                    logger.warning(f"Cannot disable private rule '{name}' via API")
+                    return False
+                rule.enabled = False
+                self._save_user_rules()
+                return True
+        return False
+    
+    def test_rule(self, text: str, direction: str = "tts") -> str:
+        """Test what a text would become after applying rules."""
+        if direction == 'tts':
+            return self.process_tts(text)
+        elif direction == 'stt':
+            return self.process_stt(text)
+        else:
+            return text
+    
+    def reload_rules(self):
+        """Reload all rules from configuration files."""
+        self._load_all_rules()
+        logger.info("Reloaded pronunciation rules")
+    
+    def _save_user_rules(self):
+        """Save current rules to user config file."""
+        user_config = Path.home() / '.voicemode' / 'config' / 'pronunciation.yaml'
+        user_config.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Only save non-default rules
+        config = {
+            'version': 1,
+            'tts_rules': [],
+            'stt_rules': []
+        }
+        
+        for rule in self.rules['tts']:
+            config['tts_rules'].append({
+                'name': rule.name,
+                'order': rule.order,
+                'pattern': rule.pattern,
+                'replacement': rule.replacement,
+                'enabled': rule.enabled,
+                'description': rule.description,
+                'private': rule.private
+            })
+        
+        for rule in self.rules['stt']:
+            config['stt_rules'].append({
+                'name': rule.name,
+                'order': rule.order,
+                'pattern': rule.pattern,
+                'replacement': rule.replacement,
+                'enabled': rule.enabled,
+                'description': rule.description,
+                'private': rule.private
+            })
+        
+        with open(user_config, 'w') as f:
+            yaml.safe_dump(config, f, default_flow_style=False, sort_keys=False)
+        
+        logger.info(f"Saved pronunciation rules to {user_config}")
+
+
+# Global instance (lazy loaded)
+_manager: Optional[PronounceManager] = None
+
+
+def get_manager() -> PronounceManager:
+    """Get or create the global pronunciation manager."""
+    global _manager
+    if _manager is None:
+        _manager = PronounceManager()
+    return _manager
+
+
+def is_enabled() -> bool:
+    """Check if pronunciation middleware is enabled."""
+    return os.environ.get('VOICEMODE_PRONUNCIATION_ENABLED', 'true').lower() == 'true'

voice_mode/providers.py

@@ -9,9 +9,8 @@ import logging
 from typing import Dict, Optional, List, Any, Tuple
 from openai import AsyncOpenAI
 
-from .config import TTS_VOICES, TTS_MODELS, TTS_BASE_URLS, OPENAI_API_KEY
+from .config import TTS_VOICES, TTS_MODELS, TTS_BASE_URLS, OPENAI_API_KEY, get_voice_preferences
 from .provider_discovery import provider_registry, EndpointInfo
-from .voice_preferences import get_preferred_voices
 
 logger = logging.getLogger("voice-mode")
 
@@ -68,14 +67,14 @@ async def get_tts_client_and_voice(
         return client, selected_voice, selected_model, endpoint_info
     
     # Voice-first selection algorithm
-    # Get user preferences and prepend to system defaults
-    user_preferences = get_preferred_voices()
-    combined_voice_list = user_preferences + [v for v in TTS_VOICES if v not in user_preferences]
+    # Get user preferences from configuration
+    voice_preferences = get_voice_preferences()
+    combined_voice_list = voice_preferences
     
     logger.info(f"TTS Provider Selection (voice-first)")
-    if user_preferences:
-        logger.info(f"  User voice preferences: {user_preferences}")
-    logger.info(f"  Combined voice list: {combined_voice_list}")
+    if voice_preferences:
+        logger.info(f"  Voice preferences: {voice_preferences}")
+    logger.info(f"  Voice list: {combined_voice_list}")
     logger.info(f"  Preferred models: {TTS_MODELS}")
     logger.info(f"  Available endpoints: {TTS_BASE_URLS}")
     

voice_mode/resources/configuration.py

@@ -267,7 +267,7 @@ async def environment_variables() -> str:
         ("VOICEMODE_AUTO_START_KOKORO", "Auto-start Kokoro service (true/false)"),
         ("VOICEMODE_TTS_BASE_URLS", "Comma-separated list of TTS endpoints"),
         ("VOICEMODE_STT_BASE_URLS", "Comma-separated list of STT endpoints"),
-        ("VOICEMODE_TTS_VOICES", "Comma-separated list of preferred voices"),
+        ("VOICEMODE_VOICES", "Comma-separated list of preferred voices"),
         ("VOICEMODE_TTS_MODELS", "Comma-separated list of preferred models"),
         # Audio Settings
         ("VOICEMODE_AUDIO_FORMAT", "Audio format for recording (pcm/mp3/wav/flac/aac/opus)"),
@@ -358,7 +358,7 @@ async def environment_template() -> str:
         f"export VOICEMODE_AUTO_START_KOKORO=\"{str(AUTO_START_KOKORO).lower()}\"",
         f"export VOICEMODE_TTS_BASE_URLS=\"{','.join(TTS_BASE_URLS)}\"",
         f"export VOICEMODE_STT_BASE_URLS=\"{','.join(STT_BASE_URLS)}\"",
-        f"export VOICEMODE_TTS_VOICES=\"{','.join(TTS_VOICES)}\"",
+        f"export VOICEMODE_VOICES=\"{','.join(TTS_VOICES)}\"",
         f"export VOICEMODE_TTS_MODELS=\"{','.join(TTS_MODELS)}\"",
         "",
         "# Audio Settings",