one-updater 0.0.8__tar.gz

one_updater-0.0.8/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.1
+Name: one-updater
+Version: 0.0.8
+Summary: One tool many packages
+Author: Tim Bryant
+Author-email: timothybryant3@gmail.com
+Requires-Python: >=3.11,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: click (>=8.1.7,<9.0.0)
+Requires-Dist: python-semantic-release (>=9.14.0,<10.0.0)
+Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
+Requires-Dist: rich (>=13.9.4,<14.0.0)
+Description-Content-Type: text/markdown
+
+# One Updater
+
+A flexible package manager updater that helps you keep all your development tools up to date.
+
+## Features
+
+- Update multiple package managers with a single command
+- Configure which package managers to update
+- Support for virtual environments and pyenv for Python packages
+- Beautiful command-line interface with rich formatting
+- Extensible architecture for adding new package managers
+
+## Supported Package Managers
+
+- Homebrew
+- pip (with virtualenv/pyenv support)
+- npm
+- cargo
+- gem
+- pipx
+- More coming soon!
+
+## Installation
+
+1. Clone the repository:
+
+```bash
+git clone https://github.com/yourusername/one-update.git
+cd one-update
+```
+
+2. Install dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+## Usage
+
+### Basic Usage
+
+Update all enabled package managers:
+
+```bash
+python -m one_update.cli update
+```
+
+Update specific package managers:
+
+```bash
+python -m one_update.cli update -m homebrew -m pip
+```
+
+List configured package managers:
+
+```bash
+python -m one_update.cli list-managers
+```
+
+### Configuration
+
+The tool uses a YAML configuration file (`config.yaml`) to specify package manager settings. You can:
+
+1. Enable/disable specific package managers
+2. Configure virtualenv/pyenv for Python packages
+3. Customize update commands
+4. Configure logging
+
+Example configuration:
+
+```yaml
+package_managers:
+  homebrew:
+    enabled: true
+    commands:
+      update: ["brew", "update"]
+      upgrade: ["brew", "upgrade"]
+
+  pip:
+    enabled: true
+    virtualenv: "/path/to/virtualenv" # Optional
+    pyenv: "3.11.0" # Optional
+    commands:
+      update: ["pip", "install", "--upgrade", "pip"]
+```
+
+## Contributing
+
+Contributions are welcome! Feel free to:
+
+1. Add support for new package managers
+2. Improve error handling and logging
+3. Add new features
+4. Fix bugs
+
+## License
+
+MIT License
+

one_updater-0.0.8/README.md

@@ -0,0 +1,98 @@
+# One Updater
+
+A flexible package manager updater that helps you keep all your development tools up to date.
+
+## Features
+
+- Update multiple package managers with a single command
+- Configure which package managers to update
+- Support for virtual environments and pyenv for Python packages
+- Beautiful command-line interface with rich formatting
+- Extensible architecture for adding new package managers
+
+## Supported Package Managers
+
+- Homebrew
+- pip (with virtualenv/pyenv support)
+- npm
+- cargo
+- gem
+- pipx
+- More coming soon!
+
+## Installation
+
+1. Clone the repository:
+
+```bash
+git clone https://github.com/yourusername/one-update.git
+cd one-update
+```
+
+2. Install dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+## Usage
+
+### Basic Usage
+
+Update all enabled package managers:
+
+```bash
+python -m one_update.cli update
+```
+
+Update specific package managers:
+
+```bash
+python -m one_update.cli update -m homebrew -m pip
+```
+
+List configured package managers:
+
+```bash
+python -m one_update.cli list-managers
+```
+
+### Configuration
+
+The tool uses a YAML configuration file (`config.yaml`) to specify package manager settings. You can:
+
+1. Enable/disable specific package managers
+2. Configure virtualenv/pyenv for Python packages
+3. Customize update commands
+4. Configure logging
+
+Example configuration:
+
+```yaml
+package_managers:
+  homebrew:
+    enabled: true
+    commands:
+      update: ["brew", "update"]
+      upgrade: ["brew", "upgrade"]
+
+  pip:
+    enabled: true
+    virtualenv: "/path/to/virtualenv" # Optional
+    pyenv: "3.11.0" # Optional
+    commands:
+      update: ["pip", "install", "--upgrade", "pip"]
+```
+
+## Contributing
+
+Contributions are welcome! Feel free to:
+
+1. Add support for new package managers
+2. Improve error handling and logging
+3. Add new features
+4. Fix bugs
+
+## License
+
+MIT License

one_updater-0.0.8/one_updater/__init__.py

@@ -0,0 +1,3 @@
+"""One Update - A flexible package manager updater."""
+
+__version__ = "0.1.0"

one_updater-0.0.8/one_updater/cli.py

@@ -0,0 +1,155 @@
+import logging
+from typing import Optional
+
+import click
+import yaml
+from rich.console import Console
+from rich.logging import RichHandler
+
+from one_updater import __version__
+from one_updater.package_managers.base import PackageManager
+from one_updater.package_managers.registry import PackageManagerRegistry
+
+console = Console()
+
+
+def setup_logging(config: dict):
+    """Setup logging configuration."""
+    logging.basicConfig(
+        level=config.get("logging", {}).get("level", "INFO"),
+        format=config.get("logging", {}).get("format", "%(message)s"),
+        handlers=[RichHandler(console=console)],
+    )
+
+
+def load_config(config_path: str) -> dict:
+    """Load configuration from YAML file."""
+    try:
+        with open(config_path, encoding="utf-8") as f:
+            return yaml.safe_load(f)
+    except Exception as e:
+        console.print(f"[red]Error loading config file: {e}[/red]")
+        return {}
+
+
+def get_package_manager(name: str, config: dict) -> Optional[PackageManager]:
+    """Get a package manager instance by name."""
+    try:
+        return PackageManagerRegistry.get_manager(name, config)
+    except ValueError as e:
+        logging.warning(str(e))
+        return None
+
+
+def run_package_manager_action(
+    name: str, cfg: dict, action_name: str, action_func, verbose: bool
+) -> None:
+    """Run a package manager action (update or upgrade) with proper console output."""
+    if not cfg.get("enabled", True):
+        return
+
+    # Check if the command is configured
+    commands = cfg.get("commands", {})
+
+    if action_name not in commands:
+        console.print(
+            f"[yellow]! {name} does not have a {action_name} command configured[/yellow]"
+        )
+        return
+
+    # Set verbose mode for this specific package manager
+    cfg["verbose"] = verbose
+
+    if pm := get_package_manager(name, cfg):
+        # strip e at end of action_name if it exists
+        action_name_without_e = action_name.title().rstrip("e")
+        console.print(f"\n[bold blue]{action_name_without_e}ing {name}...[/bold blue]")
+        if success := action_func(pm):
+            console.print(f"[green]✓ {name} {action_name}d successfully[/green]")
+        else:
+            console.print(f"[red]✗ {name} {action_name} failed[/red]")
+
+
+@click.group()
+@click.option("--config", "-c", default="config.yaml", help="Path to config file")
+@click.version_option(version=__version__, prog_name="one-updater")
+@click.pass_context
+def cli(ctx, config):
+    """One Update - Update all your package managers with one command."""
+    ctx.ensure_object(dict)
+    ctx.obj["config"] = load_config(config)
+    setup_logging(ctx.obj["config"])
+
+
+@cli.command()
+@click.option(
+    "--manager", "-m", multiple=True, help="Specific package manager(s) to update"
+)
+@click.option(
+    "--verbose", "-v", is_flag=True, help="Show verbose output from package managers"
+)
+@click.pass_context
+def update(ctx, manager, verbose):
+    """Update package manager indices/registries."""
+    config = ctx.obj["config"]
+    package_managers = config.get("package_managers", {})
+
+    # Filter package managers if specified
+    if manager:
+        # Check for requested managers that don't exist in config
+        for m in manager:
+            if m not in package_managers:
+                logging.warning(f"Package manager '{m}' is not defined in config")
+        package_managers = {k: v for k, v in package_managers.items() if k in manager}
+
+    with console.status("[bold green]Updating package managers...") as status:
+        for name, cfg in package_managers.items():
+            run_package_manager_action(
+                name, cfg, "update", lambda pm: pm.update(), verbose
+            )
+
+
+@cli.command()
+@click.option(
+    "--manager", "-m", multiple=True, help="Specific package manager(s) to upgrade"
+)
+@click.option(
+    "--verbose", "-v", is_flag=True, help="Show verbose output from package managers"
+)
+@click.pass_context
+def upgrade(ctx, manager, verbose):
+    """Upgrade all packages for specified package managers."""
+    config = ctx.obj["config"]
+    package_managers = config.get("package_managers", {})
+
+    # Filter package managers if specified
+    if manager:
+        # Check for requested managers that don't exist in config
+        for m in manager:
+            if m not in package_managers:
+                logging.warning(f"Package manager '{m}' is not defined in config")
+        package_managers = {k: v for k, v in package_managers.items() if k in manager}
+
+    with console.status("[bold green]Upgrading packages...") as status:
+        for name, cfg in package_managers.items():
+            run_package_manager_action(
+                name, cfg, "upgrade", lambda pm: pm.upgrade(), verbose
+            )
+
+
+@cli.command()
+@click.pass_context
+def list_managers(ctx):
+    """List all configured package managers and their status."""
+    config = ctx.obj["config"]
+    package_managers = config.get("package_managers", {})
+
+    console.print("\n[bold]Configured Package Managers:[/bold]")
+    for name, cfg in package_managers.items():
+        enabled = cfg.get("enabled", True)
+        status = "[green]enabled[/green]" if enabled else "[red]disabled[/red]"
+        console.print(f"  • {name}: {status}")
+
+
+if __name__ == "__main__":
+    cli(obj={})

one_updater-0.0.8/one_updater/package_managers/__init__.py

@@ -0,0 +1,33 @@
+from .apt import AptManager
+from .base import PackageManager
+from .basher import BasherManager
+from .brew import HomebrewManager
+from .cargo import CargoManager
+from .gem import GemManager
+from .ghcli import GhCliManager
+from .go import GoManager
+from .krew import KubectlKrewManager
+from .micro import MicroEditorManager
+from .npm import NpmManager
+from .pip import PipManager
+from .pipx import PipxManager
+from .pkgx import PkgxManager
+from .vagrant import VagrantPluginManager
+
+__all__ = [
+    "PackageManager",
+    "AptManager",
+    "BasherManager",
+    "HomebrewManager",
+    "CargoManager",
+    "GemManager",
+    "GhCliManager",
+    "GoManager",
+    "KubectlKrewManager",
+    "MicroEditorManager",
+    "NpmManager",
+    "PipManager",
+    "PipxManager",
+    "PkgxManager",
+    "VagrantPluginManager",
+]

one_updater-0.0.8/one_updater/package_managers/apt.py

@@ -0,0 +1,25 @@
+"""apt package manager implementation."""
+
+from .base import PackageManager
+
+
+class AptManager(PackageManager):
+    """Manager for apt packages."""
+
+    def is_available(self) -> bool:
+        """Check if apt is available."""
+        return self.run_command(["which", "apt"])
+
+    def update(self) -> bool:
+        """Update apt package lists."""
+        if not self._check_available("update"):
+            return False
+        return self.run_command(self.commands.get("update", ["sudo", "apt", "update"]))
+
+    def upgrade(self) -> bool:
+        """Upgrade apt packages."""
+        if not self._check_available("upgrade"):
+            return False
+        return self.run_command(
+            self.commands.get("upgrade", ["sudo", "apt", "upgrade", "-y"])
+        )

one_updater-0.0.8/one_updater/package_managers/base.py

@@ -0,0 +1,92 @@
+import logging
+import subprocess
+from abc import ABC, abstractmethod
+from typing import Optional
+
+
+class PackageManager(ABC):
+    """Base class for all package managers."""
+
+    def __init__(self, config: dict):
+        """Initialize the package manager with its configuration."""
+        self.config = config
+        self.enabled = config.get("enabled", True)
+        self.commands = config.get("commands", {})
+        self.verbose = config.get("verbose", False)
+
+    def run_command(self, command: list[str]) -> bool:
+        """Run a command and return True if it succeeded."""
+        if not command:
+            return True
+
+        try:
+            if self.verbose:
+                logging.info(f"Running command: {' '.join(command)}")
+            result = subprocess.run(
+                command,
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            if result.stdout:
+                logging.info(
+                    f"INFO - stdout from {' '.join(command)}:\n{result.stdout}"
+                )
+            return True
+        except subprocess.CalledProcessError as e:
+            if self.verbose:
+                logging.error(f"Command failed with exit code {e.returncode}")
+                if e.stdout:
+                    logging.error(f"stdout: {e.stdout}")
+                if e.stderr:
+                    logging.error(f"stderr: {e.stderr}")
+            if e.stdout:
+                logging.error(f"ERROR - stdout from {' '.join(command)}:\n{e.stdout}")
+            if e.stderr:
+                logging.error(f"ERROR - stderr from {' '.join(command)}:\n{e.stderr}")
+            return False
+
+    def run_command_with_output(
+        self, command: list[str]
+    ) -> tuple[bool, Optional[str], Optional[str]]:
+        """Run a command and return success status and output."""
+        try:
+            result = subprocess.run(
+                command,
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            return True, result.stdout, result.stderr
+        except subprocess.CalledProcessError as e:
+            return False, e.stdout, e.stderr
+
+    def _check_available(self, operation: str) -> bool:
+        """Check if package manager is available and log if not.
+
+        Args:
+            operation: Name of the operation being attempted (e.g., 'update', 'upgrade')
+
+        Returns:
+            bool: True if available, False if not
+        """
+        if not self.is_available():
+            manager_name = self.__class__.__name__.replace("Manager", "").lower()
+            logging.info(f"{manager_name} is not available. Skipping {operation}.")
+            return False
+        return True
+
+    @abstractmethod
+    def is_available(self) -> bool:
+        """Check if this package manager is available on the system."""
+        pass
+
+    @abstractmethod
+    def update(self) -> bool:
+        """Update package lists/indices."""
+        pass
+
+    @abstractmethod
+    def upgrade(self) -> bool:
+        """Upgrade installed packages."""
+        pass

one_updater-0.0.8/one_updater/package_managers/basher.py

@@ -0,0 +1,41 @@
+"""basher package manager implementation."""
+
+import logging
+import subprocess
+
+from .base import PackageManager
+
+
+class BasherManager(PackageManager):
+    def is_available(self) -> bool:
+        return self.run_command(["which", "basher"])
+
+    def update(self) -> bool:
+        """Update Homebrew package lists."""
+        if not self.is_available():
+            return False
+        return self.run_command(
+            self.commands.get("update", ["bash", "-c", "cd ~/.basher && git pull"])
+        )
+
+    def upgrade(self) -> bool:
+        if not self.is_available():
+            logging.info("basher is not installed. Skipping.")
+            return False
+
+        success = True
+        try:
+            result = subprocess.run(
+                ["basher", "outdated"], capture_output=True, text=True, check=True
+            )
+            outdated_packages = (
+                result.stdout.strip().split("\n") if result.stdout else []
+            )
+            upgrade_command = self.commands.get("upgrade", ["basher", "upgrade"])
+            for package in outdated_packages:
+                cmd = upgrade_command + [package]
+                success &= self.run_command(cmd)
+        except subprocess.CalledProcessError:
+            logging.error("Failed to get outdated basher packages")
+            success = False
+        return success

one_updater-0.0.8/one_updater/package_managers/brew.py

@@ -0,0 +1,22 @@
+"""Homebrew package manager implementation."""
+from .base import PackageManager
+
+
+class HomebrewManager(PackageManager):
+    """Manager for Homebrew packages."""
+
+    def is_available(self) -> bool:
+        """Check if Homebrew is installed."""
+        return self.run_command(["which", "brew"])
+
+    def update(self) -> bool:
+        """Update Homebrew package lists."""
+        if not self.is_available():
+            return False
+        return self.run_command(self.commands.get("update", ["brew", "update"]))
+
+    def upgrade(self) -> bool:
+        """Upgrade Homebrew packages."""
+        if not self.is_available():
+            return False
+        return self.run_command(self.commands.get("upgrade", ["brew", "upgrade"]))

one_updater-0.0.8/one_updater/package_managers/cargo.py

@@ -0,0 +1,65 @@
+"""cargo package manager implementation."""
+
+import logging
+import subprocess
+
+from .base import PackageManager
+
+
+class CargoManager(PackageManager):
+    """Manager for cargo packages."""
+
+    def is_available(self) -> bool:
+        """Check if cargo is available."""
+        return self.run_command(["which", "cargo"])
+
+    def update(self) -> bool:
+        """Update cargo package lists."""
+        if not self.is_available():
+            return False
+        return self.run_command(self.commands.get("update", ["rustup", "update"]))
+
+    def upgrade(self) -> bool:
+        """Upgrade cargo packages."""
+        if not self.is_available():
+            logging.info("cargo is not installed. Skipping.")
+            return False
+
+        success = True
+        # First update rustup
+        success &= self.run_command(self.commands.get("update", ["rustup", "update"]))
+
+        # Check if upgrade command is configured (even if empty list)
+        if "upgrade" not in self.commands:
+            logging.info("cargo upgrade command not configured. Skipping.")
+            return success
+
+        # Get list of installed packages
+        try:
+            result = subprocess.run(
+                ["cargo", "install", "--list"],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            # Parse output to get package names
+            # Output format is like:
+            # package-name v1.2.3:
+            #     package-name
+            packages = []
+            for line in result.stdout.split("\n"):
+                if ":" in line:  # This line contains a package name
+                    package = line.split(" ")[0].strip()
+                    packages.append(package)
+
+            # Update each package
+            for package in packages:
+                if self.verbose:
+                    logging.info(f"Updating cargo package: {package}")
+                success &= self.run_command(["cargo", "install", package])
+
+        except subprocess.CalledProcessError:
+            logging.error("Failed to list cargo packages")
+            success = False
+
+        return success

one_updater-0.0.8/one_updater/package_managers/gem.py

@@ -0,0 +1,32 @@
+"""gem package manager implementation."""
+
+import logging
+
+from .base import PackageManager
+
+
+class GemManager(PackageManager):
+    """Manager for gem packages."""
+
+    def is_available(self) -> bool:
+        """Check if gem is available."""
+        return self.run_command(["which", "gem"])
+
+    def update(self) -> bool:
+        """Update RubyGems system."""
+        if not self._check_available("update"):
+            return False
+        # First update RubyGems itself
+        success = self.run_command(
+            self.commands.get("update", ["gem", "update", "--system"])
+        )
+        if not success:
+            logging.error("Failed to update RubyGems system")
+        return success
+
+    def upgrade(self) -> bool:
+        """Upgrade installed gems."""
+        if not self._check_available("upgrade"):
+            return False
+        # Update all installed gems
+        return self.run_command(self.commands.get("upgrade", ["gem", "update"]))

one_updater-0.0.8/one_updater/package_managers/ghcli.py

@@ -0,0 +1,26 @@
+"""gh-cli package manager implementation."""
+from .base import PackageManager
+
+
+class GhCliManager(PackageManager):
+    """Manager for GitHub CLI."""
+
+    def is_available(self) -> bool:
+        """Check if gh is available."""
+        return self.run_command(["which", "gh"])
+
+    def update(self) -> bool:
+        """Update GitHub CLI."""
+        if not self.is_available():
+            return False
+        return self.run_command(
+            self.commands.get("update", ["gh", "extension", "upgrade", "--all"])
+        )
+
+    def upgrade(self) -> bool:
+        """Upgrade GitHub CLI extensions."""
+        if not self.is_available():
+            return False
+        return self.run_command(
+            self.commands.get("upgrade", ["gh", "extension", "upgrade", "--all"])
+        )

one_updater-0.0.8/one_updater/package_managers/go.py

@@ -0,0 +1,134 @@
+import logging
+import os
+import subprocess
+
+from .base import PackageManager
+
+
+class GoManager(PackageManager):
+    """Manager for Go packages."""
+
+    # Special case mappings for known tools that need specific module paths
+    SPECIAL_CASES: dict[str, str] = {
+        "staticcheck": "honnef.co/go/tools/cmd/staticcheck",
+    }
+
+    def is_available(self) -> bool:
+        """Check if Go is installed."""
+        return self.run_command(["which", "go"])
+
+    def update(self) -> bool:
+        """Go itself doesn't need updating, that's handled by the system package manager."""
+        return True
+
+    def upgrade(self) -> bool:
+        """Upgrade all globally installed Go packages."""
+        if not self.is_available():
+            logging.info("go is not installed. Skipping.")
+            return False
+
+        success = True
+        try:
+            # First try to get GOPATH
+            result = subprocess.run(
+                ["go", "env", "GOPATH"],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            gopath = result.stdout.strip() or os.path.expanduser(
+                "~/go"
+            )  # Default GOPATH
+            logging.info(f"Using GOPATH: {gopath}")
+
+            # Get list of binaries in GOPATH/bin
+            bin_dir = os.path.join(gopath, "bin")
+            if not os.path.exists(bin_dir):
+                logging.info(f"No Go binaries found in {bin_dir}")
+                return True
+
+            binaries = [
+                binary
+                for binary in os.listdir(bin_dir)
+                if not binary.startswith(".")
+                and os.path.isfile(os.path.join(bin_dir, binary))
+            ]
+            if not binaries:
+                logging.info("No Go binaries found to update")
+                return True
+
+            logging.info(f"Found Go binaries: {', '.join(binaries)}")
+
+            # For each binary, try to find its package and update it
+            for binary in binaries:
+                try:
+                    # Use go version -m to get module info
+                    binary_path = os.path.join(bin_dir, binary)
+                    logging.info(f"Getting module info for: {binary}")
+                    result = subprocess.run(
+                        ["go", "version", "-m", binary_path],
+                        capture_output=True,
+                        text=True,
+                        check=True,
+                    )
+                    logging.debug(f"Module info output:\n{result.stdout}")
+
+                    # Check special cases first
+                    if binary in self.SPECIAL_CASES:
+                        module_path = self.SPECIAL_CASES[binary]
+                        logging.info(
+                            f"Using special case path for {binary}: {module_path}"
+                        )
+                    else:
+                        module_path = next(
+                            (
+                                line.strip().split("\t")[1]
+                                for line in result.stdout.split("\n")
+                                if line.strip().startswith("mod\t")
+                            ),
+                            None,
+                        )
+
+                    if module_path:
+                        logging.info(f"Found module path: {module_path}")
+                        # Install latest version using direct subprocess call
+                        try:
+                            logging.info(f"Attempting to update {module_path}")
+                            result = subprocess.run(
+                                ["go", "install", f"{module_path}@latest"],
+                                capture_output=True,
+                                text=True,
+                                check=True,
+                            )
+                            # Check if there was meaningful stderr output
+                            if result.stderr and not (
+                                "go: downloading" in result.stderr
+                                or "go: found" in result.stderr
+                            ):
+                                logging.error(
+                                    f"Error updating {module_path}: {result.stderr}"
+                                )
+                                success = False
+                            else:
+                                if result.stdout:
+                                    logging.info(f"Update output: {result.stdout}")
+                                if result.stderr:
+                                    logging.info(f"Update info: {result.stderr}")
+                        except subprocess.CalledProcessError as e:
+                            logging.error(f"Failed to update {module_path}: {e.stderr}")
+                            success = False
+                    else:
+                        logging.warning(
+                            f"Could not determine package for binary: {binary}"
+                        )
+                except subprocess.CalledProcessError as e:
+                    logging.warning(
+                        f"Failed to get module info for {binary}: {e.stderr}"
+                    )
+                    success = False
+
+        except subprocess.CalledProcessError as e:
+            logging.error(f"Error during Go package updates: {e}")
+            success = False
+
+        return success

one_updater-0.0.8/one_updater/package_managers/krew.py

@@ -0,0 +1,26 @@
+"""kubectl-krew package manager implementation."""
+from .base import PackageManager
+
+
+class KubectlKrewManager(PackageManager):
+    """Manager for kubectl-krew packages."""
+
+    def is_available(self) -> bool:
+        """Check if kubectl-krew is available."""
+        return self.run_command(["which", "kubectl-krew"])
+
+    def update(self) -> bool:
+        """Update kubectl-krew package lists."""
+        if not self.is_available():
+            return False
+        return self.run_command(
+            self.commands.get("update", ["kubectl", "krew", "update"])
+        )
+
+    def upgrade(self) -> bool:
+        """Upgrade kubectl-krew packages."""
+        if not self.is_available():
+            return False
+        return self.run_command(
+            self.commands.get("upgrade", ["kubectl", "krew", "upgrade"])
+        )

one_updater-0.0.8/one_updater/package_managers/micro.py

@@ -0,0 +1,28 @@
+"""micro-editor package manager implementation."""
+
+from .base import PackageManager
+
+
+class MicroEditorManager(PackageManager):
+    """Manager for micro-editor packages."""
+
+    def is_available(self) -> bool:
+        """Check if micro is available."""
+        return self.run_command(["which", "micro"])
+
+    def update(self) -> bool:
+        """Update micro-editor package lists."""
+        if not self.is_available():
+            return False
+        return self.run_command(
+            self.commands.get("update", ["micro", "-plugin", "update"])
+        )
+
+    def upgrade(self) -> bool:
+        """Upgrade micro-editor packages."""
+        if not self.is_available():
+            return False
+        # Micro editor's plugin update command handles both update and upgrade
+        return self.run_command(
+            self.commands.get("upgrade", ["micro", "-plugin", "update"])
+        )

one_updater-0.0.8/one_updater/package_managers/npm.py

@@ -0,0 +1,23 @@
+"""npm package manager implementation."""
+from .base import PackageManager
+
+
+class NpmManager(PackageManager):
+    """Manager for npm packages."""
+
+    def is_available(self) -> bool:
+        """Check if npm is available."""
+        return self.run_command(["which", "npm"])
+
+    def update(self) -> bool:
+        """Update npm package lists."""
+        if not self.is_available():
+            return False
+        return self.run_command(self.commands.get("update", ["npm", "update", "-g"]))
+
+    def upgrade(self) -> bool:
+        """Upgrade npm packages."""
+        if not self.is_available():
+            return False
+        # npm update -g handles both update and upgrade
+        return self.run_command(self.commands.get("upgrade", ["npm", "update", "-g"]))

one_updater-0.0.8/one_updater/package_managers/pip.py

@@ -0,0 +1,114 @@
+"""pip package manager implementation."""
+
+import json
+import logging
+import subprocess
+from pathlib import Path
+
+from .base import PackageManager
+
+
+class PipManager(PackageManager):
+    """Manager for pip packages."""
+
+    def __init__(self, config: dict):
+        super().__init__(config)
+        self.virtualenv = config.get("virtualenv")
+        self.pyenv = config.get("pyenv")
+
+    def is_available(self) -> bool:
+        """Check if pip is available."""
+        return self.run_command(["which", "pip"])
+
+    def _get_pip_command(self) -> list[str]:
+        """Get the correct pip command based on virtualenv/pyenv settings."""
+        if self.virtualenv:
+            return [str(Path(self.virtualenv) / "bin" / "pip")]
+        return ["pip"]
+
+    def _check_available(self, operation: str) -> bool:
+        """Check if pip is available for the given operation."""
+        if not self.is_available():
+            logging.info(f"pip is not installed. Skipping {operation}.")
+            return False
+        return True
+
+    def update(self) -> bool:
+        """Update pip package lists.
+
+        pip doesn't have a separate update operation, as it checks PyPI
+        directly when installing or upgrading packages.
+        """
+        if not self._check_available("update"):
+            return False
+        # pip doesn't need a separate update operation
+        return self.run_command(self.commands.get("update", []))
+
+    def upgrade(self) -> bool:
+        """Upgrade pip packages."""
+        if not self._check_available("upgrade"):
+            return False
+
+        success = True
+        pip_cmd = self._get_pip_command()
+
+        try:
+            if self.verbose:
+                logging.info("Checking for outdated packages...")
+            # Get list of outdated packages using JSON format
+            result = subprocess.run(
+                pip_cmd + ["list", "--outdated", "--format=json"],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+
+            try:
+                packages = json.loads(result.stdout)
+                if not packages:
+                    logging.info("No outdated packages found.")
+                    return True
+
+                if self.verbose:
+                    package_names = [pkg["name"] for pkg in packages]
+                    logging.info(
+                        f"Found {len(packages)} outdated packages: {', '.join(package_names)}"
+                    )
+
+                # Upgrade each package
+                for package in packages:
+                    package_name = package["name"]
+                    if self.verbose:
+                        current_version = package.get("version", "unknown")
+                        latest_version = package.get("latest_version", "unknown")
+                        logging.info(
+                            f"Upgrading {package_name} from {current_version} to {latest_version}..."
+                        )
+
+                    try:
+                        upgrade_cmd = self.commands.get(
+                            "upgrade", pip_cmd + ["install", "--upgrade"]
+                        )
+                        if not self.run_command(upgrade_cmd + [package_name]):
+                            logging.error(f"Failed to upgrade {package_name}")
+                            success = False
+                    except Exception as e:
+                        logging.error(f"Error upgrading {package_name}: {e}")
+                        success = False
+
+            except json.JSONDecodeError as e:
+                logging.error(f"Failed to parse JSON output: {e}")
+                if self.verbose:
+                    logging.error(f"Raw output: {result.stdout}")
+                success = False
+
+        except subprocess.CalledProcessError as e:
+            logging.error(f"Error listing outdated packages: {e}")
+            if e.stderr:
+                logging.error(f"Error output: {e.stderr}")
+            success = False
+        except Exception as e:
+            logging.error(f"Unexpected error during pip upgrade: {e}")
+            success = False
+
+        return success

one_updater-0.0.8/one_updater/package_managers/pipx.py

@@ -0,0 +1,22 @@
+"""pipx package manager implementation."""
+from .base import PackageManager
+
+
+class PipxManager(PackageManager):
+    """Manager for pipx packages."""
+
+    def is_available(self) -> bool:
+        """Check if pipx is available."""
+        return self.run_command(["which", "pipx"])
+
+    def update(self) -> bool:
+        """Update pipx package lists."""
+        if not self.is_available():
+            return False
+        return self.run_command(self.commands.get("update", ["pipx", "upgrade-all"]))
+
+    def upgrade(self) -> bool:
+        """Upgrade pipx packages."""
+        if not self.is_available():
+            return False
+        return self.run_command(self.commands.get("upgrade", ["pipx", "upgrade-all"]))

one_updater-0.0.8/one_updater/package_managers/pkgx.py

@@ -0,0 +1,28 @@
+"""pkgx package manager implementation."""
+
+from .base import PackageManager
+
+
+class PkgxManager(PackageManager):
+    """Manager for pkgx packages."""
+
+    def is_available(self) -> bool:
+        """Check if pkgx is available."""
+        return self.run_command(["which", "pkgx"])
+
+    def update(self) -> bool:
+        """Update npm package lists."""
+        if not self.is_available():
+            return False
+        return self.run_command(
+            self.commands.get("update", ["pkgx", "mash", "pkgx/cache", "upgrade"])
+        )
+
+    def upgrade(self) -> bool:
+        """Upgrade npm packages."""
+        if not self.is_available():
+            return False
+        # npm update -g handles both update and upgrade
+        return self.run_command(
+            self.commands.get("upgrade", ["pkgx", "mash", "pkgx/cache", "upgrade"])
+        )

one_updater-0.0.8/one_updater/package_managers/registry.py

@@ -0,0 +1,49 @@
+"""Registry for package managers."""
+
+from .apt import AptManager
+from .base import PackageManager
+from .basher import BasherManager
+from .brew import HomebrewManager
+from .cargo import CargoManager
+from .gem import GemManager
+from .ghcli import GhCliManager
+from .go import GoManager
+from .krew import KubectlKrewManager
+from .micro import MicroEditorManager
+from .npm import NpmManager
+from .pip import PipManager
+from .pipx import PipxManager
+from .pkgx import PkgxManager
+from .snap import SnapManager
+from .tldr import TldrManager
+from .vagrant import VagrantPluginManager
+
+
+class PackageManagerRegistry:
+    """Registry for package managers."""
+
+    _managers: dict[str, type[PackageManager]] = {
+        "apt": AptManager,
+        "basher": BasherManager,
+        "brew": HomebrewManager,
+        "cargo": CargoManager,
+        "gem": GemManager,
+        "gh-cli": GhCliManager,
+        "go": GoManager,
+        "krew": KubectlKrewManager,
+        "micro": MicroEditorManager,
+        "npm": NpmManager,
+        "pip": PipManager,
+        "pipx": PipxManager,
+        "pkgx": PkgxManager,
+        "snap": SnapManager,
+        "tldr": TldrManager,
+        "vagrant": VagrantPluginManager,
+    }
+
+    @classmethod
+    def get_manager(cls, name: str, config: dict) -> PackageManager:
+        """Get a package manager instance by name."""
+        if name not in cls._managers:
+            raise ValueError(f"Unknown package manager: {name}")
+        return cls._managers[name](config)

one_updater-0.0.8/one_updater/package_managers/snap.py

@@ -0,0 +1,29 @@
+"""snap package manager implementation."""
+
+from .base import PackageManager
+
+
+class SnapManager(PackageManager):
+    """Manager for snap packages."""
+
+    def is_available(self) -> bool:
+        """Check if snap is available."""
+        return self.run_command(["which", "snap"])
+
+    def update(self) -> bool:
+        """Update snap package lists."""
+        if not self.is_available():
+            return False
+        # snap refresh handles both update and upgrade
+        return self.run_command(
+            self.commands.get("update", ["sudo", "snap", "refresh"])
+        )
+
+    def upgrade(self) -> bool:
+        """Upgrade snap packages."""
+        if not self.is_available():
+            return False
+        # snap refresh handles both update and upgrade
+        return self.run_command(
+            self.commands.get("upgrade", ["sudo", "snap", "refresh"])
+        )

one_updater-0.0.8/one_updater/package_managers/tldr.py

@@ -0,0 +1,24 @@
+"""tldr package manager implementation."""
+
+from .base import PackageManager
+
+
+class TldrManager(PackageManager):
+    """Manager for tldr pages."""
+
+    def is_available(self) -> bool:
+        """Check if tldr is available."""
+        return self.run_command(["which", "tldr"])
+
+    def update(self) -> bool:
+        """Update tldr pages cache."""
+        if not self.is_available():
+            return False
+        return self.run_command(self.commands.get("update", ["tldr", "--update"]))
+
+    def upgrade(self) -> bool:
+        """Upgrade tldr pages cache."""
+        if not self.is_available():
+            return False
+        # tldr --update handles both update and upgrade
+        return self.run_command(self.commands.get("upgrade", ["tldr", "--update"]))

one_updater-0.0.8/one_updater/package_managers/vagrant.py

@@ -0,0 +1,21 @@
+"""vagrant package manager implementation."""
+
+from .base import PackageManager
+
+
+class VagrantPluginManager(PackageManager):
+    """Manager for vagrant packages."""
+
+    def is_available(self) -> bool:
+        """Check if vagrant is available."""
+        return self.run_command(["which", "vagrant"])
+
+    def update(self) -> bool:
+        if not self.is_available():
+            return False
+        return self.run_command(["vagrant", "plugin", "update"])
+
+    def upgrade(self) -> bool:
+        if not self.is_available():
+            return False
+        return self.run_command(["vagrant", "plugin", "update"])

one_updater-0.0.8/pyproject.toml

@@ -0,0 +1,70 @@
+[tool.poetry]
+name = "one-updater"
+version = "0.0.8"
+description = "One tool many packages"
+authors = ["Tim Bryant <timothybryant3@gmail.com>"]
+readme = "README.md"
+packages = [{include = "one_updater", from = "."}]
+
+[tool.poetry.dependencies]
+python = "^3.11"
+click = "^8.1.7"
+pyyaml = "^6.0.2"
+rich = "^13.9.4"
+python-semantic-release = "^9.14.0"
+
+[tool.poetry.group.dev.dependencies]
+autopep8 = "^2.3.1"
+black = "^24.8.0"
+pytest = "^8.3.3"
+pre-commit = "^3.8.0"
+isort = "^5.13.2"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.pytest.ini_options]
+pythonpath = [
+  ".", "one_updater"
+]
+filterwarnings = [
+    "error",
+    "ignore::RuntimeWarning",
+    "ignore::DeprecationWarning",
+]
+
+[tool.poetry.scripts]
+one-updater = "one_updater.cli:cli"
+
+[tool.semantic_release.commit_parser_options]
+allowed_tags = [
+    "build",
+    "chore",
+    "refactor",
+    "fix",
+    "perf",
+    "style",
+    "docs",
+    "ci",
+    "test",
+    "feat",
+    ":boom:",
+    "BREAKING_CHANGE",
+]
+major_tags = [":boom:", "BREAKING_CHANGE"]
+minor_tags = ["feat"]
+patch_tags = ["fix", "perf", "style", "docs", "ci", "test", "refactor", "chore", "build"]
+
+[tool.semantic_release]
+version_toml = [
+    "pyproject.toml:tool.poetry.version",
+]
+branch = "main"
+changelog_file = "CHANGELOG.md"
+build_command = "poetry build"
+dist_path = "dist/"
+upload_to_vcs_release = true
+upload_to_pypi = false
+remove_dist = false
+patch_without_tag = true