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

voice_mode_install-7.4.0.dist-info/METADATA

@@ -0,0 +1,192 @@
+Metadata-Version: 2.4
+Name: voice-mode-install
+Version: 7.4.0
+Summary: Installer for VoiceMode - handles system dependencies and installation
+Project-URL: Homepage, https://github.com/mbailey/voicemode
+Project-URL: Repository, https://github.com/mbailey/voicemode
+Project-URL: Issues, https://github.com/mbailey/voicemode/issues
+Author-email: mbailey <mbailey@example.com>
+License: MIT
+Keywords: installer,mcp,setup,voice,voicemode
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: System :: Installation/Setup
+Requires-Python: >=3.10
+Requires-Dist: click>=8.0.0
+Requires-Dist: psutil>=5.9.0
+Requires-Dist: pyyaml>=6.0.0
+Description-Content-Type: text/markdown
+
+# voice-mode-install
+
+A standalone installer package for VoiceMode that handles system dependency detection and installation.
+
+## Overview
+
+`voice-mode-install` simplifies the VoiceMode installation process by:
+
+1. **Detecting your platform** - Identifies your OS, distribution, and architecture
+2. **Checking dependencies** - Scans for required system packages
+3. **Installing packages** - Uses your system's package manager (apt, dnf, brew)
+4. **Installing VoiceMode** - Runs `uv tool install voice-mode`
+5. **Hardware recommendations** - Suggests optimal configuration for your system
+6. **Logging everything** - Saves installation logs for troubleshooting
+
+## Quick Start
+
+```bash
+# Install and run
+uvx voice-mode-install
+
+# Dry run (see what would be installed)
+uvx voice-mode-install --dry-run
+
+# Install specific version
+uvx voice-mode-install --voice-mode-version=5.1.3
+
+# Skip service installation
+uvx voice-mode-install --skip-services
+
+# Non-interactive mode
+uvx voice-mode-install --non-interactive
+```
+
+## Prerequisites
+
+- **uv** - Required to run the installer (`curl -LsSf https://astral.sh/uv/install.sh | sh`)
+- **Python 3.10+** - Usually pre-installed on modern systems
+- **sudo access** - Needed to install system packages (Linux)
+- **Homebrew** (macOS) - The installer will offer to install it if missing
+
+## Supported Platforms
+
+- **macOS** - Intel and Apple Silicon (via Homebrew)
+- **Ubuntu/Debian** - Using apt package manager
+- **Fedora/RHEL** - Using dnf package manager
+
+## Features
+
+### Phase 1 (Included)
+
+✅ **Dry-run Mode** - Preview what will be installed
+✅ **Installation Logging** - Detailed logs saved to `~/.voicemode/install.log`
+✅ **Shell Completion** - Auto-configures tab completion for bash/zsh
+✅ **Health Check** - Verifies installation after completion
+✅ **Version Pinning** - Install specific VoiceMode versions
+✅ **Hardware Detection** - Recommends optimal setup for your system
+✅ **Homebrew Auto-Install** - Offers to install Homebrew on macOS if missing
+
+### Phase 2 (Future)
+
+⏱️ Config Validation - Check for conflicting settings
+⏱️ Uninstall Support - Clean removal of VoiceMode
+
+## How It Works
+
+1. **Platform Detection** - Identifies OS, distribution, and architecture
+2. **Dependency Checking** - Compares installed packages against `dependencies.yaml`
+3. **Package Manager Setup** (macOS only) - Checks for Homebrew and offers to install if missing
+4. **Package Installation** - Uses platform-specific package managers:
+   - macOS: `brew install` (installs Homebrew first if needed)
+   - Ubuntu/Debian: `sudo apt install`
+   - Fedora: `sudo dnf install`
+5. **VoiceMode Installation** - Runs `uv tool install voice-mode[==version]`
+6. **Post-Install** - Configures shell completion and verifies installation
+
+## Installation Logs
+
+Logs are saved to `~/.voicemode/install.log` in JSONL format:
+
+```json
+{"timestamp": "2025-10-12T10:30:00", "type": "start", "message": "Installation started"}
+{"timestamp": "2025-10-12T10:30:15", "type": "check", "message": "Checked core dependencies"}
+{"timestamp": "2025-10-12T10:30:45", "type": "install", "message": "Successfully installed system packages"}
+{"timestamp": "2025-10-12T10:31:30", "type": "complete", "message": "Installation completed"}
+```
+
+## Troubleshooting
+
+### VoiceMode command not found after installation
+
+Restart your shell or run:
+```bash
+source ~/.bashrc  # or ~/.zshrc for zsh
+```
+
+### Permission denied during package installation
+
+The installer needs sudo access to install system packages. Run:
+```bash
+sudo -v  # Refresh sudo credentials
+uvx voice-mode-install
+```
+
+### Network errors during installation
+
+- Check your internet connection
+- Try again with: `uvx voice-mode-install`
+- Use `uvx --refresh voice-mode-install` to get the latest installer
+
+### Installation hangs or fails
+
+1. Check the log file: `~/.voicemode/install.log`
+2. Try a dry run: `uvx voice-mode-install --dry-run`
+3. Report issues with log file attached
+
+## Development
+
+### Building from Source
+
+```bash
+cd installer/
+uv build
+```
+
+### Testing Locally
+
+```bash
+cd installer/
+uv pip install -e .
+voice-mode-install --dry-run
+```
+
+### Project Structure
+
+```
+installer/
+├── pyproject.toml          # Package definition
+├── voicemode_install/
+│   ├── __init__.py        # Version and exports
+│   ├── cli.py             # Main CLI entry point
+│   ├── system.py          # Platform detection
+│   ├── checker.py         # Dependency checking
+│   ├── installer.py       # Package installation
+│   ├── hardware.py        # Hardware detection
+│   ├── logger.py          # Installation logging
+│   └── dependencies.yaml  # System dependencies
+└── README.md
+```
+
+## Design Decisions
+
+See `DECISIONS.md` in the task directory for detailed rationale behind:
+- Version management strategy
+- Dependency synchronization approach
+- Error handling philosophy
+- Platform coverage priorities
+- Service installation scope
+
+## Contributing
+
+This installer is part of the [VoiceMode](https://github.com/mbailey/voicemode) project.
+
+## License
+
+MIT License - Same as VoiceMode

voice_mode_install-7.4.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+voicemode_install/__init__.py,sha256=_giwAMYtVyzpItm8m9Ebmfw1THrAAqGjNpRQQohRRs0,287
+voicemode_install/checker.py,sha256=DQLIcbNLagkqWG10xyJ-5aH5IuBRoU7X4ZUfcD6M8yw,7314
+voicemode_install/cli.py,sha256=YrK1dlpRD7IS-U4HOnvVR9zkXnScUPzrOnVt8oOeets,19740
+voicemode_install/dependencies.yaml,sha256=v9EIa4yMnnDoqZtt8jcp_9XSdqOVjr6lAFOVb7c-jw0,13149
+voicemode_install/hardware.py,sha256=j4bDv1v8bqyhiysWsTD4F-qEJRG-a8Z1o-qPfxofQt4,3529
+voicemode_install/installer.py,sha256=rd4v4HcSGQek-Ta__dV8IG1apaDRtERB08eGEp_9gwQ,5399
+voicemode_install/logger.py,sha256=UpNegF2D-y-7RthzhzSFMiHPRaFV09F2AUxgjm5b2Pw,2859
+voicemode_install/system.py,sha256=8RBJOPH331EBM8zFYySG2c-zZLpQgPmcGWRMZ6NmUp4,5108
+voice_mode_install-7.4.0.dist-info/METADATA,sha256=J8qpO3HijOT6031FXGJ2zeztHlUzgQ09AF9osr_JKjw,6227
+voice_mode_install-7.4.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+voice_mode_install-7.4.0.dist-info/entry_points.txt,sha256=q6994IQ1Ex4weqoPy9VrL_k7NuKSG5wgaY-_hQjzjnc,66
+voice_mode_install-7.4.0.dist-info/RECORD,,

voice_mode_install-7.4.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

voice_mode_install-7.4.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+voice-mode-install = voicemode_install.cli:main

voicemode_install/__init__.py

@@ -0,0 +1,8 @@
+"""VoiceMode Installer - System dependency management and installation."""
+
+try:
+    from importlib.metadata import version
+    __version__ = version("voice-mode-install")
+except Exception:
+    # Fallback to version from pyproject.toml if package not installed
+    __version__ = "5.1.6"

voicemode_install/checker.py

@@ -0,0 +1,200 @@
+"""Dependency checking logic."""
+
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Optional
+
+import yaml
+
+from .system import PlatformInfo, check_command_exists
+
+
+@dataclass
+class PackageInfo:
+    """Information about a system package."""
+
+    name: str
+    description: str
+    required: bool
+    installed: bool
+    check_command: Optional[str] = None
+    min_version: Optional[str] = None
+    note: Optional[str] = None
+
+
+class DependencyChecker:
+    """Check system dependencies against dependencies.yaml."""
+
+    def __init__(self, platform_info: PlatformInfo):
+        self.platform = platform_info
+        self.dependencies = self._load_dependencies()
+
+    def _load_dependencies(self) -> dict:
+        """Load dependencies from bundled YAML file."""
+        deps_file = Path(__file__).parent / 'dependencies.yaml'
+        with open(deps_file) as f:
+            return yaml.safe_load(f)
+
+    def check_core_dependencies(self) -> List[PackageInfo]:
+        """Check core VoiceMode dependencies."""
+        return self._check_component_dependencies('core')
+
+    def check_whisper_dependencies(self) -> List[PackageInfo]:
+        """Check Whisper STT dependencies."""
+        return self._check_component_dependencies('whisper')
+
+    def check_kokoro_dependencies(self) -> List[PackageInfo]:
+        """Check Kokoro TTS dependencies."""
+        return self._check_component_dependencies('kokoro')
+
+    def _check_component_dependencies(self, component: str) -> List[PackageInfo]:
+        """Check dependencies for a specific component."""
+        packages = []
+
+        # Get the component section
+        voicemode_deps = self.dependencies.get('voicemode', {})
+        component_deps = voicemode_deps.get(component, {})
+
+        if not component_deps:
+            return packages
+
+        # Check common packages first (all platforms)
+        if 'common' in component_deps:
+            packages.extend(self._check_packages(component_deps['common'].get('packages', [])))
+
+        # Check platform-specific packages
+        if self.platform.distribution in component_deps:
+            platform_packages = component_deps[self.platform.distribution].get('packages', [])
+            packages.extend(self._check_packages(platform_packages))
+
+        return packages
+
+    def _check_packages(self, package_list: List[dict]) -> List[PackageInfo]:
+        """Check a list of packages and return their status."""
+        results = []
+
+        for pkg_dict in package_list:
+            name = pkg_dict.get('name')
+            if not name:
+                continue
+
+            description = pkg_dict.get('description', '')
+            required = pkg_dict.get('required', True)
+            check_command = pkg_dict.get('check_command')
+            min_version = pkg_dict.get('min_version')
+            note = pkg_dict.get('note')
+
+            # Handle WSL-specific requirements
+            if required == 'wsl':
+                required = self.platform.is_wsl
+
+            # Check if package is installed
+            installed = self._is_package_installed(name, check_command)
+
+            results.append(PackageInfo(
+                name=name,
+                description=description,
+                required=bool(required),
+                installed=installed,
+                check_command=check_command,
+                min_version=min_version,
+                note=note
+            ))
+
+        return results
+
+    def _is_package_installed(self, package_name: str, check_command: Optional[str] = None) -> bool:
+        """Check if a package is installed."""
+        # If a check command is provided, use it
+        if check_command:
+            return self._run_check_command(check_command)
+
+        # Otherwise, use package manager-specific checks
+        if self.platform.distribution == 'darwin':
+            return self._check_homebrew_package(package_name)
+        elif self.platform.distribution == 'debian':
+            return self._check_apt_package(package_name)
+        elif self.platform.distribution == 'fedora':
+            return self._check_dnf_package(package_name)
+        else:
+            # Fallback: check if command exists
+            return check_command_exists(package_name)
+
+    def _run_check_command(self, command: str) -> bool:
+        """Run a check command and return whether it succeeded."""
+        try:
+            subprocess.run(
+                command,
+                shell=True,
+                capture_output=True,
+                check=True,
+                timeout=5
+            )
+            return True
+        except (subprocess.CalledProcessError, subprocess.TimeoutExpired):
+            return False
+
+    def _check_homebrew_package(self, package_name: str) -> bool:
+        """Check if a Homebrew package is installed."""
+        try:
+            subprocess.run(
+                ['brew', 'list', package_name],
+                capture_output=True,
+                check=True
+            )
+            return True
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            return False
+
+    def _check_apt_package(self, package_name: str) -> bool:
+        """Check if an apt package is installed."""
+        try:
+            result = subprocess.run(
+                ['dpkg', '-l', package_name],
+                capture_output=True,
+                text=True
+            )
+            # dpkg -l returns 0 even if package not found, check output
+            # Look for lines starting with "ii" (installed) followed by the exact package name
+            # Note: On ARM64 and other architectures, dpkg may include :arch suffix (e.g., python3-dev:arm64)
+            for line in result.stdout.splitlines():
+                parts = line.split()
+                if len(parts) >= 2 and parts[0] == 'ii':
+                    # Strip architecture suffix (e.g., :arm64) if present for comparison
+                    pkg_name_in_output = parts[1].split(':')[0]
+                    if pkg_name_in_output == package_name:
+                        return True
+            return False
+        except FileNotFoundError:
+            return False
+
+    def _check_dnf_package(self, package_name: str) -> bool:
+        """Check if a dnf/yum package is installed."""
+        try:
+            subprocess.run(
+                ['rpm', '-q', package_name],
+                capture_output=True,
+                check=True
+            )
+            return True
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            return False
+
+    def get_missing_packages(self, packages: List[PackageInfo]) -> List[PackageInfo]:
+        """Filter to only required packages that are not installed."""
+        return [pkg for pkg in packages if pkg.required and not pkg.installed]
+
+    def get_summary(self, packages: List[PackageInfo]) -> dict:
+        """Get a summary of package status."""
+        total = len(packages)
+        required = sum(1 for pkg in packages if pkg.required)
+        installed = sum(1 for pkg in packages if pkg.installed)
+        missing_required = sum(1 for pkg in packages if pkg.required and not pkg.installed)
+
+        return {
+            'total': total,
+            'required': required,
+            'installed': installed,
+            'missing_required': missing_required
+        }