max-cli 0.2.0__py3-none-any.whl

max_cli/main.py

@@ -0,0 +1,91 @@
+import typer
+import sys
+from rich.console import Console
+
+# Import interfaces
+from max_cli.interface import (
+    cli_images,
+    cli_files,
+    cli_pdf,
+    cli_ai,
+    cli_media,
+    cli_network,
+    cli_tools,
+    cli_config,
+)  # <--- Import this
+from max_cli.common.exceptions import MaxError
+
+# Initialize Console directly here to ensure it's available for the crash handler
+console = Console()
+
+app = typer.Typer(
+    name="max",
+    help="MAX: The High-Performance CLI Utility.",
+    add_completion=True,
+    no_args_is_help=True,
+)
+
+# --- 1. Register Commands with Aliases ---
+# We register 'images' AND 'img' so users can type less.
+app.add_typer(
+    cli_images.app, name="images", help="Compress, resize, and convert images."
+)
+app.add_typer(cli_images.app, name="img", hidden=True)  # Hidden alias
+
+app.add_typer(cli_files.app, name="files", help="Organize and bulk-rename files.")
+app.add_typer(cli_files.app, name="file", hidden=True)  # Hidden alias
+
+app.add_typer(cli_pdf.app, name="pdf", help="Merge, split, and compress PDFs.")
+
+# Register Video/Audio
+app.add_typer(
+    cli_media.app, name="video", help="Compress, convert, and process video/audio."
+)
+app.add_typer(cli_media.app, name="v", hidden=True)  # Short alias
+
+app.add_typer(cli_network.app, name="net", help="Network tools (Download, Speedtest).")
+
+app.add_typer(cli_ai.app, name="ai", help="Ask AI to run commands.")
+
+# Create a top-level shortcut because 'max grab' is very common
+app.command("grab")(cli_network.download_media)
+
+# Register the group (optional, if you want 'max tools share')
+app.add_typer(cli_tools.app, name="tools", help="System utilities (Clipboard, QR).")
+
+# Register config commands
+app.add_typer(cli_config.app, name="config", help="Manage API keys and settings.")
+
+# Register top-level Shortcuts (The "Lazy" Way)
+# This allows 'max share' instead of 'max tools share'
+app.command("share")(cli_tools.share_qr)
+app.command("paste")(cli_tools.paste_image)
+app.command("copy")(cli_tools.copy_file)
+
+# --- CRITICAL LINKING STEP ---
+# Give the AI module access to this app instance so it can read the docs
+cli_ai.MAIN_APP_REF = app
+
+
+def main():
+    """
+    Main entry point with Global Error Handling.
+    """
+    try:
+        app()
+    except MaxError as e:
+        # Expected errors (User mistake, missing file)
+        console.print(f"[bold red]✖ Error:[/bold red] {e}")
+        sys.exit(1)
+    except Exception as e:
+        # Unexpected crashes (Bugs)
+        console.print("[bold red]💥 Critical Error (Unexpected)[/bold red]")
+        console.print(f"An error occurred: {e}")
+        console.print("[dim]If this persists, please report it to the developer.[/dim]")
+        # Uncomment the next line during development to see the full stack trace:
+        # raise e
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

max_cli/plugins/__init__.py

@@ -0,0 +1,4 @@
+from max_cli.plugins.base import CLIPlugin, EnginePlugin, Plugin
+from max_cli.plugins.manager import PluginManager
+
+__all__ = ["CLIPlugin", "EnginePlugin", "Plugin", "PluginManager"]

max_cli/plugins/base.py

@@ -0,0 +1,39 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class Plugin(ABC):
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        pass
+
+    @property
+    @abstractmethod
+    def version(self) -> str:
+        pass
+
+    @property
+    def description(self) -> str:
+        return ""
+
+    @abstractmethod
+    def register(self, app: Any) -> None:
+        pass
+
+    def unregister(self, app: Any) -> None:
+        pass
+
+
+class CLIPlugin(Plugin):
+    @property
+    def command_name(self) -> str:
+        return self.name.replace("-", "_").replace(" ", "_").lower()
+
+    @property
+    def help_text(self) -> str:
+        return self.description
+
+
+class EnginePlugin(Plugin):
+    pass

max_cli/plugins/manager.py

@@ -0,0 +1,81 @@
+import importlib
+import importlib.util
+import logging
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Type
+
+from max_cli.plugins.base import Plugin
+
+logger = logging.getLogger(__name__)
+
+
+class PluginManager:
+    def __init__(self, plugin_dirs: Optional[List[Path]] = None):
+        self._plugins: Dict[str, Plugin] = {}
+        self._plugin_dirs = plugin_dirs or self._get_default_plugin_dirs()
+
+    def _get_default_plugin_dirs(self) -> List[Path]:
+        dirs = [
+            Path.home() / ".max_cli" / "plugins",
+            Path.cwd() / "plugins",
+        ]
+        return [d for d in dirs if d.exists()]
+
+    def discover_plugins(self) -> List[Type[Plugin]]:
+        plugins: List[Type[Plugin]] = []
+        for plugin_dir in self._plugin_dirs:
+            if not plugin_dir.exists():
+                continue
+            for plugin_file in plugin_dir.glob("*.py"):
+                if plugin_file.name.startswith("_"):
+                    continue
+                try:
+                    module_name = f"max_cli_plugins.{plugin_file.stem}"
+                    spec = importlib.util.spec_from_file_location(
+                        module_name, plugin_file
+                    )
+                    if spec and spec.loader:
+                        module = importlib.util.module_from_spec(spec)
+                        sys.modules[module_name] = module
+                        spec.loader.exec_module(module)
+                        for attr_name in dir(module):
+                            attr = getattr(module, attr_name)
+                            if (
+                                isinstance(attr, type)
+                                and issubclass(attr, Plugin)
+                                and attr is not Plugin
+                            ):
+                                plugins.append(attr)
+                except Exception as e:
+                    logger.warning(f"Failed to load plugin from {plugin_file}: {e}")
+        return plugins
+
+    def load_plugin(self, plugin_class: Type[Plugin], **kwargs: Any) -> Plugin:
+        plugin = plugin_class(**kwargs)
+        self._plugins[plugin.name] = plugin
+        return plugin
+
+    def register_plugin(self, plugin: Plugin) -> None:
+        self._plugins[plugin.name] = plugin
+
+    def unregister_plugin(self, name: str) -> None:
+        if name in self._plugins:
+            del self._plugins[name]
+
+    def get_plugin(self, name: str) -> Optional[Plugin]:
+        return self._plugins.get(name)
+
+    def list_plugins(self) -> List[str]:
+        return list(self._plugins.keys())
+
+    def get_all_plugins(self) -> Dict[str, Plugin]:
+        return self._plugins.copy()
+
+    def load_all(self) -> None:
+        plugin_classes = self.discover_plugins()
+        for plugin_class in plugin_classes:
+            try:
+                self.load_plugin(plugin_class)
+            except Exception as e:
+                logger.warning(f"Failed to load plugin {plugin_class}: {e}")