mcli-framework 7.2.0__py3-none-any.whl → 7.4.0__py3-none-any.whl

mcli/self/self_cmd.py

@@ -344,8 +344,38 @@ def collect_commands() -> List[Dict[str, Any]]:
                 module_name = ".".join(relative_path.with_suffix("").parts)
 
                 try:
-                    # Try to import the module
-                    module = importlib.import_module(module_name)
+                    # Suppress Streamlit warnings and logging during module import
+                    import warnings
+                    import logging
+                    import sys
+                    import os
+                    from contextlib import redirect_stderr
+                    from io import StringIO
+                    
+                    # Suppress Python warnings
+                    with warnings.catch_warnings():
+                        warnings.filterwarnings("ignore", message=".*missing ScriptRunContext.*")
+                        warnings.filterwarnings("ignore", message=".*No runtime found.*")
+                        warnings.filterwarnings("ignore", message=".*Session state does not function.*")
+                        warnings.filterwarnings("ignore", message=".*to view this Streamlit app.*")
+                        
+                        # Suppress Streamlit logger warnings
+                        streamlit_logger = logging.getLogger("streamlit")
+                        original_level = streamlit_logger.level
+                        streamlit_logger.setLevel(logging.CRITICAL)
+                        
+                        # Also suppress specific Streamlit sub-loggers
+                        logging.getLogger("streamlit.runtime.scriptrunner_utils.script_run_context").setLevel(logging.CRITICAL)
+                        logging.getLogger("streamlit.runtime.caching.cache_data_api").setLevel(logging.CRITICAL)
+                        
+                        # Redirect stderr to suppress Streamlit warnings
+                        with redirect_stderr(StringIO()):
+                            try:
+                                # Try to import the module
+                                module = importlib.import_module(module_name)
+                            finally:
+                                # Restore original logging level
+                                streamlit_logger.setLevel(original_level)
 
                     # Extract command and group objects
                     for name, obj in inspect.getmembers(module):
@@ -387,23 +417,177 @@ def collect_commands() -> List[Dict[str, Any]]:
     return commands
 
 
-@self_app.command("add-command")
+def open_editor_for_command(command_name: str, command_group: str, description: str) -> Optional[str]:
+    """
+    Open the user's default editor to allow them to write command logic.
+    
+    Args:
+        command_name: Name of the command
+        command_group: Group for the command
+        description: Description of the command
+        
+    Returns:
+        The Python code written by the user, or None if cancelled
+    """
+    import tempfile
+    import subprocess
+    import os
+    import sys
+    from pathlib import Path
+    
+    # Get the user's default editor
+    editor = os.environ.get('EDITOR')
+    if not editor:
+        # Try common editors in order of preference
+        for common_editor in ['vim', 'nano', 'code', 'subl', 'atom', 'emacs']:
+            if subprocess.run(['which', common_editor], capture_output=True).returncode == 0:
+                editor = common_editor
+                break
+    
+    if not editor:
+        click.echo("❌ No editor found. Please set the EDITOR environment variable or install vim/nano.")
+        return None
+    
+    # Create a temporary file with the template
+    template = get_command_template(command_name, command_group)
+    
+    # Add helpful comments to the template
+    enhanced_template = f'''"""
+{command_name} command for mcli.{command_group}.
+
+Description: {description}
+
+Instructions:
+1. Write your Python command logic below
+2. Use Click decorators for command definition
+3. Save and close the editor to create the command
+4. The command will be automatically converted to JSON format
+
+Example Click command structure:
+@click.command()
+@click.argument('name', default='World')
+def my_command(name):
+    \"\"\"My custom command.\"\"\"
+    click.echo(f"Hello, {{name}}!")
+"""
+import click
+from typing import Optional, List
+from pathlib import Path
+from mcli.lib.logger.logger import get_logger
+
+logger = get_logger()
+
+# Write your command logic here:
+# Replace this template with your actual command implementation
+
+{template.split('"""')[2].split('"""')[0] if '"""' in template else ''}
+
+# Your command implementation goes here:
+# Example:
+# @click.command()
+# @click.argument('name', default='World')
+# def {command_name}_command(name):
+#     \"\"\"{description}\"\"\"
+#     logger.info(f"Executing {command_name} command with name: {{name}}")
+#     click.echo(f"Hello, {{name}}! This is the {command_name} command.")
+'''
+    
+    # Create temporary file
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as temp_file:
+        temp_file.write(enhanced_template)
+        temp_file_path = temp_file.name
+    
+    try:
+        # Check if we're in an interactive environment
+        if not sys.stdin.isatty() or not sys.stdout.isatty():
+            click.echo("❌ Editor requires an interactive terminal. Use --template flag for non-interactive mode.")
+            return None
+            
+        # Open editor
+        click.echo(f"📝 Opening {editor} to edit command logic...")
+        click.echo("💡 Write your Python command logic and save the file to continue.")
+        click.echo("💡 Press Ctrl+C to cancel command creation.")
+        
+        # Run the editor
+        result = subprocess.run([editor, temp_file_path], check=False)
+        
+        if result.returncode != 0:
+            click.echo("❌ Editor exited with error. Command creation cancelled.")
+            return None
+        
+        # Read the edited content
+        with open(temp_file_path, 'r') as f:
+            edited_code = f.read()
+        
+        # Check if the file was actually edited (not just the template)
+        if edited_code.strip() == enhanced_template.strip():
+            click.echo("⚠️  No changes detected. Command creation cancelled.")
+            return None
+        
+        # Extract the actual command code (remove the instructions)
+        lines = edited_code.split('\n')
+        code_lines = []
+        in_code_section = False
+        
+        for line in lines:
+            if line.strip().startswith('# Your command implementation goes here:'):
+                in_code_section = True
+                continue
+            if in_code_section:
+                code_lines.append(line)
+        
+        if not code_lines or not any(line.strip() for line in code_lines):
+            # Fallback: use the entire file content
+            code_lines = lines
+        
+        final_code = '\n'.join(code_lines).strip()
+        
+        if not final_code:
+            click.echo("❌ No command code found. Command creation cancelled.")
+            return None
+        
+        click.echo("✅ Command code captured successfully!")
+        return final_code
+        
+    except KeyboardInterrupt:
+        click.echo("\n❌ Command creation cancelled by user.")
+        return None
+    except Exception as e:
+        click.echo(f"❌ Error opening editor: {e}")
+        return None
+    finally:
+        # Clean up temporary file
+        try:
+            os.unlink(temp_file_path)
+        except OSError:
+            pass
+
+
+@self_app.command("add-command", deprecated=True)
 @click.argument("command_name", required=True)
 @click.option("--group", "-g", help="Command group (defaults to 'workflow')", default="workflow")
 @click.option(
     "--description", "-d", help="Description for the command", default="Custom command"
 )
-def add_command(command_name, group, description):
+@click.option(
+    "--template", "-t", is_flag=True, help="Use template mode (skip editor and use predefined template)"
+)
+def add_command(command_name, group, description, template):
     """
+    [DEPRECATED] Use 'mcli commands add' instead.
+
     Generate a new portable custom command saved to ~/.mcli/commands/.
 
-    Commands are automatically nested under the 'workflow' group by default,
-    making them portable and persistent across updates.
+    This command has been moved to 'mcli commands add' for better organization.
+    Please use the new command going forward.
 
     Example:
-        mcli self add-command my_command
-        mcli self add-command analytics --group data
+        mcli commands add my_command
+        mcli commands add analytics --group data
+        mcli commands add quick_cmd --template  # Use template without editor
     """
+    click.echo("[yellow]⚠️  DEPRECATED: This command has been moved to 'mcli commands add'[/yellow]")
+    click.echo("[yellow]   Please use: mcli commands add {} [options][/yellow]\n".format(command_name))
     command_name = command_name.lower().replace("-", "_")
 
     # Validate command name
@@ -448,7 +632,17 @@ def add_command(command_name, group, description):
             return 1
 
     # Generate command code
-    code = get_command_template(command_name, command_group)
+    if template:
+        # Use template mode - generate and save directly
+        code = get_command_template(command_name, command_group)
+        click.echo(f"📝 Using template for command: {command_name}")
+    else:
+        # Editor mode - open editor for user to write code
+        click.echo(f"🔧 Opening editor for command: {command_name}")
+        code = open_editor_for_command(command_name, command_group, description)
+        if code is None:
+            click.echo("❌ Command creation cancelled.")
+            return 1
 
     # Save the command
     saved_path = manager.save_command(
@@ -469,11 +663,16 @@ def add_command(command_name, group, description):
     return 0
 
 
-@self_app.command("list-commands")
+@self_app.command("list-commands", deprecated=True)
 def list_commands():
     """
+    [DEPRECATED] Use 'mcli commands list-custom' instead.
+
     List all custom commands stored in ~/.mcli/commands/.
     """
+    click.echo("[yellow]⚠️  DEPRECATED: This command has been moved to 'mcli commands list-custom'[/yellow]")
+    click.echo("[yellow]   Please use: mcli commands list-custom[/yellow]\n")
+
     manager = get_command_manager()
     commands = manager.load_all_commands()
 
@@ -507,13 +706,18 @@ def list_commands():
     return 0
 
 
-@self_app.command("remove-command")
+@self_app.command("remove-command", deprecated=True)
 @click.argument("command_name", required=True)
 @click.option("--yes", "-y", is_flag=True, help="Skip confirmation prompt")
 def remove_command(command_name, yes):
     """
+    [DEPRECATED] Use 'mcli commands remove' instead.
+
     Remove a custom command from ~/.mcli/commands/.
     """
+    click.echo("[yellow]⚠️  DEPRECATED: This command has been moved to 'mcli commands remove'[/yellow]")
+    click.echo(f"[yellow]   Please use: mcli commands remove {command_name}[/yellow]\n")
+
     manager = get_command_manager()
     command_file = manager.commands_dir / f"{command_name}.json"
 
@@ -537,14 +741,19 @@ def remove_command(command_name, yes):
         return 1
 
 
-@self_app.command("export-commands")
+@self_app.command("export-commands", deprecated=True)
 @click.argument("export_file", type=click.Path(), required=False)
 def export_commands(export_file):
     """
+    [DEPRECATED] Use 'mcli commands export' instead.
+
     Export all custom commands to a JSON file.
 
     If no file is specified, exports to commands-export.json in current directory.
     """
+    click.echo("[yellow]⚠️  DEPRECATED: This command has been moved to 'mcli commands export'[/yellow]")
+    click.echo(f"[yellow]   Please use: mcli commands export {export_file or '<file>'}[/yellow]\n")
+
     manager = get_command_manager()
 
     if not export_file:
@@ -563,13 +772,18 @@ def export_commands(export_file):
         return 1
 
 
-@self_app.command("import-commands")
+@self_app.command("import-commands", deprecated=True)
 @click.argument("import_file", type=click.Path(exists=True), required=True)
 @click.option("--overwrite", is_flag=True, help="Overwrite existing commands")
 def import_commands(import_file, overwrite):
     """
+    [DEPRECATED] Use 'mcli commands import' instead.
+
     Import custom commands from a JSON file.
     """
+    click.echo("[yellow]⚠️  DEPRECATED: This command has been moved to 'mcli commands import'[/yellow]")
+    click.echo(f"[yellow]   Please use: mcli commands import {import_file}[/yellow]\n")
+
     manager = get_command_manager()
     import_path = Path(import_file)
 
@@ -593,11 +807,16 @@ def import_commands(import_file, overwrite):
     return 0
 
 
-@self_app.command("verify-commands")
+@self_app.command("verify-commands", deprecated=True)
 def verify_commands():
     """
+    [DEPRECATED] Use 'mcli commands verify' instead.
+
     Verify that custom commands match the lockfile.
     """
+    click.echo("[yellow]⚠️  DEPRECATED: This command has been moved to 'mcli commands verify'[/yellow]")
+    click.echo("[yellow]   Please use: mcli commands verify[/yellow]\n")
+
     manager = get_command_manager()
 
     # First, ensure lockfile is up to date
@@ -631,11 +850,16 @@ def verify_commands():
     return 1
 
 
-@self_app.command("update-lockfile")
+@self_app.command("update-lockfile", deprecated=True)
 def update_lockfile():
     """
+    [DEPRECATED] Use 'mcli commands update-lockfile' instead.
+
     Update the commands lockfile with current state.
     """
+    click.echo("[yellow]⚠️  DEPRECATED: This command has been moved to 'mcli commands update-lockfile'[/yellow]")
+    click.echo("[yellow]   Please use: mcli commands update-lockfile[/yellow]\n")
+
     manager = get_command_manager()
 
     if manager.update_lockfile():
@@ -1557,6 +1781,281 @@ def update(check: bool, pre: bool, yes: bool, skip_ci_check: bool):
         console.print(f"[dim]{traceback.format_exc()}[/dim]")
 
 
+@self_app.command("import-script", deprecated=True)
+@click.argument("script_path", type=click.Path(exists=True))
+@click.option("--name", "-n", help="Command name (defaults to script filename)")
+@click.option("--group", "-g", default="workflow", help="Command group")
+@click.option("--description", "-d", help="Command description")
+@click.option("--interactive", "-i", is_flag=True, help="Open in $EDITOR for review/editing")
+def import_script(script_path, name, group, description, interactive):
+    """
+    [DEPRECATED] Use 'mcli commands import-script' instead.
+
+    Import a Python script as a portable JSON command.
+
+    Converts a Python script into a JSON command that can be loaded
+    by mcli. The script should define Click commands.
+
+    Examples:
+        mcli commands import-script my_script.py
+        mcli commands import-script my_script.py --name custom-cmd --interactive
+    """
+    click.echo("[yellow]⚠️  DEPRECATED: This command has been moved to 'mcli commands import-script'[/yellow]")
+    click.echo(f"[yellow]   Please use: mcli commands import-script {script_path}[/yellow]\n")
+
+    import subprocess
+    import tempfile
+
+    script_file = Path(script_path).resolve()
+
+    if not script_file.exists():
+        click.echo(f"❌ Script not found: {script_file}", err=True)
+        return 1
+
+    # Read the script content
+    try:
+        with open(script_file, 'r') as f:
+            code = f.read()
+    except Exception as e:
+        click.echo(f"❌ Failed to read script: {e}", err=True)
+        return 1
+
+    # Determine command name
+    if not name:
+        name = script_file.stem.lower().replace("-", "_")
+
+    # Validate command name
+    if not re.match(r"^[a-z][a-z0-9_]*$", name):
+        click.echo(f"❌ Invalid command name: {name}", err=True)
+        return 1
+
+    # Interactive editing
+    if interactive:
+        editor = os.environ.get('EDITOR', 'vim')
+        click.echo(f"📝 Opening in {editor} for review...")
+
+        # Create temp file with the code
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as tmp:
+            tmp.write(code)
+            tmp_path = tmp.name
+
+        try:
+            subprocess.run([editor, tmp_path], check=True)
+
+            # Read edited content
+            with open(tmp_path, 'r') as f:
+                code = f.read()
+        finally:
+            Path(tmp_path).unlink(missing_ok=True)
+
+    # Get description
+    if not description:
+        # Try to extract from docstring
+        import ast
+        try:
+            tree = ast.parse(code)
+            description = ast.get_docstring(tree) or f"Imported from {script_file.name}"
+        except:
+            description = f"Imported from {script_file.name}"
+
+    # Save as JSON command
+    manager = get_command_manager()
+
+    saved_path = manager.save_command(
+        name=name,
+        code=code,
+        description=description,
+        group=group,
+        metadata={
+            "source": "import-script",
+            "original_file": str(script_file),
+            "imported_at": datetime.now().isoformat()
+        }
+    )
+
+    click.echo(f"✅ Imported script as command: {name}")
+    click.echo(f"📁 Saved to: {saved_path}")
+    click.echo(f"🔄 Use with: mcli {group} {name}")
+    click.echo(f"💡 Command will be available after restart or reload")
+
+    return 0
+
+
+@self_app.command("export-script", deprecated=True)
+@click.argument("command_name")
+@click.option("--output", "-o", type=click.Path(), help="Output file path")
+@click.option("--standalone", "-s", is_flag=True, help="Make script standalone (add if __name__ == '__main__')")
+def export_script(command_name, output, standalone):
+    """
+    [DEPRECATED] Use 'mcli commands export-script' instead.
+
+    Export a JSON command to a Python script.
+
+    Converts a portable JSON command back to a standalone Python script
+    that can be edited and run independently.
+
+    Examples:
+        mcli commands export-script my-command
+        mcli commands export-script my-command --output my_script.py --standalone
+    """
+    click.echo("[yellow]⚠️  DEPRECATED: This command has been moved to 'mcli commands export-script'[/yellow]")
+    click.echo(f"[yellow]   Please use: mcli commands export-script {command_name}[/yellow]\n")
+
+    manager = get_command_manager()
+
+    # Load the command
+    command_file = manager.commands_dir / f"{command_name}.json"
+    if not command_file.exists():
+        click.echo(f"❌ Command not found: {command_name}", err=True)
+        return 1
+
+    try:
+        with open(command_file, 'r') as f:
+            command_data = json.load(f)
+    except Exception as e:
+        click.echo(f"❌ Failed to load command: {e}", err=True)
+        return 1
+
+    # Get the code
+    code = command_data.get('code', '')
+
+    if not code:
+        click.echo(f"❌ Command has no code: {command_name}", err=True)
+        return 1
+
+    # Add standalone wrapper if requested
+    if standalone:
+        # Check if already has if __name__ == '__main__'
+        if "if __name__" not in code:
+            code += "\n\nif __name__ == '__main__':\n    app()\n"
+
+    # Determine output path
+    if not output:
+        output = f"{command_name}.py"
+
+    output_file = Path(output)
+
+    # Write the script
+    try:
+        with open(output_file, 'w') as f:
+            f.write(code)
+    except Exception as e:
+        click.echo(f"❌ Failed to write script: {e}", err=True)
+        return 1
+
+    click.echo(f"✅ Exported command to script: {output_file}")
+    click.echo(f"📝 Source command: {command_name}")
+
+    if standalone:
+        click.echo(f"🚀 Run standalone with: python {output_file}")
+
+    click.echo(f"💡 Edit and re-import with: mcli self import-script {output_file}")
+
+    return 0
+
+
+@self_app.command("edit-command", deprecated=True)
+@click.argument("command_name")
+@click.option("--editor", "-e", help="Editor to use (defaults to $EDITOR)")
+def edit_command(command_name, editor):
+    """
+    [DEPRECATED] Use 'mcli commands edit' instead.
+
+    Edit a command interactively using $EDITOR.
+
+    Opens the command's Python code in your preferred editor,
+    allows you to make changes, and saves the updated version.
+
+    Examples:
+        mcli commands edit my-command
+        mcli commands edit my-command --editor code
+    """
+    click.echo("[yellow]⚠️  DEPRECATED: This command has been moved to 'mcli commands edit'[/yellow]")
+    click.echo(f"[yellow]   Please use: mcli commands edit {command_name}[/yellow]\n")
+
+    import subprocess
+    import tempfile
+
+    manager = get_command_manager()
+
+    # Load the command
+    command_file = manager.commands_dir / f"{command_name}.json"
+    if not command_file.exists():
+        click.echo(f"❌ Command not found: {command_name}", err=True)
+        return 1
+
+    try:
+        with open(command_file, 'r') as f:
+            command_data = json.load(f)
+    except Exception as e:
+        click.echo(f"❌ Failed to load command: {e}", err=True)
+        return 1
+
+    code = command_data.get('code', '')
+
+    if not code:
+        click.echo(f"❌ Command has no code: {command_name}", err=True)
+        return 1
+
+    # Determine editor
+    if not editor:
+        editor = os.environ.get('EDITOR', 'vim')
+
+    click.echo(f"📝 Opening command in {editor}...")
+
+    # Create temp file with the code
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False,
+                                      prefix=f"{command_name}_") as tmp:
+        tmp.write(code)
+        tmp_path = tmp.name
+
+    try:
+        # Open in editor
+        result = subprocess.run([editor, tmp_path])
+
+        if result.returncode != 0:
+            click.echo(f"⚠️  Editor exited with code {result.returncode}")
+
+        # Read edited content
+        with open(tmp_path, 'r') as f:
+            new_code = f.read()
+
+        # Check if code changed
+        if new_code.strip() == code.strip():
+            click.echo("ℹ️  No changes made")
+            return 0
+
+        # Validate syntax
+        try:
+            compile(new_code, '<string>', 'exec')
+        except SyntaxError as e:
+            click.echo(f"❌ Syntax error in edited code: {e}", err=True)
+            should_save = Prompt.ask(
+                "Save anyway?", choices=["y", "n"], default="n"
+            )
+            if should_save.lower() != "y":
+                return 1
+
+        # Update the command
+        command_data['code'] = new_code
+        command_data['updated_at'] = datetime.now().isoformat()
+
+        with open(command_file, 'w') as f:
+            json.dump(command_data, f, indent=2)
+
+        # Update lockfile
+        manager.generate_lockfile()
+
+        click.echo(f"✅ Updated command: {command_name}")
+        click.echo(f"📁 Saved to: {command_file}")
+        click.echo(f"🔄 Reload with: mcli self reload" or "restart mcli")
+
+    finally:
+        Path(tmp_path).unlink(missing_ok=True)
+
+    return 0
+
+
 # Register the plugin group with self_app
 self_app.add_command(plugin)
 

mcli/workflow/daemon/__init__.py

@@ -0,0 +1,15 @@
+"""
+Daemon service for command management and execution.
+
+This module provides a background daemon service that can store, manage, and execute
+commands written in various programming languages (Python, Node.js, Lua, Shell).
+Commands are stored in a SQLite database with embeddings for similarity search and
+hierarchical grouping.
+
+The daemon CLI commands are now loaded from portable JSON files in ~/.mcli/commands/
+"""
+
+from .daemon import Command, CommandExecutor, DaemonService
+
+# Export main components
+__all__ = ["Command", "CommandExecutor", "DaemonService"]

mcli/workflow/daemon/daemon.py

@@ -16,17 +16,35 @@ import click
 import psutil
 from sklearn.feature_extraction.text import TfidfVectorizer
 from sklearn.metrics.pairwise import cosine_similarity
-from watchdog.events import FileSystemEventHandler
-from watchdog.observers import Observer
+
+try:
+    from watchdog.events import FileSystemEventHandler
+    from watchdog.observers import Observer
+    HAS_WATCHDOG = True
+except ImportError:
+    # Watchdog not available, file watching will be disabled
+    HAS_WATCHDOG = False
+    FileSystemEventHandler = object  # Stub for inheritance
+    Observer = None
 
 # Import existing utilities
 from mcli.lib.logger.logger import get_logger
 from mcli.lib.toml.toml import read_from_toml
-from mcli.workflow.daemon.commands import CommandDatabase
 
 logger = get_logger(__name__)
 
 
+# Stub CommandDatabase for backward compatibility
+# Commands are now managed via JSON files in ~/.mcli/commands/
+class CommandDatabase:
+    """Stub database for backward compatibility.
+    Commands are now stored as JSON files and loaded via the custom commands system.
+    """
+    def __init__(self, db_path: Optional[str] = None):
+        logger.debug("CommandDatabase stub initialized - commands now managed via JSON files")
+        pass
+
+
 @dataclass
 class Command:
     """Represents a stored command"""