mcli-framework 7.0.0__py3-none-any.whl

mcli/workflow/daemon/test_daemon.py

@@ -0,0 +1,275 @@
+#!/usr/bin/env python3
+"""
+Test script for the MCLI Daemon Service.
+
+This script demonstrates the daemon functionality by creating and executing
+example commands in different programming languages.
+"""
+
+import os
+import subprocess
+import tempfile
+import time
+from pathlib import Path
+
+
+def create_test_scripts():
+    """Create test scripts for different languages"""
+    scripts = {}
+
+    # Python script
+    python_script = '''#!/usr/bin/env python3
+import sys
+import json
+
+def process_data(input_data):
+    """Process input data and return result"""
+    try:
+        data = json.loads(input_data)
+        result = {
+            "processed": True,
+            "count": len(data),
+            "sum": sum(data) if isinstance(data, list) else 0,
+            "timestamp": time.time()
+        }
+        return json.dumps(result)
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+if __name__ == "__main__":
+    import time
+    input_data = sys.argv[1] if len(sys.argv) > 1 else '[1, 2, 3, 4, 5]'
+    result = process_data(input_data)
+    print(result)
+'''
+    scripts["python"] = python_script
+
+    # Node.js script
+    node_script = """#!/usr/bin/env node
+const fs = require('fs');
+
+function processFile(filename) {
+    try {
+        const content = fs.readFileSync(filename, 'utf8');
+        const lines = content.split('\\n').filter(line => line.trim());
+        const result = {
+            filename: filename,
+            lineCount: lines.length,
+            wordCount: content.split('\\s+').filter(word => word.trim()).length,
+            timestamp: new Date().toISOString()
+        };
+        console.log(JSON.stringify(result, null, 2));
+    } catch (error) {
+        console.error(JSON.stringify({error: error.message}));
+    }
+}
+
+const filename = process.argv[2] || __filename;
+processFile(filename);
+"""
+    scripts["node"] = node_script
+
+    # Shell script
+    shell_script = """#!/bin/bash
+
+# Simple system info script
+echo "=== System Information ==="
+echo "Hostname: $(hostname)"
+echo "OS: $(uname -s)"
+echo "Architecture: $(uname -m)"
+echo "Uptime: $(uptime)"
+echo "Memory: $(free -h | grep Mem | awk '{print $2}')"
+echo "Disk Usage: $(df -h / | tail -1 | awk '{print $5}')"
+echo "=== End ==="
+"""
+    scripts["shell"] = shell_script
+
+    return scripts
+
+
+def test_daemon_functionality():
+    """Test the daemon functionality"""
+    print("🧪 Testing MCLI Daemon Service")
+    print("=" * 50)
+
+    # Create test scripts
+    scripts = create_test_scripts()
+
+    # Create temporary directory for test scripts
+    with tempfile.TemporaryDirectory() as temp_dir:
+        temp_path = Path(temp_dir)
+
+        # Write test scripts
+        script_files = {}
+        for lang, script in scripts.items():
+            if lang == "python":
+                filename = temp_path / "test_script.py"
+            elif lang == "node":
+                filename = temp_path / "test_script.js"
+            elif lang == "shell":
+                filename = temp_path / "test_script.sh"
+
+            with open(filename, "w") as f:
+                f.write(script)
+
+            # Make shell script executable
+            if lang == "shell":
+                os.chmod(filename, 0o755)
+
+            script_files[lang] = filename
+
+        print("✅ Test scripts created")
+
+        # Test daemon commands
+        try:
+            # Test daemon status
+            print("\n📊 Testing daemon status...")
+            result = subprocess.run(
+                ["mcli", "workflow", "daemon", "status"], capture_output=True, text=True
+            )
+            print(f"Status: {result.stdout.strip()}")
+
+            # Test adding commands
+            print("\n➕ Testing command addition...")
+            for lang, script_file in script_files.items():
+                print(f"Adding {lang} command...")
+                result = subprocess.run(
+                    [
+                        "mcli",
+                        "workflow",
+                        "daemon",
+                        "client",
+                        "add-file",
+                        f"test-{lang}",
+                        str(script_file),
+                        "--description",
+                        f"Test {lang} script",
+                        "--language",
+                        lang,
+                        "--group",
+                        "test",
+                        "--tags",
+                        f"test,{lang},demo",
+                    ],
+                    capture_output=True,
+                    text=True,
+                )
+
+                if result.returncode == 0:
+                    print(f"✅ {lang} command added successfully")
+                else:
+                    print(f"❌ Failed to add {lang} command: {result.stderr}")
+
+            # Test listing commands
+            print("\n📋 Testing command listing...")
+            result = subprocess.run(
+                ["mcli", "workflow", "daemon", "client", "list"], capture_output=True, text=True
+            )
+            print(result.stdout)
+
+            # Test searching commands
+            print("\n🔍 Testing command search...")
+            result = subprocess.run(
+                ["mcli", "workflow", "daemon", "client", "search", "test"],
+                capture_output=True,
+                text=True,
+            )
+            print(result.stdout)
+
+            # Test command execution (if we can get command IDs)
+            print("\n⚡ Testing command execution...")
+            # Note: In a real scenario, you'd get the command ID from the add command output
+            # For this test, we'll just show the command structure
+            print("Command execution would be tested with:")
+            print("mcli workflow daemon client execute <command-id> [args...]")
+
+        except Exception as e:
+            print(f"❌ Error during testing: {e}")
+
+    print("\n✅ Daemon functionality test completed!")
+
+
+def show_usage_examples():
+    """Show usage examples"""
+    print("\n📚 Usage Examples")
+    print("=" * 50)
+
+    examples = [
+        {
+            "title": "Start the daemon",
+            "command": "mcli workflow daemon start",
+            "description": "Start the background daemon service",
+        },
+        {
+            "title": "Add a Python command",
+            "command": "mcli workflow daemon client add-file my-script script.py --language python --group utils",
+            "description": "Add a Python script as a command",
+        },
+        {
+            "title": "Add command interactively",
+            "command": "mcli workflow daemon client add-interactive",
+            "description": "Interactive command creation with prompts",
+        },
+        {
+            "title": "Search for commands",
+            "command": "mcli workflow daemon client search 'data processing'",
+            "description": "Search for commands by name, description, or tags",
+        },
+        {
+            "title": "Execute a command",
+            "command": "mcli workflow daemon client execute <command-id> arg1 arg2",
+            "description": "Execute a stored command with arguments",
+        },
+        {
+            "title": "List all commands",
+            "command": "mcli workflow daemon client list",
+            "description": "List all stored commands",
+        },
+        {
+            "title": "Show command details",
+            "command": "mcli workflow daemon client show <command-id>",
+            "description": "Show detailed information about a command",
+        },
+    ]
+
+    for i, example in enumerate(examples, 1):
+        print(f"\n{i}. {example['title']}")
+        print(f"   Command: {example['command']}")
+        print(f"   Description: {example['description']}")
+
+
+def main():
+    """Main test function"""
+    print("🚀 MCLI Daemon Service Test Suite")
+    print("=" * 60)
+
+    # Check if mcli is available
+    try:
+        result = subprocess.run(["mcli", "--version"], capture_output=True, text=True)
+        if result.returncode != 0:
+            print("❌ MCLI not found or not working properly")
+            return
+    except FileNotFoundError:
+        print("❌ MCLI command not found in PATH")
+        return
+
+    print("✅ MCLI is available")
+
+    # Show usage examples
+    show_usage_examples()
+
+    # Ask if user wants to run tests
+    print("\n" + "=" * 60)
+    response = input("Would you like to run the daemon functionality tests? (y/n): ")
+
+    if response.lower() in ["y", "yes"]:
+        test_daemon_functionality()
+    else:
+        print("Skipping tests. You can run them manually using the examples above.")
+
+    print("\n🎉 Test suite completed!")
+    print("\nFor more information, see: src/mcli/workflow/daemon/README.md")
+
+
+if __name__ == "__main__":
+    main()

mcli/workflow/dashboard/dashboard_cmd.py

@@ -0,0 +1,113 @@
+"""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")
+def launch(port, host, debug):
+    """Launch the ML monitoring dashboard."""
+
+    click.echo(f"🚀 Starting ML Dashboard on http://{host}:{port}")
+
+    # Get the dashboard app path - use Supabase version to avoid joblib issues
+    dashboard_path = Path(__file__).parent.parent.parent / "ml" / "dashboard" / "app_supabase.py"
+
+    if not dashboard_path.exists():
+        click.echo("❌ Dashboard app not found!")
+        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("📊 Dashboard is starting...")
+    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 streamlit
+        import plotly
+
+        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 sync --extra dashboard")
+
+    # Check database connection
+    try:
+        from mcli.ml.config import settings
+        click.echo(f"\n📁 Database URL: {settings.database.url}")
+        click.echo(f"📍 Redis URL: {settings.redis.url}")
+    except Exception as e:
+        click.echo(f"⚠️  Configuration not available: {e}")
+
+    click.echo("\n💡 Quick start:")
+    click.echo("   mcli workflow dashboard launch")
+    click.echo("   mcli workflow dashboard launch --port 8502 --host 0.0.0.0")
+
+
+@dashboard.command()
+@click.argument("action", type=click.Choice(["start", "stop", "restart"]))
+def service(action):
+    """Manage dashboard as a background service."""
+
+    if action == "start":
+        click.echo("🚀 Starting dashboard service...")
+        # Could implement systemd or pm2 integration here
+        click.echo("⚠️  Service mode not yet implemented")
+        click.echo("   Use 'mcli workflow dashboard launch' instead")
+    elif action == "stop":
+        click.echo("⏹️  Stopping dashboard service...")
+        click.echo("⚠️  Service mode not yet implemented")
+    elif action == "restart":
+        click.echo("🔄 Restarting dashboard service...")
+        click.echo("⚠️  Service mode not yet implemented")
+
+
+if __name__ == "__main__":
+    dashboard()

mcli/workflow/file/file.py

@@ -0,0 +1,100 @@
+import click
+import fitz  # PyMuPDF
+
+
+@click.group(name="file")
+def file():
+    """Personal file utility to use with custom and/or default file system paths."""
+    pass
+
+
+@file.command()
+@click.argument("input_oxps", type=click.Path(exists=True))
+@click.argument("output_pdf", type=click.Path())
+def oxps_to_pdf(input_oxps, output_pdf):
+    """Converts an OXPS file (INPUT_OXPS) to a PDF file (OUTPUT_PDF)."""
+    try:
+        # Open the OXPS file
+        oxps_document = fitz.open(input_oxps)
+
+        # Convert to PDF bytes
+        pdf_bytes = oxps_document.convert_to_pdf()
+
+        # Open the PDF bytes as a new PDF document
+        pdf_document = fitz.open("pdf", pdf_bytes)
+
+        # Save the PDF document to a file
+        pdf_document.save(output_pdf)
+
+        click.echo(f"Successfully converted '{input_oxps}' to '{output_pdf}'")
+
+    except Exception as e:
+        click.echo(f"Error converting file: {e}", err=True)
+
+
+import os
+import subprocess
+from pathlib import Path
+from typing import List, Optional
+
+DEFAULT_DIRS = ["~/repos/lefv-vault", "~/Documents/OneDrive", "~/Documents/Documents"]
+
+
+@file.command(name="search")
+@click.argument("search-string", type=str)
+@click.argument("search-dirs", default=DEFAULT_DIRS)
+@click.argument("context-lines", default=3, type=int)
+def find_string_with_fzf(
+    search_string: str = "foo",
+    search_dirs: Optional[List[str]] = DEFAULT_DIRS,
+    context_lines: int = 3,
+) -> List[str]:
+    """
+    Search for a string with ripgrep in given directories and select matches with fzf.
+
+    Parameters:
+        search_string (str): The string to search for.
+        search_dirs (Optional[List[str]]): Directories to search in. Defaults to a predefined list.
+        context_lines (int): Number of lines of context above and below the match.
+
+    Returns:
+        List[str]: List of selected lines with context from fzf.
+    """
+    if not search_string.strip():
+        raise ValueError("Search string cannot be empty")
+
+    dirs_to_search = search_dirs or DEFAULT_DIRS
+    expanded_dirs = [str(Path(d).expanduser()) for d in dirs_to_search]
+
+    # Validate directories exist
+    valid_dirs = [d for d in expanded_dirs if Path(d).exists()]
+    if not valid_dirs:
+        raise FileNotFoundError("None of the provided or default directories exist")
+
+    # Run ripgrep with context lines
+    rg_command = ["rg", "--color=always", f"-C{context_lines}", search_string, *valid_dirs]
+
+    try:
+        rg_proc = subprocess.run(rg_command, capture_output=True, text=True, check=True)
+    except subprocess.CalledProcessError as e:
+        print("No matches found or error running rg.")
+        return []
+
+    # Pipe the output through fzf
+    try:
+        fzf_proc = subprocess.run(
+            ["fzf", "--ansi", "--multi"],
+            input=rg_proc.stdout,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        selections = fzf_proc.stdout.strip().split("\n")
+        return [s for s in selections if s.strip()]
+    except subprocess.CalledProcessError:
+        # User exited fzf without selection
+        return []
+
+
+if __name__ == "__main__":
+    file()

mcli/workflow/gcloud/config.toml

@@ -0,0 +1,21 @@
+[gcloud]
+default_project = "remote-ws-88"  # Default project value
+default_region = "us-west1"       # Default region value
+
+[workstations]
+cluster = "cluster-cirrus-ws"     # Default cluster value
+config = "config-cirrus-ws"       # Default config value
+
+[instances]
+alpha = "apps-luis-fernandez-de-la-vara"
+
+[tcp_tunnel]
+local_host = "127.0.0.1"         # Local host for TCP tunnel
+local_port = "2222"              # Local port for TCP tunnel
+remote_port = "22"               # Remote port for SSH connection
+
+[commands.describe]
+command = "describe"             # Command for querying workstation details
+
+[commands.tunnel]
+command = "start-tcp-tunnel"     # Command for establishing TCP tunnel

mcli/workflow/gcloud/gcloud.py

@@ -0,0 +1,58 @@
+import click
+
+# from mcli.public.mcli.lib.shell.shell import shell_exec, get_shell_script_path
+from mcli.lib.shell.shell import get_shell_script_path, shell_exec
+
+
+# Click CLI group renamed to 'gcloud'
+@click.group()
+def gcloud():
+    """gcloud utility - use this to interact with gcloud"""
+    pass
+
+
+@click.command()
+def start():
+    """Start a gcloud instance"""
+    scripts_path = get_shell_script_path("gcloud", __file__)
+    shell_exec(scripts_path, "start")
+
+
+@gcloud.command()
+def stop():
+    """Start a gcloud instance"""
+    scripts_path = get_shell_script_path("gcloud", __file__)
+    shell_exec(scripts_path, "stop")
+
+
+@gcloud.command()
+def describe():
+    """Start a gcloud instance"""
+    scripts_path = get_shell_script_path("gcloud", __file__)
+    shell_exec(scripts_path, "describe")
+
+
+@gcloud.command()
+@click.argument("remote-port", type=str)
+@click.argument("local-port", type=str)
+def tunnel(remote_port: str, local_port: str):
+    """Create an alpha tunnel using the instance"""
+    logger.info(f"Creating a tunnel at {remote_port} to local port {local_port}")
+    scripts_path = get_shell_script_path("gcloud", __file__)
+    shell_exec(scripts_path, "tunnel", remote_port, local_port)
+
+
+@gcloud.command()
+def login(remote_port: str, local_port: str):
+    """Login to gcloud"""
+    logger.info(f"Authenticating into gcloud")
+    scripts_path = get_shell_script_path("gcloud", __file__)
+    shell_exec(scripts_path, "login", remote_port, local_port)
+
+
+gcloud.add_command(start)
+gcloud.add_command(tunnel)
+
+
+if __name__ == "__main__":
+    gcloud()