voice-mode-install 7.4.0__py3-none-any.whl

voicemode_install/dependencies.yaml

@@ -0,0 +1,367 @@
+# VoiceMode System Dependencies
+# Organized by: voicemode → component → OS/distribution → package list
+#
+# ## SUMMARY
+#
+# ### Installation Tool
+# **UV (required for installation):**
+# - All platforms: UV package manager (https://astral.sh/uv)
+# - Used by install script and for `uv tool install voice-mode`
+# - Provides consistent binary location at ~/.local/bin
+#
+# ### Core (VoiceMode base)
+# **Required (runtime):**
+# - macOS: portaudio, ffmpeg
+# - Ubuntu/Debian: libportaudio2, ffmpeg
+# - Fedora: portaudio, ffmpeg
+#
+# **Required (build tools - for webrtcvad and simpleaudio):**
+# - Ubuntu/Debian: python3-dev, gcc, libasound2-dev
+# - Fedora: python3-devel, gcc, alsa-lib-devel
+# - Note: webrtcvad is a Python C extension used for silence detection. It must be compiled during installation.
+#   simpleaudio is a Python C extension used for audio playback. It requires ALSA headers to compile.
+#   Testing confirmed: Only gcc is required for core, g++/gcc-c++ not needed.
+#
+# **Optional (build from source):**
+# - Ubuntu/Debian: portaudio19-dev
+# - Fedora: portaudio-devel
+#
+# **Required for WSL:**
+# - WSL Ubuntu/Debian: pulseaudio, pulseaudio-utils, libasound2-plugins
+# - WSL Fedora: pulseaudio, pulseaudio-utils
+# - Note: Must be running for audio to work in WSL2
+#
+# **Optional (audio server - native Linux):**
+# - Usually pre-installed on desktop Linux distributions
+#
+# ### Whisper (STT)
+# - macOS: cmake, portaudio
+# - Ubuntu/Debian: cmake, gcc, g++, make, portaudio19-dev, libasound2-dev
+# - Fedora: cmake, gcc, gcc-c++, make, portaudio-devel, alsa-lib-devel
+#
+# ### Kokoro (TTS)
+# - macOS: rust (optional)
+# - Ubuntu/Debian: cargo, rustc (ARM64 only)
+# - Fedora: cargo, rust (ARM64 only)
+#
+# ### LiveKit
+# - All platforms: No system dependencies (single binary)
+#
+# ---
+#
+# ## DETAIL
+#
+# Structure:
+#   voicemode:
+#     component:  # core, whisper, kokoro, livekit
+#       description: What this component does
+#       os_or_distro:
+#         packages:
+#           - name: package_name
+#             description: Why this package is needed
+#             required: true/false
+#             min_version: optional minimum version
+#             check_command: optional command to verify installation
+
+voicemode:
+  installation:
+    description: Tools required for installing VoiceMode
+
+    common:  # All platforms
+      packages:
+        - name: uv
+          description: UV package manager for Python
+          required: true
+          check_command: uv --version
+          install_command: curl -LsSf https://astral.sh/uv/install.sh | sh
+          note: Provides consistent installation and binary location (~/.local/bin)
+
+  core:
+    description: VoiceMode core audio and Python dependencies
+
+    debian:  # Ubuntu, Debian
+      packages:
+        - name: python3-dev
+          description: Python development headers (needed for building extensions)
+          required: true
+          # Don't use check_command - let it use _check_apt_package which properly checks dpkg output
+          note: Required for compiling webrtcvad (C extension used for silence detection)
+
+        - name: gcc
+          description: C compiler (needed for building Python extensions)
+          required: true
+          check_command: gcc --version
+          note: Required for compiling webrtcvad (C extension used for silence detection)
+
+        - name: g++
+          description: C++ compiler (needed for building Python extensions)
+          required: false
+          check_command: g++ --version
+          note: Optional - not needed for webrtcvad. Only needed if building other C++ packages from source.
+
+        - name: libasound2-dev
+          description: ALSA development files (audio support)
+          required: true
+          # Don't use check_command - let it use _check_apt_package which properly checks dpkg output
+          note: Required for compiling simpleaudio (C extension used for audio playback)
+
+        - name: libasound2-plugins
+          description: ALSA plugins for PulseAudio
+          required: false
+          # Don't use check_command - let it use _check_apt_package which properly checks dpkg output
+
+        - name: libportaudio2
+          description: PortAudio library (for sounddevice)
+          required: true
+          # Don't use check_command - let it use _check_apt_package which properly checks dpkg output
+
+        - name: portaudio19-dev
+          description: PortAudio development files
+          required: false
+          # Don't use check_command - let it use _check_apt_package which properly checks dpkg output
+          note: Optional - only needed for building, not runtime (libportaudio2 has the runtime library)
+
+        - name: pulseaudio
+          description: PulseAudio sound server
+          required: wsl  # Required for WSL, optional for native Linux
+          check_command: pulseaudio --version
+          note: Essential for WSL2 audio. Usually pre-installed on native Linux desktops.
+
+        - name: pulseaudio-utils
+          description: PulseAudio utilities
+          required: wsl  # Required for WSL, optional for native Linux
+          # Don't use check_command - let it use _check_apt_package which properly checks dpkg output
+          note: Essential for WSL2 audio. Usually pre-installed on native Linux desktops.
+
+        - name: ffmpeg
+          description: Audio/video processing
+          required: true
+          check_command: ffmpeg -version
+
+    fedora:  # Fedora, RHEL, CentOS
+      packages:
+        - name: python3-devel
+          description: Python development headers (needed for building extensions)
+          required: true
+          check_command: rpm -q python3-devel
+          note: Required for compiling webrtcvad (C extension used for silence detection)
+
+        - name: gcc
+          description: C compiler (needed for building Python extensions)
+          required: true
+          check_command: gcc --version
+          note: Required for compiling webrtcvad (C extension used for silence detection)
+
+        - name: gcc-c++
+          description: C++ compiler (needed for building Python extensions)
+          required: false
+          check_command: g++ --version
+          note: Optional - not needed for webrtcvad. Only needed if building other C++ packages from source.
+
+        - name: alsa-lib-devel
+          description: ALSA development files (audio support)
+          required: true
+          check_command: rpm -q alsa-lib-devel
+          note: Required for compiling simpleaudio (C extension used for audio playback)
+
+        - name: portaudio
+          description: PortAudio library (for sounddevice runtime)
+          required: true
+          check_command: rpm -q portaudio
+
+        - name: portaudio-devel
+          description: PortAudio development files
+          required: false
+          check_command: rpm -q portaudio-devel
+          note: Optional - only needed for building, not runtime
+
+        - name: pulseaudio
+          description: PulseAudio sound server
+          required: wsl  # Required for WSL, optional for native Linux
+          check_command: pulseaudio --version
+          note: Essential for WSL2 audio. Usually pre-installed on native Linux desktops.
+
+        - name: pulseaudio-utils
+          description: PulseAudio utilities
+          required: wsl  # Required for WSL, optional for native Linux
+          check_command: rpm -q pulseaudio-utils
+          note: Essential for WSL2 audio. Usually pre-installed on native Linux desktops.
+
+        - name: ffmpeg
+          description: Audio/video processing
+          required: true
+          check_command: ffmpeg -version
+          note: May need RPM Fusion repository enabled
+
+    darwin:  # macOS
+      packages:
+        - name: portaudio
+          description: PortAudio library (for sounddevice)
+          required: true
+          check_command: brew list portaudio
+          install_via: homebrew
+
+        - name: ffmpeg
+          description: Audio/video processing
+          required: true
+          check_command: ffmpeg -version
+          install_via: homebrew
+
+  whisper:
+    description: Whisper STT service dependencies
+
+    common:  # All platforms
+      packages:
+        - name: git
+          description: Version control system (needed to clone whisper.cpp repository)
+          required: true
+          check_command: git --version
+          note: Required for cloning whisper.cpp from GitHub
+
+    debian:
+      packages:
+        - name: cmake
+          description: Build system (needed for compiling whisper.cpp)
+          required: true
+          min_version: "3.10"
+          check_command: cmake --version
+
+        - name: gcc
+          description: C compiler
+          required: true
+          min_version: "9.0"
+          check_command: gcc --version
+
+        - name: g++
+          description: C++ compiler
+          required: true
+          min_version: "9.0"
+          check_command: g++ --version
+
+        - name: make
+          description: Build tool
+          required: true
+          check_command: make --version
+
+        - name: portaudio19-dev
+          description: Audio I/O library (for real-time transcription)
+          required: true
+          check_command: pkg-config --exists portaudio-2.0
+
+        - name: libasound2-dev
+          description: Advanced Linux Sound Architecture
+          required: true
+          check_command: pkg-config --exists alsa
+
+    fedora:
+      packages:
+        - name: cmake
+          description: Build system (needed for compiling whisper.cpp)
+          required: true
+          min_version: "3.10"
+          check_command: cmake --version
+
+        - name: gcc
+          description: C compiler
+          required: true
+          min_version: "9.0"
+          check_command: gcc --version
+
+        - name: gcc-c++
+          description: C++ compiler
+          required: true
+          min_version: "9.0"
+          check_command: g++ --version
+
+        - name: make
+          description: Build tool
+          required: true
+          check_command: make --version
+
+        - name: portaudio-devel
+          description: Audio I/O library (for real-time transcription)
+          required: true
+          check_command: pkg-config --exists portaudio-2.0
+
+        - name: alsa-lib-devel
+          description: Advanced Linux Sound Architecture
+          required: true
+          check_command: pkg-config --exists alsa
+
+    darwin:
+      packages:
+        - name: cmake
+          description: Build system
+          required: true
+          check_command: cmake --version
+          install_via: homebrew
+
+        - name: portaudio
+          description: Audio I/O library
+          required: true
+          check_command: brew list portaudio
+          install_via: homebrew
+
+  kokoro:
+    description: Kokoro TTS service dependencies
+
+    common:  # All platforms
+      packages:
+        - name: git
+          description: Version control system (needed to clone kokoro repository)
+          required: true
+          check_command: git --version
+          note: Required for installing Kokoro from GitHub repository
+
+    debian:
+      packages:
+        - name: cargo
+          description: Rust package manager (needed for building sudachipy on ARM)
+          required: false  # Only on ARM64, not x86_64
+          check_command: cargo --version
+          note: Only required for ARM64 architecture
+
+        - name: rustc
+          description: Rust compiler (needed for building sudachipy on ARM)
+          required: false  # Only on ARM64, not x86_64
+          check_command: rustc --version
+          note: Only required for ARM64 architecture
+
+    fedora:
+      packages:
+        - name: cargo
+          description: Rust package manager (needed for building sudachipy)
+          required: true
+          check_command: cargo --version
+          note: Required for building sudachipy dependency
+
+        - name: rust
+          description: Rust compiler
+          required: true
+          check_command: rustc --version
+          note: Required for building sudachipy dependency
+
+    darwin:
+      packages:
+        - name: rust
+          description: Rust compiler (if needed for building dependencies)
+          required: false
+          check_command: rustc --version
+          install_via: homebrew or rustup
+          note: kokoro-fastapi handles most deps via UV
+
+  livekit:
+    description: LiveKit server dependencies (optional)
+
+    common:
+      note: LiveKit server is distributed as a single binary, no system dependencies required
+      packages: []
+
+# Notes:
+# - macOS typically uses Homebrew for all packages
+# - Linux distributions may need additional repositories (e.g., RPM Fusion for Fedora ffmpeg)
+# - ARM64 systems may need Rust for building certain Python packages from source
+# - WSL requires PulseAudio to be running for audio support
+# - webrtcvad (C extension for silence detection) MUST be compiled during installation on all platforms
+#   This requires gcc/g++, python3-dev/python3-devel to be installed before running 'uv tool install voice-mode'
+# - Most other Python packages (numpy, scipy, sounddevice, etc.) have pre-built wheels for x86_64

voicemode_install/hardware.py

@@ -0,0 +1,92 @@
+"""Hardware detection for service recommendations."""
+
+import psutil
+
+from .system import PlatformInfo
+
+
+class HardwareInfo:
+    """Detect and provide hardware recommendations."""
+
+    def __init__(self, platform_info: PlatformInfo):
+        self.platform = platform_info
+        self.cpu_count = psutil.cpu_count(logical=False) or 1
+        self.total_ram_gb = psutil.virtual_memory().total / (1024 ** 3)
+
+    def is_apple_silicon(self) -> bool:
+        """Check if running on Apple Silicon."""
+        return self.platform.os_type == 'darwin' and self.platform.architecture == 'arm64'
+
+    def is_arm64(self) -> bool:
+        """Check if running on ARM64 architecture."""
+        return self.platform.architecture == 'arm64'
+
+    def get_ram_category(self) -> str:
+        """Categorize RAM amount."""
+        if self.total_ram_gb < 4:
+            return 'low'
+        elif self.total_ram_gb < 8:
+            return 'medium'
+        elif self.total_ram_gb < 16:
+            return 'good'
+        else:
+            return 'excellent'
+
+    def should_recommend_local_services(self) -> bool:
+        """Determine if local services should be recommended."""
+        # Apple Silicon is great for local services
+        if self.is_apple_silicon():
+            return True
+
+        # Other ARM64 with good RAM
+        if self.is_arm64() and self.total_ram_gb >= 8:
+            return True
+
+        # x86_64 with good specs
+        if self.total_ram_gb >= 8 and self.cpu_count >= 4:
+            return True
+
+        return False
+
+    def get_recommendation_message(self) -> str:
+        """Get a recommendation message for local services."""
+        if self.is_apple_silicon():
+            return (
+                f"Your Apple Silicon Mac with {self.total_ram_gb:.1f}GB RAM is great for local services.\n"
+                f"Whisper and Kokoro will run fast and privately on your hardware."
+            )
+        elif self.is_arm64():
+            if self.total_ram_gb >= 8:
+                return (
+                    f"Your ARM64 system with {self.total_ram_gb:.1f}GB RAM can run local services well.\n"
+                    f"Recommended for privacy and offline use."
+                )
+            else:
+                return (
+                    f"Your ARM64 system has {self.total_ram_gb:.1f}GB RAM.\n"
+                    f"Local services may work but cloud services might be more responsive."
+                )
+        else:  # x86_64
+            if self.total_ram_gb >= 8 and self.cpu_count >= 4:
+                return (
+                    f"Your system ({self.cpu_count} cores, {self.total_ram_gb:.1f}GB RAM) can run local services.\n"
+                    f"Recommended for privacy and offline use."
+                )
+            elif self.total_ram_gb >= 4:
+                return (
+                    f"Your system has {self.total_ram_gb:.1f}GB RAM.\n"
+                    f"Local services will work but may be slower. Cloud services recommended for best performance."
+                )
+            else:
+                return (
+                    f"Your system has {self.total_ram_gb:.1f}GB RAM.\n"
+                    f"Cloud services strongly recommended - local services may struggle."
+                )
+
+    def get_download_estimate(self) -> str:
+        """Estimate download size for local services."""
+        # Rough estimates:
+        # Whisper: ~150MB (base model) to ~3GB (large model)
+        # Kokoro: ~500MB
+        # Total: ~2-4GB for full setup
+        return "~2-4GB total (Whisper models + Kokoro)"

voicemode_install/installer.py

@@ -0,0 +1,150 @@
+"""System package installation."""
+
+import subprocess
+from typing import List, Optional
+
+from .checker import PackageInfo
+from .system import PlatformInfo, get_package_manager
+
+
+class PackageInstaller:
+    """Install system packages using platform-specific package managers."""
+
+    def __init__(self, platform_info: PlatformInfo, dry_run: bool = False, non_interactive: bool = False):
+        self.platform = platform_info
+        self.dry_run = dry_run
+        self.non_interactive = non_interactive
+        self.package_manager = get_package_manager(platform_info.distribution)
+
+    def install_packages(self, packages: List[PackageInfo]) -> bool:
+        """
+        Install a list of packages.
+
+        Returns True if all installations succeeded, False otherwise.
+        """
+        if not packages:
+            return True
+
+        package_names = [pkg.name for pkg in packages]
+
+        if self.dry_run:
+            print(f"[DRY RUN] Would install: {', '.join(package_names)}")
+            return True
+
+        try:
+            if self.platform.distribution == 'darwin':
+                return self._install_homebrew(package_names)
+            elif self.platform.distribution == 'debian':
+                return self._install_apt(package_names)
+            elif self.platform.distribution == 'fedora':
+                return self._install_dnf(package_names)
+            else:
+                print(f"Error: Unsupported distribution: {self.platform.distribution}")
+                return False
+        except Exception as e:
+            print(f"Error installing packages: {e}")
+            return False
+
+    def _install_homebrew(self, packages: List[str]) -> bool:
+        """Install packages using Homebrew.
+
+        Note: Homebrew should already be installed by the time this is called.
+        The CLI ensures Homebrew is present before dependency checking.
+        """
+        try:
+            cmd = ['brew', 'install'] + packages
+            result = subprocess.run(
+                cmd,
+                check=True,
+                capture_output=False  # Show output to user
+            )
+            return result.returncode == 0
+        except subprocess.CalledProcessError as e:
+            print(f"Homebrew package installation failed: {e}")
+            return False
+        except FileNotFoundError:
+            print("Error: Homebrew not found. This should have been installed earlier.")
+            print("Please report this as a bug.")
+            return False
+
+    def _install_apt(self, packages: List[str]) -> bool:
+        """Install packages using apt."""
+        try:
+            # Update package lists first
+            print("Updating package lists...")
+            subprocess.run(
+                ['sudo', 'apt', 'update'],
+                check=True,
+                capture_output=False
+            )
+
+            # Install packages
+            cmd = ['sudo', 'apt', 'install', '-y'] + packages
+            result = subprocess.run(
+                cmd,
+                check=True,
+                capture_output=False
+            )
+            return result.returncode == 0
+        except subprocess.CalledProcessError as e:
+            print(f"apt installation failed: {e}")
+            return False
+        except FileNotFoundError:
+            print("Error: apt not found")
+            return False
+
+    def _install_dnf(self, packages: List[str]) -> bool:
+        """Install packages using dnf."""
+        try:
+            cmd = ['sudo', 'dnf', 'install', '-y'] + packages
+            result = subprocess.run(
+                cmd,
+                check=True,
+                capture_output=False
+            )
+            return result.returncode == 0
+        except subprocess.CalledProcessError as e:
+            print(f"dnf installation failed: {e}")
+            return False
+        except FileNotFoundError:
+            print("Error: dnf not found")
+            return False
+
+    def install_voicemode(self, version: Optional[str] = None) -> bool:
+        """
+        Install or upgrade voice-mode using uv tool install --upgrade.
+
+        Args:
+            version: Optional version to install (e.g., "5.1.3")
+
+        Returns:
+            True if installation succeeded, False otherwise.
+        """
+        if self.dry_run:
+            if version:
+                print(f"[DRY RUN] Would install: uv tool install --upgrade voice-mode=={version}")
+            else:
+                print("[DRY RUN] Would install: uv tool install --upgrade voice-mode")
+            return True
+
+        try:
+            # Always use --upgrade to ensure we get the latest/requested version
+            # This also implies --refresh to check for new versions
+            if version:
+                cmd = ['uv', 'tool', 'install', '--upgrade', f'voice-mode=={version}']
+            else:
+                cmd = ['uv', 'tool', 'install', '--upgrade', 'voice-mode']
+
+            result = subprocess.run(
+                cmd,
+                check=True,
+                capture_output=False
+            )
+            return result.returncode == 0
+        except subprocess.CalledProcessError as e:
+            print(f"VoiceMode installation failed: {e}")
+            return False
+        except FileNotFoundError:
+            print("Error: uv not found. Please install uv first:")
+            print("  curl -LsSf https://astral.sh/uv/install.sh | sh")
+            return False

voicemode_install/logger.py

@@ -0,0 +1,90 @@
+"""Installation logging."""
+
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict
+
+
+class InstallLogger:
+    """Log installation progress and results."""
+
+    def __init__(self, log_path: Path = None):
+        if log_path is None:
+            voicemode_dir = Path.home() / '.voicemode'
+            voicemode_dir.mkdir(exist_ok=True)
+            log_path = voicemode_dir / 'install.log'
+
+        self.log_path = log_path
+        self.session_id = datetime.now().strftime('%Y%m%d_%H%M%S')
+        self.events = []
+
+    def log_event(self, event_type: str, message: str, details: Dict[str, Any] = None):
+        """Log an installation event."""
+        event = {
+            'timestamp': datetime.now().isoformat(),
+            'session_id': self.session_id,
+            'type': event_type,
+            'message': message,
+        }
+
+        if details:
+            event['details'] = details
+
+        self.events.append(event)
+
+        # Append to log file
+        with open(self.log_path, 'a') as f:
+            f.write(json.dumps(event) + '\n')
+
+    def log_start(self, system_info: Dict[str, Any]):
+        """Log installation start."""
+        self.log_event('start', 'Installation started', {'system': system_info})
+
+    def log_check(self, component: str, packages_found: int, packages_missing: int):
+        """Log dependency check results."""
+        self.log_event(
+            'check',
+            f'Checked {component} dependencies',
+            {
+                'component': component,
+                'found': packages_found,
+                'missing': packages_missing
+            }
+        )
+
+    def log_install(self, package_type: str, packages: list, success: bool):
+        """Log package installation."""
+        self.log_event(
+            'install',
+            f'{"Successfully installed" if success else "Failed to install"} {package_type} packages',
+            {
+                'package_type': package_type,
+                'packages': packages,
+                'success': success
+            }
+        )
+
+    def log_error(self, message: str, error: Exception = None):
+        """Log an error."""
+        details = {'message': message}
+        if error:
+            details['error'] = str(error)
+            details['error_type'] = type(error).__name__
+
+        self.log_event('error', message, details)
+
+    def log_complete(self, success: bool, voicemode_installed: bool):
+        """Log installation completion."""
+        self.log_event(
+            'complete',
+            'Installation completed' if success else 'Installation failed',
+            {
+                'success': success,
+                'voicemode_installed': voicemode_installed
+            }
+        )
+
+    def get_log_path(self) -> str:
+        """Get the path to the log file."""
+        return str(self.log_path)