aibox-cli 0.3.1__py3-none-any.whl

aibox/__init__.py

@@ -0,0 +1,12 @@
+"""aibox - Container-Based Multi-AI Development Environment."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("aibox-cli")
+except PackageNotFoundError:
+    # Package not installed, use fallback for development
+    __version__ = "0.0.0+dev"
+
+__author__ = "Your Name"
+__email__ = "your@email.com"

aibox/cli/__init__.py

@@ -0,0 +1,18 @@
+from aibox.cli.commands.config import config_edit, config_show, config_validate
+from aibox.cli.commands.init import init_command
+from aibox.cli.commands.profile import profile_info, profile_list
+from aibox.cli.commands.slot import slot_add, slot_cleanup, slot_list
+from aibox.cli.commands.status import status_command
+
+__all__ = [
+    "init_command",
+    "config_edit",
+    "config_show",
+    "config_validate",
+    "profile_info",
+    "profile_list",
+    "slot_add",
+    "slot_cleanup",
+    "slot_list",
+    "status_command",
+]

aibox/cli/autocomplete.py

@@ -0,0 +1,80 @@
+"""
+Autocompletion functions for aibox CLI.
+
+Provides custom autocompletion for dynamic values like profiles, providers, and slots.
+These functions are called by Typer when users press TAB in their shell.
+"""
+
+from pathlib import Path
+
+from aibox.containers.slot import SlotManager
+from aibox.profiles.loader import ProfileLoader
+from aibox.providers.registry import ProviderRegistry
+from aibox.utils.hash import get_project_storage_dir
+
+
+def complete_profile_name() -> list[str]:
+    """
+    Autocomplete profile names with versions.
+
+    Returns:
+        List of profile specifications (e.g., ["python", "python:3.11", "nodejs:20"])
+    """
+    try:
+        loader = ProfileLoader()
+        all_profiles = loader.list_profiles()
+
+        completions = []
+        for profile_name in all_profiles:
+            # Add base profile name
+            completions.append(profile_name)
+
+            # Add profile:version variants
+            try:
+                profile, _ = loader.load_profile(profile_name)
+                if profile.versions:
+                    for version in profile.versions:
+                        completions.append(f"{profile_name}:{version}")
+            except Exception:
+                # If we can't load profile details, just skip versions
+                pass
+
+        return sorted(completions)
+    except Exception:
+        # Fail gracefully if autocomplete fails
+        return []
+
+
+def complete_provider_name() -> list[str]:
+    """
+    Autocomplete AI provider names.
+
+    Returns:
+        List of provider names (e.g., ["claude", "gemini", "openai"])
+    """
+    try:
+        return ProviderRegistry.list_providers()
+    except Exception:
+        # Fail gracefully if autocomplete fails
+        return []
+
+
+def complete_slot_number() -> list[str]:
+    """
+    Autocomplete configured slot numbers for current project.
+
+    Returns:
+        List of configured slot numbers as strings (e.g., ["1", "2", "3"])
+    """
+    try:
+        project_root = Path.cwd()
+        storage_dir = get_project_storage_dir(project_root)
+        slot_manager = SlotManager(storage_dir)
+        slots = slot_manager.list_slots()
+
+        # Return slot numbers as strings (Typer expects strings)
+        return [str(slot["slot"]) for slot in slots]
+    except Exception:
+        # Fail gracefully if autocomplete fails
+        # Return all possible slots if we can't determine configured ones
+        return [str(i) for i in range(1, 11)]

aibox/cli/commands/__init__.py

@@ -0,0 +1,25 @@
+"""CLI command implementations for aibox."""
+
+from aibox.cli.commands.config import config_edit, config_show, config_validate
+from aibox.cli.commands.images import images_list, images_prune
+from aibox.cli.commands.init import init_command
+from aibox.cli.commands.profile import profile_info, profile_list
+from aibox.cli.commands.slot import slot_add, slot_cleanup, slot_list
+from aibox.cli.commands.start import start_command
+from aibox.cli.commands.status import status_command
+
+__all__ = [
+    "init_command",
+    "start_command",
+    "status_command",
+    "profile_list",
+    "profile_info",
+    "slot_list",
+    "slot_add",
+    "slot_cleanup",
+    "config_show",
+    "config_validate",
+    "config_edit",
+    "images_list",
+    "images_prune",
+]

aibox/cli/commands/config.py

@@ -0,0 +1,228 @@
+"""
+Configuration management commands.
+
+Provides commands to view and validate aibox configuration.
+"""
+
+import os
+import subprocess
+from pathlib import Path
+
+import yaml
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm
+from rich.syntax import Syntax
+
+from aibox.config.loader import get_project_config_path, load_config
+from aibox.containers.slot import SlotManager
+from aibox.utils.errors import ConfigNotFoundError, SlotNotFoundError
+from aibox.utils.hash import get_project_storage_dir
+
+console = Console()
+
+
+def config_show(project_root: Path, slot_number: int = 1) -> None:
+    """
+    Show current configuration.
+
+    Displays the merged global + project + slot configuration in YAML format.
+
+    Args:
+        project_root: Project root directory
+        slot_number: Slot number to show configuration for (default: 1)
+
+    Raises:
+        ConfigNotFoundError: If project configuration not found
+        SlotNotFoundError: If specified slot doesn't exist
+    """
+    try:
+        config = load_config(str(project_root))
+
+        # Build global config dict
+        config_dict = {
+            "global": {
+                "version": config.global_config.version,
+                "docker": {
+                    "base_image": config.global_config.docker.base_image,
+                    "default_resources": {
+                        "cpus": config.global_config.docker.default_resources.cpus,
+                        "memory": config.global_config.docker.default_resources.memory,
+                    },
+                },
+            },
+            "project": {
+                "name": config.project.name,
+                "profiles": config.project.profiles,
+                "mounts": [
+                    {"source": m.source, "target": m.target, "mode": m.mode}
+                    for m in config.project.mounts
+                ],
+                "environment": config.project.environment,
+            },
+        }
+
+        # Load slot configuration
+        storage_dir = get_project_storage_dir(project_root)
+        slot_manager = SlotManager(storage_dir)
+        slot_config = slot_manager.get_slot(slot_number)
+        slot_data = slot_config.load()
+
+        if slot_data is None:
+            raise SlotNotFoundError(
+                message=f"Slot {slot_number} not found",
+                suggestion="Available slots: Use 'aibox slot list' to see configured slots, or create a new slot with 'aibox slot add'",
+            )
+
+        # Add slot config to dict
+        config_dict["slot"] = {
+            "slot_number": slot_number,
+            **slot_data,
+        }
+
+        # Convert to YAML
+        yaml_content = yaml.dump(config_dict, default_flow_style=False, sort_keys=False)
+
+        # Syntax highlighting
+        syntax = Syntax(yaml_content, "yaml", theme="monokai", line_numbers=False)
+
+        # Show in panel with slot number
+        panel = Panel(
+            syntax,
+            title=f"[bold]aibox Configuration (Slot {slot_number})[/bold]",
+            border_style="blue",
+        )
+
+        console.print()
+        console.print(panel)
+        console.print()
+
+    except (ConfigNotFoundError, SlotNotFoundError):
+        raise
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise
+
+
+def config_validate(project_root: Path) -> None:
+    """
+    Validate configuration files.
+
+    Checks that configuration files are valid and can be loaded.
+
+    Args:
+        project_root: Project root directory
+    """
+    try:
+        console.print("\n[bold blue]Validating configuration...[/bold blue]\n")
+
+        with console.status("[cyan]Loading configuration...[/cyan]", spinner="dots"):
+            config = load_config(str(project_root))
+
+        # If we got here, config is valid
+        console.print("[bold green]✓[/bold green] Configuration is valid!\n")
+
+        # Show summary
+        console.print("[bold]Summary:[/bold]")
+        console.print(f"  • Project: [cyan]{config.project.name}[/cyan]")
+        console.print(f"  • Profiles: [cyan]{len(config.project.profiles)}[/cyan]")
+        console.print(f"  • Custom Mounts: [cyan]{len(config.project.mounts)}[/cyan]")
+        console.print()
+
+    except Exception as e:
+        console.print("\n[bold red]✗[/bold red] Configuration is invalid\n")
+        console.print(f"[red]Error:[/red] {e}\n")
+        raise SystemExit(1) from e
+
+
+def config_edit(project_root: Path) -> None:
+    """
+    Edit project configuration in your default editor.
+
+    Opens the project config file from ~/.aibox/projects/<hash>/config.yml
+    in the editor specified by $EDITOR or $VISUAL environment variable.
+    After editing, validates the configuration and prompts to re-edit if invalid.
+
+    Args:
+        project_root: Project root directory
+
+    Raises:
+        ConfigNotFoundError: If project is not initialized
+        SystemExit: If user aborts or validation fails
+    """
+    try:
+        # Get project config path from centralized storage
+        config_path = get_project_config_path(project_root)
+        if not config_path.exists():
+            raise ConfigNotFoundError(
+                "No project configuration found",
+                suggestion="Run 'aibox init' to initialize this project first",
+            )
+
+        # Get editor from environment
+        editor = os.environ.get("EDITOR") or os.environ.get("VISUAL") or "nano"
+
+        console.print(f"\n[bold blue]Opening config in {editor}...[/bold blue]\n")
+
+        # Open editor in a loop to allow re-editing on validation failure
+        while True:
+            # Open the config file in the editor
+            try:
+                result = subprocess.run([editor, str(config_path)], check=False)
+                if result.returncode != 0:
+                    console.print(
+                        f"\n[yellow]Editor exited with code {result.returncode}[/yellow]\n"
+                    )
+            except FileNotFoundError:
+                console.print(f"\n[red]Error:[/red] Editor '{editor}' not found\n")
+                console.print(
+                    "Set $EDITOR or $VISUAL environment variable to your preferred editor\n"
+                )
+                raise SystemExit(1) from None
+            except Exception as e:
+                console.print(f"\n[red]Error:[/red] Failed to open editor: {e}\n")
+                raise SystemExit(1) from e
+
+            # Validate the edited configuration
+            console.print("\n[bold blue]Validating configuration...[/bold blue]\n")
+
+            try:
+                with console.status("[cyan]Loading configuration...[/cyan]", spinner="dots"):
+                    config = load_config(str(project_root))
+
+                # Configuration is valid
+                console.print("[bold green]✓[/bold green] Configuration is valid!\n")
+
+                # Show summary
+                console.print("[bold]Updated configuration:[/bold]")
+                console.print(f"  • Project: [cyan]{config.project.name}[/cyan]")
+                console.print(
+                    f"  • Profiles: [cyan]{', '.join(config.project.profiles) if config.project.profiles else 'none'}[/cyan]"
+                )
+                console.print()
+
+                break  # Exit the loop, config is valid
+
+            except Exception as e:
+                # Configuration is invalid
+                console.print("[bold red]✗[/bold red] Configuration is invalid\n")
+                console.print(f"[red]Error:[/red] {e}\n")
+
+                # Ask if user wants to re-edit
+                retry = Confirm.ask(
+                    "[yellow]Would you like to edit the configuration again?[/yellow]",
+                    default=True,
+                )
+
+                if not retry:
+                    console.print("\n[yellow]Aborted[/yellow]\n")
+                    raise SystemExit(1) from e
+
+                # Loop continues to re-edit
+
+    except ConfigNotFoundError:
+        # Re-raise to be handled by main error handler
+        raise
+    except KeyboardInterrupt:
+        console.print("\n\n[yellow]Aborted by user[/yellow]\n")
+        raise SystemExit(130) from None

aibox/cli/commands/images.py

@@ -0,0 +1,173 @@
+"""
+Image management commands.
+
+Provides commands to list and prune Docker images created by aibox.
+"""
+
+from pathlib import Path
+
+from rich.console import Console
+from rich.table import Table
+
+from aibox.containers.manager import ContainerManager
+from aibox.utils.errors import DockerNotFoundError
+from aibox.utils.hash import get_project_storage_dir
+
+console = Console()
+
+
+def images_list(project_root: Path) -> None:
+    """
+    List all aibox Docker images for the current project.
+
+    Shows a table with image tags, sizes, and creation dates.
+
+    Args:
+        project_root: Project root directory
+    """
+    try:
+        # Initialize container manager
+        try:
+            container_manager = ContainerManager()
+        except DockerNotFoundError as e:
+            console.print(f"\n[red]✗[/red] {e.message}\n")
+            console.print(f"[bold]💡 Solution:[/bold] {e.suggestion}\n")
+            return
+
+        # Get project name from storage directory
+        storage_dir = get_project_storage_dir(project_root)
+        storage_dir_name = Path(storage_dir).name
+        project_name = storage_dir_name.rsplit("-", 1)[0] if "-" in storage_dir_name else "aibox"
+
+        # List images with project name filter
+        filters = {"reference": f"aibox-{project_name}-*"}
+        images = container_manager.list_images(filters=filters)
+
+        if not images:
+            console.print(
+                f"\n[yellow]No aibox images found for project '{project_name}'[/yellow]\n"
+            )
+            console.print(
+                "[dim]Images are created automatically when you run 'aibox start'[/dim]\n"
+            )
+            return
+
+        # Create table
+        table = Table(title=f"[bold]aibox Images - {project_name}[/bold]", show_lines=False)
+        table.add_column("Tag", style="cyan", no_wrap=True)
+        table.add_column("Image ID", style="dim", no_wrap=True)
+        table.add_column("Size", style="green", justify="right")
+        table.add_column("Created", style="yellow")
+
+        total_size = 0
+        for image in images:
+            # Get all tags for this image
+            tags = image.tags if image.tags else ["<none>:<none>"]
+
+            # Get image details
+            image_id = image.short_id.replace("sha256:", "")
+            size_bytes = image.attrs.get("Size", 0)
+            size_mb = size_bytes / (1024 * 1024)
+            total_size += size_bytes
+
+            # Get created date
+            created = image.attrs.get("Created", "N/A")
+            if created != "N/A":
+                # Parse and format date
+                from datetime import datetime
+
+                try:
+                    created_dt = datetime.fromisoformat(created.replace("Z", "+00:00"))
+                    created = created_dt.strftime("%Y-%m-%d %H:%M")
+                except Exception:
+                    pass
+
+            # Add row for each tag
+            for tag in tags:
+                # Highlight hash tags vs :latest
+                tag_display = f"[bold]{tag}[/bold]" if ":latest" in tag else tag
+
+                table.add_row(
+                    tag_display,
+                    image_id,
+                    f"{size_mb:.1f} MB",
+                    created,
+                )
+
+        console.print()
+        console.print(table)
+
+        # Show summary
+        total_size_mb = total_size / (1024 * 1024)
+        console.print(
+            f"\n[dim]Total images: {len(images)} | Total size: {total_size_mb:.1f} MB[/dim]\n"
+        )
+
+        # Show hint about cleanup
+        console.print("[dim]💡 Run [cyan]aibox images prune[/cyan] to remove unused images[/dim]\n")
+
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise
+
+
+def images_prune(project_root: Path | None = None, all_projects: bool = False) -> None:
+    """
+    Prune dangling aibox Docker images.
+
+    Removes images with <none> tags that are no longer needed.
+
+    Args:
+        project_root: Project root directory (optional for project-specific pruning)
+        all_projects: If True, prune dangling images for all aibox projects
+    """
+    try:
+        # Initialize container manager
+        try:
+            container_manager = ContainerManager()
+        except DockerNotFoundError as e:
+            console.print(f"\n[red]✗[/red] {e.message}\n")
+            console.print(f"[bold]💡 Solution:[/bold] {e.suggestion}\n")
+            return
+
+        # Determine scope
+        if all_projects or project_root is None:
+            console.print("\n[bold blue]Pruning dangling aibox images...[/bold blue]\n")
+            filters = None  # Prune all dangling images
+        else:
+            # Get project name for filtering
+            storage_dir = get_project_storage_dir(project_root)
+            storage_dir_name = Path(storage_dir).name
+            project_name = (
+                storage_dir_name.rsplit("-", 1)[0] if "-" in storage_dir_name else "aibox"
+            )
+            console.print(
+                f"\n[bold blue]Pruning dangling images for project '{project_name}'...[/bold blue]\n"
+            )
+            filters = None  # Docker doesn't support reference filter for prune
+
+        # Prune images
+        with console.status(
+            "[cyan]Removing dangling images...[/cyan]",
+            spinner="dots",
+        ):
+            result = container_manager.prune_dangling_images(filters=filters)
+
+        images_deleted = result.get("ImagesDeleted") or []
+        space_reclaimed = result.get("SpaceReclaimed", 0)
+        space_mb = space_reclaimed / (1024 * 1024)
+
+        if images_deleted:
+            console.print(
+                f"[bold green]✓[/bold green] Removed {len(images_deleted)} dangling image(s)\n"
+            )
+            console.print(f"[dim]Space reclaimed: {space_mb:.1f} MB[/dim]\n")
+        else:
+            console.print("[green]✓[/green] No dangling images to remove\n")
+
+    except KeyboardInterrupt:
+        console.print("\n\n[yellow]⚠[/yellow]  Cancelled by user\n")
+        raise SystemExit(1) from None
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise