mcli-framework 7.8.5__py3-none-any.whl → 7.9.1__py3-none-any.whl

mcli/lib/secrets/repl.py

@@ -0,0 +1,297 @@
+"""
+REPL (Read-Eval-Print Loop) for LSH secrets management.
+"""
+
+import os
+from pathlib import Path
+from typing import List
+
+import click
+from prompt_toolkit import prompt
+from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
+from prompt_toolkit.completion import WordCompleter
+from prompt_toolkit.history import FileHistory
+
+from mcli.lib.logger.logger import get_logger
+
+logger = get_logger(__name__)
+from mcli.lib.ui.styling import console, error, info, success, warning
+
+from .manager import SecretsManager
+from .store import SecretsStore
+
+
+class SecretsREPL:
+    """Interactive REPL for secrets management."""
+
+    def __init__(self):
+        """Initialize the REPL."""
+        self.manager = SecretsManager()
+        self.store = SecretsStore()
+        self.running = False
+        self.namespace = "default"
+        self.history_file = Path.home() / ".mcli" / "secrets_repl_history"
+
+        # Commands
+        self.commands = {
+            "set": self.cmd_set,
+            "get": self.cmd_get,
+            "list": self.cmd_list,
+            "delete": self.cmd_delete,
+            "namespace": self.cmd_namespace,
+            "export": self.cmd_export,
+            "import": self.cmd_import,
+            "push": self.cmd_push,
+            "pull": self.cmd_pull,
+            "sync": self.cmd_sync,
+            "status": self.cmd_status,
+            "help": self.cmd_help,
+            "exit": self.cmd_exit,
+            "quit": self.cmd_exit,
+        }
+
+        # Command completer
+        self.completer = WordCompleter(list(self.commands.keys()) + ["ns"], ignore_case=True)
+
+    def run(self):
+        """Run the REPL."""
+        self.running = True
+
+        # Print welcome message
+        console.print("[bold cyan]MCLI Secrets Management Shell[/bold cyan]")
+        console.print("Type 'help' for available commands or 'exit' to quit.\n")
+
+        # Create history file directory if needed
+        self.history_file.parent.mkdir(parents=True, exist_ok=True)
+
+        while self.running:
+            try:
+                # Build prompt
+                prompt_text = f"[{self.namespace}]> "
+
+                # Get user input
+                user_input = prompt(
+                    prompt_text,
+                    completer=self.completer,
+                    history=FileHistory(str(self.history_file)),
+                    auto_suggest=AutoSuggestFromHistory(),
+                ).strip()
+
+                if not user_input:
+                    continue
+
+                # Parse command and arguments
+                parts = user_input.split()
+                command = parts[0].lower()
+                args = parts[1:] if len(parts) > 1 else []
+
+                # Handle command aliases
+                if command == "ns":
+                    command = "namespace"
+
+                # Execute command
+                if command in self.commands:
+                    self.commands[command](args)
+                else:
+                    error(f"Unknown command: {command}")
+                    console.print("Type 'help' for available commands.")
+
+            except KeyboardInterrupt:
+                console.print("\nUse 'exit' or 'quit' to leave the shell.")
+            except EOFError:
+                self.cmd_exit([])
+            except Exception as e:
+                error(f"Error: {e}")
+                logger.exception("REPL error")
+
+    def cmd_set(self, args: List[str]):
+        """Set a secret value."""
+        if len(args) < 2:
+            error("Usage: set <key> <value>")
+            return
+
+        key = args[0]
+        value = " ".join(args[1:])
+
+        try:
+            self.manager.set(key, value, self.namespace)
+            success(f"Secret '{key}' set in namespace '{self.namespace}'")
+        except Exception as e:
+            error(f"Failed to set secret: {e}")
+
+    def cmd_get(self, args: List[str]):
+        """Get a secret value."""
+        if len(args) != 1:
+            error("Usage: get <key>")
+            return
+
+        key = args[0]
+        value = self.manager.get(key, self.namespace)
+
+        if value is not None:
+            # Mask the value for security
+            masked_value = (
+                value[:3] + "*" * (len(value) - 6) + value[-3:]
+                if len(value) > 6
+                else "*" * len(value)
+            )
+            info(f"{key} = {masked_value}")
+
+            if click.confirm("Show full value?", default=False):
+                console.print(f"[yellow]{value}[/yellow]")
+        else:
+            warning(f"Secret '{key}' not found in namespace '{self.namespace}'")
+
+    def cmd_list(self, args: List[str]):
+        """List all secrets."""
+        secrets = self.manager.list(self.namespace if args != ["all"] else None)
+
+        if secrets:
+            console.print("[bold]Secrets:[/bold]")
+            for secret in secrets:
+                console.print(f"  • {secret}")
+        else:
+            info("No secrets found")
+
+    def cmd_delete(self, args: List[str]):
+        """Delete a secret."""
+        if len(args) != 1:
+            error("Usage: delete <key>")
+            return
+
+        key = args[0]
+
+        if click.confirm(f"Delete secret '{key}' from namespace '{self.namespace}'?"):
+            if self.manager.delete(key, self.namespace):
+                success(f"Secret '{key}' deleted")
+            else:
+                warning(f"Secret '{key}' not found")
+
+    def cmd_namespace(self, args: List[str]):
+        """Switch namespace."""
+        if len(args) == 0:
+            # List namespaces
+            namespaces = set()
+            for d in self.manager.secrets_dir.iterdir():
+                if d.is_dir() and not d.name.startswith("."):
+                    namespaces.add(d.name)
+
+            console.print(f"[bold]Current namespace:[/bold] {self.namespace}")
+            if namespaces:
+                console.print("[bold]Available namespaces:[/bold]")
+                for ns in sorted(namespaces):
+                    marker = "→" if ns == self.namespace else " "
+                    console.print(f"  {marker} {ns}")
+        elif len(args) == 1:
+            self.namespace = args[0]
+            success(f"Switched to namespace '{self.namespace}'")
+        else:
+            error("Usage: namespace [<name>]")
+
+    def cmd_export(self, args: List[str]):
+        """Export secrets as environment variables."""
+        env_vars = self.manager.export_env(self.namespace)
+
+        if env_vars:
+            if args and args[0] == "file":
+                # Export to file
+                filename = args[1] if len(args) > 1 else f"{self.namespace}.env"
+                with open(filename, "w") as f:
+                    for key, value in env_vars.items():
+                        f.write(f"{key}={value}\n")
+                success(f"Exported {len(env_vars)} secrets to {filename}")
+            else:
+                # Display export commands
+                console.print("[bold]Export commands:[/bold]")
+                for key, value in env_vars.items():
+                    masked_value = value[:3] + "***" + value[-3:] if len(value) > 6 else "***"
+                    console.print(f"export {key}={masked_value}")
+        else:
+            info("No secrets to export")
+
+    def cmd_import(self, args: List[str]):
+        """Import secrets from environment file."""
+        if len(args) != 1:
+            error("Usage: import <env-file>")
+            return
+
+        env_file = Path(args[0])
+        if not env_file.exists():
+            error(f"File not found: {env_file}")
+            return
+
+        count = self.manager.import_env(env_file, self.namespace)
+        success(f"Imported {count} secrets from {env_file}")
+
+    def cmd_push(self, args: List[str]):
+        """Push secrets to git store."""
+        message = " ".join(args) if args else None
+        self.store.push(self.manager.secrets_dir, message)
+
+    def cmd_pull(self, args: List[str]):
+        """Pull secrets from git store."""
+        self.store.pull(self.manager.secrets_dir)
+
+    def cmd_sync(self, args: List[str]):
+        """Sync secrets with git store."""
+        message = " ".join(args) if args else None
+        self.store.sync(self.manager.secrets_dir, message)
+
+    def cmd_status(self, args: List[str]):
+        """Show store status."""
+        status = self.store.status()
+
+        console.print("[bold]Secrets Store Status:[/bold]")
+        console.print(f"  Initialized: {status['initialized']}")
+        console.print(f"  Path: {status['store_path']}")
+
+        if status["initialized"]:
+            console.print(f"  Branch: {status['branch']}")
+            console.print(f"  Commit: {status['commit']}")
+            console.print(f"  Clean: {status['clean']}")
+
+            if status["has_remote"]:
+                console.print(f"  Remote: {status['remote_url']}")
+            else:
+                console.print("  Remote: [dim]Not configured[/dim]")
+
+    def cmd_help(self, args: List[str]):
+        """Show help information."""
+        console.print("[bold]Available Commands:[/bold]\n")
+
+        help_text = {
+            "set": "Set a secret value",
+            "get": "Get a secret value",
+            "list": "List all secrets (use 'list all' for all namespaces)",
+            "delete": "Delete a secret",
+            "namespace": "Switch namespace or list namespaces (alias: ns)",
+            "export": "Export secrets as environment variables",
+            "import": "Import secrets from .env file",
+            "push": "Push secrets to git store",
+            "pull": "Pull secrets from git store",
+            "sync": "Sync secrets with git store",
+            "status": "Show store status",
+            "help": "Show this help",
+            "exit": "Exit the shell (alias: quit)",
+        }
+
+        for cmd, desc in help_text.items():
+            console.print(f"  [cyan]{cmd:12}[/cyan] {desc}")
+
+        console.print("\n[bold]Examples:[/bold]")
+        console.print("  set api-key sk-1234567890")
+        console.print("  get api-key")
+        console.print("  namespace production")
+        console.print("  export file production.env")
+        console.print("  import .env.local")
+
+    def cmd_exit(self, args: List[str]):
+        """Exit the REPL."""
+        self.running = False
+        console.print("\nGoodbye!")
+
+
+def run_repl():
+    """Entry point for the REPL."""
+    repl = SecretsREPL()
+    repl.run()

mcli/lib/secrets/store.py

@@ -0,0 +1,246 @@
+"""
+Git-based secrets store for synchronization across machines.
+"""
+
+import os
+import shutil
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import click
+from git import GitCommandError, Repo
+
+from mcli.lib.logger.logger import get_logger
+
+logger = get_logger(__name__)
+from mcli.lib.ui.styling import error, info, success, warning
+
+
+class SecretsStore:
+    """Manages git-based secrets synchronization."""
+
+    def __init__(self, store_path: Optional[Path] = None):
+        """Initialize the secrets store.
+
+        Args:
+            store_path: Path to git repository for secrets. Defaults to ~/repos/mcli-secrets
+        """
+        self.store_path = store_path or Path.home() / "repos" / "mcli-secrets"
+        self.config_file = Path.home() / ".mcli" / "secrets-store.conf"
+        self.load_config()
+
+    def load_config(self) -> None:
+        """Load store configuration."""
+        self.store_config = {}
+        if self.config_file.exists():
+            with open(self.config_file) as f:
+                for line in f:
+                    line = line.strip()
+                    if "=" in line:
+                        key, value = line.split("=", 1)
+                        self.store_config[key.strip()] = value.strip()
+
+        # Override store path if configured
+        if "store_path" in self.store_config:
+            self.store_path = Path(self.store_config["store_path"])
+
+    def save_config(self) -> None:
+        """Save store configuration."""
+        self.config_file.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.config_file, "w") as f:
+            for key, value in self.store_config.items():
+                f.write(f"{key}={value}\n")
+
+    def init(self, remote_url: Optional[str] = None) -> None:
+        """Initialize the secrets store repository.
+
+        Args:
+            remote_url: Optional git remote URL
+        """
+        if self.store_path.exists() and (self.store_path / ".git").exists():
+            error("Store already initialized")
+            return
+
+        self.store_path.mkdir(parents=True, exist_ok=True)
+
+        try:
+            repo = Repo.init(self.store_path)
+
+            # Create README
+            readme_path = self.store_path / "README.md"
+            readme_path.write_text(
+                "# MCLI Secrets Store\n\n"
+                "This repository stores encrypted secrets for MCLI.\n\n"
+                "**WARNING**: This repository contains encrypted sensitive data.\n"
+                "Ensure it is kept private and access is restricted.\n"
+            )
+
+            # Create .gitignore
+            gitignore_path = self.store_path / ".gitignore"
+            gitignore_path.write_text("*.key\n*.tmp\n.DS_Store\n")
+
+            repo.index.add([readme_path.name, gitignore_path.name])
+            repo.index.commit("Initial commit")
+
+            if remote_url:
+                repo.create_remote("origin", remote_url)
+                self.store_config["remote_url"] = remote_url
+                self.save_config()
+                info(f"Remote added: {remote_url}")
+
+            success(f"Secrets store initialized at {self.store_path}")
+
+        except GitCommandError as e:
+            error(f"Failed to initialize store: {e}")
+
+    def push(self, secrets_dir: Path, message: Optional[str] = None) -> None:
+        """Push secrets to the store.
+
+        Args:
+            secrets_dir: Directory containing encrypted secrets
+            message: Commit message
+        """
+        if not self._check_initialized():
+            return
+
+        try:
+            repo = Repo(self.store_path)
+
+            # Copy secrets to store
+            store_secrets_dir = self.store_path / "secrets"
+
+            # Remove existing secrets
+            if store_secrets_dir.exists():
+                shutil.rmtree(store_secrets_dir)
+
+            # Copy new secrets
+            shutil.copytree(secrets_dir, store_secrets_dir)
+
+            # Add to git
+            repo.index.add(["secrets"])
+
+            # Check if there are changes
+            if repo.is_dirty():
+                message = message or f"Update secrets from {os.uname().nodename}"
+                repo.index.commit(message)
+
+                # Push if remote exists
+                if "origin" in repo.remotes:
+                    info("Pushing to remote...")
+                    repo.remotes.origin.push()
+                    success("Secrets pushed to remote")
+                else:
+                    success("Secrets committed locally")
+            else:
+                info("No changes to push")
+
+        except GitCommandError as e:
+            error(f"Failed to push secrets: {e}")
+
+    def pull(self, secrets_dir: Path) -> None:
+        """Pull secrets from the store.
+
+        Args:
+            secrets_dir: Directory to store pulled secrets
+        """
+        if not self._check_initialized():
+            return
+
+        try:
+            repo = Repo(self.store_path)
+
+            # Pull from remote if exists
+            if "origin" in repo.remotes:
+                info("Pulling from remote...")
+                repo.remotes.origin.pull()
+
+            # Copy secrets from store
+            store_secrets_dir = self.store_path / "secrets"
+
+            if not store_secrets_dir.exists():
+                warning("No secrets found in store")
+                return
+
+            # Backup existing secrets
+            if secrets_dir.exists():
+                backup_dir = secrets_dir.parent / f"{secrets_dir.name}.backup"
+                if backup_dir.exists():
+                    shutil.rmtree(backup_dir)
+                shutil.move(str(secrets_dir), str(backup_dir))
+                info(f"Existing secrets backed up to {backup_dir}")
+
+            # Copy secrets from store
+            shutil.copytree(store_secrets_dir, secrets_dir)
+
+            success(f"Secrets pulled to {secrets_dir}")
+
+        except GitCommandError as e:
+            error(f"Failed to pull secrets: {e}")
+
+    def sync(self, secrets_dir: Path, message: Optional[str] = None) -> None:
+        """Synchronize secrets (pull then push).
+
+        Args:
+            secrets_dir: Directory containing secrets
+            message: Commit message
+        """
+        if not self._check_initialized():
+            return
+
+        info("Synchronizing secrets...")
+
+        # First pull
+        self.pull(secrets_dir)
+
+        # Then push
+        self.push(secrets_dir, message)
+
+    def status(self) -> Dict[str, Any]:
+        """Get status of the secrets store.
+
+        Returns:
+            Status information
+        """
+        status = {
+            "initialized": False,
+            "store_path": str(self.store_path),
+            "has_remote": False,
+            "remote_url": None,
+            "clean": True,
+            "branch": None,
+            "commit": None,
+        }
+
+        if not self._check_initialized(silent=True):
+            return status
+
+        try:
+            repo = Repo(self.store_path)
+            status["initialized"] = True
+            status["clean"] = not repo.is_dirty()
+            status["branch"] = repo.active_branch.name
+            status["commit"] = str(repo.head.commit)[:8]
+
+            if "origin" in repo.remotes:
+                status["has_remote"] = True
+                status["remote_url"] = repo.remotes.origin.url
+
+        except Exception:
+            pass
+
+        return status
+
+    def _check_initialized(self, silent: bool = False) -> bool:
+        """Check if store is initialized.
+
+        Args:
+            silent: Don't print error message
+
+        Returns:
+            True if initialized
+        """
+        if not self.store_path.exists() or not (self.store_path / ".git").exists():
+            if not silent:
+                error("Store not initialized. Run 'mcli secrets store init' first.")
+            return False
+        return True

mcli/ml/backtesting/backtest_engine.py

@@ -13,9 +13,7 @@ from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 import numpy as np
 import pandas as pd
 
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), "../.."))
-
-from ml.models.recommendation_models import PortfolioRecommendation, StockRecommendationModel
+from mcli.ml.models.recommendation_models import PortfolioRecommendation, StockRecommendationModel
 
 logger = logging.getLogger(__name__)
 

mcli/ml/backtesting/run.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+"""Entry point for backtesting CLI."""
+
+import click
+
+from mcli.lib.ui.styling import error, info, success
+
+
+@click.group(name="mcli-backtest", help="Backtesting CLI for MCLI trading strategies")
+def cli():
+    """Main CLI group for backtesting."""
+    pass
+
+
+@cli.command(name="run", help="Run a backtest on historical data")
+@click.option("--strategy", required=True, help="Strategy to backtest")
+@click.option("--start-date", required=True, help="Start date (YYYY-MM-DD)")
+@click.option("--end-date", required=True, help="End date (YYYY-MM-DD)")
+@click.option("--initial-capital", default=100000, help="Initial capital")
+@click.option("--output", help="Output file for results")
+def run_backtest(strategy: str, start_date: str, end_date: str, initial_capital: float, output: str):
+    """Run a backtest with the specified parameters."""
+    info(f"Running backtest for strategy: {strategy}")
+    info(f"Period: {start_date} to {end_date}")
+    info(f"Initial capital: ${initial_capital:,.2f}")
+    
+    # TODO: Implement actual backtesting logic
+    error("Backtesting functionality not yet implemented")
+
+
+@cli.command(name="list", help="List available strategies")
+def list_strategies():
+    """List all available trading strategies."""
+    info("Available strategies:")
+    # TODO: Implement strategy listing
+    error("Strategy listing not yet implemented")
+
+
+@cli.command(name="analyze", help="Analyze backtest results")
+@click.argument("results_file")
+def analyze_results(results_file: str):
+    """Analyze backtest results from a file."""
+    info(f"Analyzing results from: {results_file}")
+    # TODO: Implement results analysis
+    error("Results analysis not yet implemented")
+
+
+def main():
+    """Main entry point."""
+    cli()
+
+
+if __name__ == "__main__":
+    main()

mcli/ml/models/ensemble_models.py

@@ -9,7 +9,7 @@ import pandas as pd
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
-from base_models import BaseStockModel, ModelMetrics, ValidationResult
+from mcli.ml.models.base_models import BaseStockModel, ModelMetrics, ValidationResult
 
 logger = logging.getLogger(__name__)
 

mcli/ml/models/recommendation_models.py

@@ -10,8 +10,8 @@ import pandas as pd
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
-from base_models import BaseStockModel, ModelMetrics, ValidationResult
-from ensemble_models import DeepEnsembleModel, EnsembleConfig, ModelConfig
+from mcli.ml.models.base_models import BaseStockModel, ModelMetrics, ValidationResult
+from mcli.ml.models.ensemble_models import DeepEnsembleModel, EnsembleConfig, ModelConfig
 
 logger = logging.getLogger(__name__)
 

mcli/ml/optimization/optimize.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""Entry point for portfolio optimization CLI."""
+
+import click
+
+from mcli.lib.ui.styling import error, info, success
+
+
+@click.group(name="mcli-optimize", help="Portfolio optimization CLI for MCLI trading system")
+def cli():
+    """Main CLI group for portfolio optimization."""
+    pass
+
+
+@cli.command(name="portfolio", help="Optimize portfolio allocation")
+@click.option("--symbols", required=True, help="Comma-separated list of symbols")
+@click.option("--start-date", required=True, help="Start date (YYYY-MM-DD)")
+@click.option("--end-date", required=True, help="End date (YYYY-MM-DD)")
+@click.option("--risk-free-rate", default=0.02, help="Risk-free rate")
+@click.option("--output", help="Output file for results")
+def optimize_portfolio(symbols: str, start_date: str, end_date: str, risk_free_rate: float, output: str):
+    """Optimize portfolio allocation for given symbols."""
+    symbol_list = [s.strip() for s in symbols.split(",")]
+    info(f"Optimizing portfolio for: {', '.join(symbol_list)}")
+    info(f"Period: {start_date} to {end_date}")
+    info(f"Risk-free rate: {risk_free_rate:.2%}")
+    
+    # TODO: Implement actual optimization
+    error("Portfolio optimization not yet implemented")
+
+
+@cli.command(name="efficient-frontier", help="Generate efficient frontier")
+@click.option("--symbols", required=True, help="Comma-separated list of symbols")
+@click.option("--points", default=100, help="Number of points on frontier")
+def efficient_frontier(symbols: str, points: int):
+    """Generate efficient frontier for given symbols."""
+    symbol_list = [s.strip() for s in symbols.split(",")]
+    info(f"Generating efficient frontier for: {', '.join(symbol_list)}")
+    info(f"Points: {points}")
+    
+    # TODO: Implement efficient frontier generation
+    error("Efficient frontier generation not yet implemented")
+
+
+def main():
+    """Main entry point."""
+    cli()
+
+
+if __name__ == "__main__":
+    main()

mcli/ml/serving/__init__.py

@@ -0,0 +1 @@
+"""Model serving module for MCLI ML system."""