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

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,143 @@
+"""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):
+        self.platform = platform_info
+        self.dry_run = dry_run
+        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."""
+        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 installation failed: {e}")
+            return False
+        except FileNotFoundError:
+            print("Error: Homebrew not found. Please install Homebrew first.")
+            print("Visit: https://brew.sh")
+            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 voice-mode using uv tool install.
+
+        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 voice-mode=={version}")
+            else:
+                print("[DRY RUN] Would install: uv tool install voice-mode")
+            return True
+
+        try:
+            if version:
+                cmd = ['uv', 'tool', 'install', f'voice-mode=={version}']
+            else:
+                cmd = ['uv', 'tool', 'install', '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)

voicemode_install/system.py

@@ -0,0 +1,141 @@
+"""System detection and platform utilities."""
+
+import platform
+import shutil
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+
+@dataclass
+class PlatformInfo:
+    """Information about the current platform."""
+
+    os_type: str  # darwin, linux, windows
+    os_name: str  # macOS, Ubuntu, Fedora, etc.
+    distribution: str  # debian, fedora, darwin, etc. (for yaml lookup)
+    architecture: str  # arm64, x86_64
+    is_wsl: bool = False
+
+
+def detect_platform() -> PlatformInfo:
+    """Detect the current platform and return platform information."""
+    os_type = platform.system().lower()
+    architecture = platform.machine().lower()
+
+    # Normalize architecture names
+    if architecture in ('amd64', 'x86_64', 'x64'):
+        architecture = 'x86_64'
+    elif architecture in ('aarch64', 'arm64'):
+        architecture = 'arm64'
+
+    # Detect WSL
+    is_wsl = False
+    if os_type == 'linux':
+        try:
+            with open('/proc/version', 'r') as f:
+                is_wsl = 'microsoft' in f.read().lower() or 'wsl' in f.read().lower()
+        except FileNotFoundError:
+            pass
+
+    if os_type == 'darwin':
+        return PlatformInfo(
+            os_type='darwin',
+            os_name='macOS',
+            distribution='darwin',
+            architecture=architecture,
+            is_wsl=False
+        )
+    elif os_type == 'linux':
+        # Detect Linux distribution
+        distro_info = _detect_linux_distro()
+        return PlatformInfo(
+            os_type='linux',
+            os_name=distro_info['name'],
+            distribution=distro_info['family'],
+            architecture=architecture,
+            is_wsl=is_wsl
+        )
+    else:
+        raise RuntimeError(f"Unsupported operating system: {os_type}")
+
+
+def _detect_linux_distro() -> dict:
+    """Detect Linux distribution and family."""
+    # Try /etc/os-release first (most modern distros)
+    if Path('/etc/os-release').exists():
+        os_release = {}
+        with open('/etc/os-release') as f:
+            for line in f:
+                if '=' in line:
+                    key, value = line.strip().split('=', 1)
+                    os_release[key] = value.strip('"')
+
+        distro_id = os_release.get('ID', '').lower()
+        distro_id_like = os_release.get('ID_LIKE', '').lower()
+        distro_name = os_release.get('NAME', 'Linux')
+
+        # Determine family for yaml lookup
+        if distro_id in ('ubuntu', 'debian') or 'debian' in distro_id_like or 'ubuntu' in distro_id_like:
+            return {'name': distro_name, 'family': 'debian'}
+        elif distro_id in ('fedora', 'rhel', 'centos', 'rocky', 'alma') or 'fedora' in distro_id_like or 'rhel' in distro_id_like:
+            return {'name': distro_name, 'family': 'fedora'}
+        elif distro_id == 'arch' or 'arch' in distro_id_like:
+            return {'name': distro_name, 'family': 'arch'}
+        elif distro_id == 'alpine':
+            return {'name': distro_name, 'family': 'alpine'}
+        elif distro_id in ('opensuse', 'suse') or 'suse' in distro_id_like:
+            return {'name': distro_name, 'family': 'suse'}
+        else:
+            # Try to infer from ID_LIKE
+            if 'debian' in distro_id_like:
+                return {'name': distro_name, 'family': 'debian'}
+            elif 'fedora' in distro_id_like or 'rhel' in distro_id_like:
+                return {'name': distro_name, 'family': 'fedora'}
+
+    # Fallback: check for package managers
+    if Path('/usr/bin/apt').exists() or Path('/usr/bin/apt-get').exists():
+        return {'name': 'Debian-based Linux', 'family': 'debian'}
+    elif Path('/usr/bin/dnf').exists() or Path('/usr/bin/yum').exists():
+        return {'name': 'Fedora-based Linux', 'family': 'fedora'}
+
+    raise RuntimeError("Unable to detect Linux distribution")
+
+
+def get_package_manager(distribution: str) -> str:
+    """Get the package manager command for the distribution."""
+    if distribution == 'darwin':
+        return 'brew'
+    elif distribution == 'debian':
+        return 'apt'
+    elif distribution == 'fedora':
+        return 'dnf'
+    elif distribution == 'arch':
+        return 'pacman'
+    elif distribution == 'alpine':
+        return 'apk'
+    elif distribution == 'suse':
+        return 'zypper'
+    else:
+        raise ValueError(f"Unknown distribution: {distribution}")
+
+
+def check_command_exists(command: str) -> bool:
+    """Check if a command exists in PATH."""
+    return shutil.which(command) is not None
+
+
+def get_system_info() -> dict:
+    """Get comprehensive system information for logging."""
+    platform_info = detect_platform()
+
+    return {
+        'os_type': platform_info.os_type,
+        'os_name': platform_info.os_name,
+        'distribution': platform_info.distribution,
+        'architecture': platform_info.architecture,
+        'is_wsl': platform_info.is_wsl,
+        'python_version': platform.python_version(),
+        'platform': platform.platform(),
+    }