mcli-framework 7.10.2__py3-none-any.whl → 7.11.1__py3-none-any.whl

mcli/app/main.py

@@ -326,14 +326,14 @@ class LazyGroup(click.Group):
 
 def _add_lazy_commands(app: click.Group):
     """Add command groups with lazy loading."""
-    # Essential commands - load immediately for fast access
+    # Workflow management - load immediately for fast access (renamed from 'commands')
     try:
-        from mcli.app.commands_cmd import commands
+        from mcli.app.commands_cmd import workflow
 
-        app.add_command(commands, name="commands")
-        logger.debug("Added commands group")
+        app.add_command(workflow, name="workflow")
+        logger.debug("Added workflow management group")
     except ImportError as e:
-        logger.debug(f"Could not load commands group: {e}")
+        logger.debug(f"Could not load workflow management group: {e}")
 
     # Self management - load immediately as it's commonly used
     try:
@@ -344,35 +344,29 @@ def _add_lazy_commands(app: click.Group):
     except Exception as e:
         logger.debug(f"Could not load self commands: {e}")
 
-    # Library utilities and secrets management
-    try:
-        from mcli.lib.lib import lib
-
-        app.add_command(lib, name="lib")
-        logger.debug("Added lib commands")
-    except Exception as e:
-        logger.debug(f"Could not load lib commands: {e}")
+    # Note: lib group removed - secrets moved to workflows
+    # Previous: mcli lib secrets -> Now: mcli workflows secrets
 
-    # Add workflow with completion-aware lazy loading
+    # Add workflows group (renamed from 'workflow') with completion-aware lazy loading
     try:
         from mcli.app.completion_helpers import create_completion_aware_lazy_group
 
-        workflow_group = create_completion_aware_lazy_group(
-            "workflow",
-            "mcli.workflow.workflow.workflow",
-            "Workflow commands for automation, video processing, and daemon management",
+        workflows_group = create_completion_aware_lazy_group(
+            "workflows",
+            "mcli.workflow.workflow.workflows",
+            "Runnable workflows for automation, video processing, and daemon management",
         )
-        app.add_command(workflow_group, name="workflow")
-        logger.debug("Added completion-aware workflow group")
+        app.add_command(workflows_group, name="workflows")
+        logger.debug("Added completion-aware workflows group")
     except ImportError as e:
         logger.debug(f"Could not load completion helpers, using standard lazy group: {e}")
         # Fallback to standard lazy group
-        workflow_group = LazyGroup(
-            "workflow",
-            "mcli.workflow.workflow.workflow",
-            help="Workflow commands for automation, video processing, and daemon management",
+        workflows_group = LazyGroup(
+            "workflows",
+            "mcli.workflow.workflow.workflows",
+            help="Runnable workflows for automation, video processing, and daemon management",
         )
-        app.add_command(workflow_group, name="workflow")
+        app.add_command(workflows_group, name="workflows")
 
     # Lazy load other heavy commands that are used less frequently
     # NOTE: chat and model commands have been removed
@@ -382,8 +376,8 @@ def _add_lazy_commands(app: click.Group):
     lazy_commands = {}
 
     for cmd_name, cmd_info in lazy_commands.items():
-        # Skip workflow since we already added it with completion support
-        if cmd_name == "workflow":
+        # Skip workflows since we already added it with completion support
+        if cmd_name == "workflows":
             continue
 
         if cmd_name in ["model"]:

mcli/app/video/__init__.py

@@ -0,0 +1,5 @@
+"""
+Video processing commands for mcli.
+"""
+
+from .video import *

mcli/chat/__init__.py

@@ -0,0 +1,34 @@
+"""
+MCLI Chat System
+Real-time system control and interaction capabilities for MCLI chat
+"""
+
+from .system_controller import (
+    SystemController,
+    control_app,
+    execute_system_command,
+    open_file_or_url,
+    open_textedit_and_write,
+    system_controller,
+    take_screenshot,
+)
+from .system_integration import (
+    ChatSystemIntegration,
+    chat_system_integration,
+    get_system_capabilities,
+    handle_system_request,
+)
+
+__all__ = [
+    "SystemController",
+    "system_controller",
+    "ChatSystemIntegration",
+    "chat_system_integration",
+    "handle_system_request",
+    "get_system_capabilities",
+    "open_textedit_and_write",
+    "control_app",
+    "execute_system_command",
+    "take_screenshot",
+    "open_file_or_url",
+]

mcli/lib/auth/__init__.py

@@ -0,0 +1 @@
+from .auth import *

mcli/lib/config/__init__.py

@@ -0,0 +1 @@
+from .config import *

mcli/lib/custom_commands.py

@@ -19,7 +19,12 @@ from typing import Any, Dict, List, Optional
 import click
 
 from mcli.lib.logger.logger import get_logger, register_subprocess
-from mcli.lib.paths import get_custom_commands_dir
+from mcli.lib.paths import (
+    get_custom_commands_dir,
+    get_lockfile_path,
+    is_git_repository,
+    get_git_root,
+)
 
 logger = get_logger()
 
@@ -27,10 +32,22 @@ logger = get_logger()
 class CustomCommandManager:
     """Manages custom user commands stored in JSON format."""
 
-    def __init__(self):
-        self.commands_dir = get_custom_commands_dir()
+    def __init__(self, global_mode: bool = False):
+        """
+        Initialize the custom command manager.
+
+        Args:
+            global_mode: If True, use global commands directory (~/.mcli/commands/).
+                        If False, use local directory (.mcli/commands/) when in a git repository.
+        """
+        self.global_mode = global_mode
+        self.commands_dir = get_custom_commands_dir(global_mode=global_mode)
         self.loaded_commands: Dict[str, Any] = {}
-        self.lockfile_path = self.commands_dir / "commands.lock.json"
+        self.lockfile_path = get_lockfile_path(global_mode=global_mode)
+
+        # Store context information for display
+        self.is_local = not global_mode and is_git_repository()
+        self.git_root = get_git_root() if self.is_local else None
 
     def save_command(
         self,
@@ -486,16 +503,39 @@ class CustomCommandManager:
             return results
 
 
-# Global instance
-_command_manager: Optional[CustomCommandManager] = None
+# Global and local instances
+_global_command_manager: Optional[CustomCommandManager] = None
+_local_command_manager: Optional[CustomCommandManager] = None
+
 
+def get_command_manager(global_mode: bool = False) -> CustomCommandManager:
+    """
+    Get the custom command manager instance.
+
+    Args:
+        global_mode: If True, return global manager. If False, return local manager (if in git repo).
 
-def get_command_manager() -> CustomCommandManager:
-    """Get the global custom command manager instance."""
-    global _command_manager
-    if _command_manager is None:
-        _command_manager = CustomCommandManager()
-    return _command_manager
+    Returns:
+        CustomCommandManager instance for the appropriate scope
+    """
+    global _global_command_manager, _local_command_manager
+
+    if global_mode:
+        if _global_command_manager is None:
+            _global_command_manager = CustomCommandManager(global_mode=True)
+        return _global_command_manager
+    else:
+        # Use local manager if in git repository
+        if is_git_repository():
+            # Recreate local manager if git root changed (e.g., changed directory)
+            if _local_command_manager is None or _local_command_manager.git_root != get_git_root():
+                _local_command_manager = CustomCommandManager(global_mode=False)
+            return _local_command_manager
+        else:
+            # Fallback to global manager when not in a git repository
+            if _global_command_manager is None:
+                _global_command_manager = CustomCommandManager(global_mode=True)
+            return _global_command_manager
 
 
 def load_custom_commands(target_group: click.Group) -> int:

mcli/lib/erd/__init__.py

@@ -0,0 +1,25 @@
+"""
+Entity Relationship Diagram (ERD) package.
+
+This package provides utilities for generating Entity Relationship Diagrams from MCLI type metadata.
+"""
+
+# Import and export all public functions from erd.py
+from .erd import (
+    analyze_graph_for_hierarchical_exports,
+    create_merged_erd,
+    do_erd,
+    find_top_nodes_in_graph,
+    generate_erd_for_top_nodes,
+    generate_merged_erd_for_types,
+)
+
+# Define __all__ to control exports
+__all__ = [
+    "do_erd",
+    "create_merged_erd",
+    "generate_merged_erd_for_types",
+    "find_top_nodes_in_graph",
+    "generate_erd_for_top_nodes",
+    "analyze_graph_for_hierarchical_exports",
+]

mcli/lib/fs/__init__.py

@@ -0,0 +1 @@
+from .fs import *

mcli/lib/logger/__init__.py

@@ -0,0 +1,3 @@
+from .logger import get_logger
+
+__all__ = ["get_logger"]

mcli/lib/paths.py

@@ -82,13 +82,141 @@ 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 .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
+
+        # Check if old commands directory exists (for migration support)
+        commands_dir = local_mcli / "commands"
+        if commands_dir.exists():
+            return commands_dir
+
+        # If neither exists, return workflows path (for new installations)
+        return workflows_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 commands directory (e.g., ~/.mcli/commands), created if it doesn't exist
+        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/lib/performance/__init__.py

@@ -0,0 +1,17 @@
+"""
+Performance optimization utilities for mcli
+"""
+
+from .uvloop_config import (
+    configure_event_loop_for_performance,
+    get_event_loop_info,
+    install_uvloop,
+    should_use_uvloop,
+)
+
+__all__ = [
+    "install_uvloop",
+    "should_use_uvloop",
+    "get_event_loop_info",
+    "configure_event_loop_for_performance",
+]

mcli/lib/pickles/__init__.py

@@ -0,0 +1 @@
+from .pickles import ObjectCache

mcli/lib/secrets/__init__.py

@@ -0,0 +1,10 @@
+"""
+Secrets management module for MCLI.
+
+Provides secure storage and retrieval of secrets with git-based synchronization.
+"""
+
+from .manager import SecretsManager
+from .store import SecretsStore
+
+__all__ = ["SecretsManager", "SecretsStore"]

mcli/lib/toml/__init__.py

@@ -0,0 +1 @@
+from .toml import read_from_toml

mcli/ml/__init__.py

@@ -0,0 +1,16 @@
+"""MCLI Machine Learning Module for Stock Recommendation System"""
+
+from .configs.dvc_config import get_dvc_config, setup_dvc
+from .configs.mlflow_config import get_mlflow_config, setup_mlflow
+from .configs.mlops_manager import MLOpsManager, get_mlops_manager
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "get_mlops_manager",
+    "MLOpsManager",
+    "get_mlflow_config",
+    "setup_mlflow",
+    "get_dvc_config",
+    "setup_dvc",
+]

mcli/ml/api/__init__.py

@@ -0,0 +1,30 @@
+"""API routes and endpoints for ML system"""
+
+from .app import create_app, get_application
+from .routers import (
+    admin_router,
+    auth_router,
+    backtest_router,
+    data_router,
+    model_router,
+    monitoring_router,
+    portfolio_router,
+    prediction_router,
+    trade_router,
+    websocket_router,
+)
+
+__all__ = [
+    "auth_router",
+    "model_router",
+    "prediction_router",
+    "portfolio_router",
+    "data_router",
+    "trade_router",
+    "backtest_router",
+    "monitoring_router",
+    "admin_router",
+    "websocket_router",
+    "create_app",
+    "get_application",
+]

mcli/ml/api/routers/__init__.py

@@ -0,0 +1,27 @@
+"""API routers"""
+
+from . import (
+    admin_router,
+    auth_router,
+    backtest_router,
+    data_router,
+    model_router,
+    monitoring_router,
+    portfolio_router,
+    prediction_router,
+    trade_router,
+    websocket_router,
+)
+
+__all__ = [
+    "auth_router",
+    "model_router",
+    "prediction_router",
+    "portfolio_router",
+    "data_router",
+    "trade_router",
+    "backtest_router",
+    "monitoring_router",
+    "admin_router",
+    "websocket_router",
+]

mcli/ml/auth/__init__.py

@@ -0,0 +1,41 @@
+"""Authentication and authorization system"""
+
+from .auth_manager import (
+    AuthManager,
+    create_access_token,
+    get_current_active_user,
+    get_current_user,
+    hash_password,
+    require_role,
+    verify_access_token,
+    verify_password,
+)
+from .models import (
+    PasswordChange,
+    PasswordReset,
+    TokenResponse,
+    UserCreate,
+    UserLogin,
+    UserResponse,
+)
+from .permissions import Permission, check_permission, has_permission
+
+__all__ = [
+    "AuthManager",
+    "create_access_token",
+    "verify_access_token",
+    "get_current_user",
+    "get_current_active_user",
+    "require_role",
+    "hash_password",
+    "verify_password",
+    "UserCreate",
+    "UserLogin",
+    "UserResponse",
+    "TokenResponse",
+    "PasswordReset",
+    "PasswordChange",
+    "Permission",
+    "check_permission",
+    "has_permission",
+]

mcli/ml/backtesting/__init__.py

@@ -0,0 +1,33 @@
+"""Backtesting framework for trading strategies"""
+
+from .backtest_engine import (
+    BacktestConfig,
+    BacktestEngine,
+    BacktestResult,
+    PositionManager,
+    TradingStrategy,
+)
+from .performance_metrics import (
+    PerformanceAnalyzer,
+    PortfolioMetrics,
+    RiskMetrics,
+    plot_performance,
+)
+from .trading_simulator import MarketSimulator, Order, Portfolio, Position, TradingSimulator
+
+__all__ = [
+    "BacktestEngine",
+    "BacktestConfig",
+    "BacktestResult",
+    "TradingStrategy",
+    "PositionManager",
+    "PerformanceAnalyzer",
+    "PortfolioMetrics",
+    "RiskMetrics",
+    "plot_performance",
+    "TradingSimulator",
+    "Order",
+    "Position",
+    "Portfolio",
+    "MarketSimulator",
+]

mcli/ml/cli/__init__.py

@@ -0,0 +1,5 @@
+"""CLI interface for ML system"""
+
+from .main import app
+
+__all__ = ["app"]

mcli/ml/config/__init__.py

@@ -0,0 +1,33 @@
+"""Configuration management for ML system"""
+
+from .settings import (
+    APISettings,
+    DatabaseSettings,
+    DataSettings,
+    MLflowSettings,
+    ModelSettings,
+    MonitoringSettings,
+    RedisSettings,
+    SecuritySettings,
+    Settings,
+    create_settings,
+    get_settings,
+    settings,
+    update_settings,
+)
+
+__all__ = [
+    "Settings",
+    "DatabaseSettings",
+    "RedisSettings",
+    "MLflowSettings",
+    "ModelSettings",
+    "DataSettings",
+    "APISettings",
+    "MonitoringSettings",
+    "SecuritySettings",
+    "settings",
+    "get_settings",
+    "update_settings",
+    "create_settings",
+]

mcli/ml/configs/__init__.py

@@ -0,0 +1,16 @@
+"""ML Configuration Module"""
+
+from .dvc_config import DVCConfig, get_dvc_config, setup_dvc
+from .mlflow_config import MLflowConfig, get_mlflow_config, setup_mlflow
+from .mlops_manager import MLOpsManager, get_mlops_manager
+
+__all__ = [
+    "MLflowConfig",
+    "get_mlflow_config",
+    "setup_mlflow",
+    "DVCConfig",
+    "get_dvc_config",
+    "setup_dvc",
+    "MLOpsManager",
+    "get_mlops_manager",
+]

mcli/ml/dashboard/__init__.py

@@ -0,0 +1,12 @@
+"""ML Dashboard for real-time monitoring"""
+
+from .app import main
+from .cli import app as cli_app
+
+
+def main():
+    """Main entry point for dashboard CLI"""
+    cli_app()
+
+
+__all__ = ["main", "cli_app"]