mcli-framework 7.8.1__py3-none-any.whl → 7.8.3__py3-none-any.whl

mcli/ml/dashboard/app_supabase.py

@@ -1,6 +1,7 @@
 """Streamlit dashboard for ML system monitoring - Supabase version"""
 
 import asyncio
+import os
 from datetime import datetime, timedelta
 
 import numpy as np

mcli/self/self_cmd.py

@@ -1280,6 +1280,14 @@ try:
 except ImportError as e:
     logger.debug(f"Could not load visual command: {e}")
 
+try:
+    from mcli.self.store_cmd import store
+
+    self_app.add_command(store, name="store")
+    logger.debug("Added store command to self group")
+except ImportError as e:
+    logger.debug(f"Could not load store command: {e}")
+
 # This part is important to make the command available to the CLI
 if __name__ == "__main__":
     self_app()

mcli/self/store_cmd.py

@@ -0,0 +1,422 @@
+"""
+Command Store Management - Sync ~/.mcli/commands/ to git
+Similar to lsh secrets but for workflow commands
+"""
+
+import click
+import os
+import shutil
+import subprocess
+from pathlib import Path
+from datetime import datetime
+from mcli.lib.ui.styling import success, error, info, warning
+from mcli.lib.logger.logger import get_logger
+
+logger = get_logger()
+
+# Default store location
+DEFAULT_STORE_PATH = Path.home() / "repos" / "mcli-commands"
+COMMANDS_PATH = Path.home() / ".mcli" / "commands"
+
+
+@click.group(name="store")
+def store():
+    """Manage command store - sync ~/.mcli/commands/ to git"""
+    pass
+
+
+@store.command(name="init")
+@click.option("--path", "-p", type=click.Path(), help=f"Store path (default: {DEFAULT_STORE_PATH})")
+@click.option("--remote", "-r", help="Git remote URL (optional)")
+def init_store(path, remote):
+    """Initialize command store with git"""
+    store_path = Path(path) if path else DEFAULT_STORE_PATH
+
+    try:
+        # Create store directory
+        store_path.mkdir(parents=True, exist_ok=True)
+
+        # Initialize git if not already initialized
+        git_dir = store_path / ".git"
+        if not git_dir.exists():
+            subprocess.run(["git", "init"], cwd=store_path, check=True, capture_output=True)
+            success(f"Initialized git repository at {store_path}")
+
+            # Create .gitignore
+            gitignore = store_path / ".gitignore"
+            gitignore.write_text("*.backup\n.DS_Store\n")
+
+            # Create README
+            readme = store_path / "README.md"
+            readme.write_text(
+                f"""# MCLI Commands Store
+
+Personal workflow commands for mcli framework.
+
+## Usage
+
+Push commands:
+```bash
+mcli self store push
+```
+
+Pull commands:
+```bash
+mcli self store pull
+```
+
+Sync (bidirectional):
+```bash
+mcli self store sync
+```
+
+## Structure
+
+All JSON command files from `~/.mcli/commands/` are stored here and version controlled.
+
+Last updated: {datetime.now().isoformat()}
+"""
+            )
+
+            # Add remote if provided
+            if remote:
+                subprocess.run(
+                    ["git", "remote", "add", "origin", remote], cwd=store_path, check=True
+                )
+                success(f"Added remote: {remote}")
+        else:
+            info(f"Git repository already exists at {store_path}")
+
+        # Save store path to config
+        config_file = Path.home() / ".mcli" / "store.conf"
+        config_file.parent.mkdir(parents=True, exist_ok=True)
+        config_file.write_text(str(store_path))
+
+        success(f"Command store initialized at {store_path}")
+        info(f"Store path saved to {config_file}")
+
+    except subprocess.CalledProcessError as e:
+        error(f"Git command failed: {e}")
+        logger.error(f"Git init failed: {e}")
+    except Exception as e:
+        error(f"Failed to initialize store: {e}")
+        logger.exception(e)
+
+
+@store.command(name="push")
+@click.option("--message", "-m", help="Commit message")
+@click.option("--all", "-a", is_flag=True, help="Push all files (including backups)")
+def push_commands(message, all):
+    """Push commands from ~/.mcli/commands/ to git store"""
+    try:
+        store_path = _get_store_path()
+
+        # Copy commands to store
+        info(f"Copying commands from {COMMANDS_PATH} to {store_path}...")
+
+        copied_count = 0
+        for item in COMMANDS_PATH.glob("*"):
+            # Skip backups unless --all specified
+            if not all and item.name.endswith(".backup"):
+                continue
+
+            dest = store_path / item.name
+            if item.is_file():
+                shutil.copy2(item, dest)
+                copied_count += 1
+            elif item.is_dir():
+                shutil.copytree(item, dest, dirs_exist_ok=True)
+                copied_count += 1
+
+        success(f"Copied {copied_count} items to store")
+
+        # Git add, commit, push
+        subprocess.run(["git", "add", "."], cwd=store_path, check=True)
+
+        # Check if there are changes
+        result = subprocess.run(
+            ["git", "status", "--porcelain"], cwd=store_path, capture_output=True, text=True
+        )
+
+        if not result.stdout.strip():
+            info("No changes to commit")
+            return
+
+        # Commit with message
+        commit_msg = message or f"Update commands {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
+        subprocess.run(["git", "commit", "-m", commit_msg], cwd=store_path, check=True)
+        success(f"Committed changes: {commit_msg}")
+
+        # Push to remote if configured
+        try:
+            subprocess.run(["git", "push"], cwd=store_path, check=True, capture_output=True)
+            success("Pushed to remote")
+        except subprocess.CalledProcessError:
+            warning("No remote configured or push failed. Commands committed locally.")
+
+    except Exception as e:
+        error(f"Failed to push commands: {e}")
+        logger.exception(e)
+
+
+@store.command(name="pull")
+@click.option("--force", "-f", is_flag=True, help="Overwrite local commands without backup")
+def pull_commands(force):
+    """Pull commands from git store to ~/.mcli/commands/"""
+    try:
+        store_path = _get_store_path()
+
+        # Pull from remote
+        try:
+            subprocess.run(["git", "pull"], cwd=store_path, check=True)
+            success("Pulled latest changes from remote")
+        except subprocess.CalledProcessError:
+            warning("No remote configured or pull failed. Using local store.")
+
+        # Backup existing commands if not force
+        if not force and COMMANDS_PATH.exists():
+            backup_dir = (
+                COMMANDS_PATH.parent / f"commands_backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+            )
+            shutil.copytree(COMMANDS_PATH, backup_dir)
+            info(f"Backed up existing commands to {backup_dir}")
+
+        # Copy from store to commands directory
+        info(f"Copying commands from {store_path} to {COMMANDS_PATH}...")
+
+        COMMANDS_PATH.mkdir(parents=True, exist_ok=True)
+
+        copied_count = 0
+        for item in store_path.glob("*"):
+            # Skip git directory and README
+            if item.name in [".git", "README.md", ".gitignore"]:
+                continue
+
+            dest = COMMANDS_PATH / item.name
+            if item.is_file():
+                shutil.copy2(item, dest)
+                copied_count += 1
+            elif item.is_dir():
+                shutil.copytree(item, dest, dirs_exist_ok=True)
+                copied_count += 1
+
+        success(f"Pulled {copied_count} items from store")
+
+    except Exception as e:
+        error(f"Failed to pull commands: {e}")
+        logger.exception(e)
+
+
+@store.command(name="sync")
+@click.option("--message", "-m", help="Commit message if pushing")
+def sync_commands(message):
+    """Sync commands bidirectionally (pull then push if changes)"""
+    try:
+        store_path = _get_store_path()
+
+        # First pull
+        info("Pulling latest changes...")
+        try:
+            subprocess.run(["git", "pull"], cwd=store_path, check=True, capture_output=True)
+            success("Pulled from remote")
+        except subprocess.CalledProcessError:
+            warning("No remote or pull failed")
+
+        # Then push local changes
+        info("Pushing local changes...")
+
+        # Copy commands
+        for item in COMMANDS_PATH.glob("*"):
+            if item.name.endswith(".backup"):
+                continue
+            dest = store_path / item.name
+            if item.is_file():
+                shutil.copy2(item, dest)
+            elif item.is_dir():
+                shutil.copytree(item, dest, dirs_exist_ok=True)
+
+        # Check for changes
+        result = subprocess.run(
+            ["git", "status", "--porcelain"], cwd=store_path, capture_output=True, text=True
+        )
+
+        if not result.stdout.strip():
+            success("Everything in sync!")
+            return
+
+        # Commit and push
+        subprocess.run(["git", "add", "."], cwd=store_path, check=True)
+        commit_msg = message or f"Sync commands {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
+        subprocess.run(["git", "commit", "-m", commit_msg], cwd=store_path, check=True)
+
+        try:
+            subprocess.run(["git", "push"], cwd=store_path, check=True, capture_output=True)
+            success("Synced and pushed to remote")
+        except subprocess.CalledProcessError:
+            success("Synced locally (no remote configured)")
+
+    except Exception as e:
+        error(f"Sync failed: {e}")
+        logger.exception(e)
+
+
+@store.command(name="list")
+@click.option("--store", "-s", is_flag=True, help="List store instead of local")
+def list_commands(store):
+    """List all commands"""
+    try:
+        if store:
+            store_path = _get_store_path()
+            path = store_path
+            title = f"Commands in store ({store_path})"
+        else:
+            path = COMMANDS_PATH
+            title = f"Local commands ({COMMANDS_PATH})"
+
+        click.echo(f"\n{title}:\n")
+
+        if not path.exists():
+            warning(f"Directory does not exist: {path}")
+            return
+
+        items = sorted(path.glob("*"))
+        if not items:
+            info("No commands found")
+            return
+
+        for item in items:
+            if item.name in [".git", ".gitignore", "README.md"]:
+                continue
+
+            if item.is_file():
+                size = item.stat().st_size / 1024
+                modified = datetime.fromtimestamp(item.stat().st_mtime).strftime("%Y-%m-%d %H:%M")
+                click.echo(f"  📄 {item.name:<40} {size:>8.1f} KB  {modified}")
+            elif item.is_dir():
+                count = len(list(item.glob("*")))
+                click.echo(f"  📁 {item.name:<40} {count:>3} files")
+
+        click.echo()
+
+    except Exception as e:
+        error(f"Failed to list commands: {e}")
+        logger.exception(e)
+
+
+@store.command(name="status")
+def store_status():
+    """Show git status of command store"""
+    try:
+        store_path = _get_store_path()
+
+        click.echo(f"\n📦 Store: {store_path}\n")
+
+        # Git status
+        result = subprocess.run(
+            ["git", "status", "--short", "--branch"], cwd=store_path, capture_output=True, text=True
+        )
+
+        if result.stdout:
+            click.echo(result.stdout)
+
+        # Show remote
+        result = subprocess.run(
+            ["git", "remote", "-v"], cwd=store_path, capture_output=True, text=True
+        )
+
+        if result.stdout:
+            click.echo("\n🌐 Remotes:")
+            click.echo(result.stdout)
+        else:
+            info("\nNo remote configured")
+
+        click.echo()
+
+    except Exception as e:
+        error(f"Failed to get status: {e}")
+        logger.exception(e)
+
+
+@store.command(name="show")
+@click.argument("command_name")
+@click.option("--store", "-s", is_flag=True, help="Show from store instead of local")
+def show_command(command_name, store):
+    """Show command file contents"""
+    try:
+        if store:
+            store_path = _get_store_path()
+            path = store_path / command_name
+        else:
+            path = COMMANDS_PATH / command_name
+
+        if not path.exists():
+            error(f"Command not found: {command_name}")
+            return
+
+        if path.is_file():
+            click.echo(f"\n📄 {path}:\n")
+            click.echo(path.read_text())
+        else:
+            info(f"{command_name} is a directory")
+            for item in sorted(path.glob("*")):
+                click.echo(f"  {item.name}")
+
+        click.echo()
+
+    except Exception as e:
+        error(f"Failed to show command: {e}")
+        logger.exception(e)
+
+
+@store.command(name="config")
+@click.option("--remote", "-r", help="Set git remote URL")
+@click.option("--path", "-p", type=click.Path(), help="Change store path")
+def configure_store(remote, path):
+    """Configure store settings"""
+    try:
+        store_path = _get_store_path()
+
+        if path:
+            new_path = Path(path).expanduser().resolve()
+            config_file = Path.home() / ".mcli" / "store.conf"
+            config_file.write_text(str(new_path))
+            success(f"Store path updated to: {new_path}")
+            return
+
+        if remote:
+            # Check if remote exists
+            result = subprocess.run(
+                ["git", "remote"], cwd=store_path, capture_output=True, text=True
+            )
+
+            if "origin" in result.stdout:
+                subprocess.run(
+                    ["git", "remote", "set-url", "origin", remote], cwd=store_path, check=True
+                )
+                success(f"Updated remote URL: {remote}")
+            else:
+                subprocess.run(
+                    ["git", "remote", "add", "origin", remote], cwd=store_path, check=True
+                )
+                success(f"Added remote URL: {remote}")
+
+    except Exception as e:
+        error(f"Configuration failed: {e}")
+        logger.exception(e)
+
+
+def _get_store_path() -> Path:
+    """Get store path from config or default"""
+    config_file = Path.home() / ".mcli" / "store.conf"
+
+    if config_file.exists():
+        store_path = Path(config_file.read_text().strip())
+        if store_path.exists():
+            return store_path
+
+    # Use default
+    return DEFAULT_STORE_PATH
+
+
+if __name__ == "__main__":
+    store()

mcli/workflow/dashboard/dashboard_cmd.py

@@ -0,0 +1,179 @@
+"""ML Dashboard commands for mcli."""
+
+import subprocess
+import sys
+from pathlib import Path
+
+import click
+
+from mcli.lib.logger.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+@click.group(name="dashboard")
+def dashboard():
+    """ML monitoring dashboard commands."""
+    pass
+
+
+@dashboard.command()
+@click.option("--port", "-p", default=8501, help="Port to run dashboard on")
+@click.option("--host", "-h", default="localhost", help="Host to bind to")
+@click.option("--debug", is_flag=True, help="Run in debug mode")
+@click.option(
+    "--variant",
+    "-v",
+    type=click.Choice(["integrated", "supabase", "training"]),
+    default="supabase",
+    help="Dashboard variant to launch (default: supabase)",
+)
+def launch(port, host, debug, variant):
+    """Launch the ML monitoring dashboard.
+
+    Variants:
+      - supabase: Politician trading dashboard with Supabase integration (default)
+      - integrated: Full ML dashboard with local database
+      - training: ML training dashboard
+    """
+
+    click.echo(f"🚀 Starting {variant.title()} Dashboard on http://{host}:{port}")
+
+    # Get the dashboard app path based on variant
+    dashboard_dir = Path(__file__).parent.parent.parent / "ml" / "dashboard"
+
+    if variant == "supabase":
+        dashboard_path = dashboard_dir / "app_supabase.py"
+    elif variant == "integrated":
+        dashboard_path = dashboard_dir / "app_integrated.py"
+    elif variant == "training":
+        dashboard_path = dashboard_dir / "app_training.py"
+    else:
+        dashboard_path = dashboard_dir / "app.py"
+
+    if not dashboard_path.exists():
+        click.echo(f"❌ Dashboard app not found at {dashboard_path}!")
+        logger.error(f"Dashboard app not found at {dashboard_path}")
+        sys.exit(1)
+
+    # Build streamlit command
+    cmd = [
+        sys.executable,
+        "-m",
+        "streamlit",
+        "run",
+        str(dashboard_path),
+        "--server.port",
+        str(port),
+        "--server.address",
+        host,
+        "--browser.gatherUsageStats",
+        "false",
+    ]
+
+    if debug:
+        cmd.extend(["--logger.level", "debug"])
+
+    click.echo(f"📊 Dashboard is starting from {dashboard_path.name}...")
+    click.echo("Press Ctrl+C to stop")
+
+    try:
+        subprocess.run(cmd, check=True)
+    except KeyboardInterrupt:
+        click.echo("\n⏹️  Dashboard stopped")
+    except subprocess.CalledProcessError as e:
+        click.echo(f"❌ Failed to start dashboard: {e}")
+        logger.error(f"Dashboard failed to start: {e}")
+        sys.exit(1)
+
+
+@dashboard.command()
+def info():
+    """Show dashboard information and status."""
+
+    click.echo("📊 ML Dashboard Information")
+    click.echo("━" * 40)
+
+    # Check if dependencies are installed
+    try:
+        import plotly
+        import streamlit
+
+        click.echo("✅ Dashboard dependencies installed")
+        click.echo(f"   Streamlit version: {streamlit.__version__}")
+        click.echo(f"   Plotly version: {plotly.__version__}")
+    except ImportError as e:
+        click.echo(f"❌ Missing dependencies: {e}")
+        click.echo("   Run: uv pip install streamlit plotly")
+
+    # Check Supabase configuration
+    import os
+
+    supabase_url = os.getenv("SUPABASE_URL")
+    supabase_key = os.getenv("SUPABASE_KEY") or os.getenv("SUPABASE_ANON_KEY")
+
+    click.echo("\n🔌 Supabase Configuration:")
+    if supabase_url:
+        click.echo(f"   URL: {supabase_url}")
+    else:
+        click.echo("   ❌ SUPABASE_URL not set")
+
+    if supabase_key:
+        click.echo(f"   Key: {'*' * 20}...{supabase_key[-8:]}")
+    else:
+        click.echo("   ❌ SUPABASE_KEY not set")
+
+    if not supabase_url or not supabase_key:
+        click.echo("\n⚠️  To configure Supabase, set environment variables:")
+        click.echo("   export SUPABASE_URL=https://your-project.supabase.co")
+        click.echo("   export SUPABASE_KEY=your-anon-key")
+
+    click.echo("\n💡 Quick start:")
+    click.echo("   mcli workflow dashboard launch                    # Launch Supabase dashboard")
+    click.echo("   mcli workflow dashboard launch --variant training # Launch training dashboard")
+    click.echo("   mcli workflow dashboard launch --port 8502        # Custom port")
+    click.echo("   mcli workflow dashboard launch --host 0.0.0.0     # Expose to network")
+
+
+@dashboard.command()
+def test():
+    """Test Supabase connection."""
+    import os
+    from mcli.ml.dashboard.common import get_supabase_client
+
+    click.echo("🔍 Testing Supabase connection...")
+    click.echo("━" * 40)
+
+    # Check environment variables
+    url = os.getenv("SUPABASE_URL")
+    key = os.getenv("SUPABASE_KEY") or os.getenv("SUPABASE_ANON_KEY")
+
+    if not url:
+        click.echo("❌ SUPABASE_URL not set")
+        sys.exit(1)
+
+    if not key:
+        click.echo("❌ SUPABASE_KEY or SUPABASE_ANON_KEY not set")
+        sys.exit(1)
+
+    click.echo(f"✅ URL configured: {url}")
+    click.echo(f"✅ Key configured: {'*' * 20}...{key[-8:]}")
+
+    # Try to connect
+    client = get_supabase_client()
+
+    if not client:
+        click.echo("❌ Failed to create Supabase client")
+        sys.exit(1)
+
+    click.echo("✅ Supabase client created")
+
+    # Try to query a table
+    try:
+        response = client.table("politicians").select("id").limit(1).execute()
+        click.echo(f"✅ Successfully queried 'politicians' table ({len(response.data)} records)")
+    except Exception as e:
+        click.echo(f"⚠️  Could not query 'politicians' table: {e}")
+        click.echo("   (Table might not exist yet)")
+
+    click.echo("\n✅ Connection test passed!")