mcli-framework 7.10.1__py3-none-any.whl → 7.11.0__py3-none-any.whl

mcli/lib/optional_deps.py

@@ -0,0 +1,240 @@
+"""
+Utilities for graceful handling of optional dependencies.
+
+This module provides helper functions and decorators to handle optional
+dependencies gracefully, with clear error messages when features are unavailable.
+"""
+
+import functools
+from typing import Any, Callable, Dict, Optional, Tuple
+
+from mcli.lib.logger.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class OptionalDependency:
+    """
+    Container for an optional dependency with availability tracking.
+
+    Example:
+        >>> ollama = OptionalDependency("ollama")
+        >>> if ollama.available:
+        ...     client = ollama.module.Client()
+    """
+
+    def __init__(
+        self,
+        module_name: str,
+        import_name: Optional[str] = None,
+        install_hint: Optional[str] = None,
+    ):
+        """
+        Initialize optional dependency handler.
+
+        Args:
+            module_name: Name of the module to import (e.g., "ollama")
+            import_name: Alternative import name if different from module_name
+            install_hint: Custom installation instruction
+        """
+        self.module_name = module_name
+        self.import_name = import_name or module_name
+        self.install_hint = install_hint or f"pip install {module_name}"
+        self.module: Optional[Any] = None
+        self.available = False
+        self.error: Optional[Exception] = None
+
+        self._try_import()
+
+    def _try_import(self):
+        """Attempt to import the module."""
+        try:
+            self.module = __import__(self.import_name)
+            self.available = True
+            logger.debug(f"Optional dependency '{self.module_name}' is available")
+        except ImportError as e:
+            self.available = False
+            self.error = e
+            logger.debug(f"Optional dependency '{self.module_name}' is not available: {e}")
+
+    def require(self, feature_name: Optional[str] = None) -> Any:
+        """
+        Require the dependency to be available, raising an error if not.
+
+        Args:
+            feature_name: Name of the feature requiring this dependency
+
+        Returns:
+            The imported module
+
+        Raises:
+            ImportError: If the dependency is not available
+        """
+        if not self.available:
+            feature_msg = f" for {feature_name}" if feature_name else ""
+            raise ImportError(
+                f"'{self.module_name}' is required{feature_msg} but not installed.\n"
+                f"Install it with: {self.install_hint}"
+            )
+        return self.module
+
+    def __getattr__(self, name: str) -> Any:
+        """Allow direct attribute access to the module."""
+        if not self.available:
+            raise ImportError(
+                f"Cannot access '{name}' from '{self.module_name}' - module not installed.\n"
+                f"Install it with: {self.install_hint}"
+            )
+        return getattr(self.module, name)
+
+
+def optional_import(
+    module_name: str, import_name: Optional[str] = None, install_hint: Optional[str] = None
+) -> Tuple[Optional[Any], bool]:
+    """
+    Try to import an optional dependency.
+
+    Args:
+        module_name: Name of the module to import
+        import_name: Alternative import name if different from module_name
+        install_hint: Custom installation instruction
+
+    Returns:
+        Tuple of (module, available) where module is None if unavailable
+
+    Example:
+        >>> ollama, OLLAMA_AVAILABLE = optional_import("ollama")
+        >>> if OLLAMA_AVAILABLE:
+        ...     client = ollama.Client()
+    """
+    dep = OptionalDependency(module_name, import_name, install_hint)
+    return (dep.module, dep.available)
+
+
+def require_dependency(
+    module_name: str, feature_name: str, install_hint: Optional[str] = None
+) -> Any:
+    """
+    Require a dependency, raising clear error if not available.
+
+    Args:
+        module_name: Name of the module to import
+        feature_name: Name of the feature requiring this dependency
+        install_hint: Custom installation instruction
+
+    Returns:
+        The imported module
+
+    Raises:
+        ImportError: If the dependency is not available
+
+    Example:
+        >>> streamlit = require_dependency("streamlit", "dashboard")
+    """
+    dep = OptionalDependency(module_name, install_hint=install_hint)
+    return dep.require(feature_name)
+
+
+def requires(*dependencies: str, install_all_hint: Optional[str] = None):
+    """
+    Decorator to mark a function as requiring specific dependencies.
+
+    Args:
+        *dependencies: Module names required by the function
+        install_all_hint: Custom installation instruction for all dependencies
+
+    Raises:
+        ImportError: If any required dependency is not available
+
+    Example:
+        >>> @requires("torch", "transformers")
+        ... def train_model():
+        ...     import torch
+        ...     import transformers
+        ...     # training code
+    """
+
+    def decorator(func: Callable) -> Callable:
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            missing = []
+            for dep_name in dependencies:
+                dep = OptionalDependency(dep_name)
+                if not dep.available:
+                    missing.append(dep_name)
+
+            if missing:
+                if install_all_hint:
+                    hint = install_all_hint
+                else:
+                    hint = f"pip install {' '.join(missing)}"
+
+                raise ImportError(
+                    f"Function '{func.__name__}' requires missing dependencies: {', '.join(missing)}\n"
+                    f"Install them with: {hint}"
+                )
+
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+# Common optional dependencies registry
+OPTIONAL_DEPS: Dict[str, OptionalDependency] = {}
+
+
+def register_optional_dependency(
+    module_name: str, import_name: Optional[str] = None, install_hint: Optional[str] = None
+) -> OptionalDependency:
+    """
+    Register and cache an optional dependency.
+
+    Args:
+        module_name: Name of the module to import
+        import_name: Alternative import name if different from module_name
+        install_hint: Custom installation instruction
+
+    Returns:
+        OptionalDependency instance
+    """
+    if module_name not in OPTIONAL_DEPS:
+        OPTIONAL_DEPS[module_name] = OptionalDependency(module_name, import_name, install_hint)
+    return OPTIONAL_DEPS[module_name]
+
+
+def check_dependencies(*module_names: str) -> Dict[str, bool]:
+    """
+    Check availability of multiple dependencies.
+
+    Args:
+        *module_names: Module names to check
+
+    Returns:
+        Dictionary mapping module names to availability status
+
+    Example:
+        >>> status = check_dependencies("torch", "transformers", "streamlit")
+        >>> print(status)
+        {'torch': True, 'transformers': False, 'streamlit': True}
+    """
+    return {
+        name: OptionalDependency(name).available for name in module_names
+    }
+
+
+# Pre-register common optional dependencies
+_COMMON_DEPS = {
+    "ollama": ("ollama", "pip install ollama"),
+    "streamlit": ("streamlit", "pip install streamlit"),
+    "torch": ("torch", "pip install torch"),
+    "transformers": ("transformers", "pip install transformers"),
+    "mlflow": ("mlflow", "pip install mlflow"),
+    "plotly": ("plotly", "pip install plotly"),
+    "pandas": ("pandas", "pip install pandas"),
+    "numpy": ("numpy", "pip install numpy"),
+}
+
+for module_name, (import_name, hint) in _COMMON_DEPS.items():
+    register_optional_dependency(module_name, import_name, hint)

mcli/lib/paths.py

@@ -82,13 +82,137 @@ def get_cache_dir() -> Path:
     return cache_dir
 
 
-def get_custom_commands_dir() -> Path:
+def is_git_repository(path: Optional[Path] = None) -> bool:
     """
-    Get the custom commands directory for mcli.
+    Check if the current directory (or specified path) is inside a git repository.
+
+    Args:
+        path: Path to check (defaults to current working directory)
+
+    Returns:
+        True if inside a git repository, False otherwise
+    """
+    check_path = path or Path.cwd()
+
+    # Walk up the directory tree looking for .git
+    current = check_path.resolve()
+    while current != current.parent:
+        if (current / ".git").exists():
+            return True
+        current = current.parent
+
+    return False
+
+
+def get_git_root(path: Optional[Path] = None) -> Optional[Path]:
+    """
+    Get the root directory of the git repository.
+
+    Args:
+        path: Path to check (defaults to current working directory)
+
+    Returns:
+        Path to git root, or None if not in a git repository
+    """
+    check_path = path or Path.cwd()
+
+    # Walk up the directory tree looking for .git
+    current = check_path.resolve()
+    while current != current.parent:
+        if (current / ".git").exists():
+            return current
+        current = current.parent
+
+    return None
+
+
+def get_local_mcli_dir() -> Optional[Path]:
+    """
+    Get the local .mcli directory for the current git repository.
 
     Returns:
-        Path to custom commands directory (e.g., ~/.mcli/commands), created if it doesn't exist
+        Path to .mcli directory in git root, or None if not in a git repository
     """
+    git_root = get_git_root()
+    if git_root:
+        local_mcli = git_root / ".mcli"
+        return local_mcli
+    return None
+
+
+def get_local_commands_dir() -> Optional[Path]:
+    """
+    Get the local workflows directory for the current git repository.
+
+    Note: This function name is kept for backward compatibility but now returns
+    the workflows directory. Checks workflows first, then commands for migration.
+
+    Returns:
+        Path to .mcli/workflows (or .mcli/commands for migration) in git root,
+        or None if not in a git repository
+    """
+    local_mcli = get_local_mcli_dir()
+    if local_mcli:
+        # Check for new workflows directory first
+        workflows_dir = local_mcli / "workflows"
+        if workflows_dir.exists():
+            return workflows_dir
+
+        # Fall back to old commands directory for migration support
+        commands_dir = local_mcli / "commands"
+        return commands_dir
+    return None
+
+
+def get_custom_commands_dir(global_mode: bool = False) -> Path:
+    """
+    Get the custom workflows directory for mcli.
+
+    Note: This function name is kept for backward compatibility but now returns
+    the workflows directory. Checks workflows first, then commands for migration.
+
+    Args:
+        global_mode: If True, always use global directory. If False, use local if in git repo.
+
+    Returns:
+        Path to custom workflows directory, created if it doesn't exist
+    """
+    # If not in global mode and we're in a git repository, use local directory
+    if not global_mode:
+        local_dir = get_local_commands_dir()
+        if local_dir:
+            local_dir.mkdir(parents=True, exist_ok=True)
+            return local_dir
+
+    # Otherwise, use global directory
+    # Check for new workflows directory first
+    workflows_dir = get_mcli_home() / "workflows"
+    if workflows_dir.exists():
+        return workflows_dir
+
+    # Check for old commands directory (for migration support)
     commands_dir = get_mcli_home() / "commands"
-    commands_dir.mkdir(parents=True, exist_ok=True)
-    return commands_dir
+    if commands_dir.exists():
+        # Return commands directory if it exists (user hasn't migrated yet)
+        return commands_dir
+
+    # If neither exists, create the new workflows directory
+    workflows_dir.mkdir(parents=True, exist_ok=True)
+    return workflows_dir
+
+
+def get_lockfile_path(global_mode: bool = False) -> Path:
+    """
+    Get the lockfile path for workflow management.
+
+    Note: Lockfile remains named commands.lock.json for compatibility.
+
+    Args:
+        global_mode: If True, use global lockfile. If False, use local if in git repo.
+
+    Returns:
+        Path to the lockfile
+    """
+    workflows_dir = get_custom_commands_dir(global_mode=global_mode)
+    # Keep the old lockfile name for compatibility
+    return workflows_dir / "commands.lock.json"

mcli/self/migrate_cmd.py

@@ -0,0 +1,261 @@
+"""
+Migration commands for mcli self-management.
+
+Handles migrations between different versions of mcli, including:
+- Directory structure changes
+- Configuration format changes
+- Command structure changes
+"""
+
+import json
+import shutil
+from datetime import datetime
+from pathlib import Path
+from typing import List, Tuple
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from mcli.lib.logger.logger import get_logger
+from mcli.lib.ui.styling import error, info, success, warning
+
+logger = get_logger(__name__)
+console = Console()
+
+
+def get_migration_status() -> dict:
+    """
+    Check the current migration status.
+
+    Returns:
+        Dictionary with migration status information
+    """
+    mcli_home = Path.home() / ".mcli"
+    old_commands_dir = mcli_home / "commands"
+    new_workflows_dir = mcli_home / "workflows"
+
+    status = {
+        "old_dir_exists": old_commands_dir.exists(),
+        "old_dir_path": str(old_commands_dir),
+        "new_dir_exists": new_workflows_dir.exists(),
+        "new_dir_path": str(new_workflows_dir),
+        "needs_migration": False,
+        "files_to_migrate": [],
+        "migration_done": False,
+    }
+
+    # Check if migration is needed
+    if old_commands_dir.exists():
+        # Count files that need migration (excluding hidden files)
+        files = [
+            f for f in old_commands_dir.iterdir()
+            if f.is_file() and not f.name.startswith('.')
+        ]
+        status["files_to_migrate"] = [f.name for f in files]
+        status["needs_migration"] = len(files) > 0
+
+    # Check if migration already done
+    if new_workflows_dir.exists() and not old_commands_dir.exists():
+        status["migration_done"] = True
+
+    return status
+
+
+def migrate_commands_to_workflows(dry_run: bool = False, force: bool = False) -> Tuple[bool, str]:
+    """
+    Migrate ~/.mcli/commands to ~/.mcli/workflows.
+
+    Args:
+        dry_run: If True, show what would be done without actually doing it
+        force: If True, proceed even if workflows directory exists
+
+    Returns:
+        Tuple of (success, message)
+    """
+    mcli_home = Path.home() / ".mcli"
+    old_dir = mcli_home / "commands"
+    new_dir = mcli_home / "workflows"
+
+    # Check if old directory exists
+    if not old_dir.exists():
+        return False, f"Nothing to migrate: {old_dir} does not exist"
+
+    # Check if new directory already exists
+    if new_dir.exists() and not force:
+        return False, f"Target directory {new_dir} already exists. Use --force to override."
+
+    # Get list of files to migrate
+    files_to_migrate = [
+        f for f in old_dir.iterdir()
+        if f.is_file() and not f.name.startswith('.')
+    ]
+
+    if not files_to_migrate:
+        return False, f"No files to migrate in {old_dir}"
+
+    if dry_run:
+        message = f"[DRY RUN] Would migrate {len(files_to_migrate)} files from {old_dir} to {new_dir}"
+        return True, message
+
+    try:
+        # Create new directory if it doesn't exist
+        new_dir.mkdir(parents=True, exist_ok=True)
+
+        # Track migrated files
+        migrated_files = []
+        skipped_files = []
+
+        # Move files
+        for file_path in files_to_migrate:
+            target_path = new_dir / file_path.name
+
+            # Check if file already exists in target
+            if target_path.exists():
+                if force:
+                    # Backup existing file
+                    backup_path = target_path.with_suffix(f".backup.{datetime.now().strftime('%Y%m%d%H%M%S')}")
+                    shutil.move(str(target_path), str(backup_path))
+                    logger.info(f"Backed up existing file to {backup_path}")
+                else:
+                    skipped_files.append(file_path.name)
+                    continue
+
+            # Move the file
+            shutil.move(str(file_path), str(target_path))
+            migrated_files.append(file_path.name)
+            logger.info(f"Migrated: {file_path.name}")
+
+        # Check if old directory is now empty (only hidden files remain)
+        remaining_files = [
+            f for f in old_dir.iterdir()
+            if f.is_file() and not f.name.startswith('.')
+        ]
+
+        # If empty, remove old directory
+        if not remaining_files:
+            # Keep hidden files like .gitignore but remove directory if truly empty
+            all_remaining = list(old_dir.iterdir())
+            if not all_remaining:
+                old_dir.rmdir()
+                logger.info(f"Removed empty directory: {old_dir}")
+
+        # Create migration report
+        report_lines = [
+            f"Successfully migrated {len(migrated_files)} files from {old_dir} to {new_dir}"
+        ]
+
+        if skipped_files:
+            report_lines.append(f"Skipped {len(skipped_files)} files (already exist in target)")
+
+        if remaining_files:
+            report_lines.append(f"Note: {len(remaining_files)} files remain in {old_dir}")
+
+        return True, "\n".join(report_lines)
+
+    except Exception as e:
+        logger.error(f"Migration failed: {e}")
+        return False, f"Migration failed: {str(e)}"
+
+
+@click.command(name="migrate", help="Perform system migrations for mcli")
+@click.option(
+    "--dry-run",
+    is_flag=True,
+    help="Show what would be done without actually doing it",
+)
+@click.option(
+    "--force",
+    is_flag=True,
+    help="Force migration even if target directory exists",
+)
+@click.option(
+    "--status",
+    is_flag=True,
+    help="Show migration status without performing migration",
+)
+def migrate_command(dry_run: bool, force: bool, status: bool):
+    """
+    Migrate mcli configuration and data to new structure.
+
+    Currently handles:
+    - Moving ~/.mcli/commands to ~/.mcli/workflows
+
+    Examples:
+        mcli self migrate --status       # Check migration status
+        mcli self migrate --dry-run      # See what would be done
+        mcli self migrate                # Perform migration
+        mcli self migrate --force        # Force migration (overwrite existing)
+    """
+
+    # Get current status
+    migration_status = get_migration_status()
+
+    # If --status flag, just show status and exit
+    if status:
+        console.print("\n[bold cyan]Migration Status[/bold cyan]")
+        console.print(f"\n[bold]Old location:[/bold] {migration_status['old_dir_path']}")
+        console.print(f"  Exists: {'✓ Yes' if migration_status['old_dir_exists'] else '✗ No'}")
+
+        console.print(f"\n[bold]New location:[/bold] {migration_status['new_dir_path']}")
+        console.print(f"  Exists: {'✓ Yes' if migration_status['new_dir_exists'] else '✗ No'}")
+
+        if migration_status['needs_migration']:
+            console.print(f"\n[yellow]⚠ Migration needed[/yellow]")
+            console.print(f"Files to migrate: {len(migration_status['files_to_migrate'])}")
+
+            if migration_status['files_to_migrate']:
+                table = Table(title="Files to Migrate")
+                table.add_column("File Name", style="cyan")
+
+                for filename in sorted(migration_status['files_to_migrate']):
+                    table.add_row(filename)
+
+                console.print(table)
+
+            console.print(f"\n[dim]Run 'mcli self migrate' to perform migration[/dim]")
+        elif migration_status['migration_done']:
+            console.print(f"\n[green]✓ Migration already completed[/green]")
+        else:
+            console.print(f"\n[green]✓ No migration needed[/green]")
+
+        return
+
+    # Check if migration is needed
+    if not migration_status['needs_migration']:
+        if migration_status['migration_done']:
+            info("Migration already completed")
+            info(f"Workflows directory: {migration_status['new_dir_path']}")
+        else:
+            info("No migration needed")
+        return
+
+    # Show what will be migrated
+    console.print("\n[bold cyan]Migration Plan[/bold cyan]")
+    console.print(f"\nSource: [cyan]{migration_status['old_dir_path']}[/cyan]")
+    console.print(f"Target: [cyan]{migration_status['new_dir_path']}[/cyan]")
+    console.print(f"Files: [yellow]{len(migration_status['files_to_migrate'])}[/yellow]")
+
+    if dry_run:
+        console.print(f"\n[yellow]DRY RUN MODE - No changes will be made[/yellow]")
+
+    # Perform migration
+    success_flag, message = migrate_commands_to_workflows(dry_run=dry_run, force=force)
+
+    if success_flag:
+        if dry_run:
+            info(message)
+        else:
+            success(message)
+            console.print("\n[green]✓ Migration completed successfully[/green]")
+            console.print(f"\nYour workflows are now in: [cyan]{migration_status['new_dir_path']}[/cyan]")
+            console.print("\n[dim]You can now use 'mcli workflow' to manage and 'mcli workflows' to run them[/dim]")
+    else:
+        error(message)
+        if not force and "already exists" in message:
+            console.print("\n[yellow]Tip: Use --force to proceed anyway (will backup existing files)[/yellow]")
+
+
+if __name__ == "__main__":
+    migrate_command()

mcli/self/self_cmd.py

@@ -1045,6 +1045,14 @@ try:
 except ImportError as e:
     logger.debug(f"Could not load visual command: {e}")
 
+try:
+    from mcli.self.migrate_cmd import migrate_command
+
+    self_app.add_command(migrate_command, name="migrate")
+    logger.debug("Added migrate command to self group")
+except ImportError as e:
+    logger.debug(f"Could not load migrate command: {e}")
+
 # NOTE: store command has been moved to mcli.app.commands_cmd for better organization
 
 # This part is important to make the command available to the CLI

mcli/workflow/git_commit/ai_service.py

@@ -2,11 +2,13 @@ import json
 import logging
 from typing import Any, Dict, Optional
 
-import ollama
-
 from mcli.lib.logger.logger import get_logger
+from mcli.lib.optional_deps import optional_import
 from mcli.lib.toml.toml import read_from_toml
 
+# Gracefully handle optional ollama dependency
+ollama, OLLAMA_AVAILABLE = optional_import("ollama")
+
 logger = get_logger(__name__)
 
 
@@ -204,6 +206,15 @@ Generate ONLY the commit message, nothing else:"""
     def generate_commit_message(self, changes: Dict[str, Any], diff_content: str) -> str:
         """Generate an AI-powered commit message"""
         try:
+            # Check if ollama is available
+            if not OLLAMA_AVAILABLE:
+                logger.warning(
+                    "Ollama is not installed. Install it with: pip install ollama\n"
+                    "Falling back to rule-based commit message generation."
+                )
+                analysis = self._analyze_file_patterns(changes)
+                return self._generate_fallback_message(changes, analysis)
+
             # Analyze the changes first
             analysis = self._analyze_file_patterns(changes)