mcli-framework 7.3.1__py3-none-any.whl → 7.5.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,263 +417,150 @@ def collect_commands() -> List[Dict[str, Any]]:
     return commands
 
 
-@self_app.command("add-command")
-@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):
-    """
-    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.
-
-    Example:
-        mcli self add-command my_command
-        mcli self add-command analytics --group data
-    """
-    command_name = command_name.lower().replace("-", "_")
-
-    # Validate command name
-    if not re.match(r"^[a-z][a-z0-9_]*$", command_name):
-        logger.error(
-            f"Invalid command name: {command_name}. Use lowercase letters, numbers, and underscores (starting with a letter)."
-        )
-        click.echo(
-            f"Invalid command name: {command_name}. Use lowercase letters, numbers, and underscores (starting with a letter).",
-            err=True,
-        )
-        return 1
-
-    # Validate group name if provided
-    if group:
-        command_group = group.lower().replace("-", "_")
-        if not re.match(r"^[a-z][a-z0-9_]*$", command_group):
-            logger.error(
-                f"Invalid group name: {command_group}. Use lowercase letters, numbers, and underscores (starting with a letter)."
-            )
-            click.echo(
-                f"Invalid group name: {command_group}. Use lowercase letters, numbers, and underscores (starting with a letter).",
-                err=True,
-            )
-            return 1
-    else:
-        command_group = "workflow"  # Default to workflow group
-
-    # Get the command manager
-    manager = get_command_manager()
-
-    # Check if command already exists
-    command_file = manager.commands_dir / f"{command_name}.json"
-    if command_file.exists():
-        logger.warning(f"Custom command already exists: {command_name}")
-        should_override = Prompt.ask(
-            "Command already exists. Override?", choices=["y", "n"], default="n"
-        )
-        if should_override.lower() != "y":
-            logger.info("Command creation aborted.")
-            click.echo("Command creation aborted.")
-            return 1
-
-    # Generate command code
-    code = get_command_template(command_name, command_group)
-
-    # Save the command
-    saved_path = manager.save_command(
-        name=command_name,
-        code=code,
-        description=description,
-        group=command_group,
-    )
-
-    logger.info(f"Created portable custom command: {command_name}")
-    click.echo(f"✅ Created portable custom command: {command_name}")
-    click.echo(f"📁 Saved to: {saved_path}")
-    click.echo(f"🔄 Command will be automatically loaded on next mcli startup")
-    click.echo(
-        f"💡 You can share this command by copying {saved_path} to another machine's ~/.mcli/commands/ directory"
-    )
-
-    return 0
-
-
-@self_app.command("list-commands")
-def list_commands():
-    """
-    List all custom commands stored in ~/.mcli/commands/.
-    """
-    manager = get_command_manager()
-    commands = manager.load_all_commands()
-
-    if not commands:
-        click.echo("No custom commands found.")
-        click.echo(
-            f"Create one with: mcli self add-command <name>"
-        )
-        return 0
-
-    table = Table(title="Custom Commands")
-    table.add_column("Name", style="green")
-    table.add_column("Group", style="blue")
-    table.add_column("Description", style="yellow")
-    table.add_column("Version", style="cyan")
-    table.add_column("Updated", style="dim")
-
-    for cmd in commands:
-        table.add_row(
-            cmd["name"],
-            cmd.get("group", "-"),
-            cmd.get("description", ""),
-            cmd.get("version", "1.0"),
-            cmd.get("updated_at", "")[:10] if cmd.get("updated_at") else "-",
-        )
-
-    console.print(table)
-    click.echo(f"\n📁 Commands directory: {manager.commands_dir}")
-    click.echo(f"🔒 Lockfile: {manager.lockfile_path}")
-
-    return 0
-
-
-@self_app.command("remove-command")
-@click.argument("command_name", required=True)
-@click.option("--yes", "-y", is_flag=True, help="Skip confirmation prompt")
-def remove_command(command_name, yes):
+def open_editor_for_command(command_name: str, command_group: str, description: str) -> Optional[str]:
     """
-    Remove a custom command from ~/.mcli/commands/.
+    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
     """
-    manager = get_command_manager()
-    command_file = manager.commands_dir / f"{command_name}.json"
-
-    if not command_file.exists():
-        click.echo(f"❌ Command '{command_name}' not found.", err=True)
-        return 1
-
-    if not yes:
-        should_delete = Prompt.ask(
-            f"Delete command '{command_name}'?", choices=["y", "n"], default="n"
-        )
-        if should_delete.lower() != "y":
-            click.echo("Deletion cancelled.")
-            return 0
-
-    if manager.delete_command(command_name):
-        click.echo(f"✅ Deleted custom command: {command_name}")
-        return 0
-    else:
-        click.echo(f"❌ Failed to delete command: {command_name}", err=True)
-        return 1
-
-
-@self_app.command("export-commands")
-@click.argument("export_file", type=click.Path(), required=False)
-def export_commands(export_file):
-    """
-    Export all custom commands to a JSON file.
-
-    If no file is specified, exports to commands-export.json in current directory.
-    """
-    manager = get_command_manager()
-
-    if not export_file:
-        export_file = "commands-export.json"
-
-    export_path = Path(export_file)
-
-    if manager.export_commands(export_path):
-        click.echo(f"✅ Exported custom commands to: {export_path}")
-        click.echo(
-            f"💡 Import on another machine with: mcli self import-commands {export_path}"
-        )
-        return 0
-    else:
-        click.echo("❌ Failed to export commands.", err=True)
-        return 1
-
-
-@self_app.command("import-commands")
-@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):
-    """
-    Import custom commands from a JSON file.
-    """
-    manager = get_command_manager()
-    import_path = Path(import_file)
-
-    results = manager.import_commands(import_path, overwrite=overwrite)
-
-    success_count = sum(1 for v in results.values() if v)
-    failed_count = len(results) - success_count
-
-    if success_count > 0:
-        click.echo(f"✅ Imported {success_count} command(s)")
-
-    if failed_count > 0:
-        click.echo(
-            f"⚠️  Skipped {failed_count} command(s) (already exist, use --overwrite to replace)"
-        )
-        click.echo("Skipped commands:")
-        for name, success in results.items():
-            if not success:
-                click.echo(f"  - {name}")
-
-    return 0
-
-
-@self_app.command("verify-commands")
-def verify_commands():
-    """
-    Verify that custom commands match the lockfile.
-    """
-    manager = get_command_manager()
-
-    # First, ensure lockfile is up to date
-    manager.update_lockfile()
-
-    verification = manager.verify_lockfile()
-
-    if verification["valid"]:
-        click.echo("✅ All custom commands are in sync with the lockfile.")
-        return 0
-
-    click.echo("⚠️  Commands are out of sync with the lockfile:\n")
-
-    if verification["missing"]:
-        click.echo(f"Missing commands (in lockfile but not found):")
-        for name in verification["missing"]:
-            click.echo(f"  - {name}")
-
-    if verification["extra"]:
-        click.echo(f"\nExtra commands (not in lockfile):")
-        for name in verification["extra"]:
-            click.echo(f"  - {name}")
-
-    if verification["modified"]:
-        click.echo(f"\nModified commands:")
-        for name in verification["modified"]:
-            click.echo(f"  - {name}")
-
-    click.echo(f"\n💡 Run 'mcli self update-lockfile' to sync the lockfile")
+    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
 
-    return 1
+logger = get_logger()
 
+# Write your command logic here:
+# Replace this template with your actual command implementation
 
-@self_app.command("update-lockfile")
-def update_lockfile():
-    """
-    Update the commands lockfile with current state.
-    """
-    manager = get_command_manager()
+{template.split('"""')[2].split('"""')[0] if '"""' in template else ''}
 
-    if manager.update_lockfile():
-        click.echo(f"✅ Updated lockfile: {manager.lockfile_path}")
-        return 0
-    else:
-        click.echo("❌ Failed to update lockfile.", err=True)
-        return 1
+# 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("extract-workflow-commands")
@@ -971,265 +888,21 @@ def hello(name: str):
 
 
 @self_app.command("logs")
-@click.option(
-    "--type",
-    "-t",
-    type=click.Choice(["main", "system", "trace", "all"]),
-    default="main",
-    help="Type of logs to display",
-)
-@click.option("--lines", "-n", default=50, help="Number of lines to show (default: 50)")
-@click.option("--follow", "-f", is_flag=True, help="Follow log output in real-time")
-@click.option("--date", "-d", help="Show logs for specific date (YYYYMMDD format)")
-@click.option("--grep", "-g", help="Filter logs by pattern")
-@click.option(
-    "--level",
-    "-l",
-    type=click.Choice(["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]),
-    help="Filter logs by minimum level",
-)
-def logs(type: str, lines: int, follow: bool, date: str, grep: str, level: str):
+def logs():
     """
-    Display runtime logs of the mcli application.
+    [DEPRECATED] Display runtime logs - Use 'mcli logs' instead.
 
-    Shows the most recent log entries from the application's logging system.
-    Supports filtering by log type, date, content, and log level.
-
-    Log files are named as mcli_YYYYMMDD.log, mcli_system_YYYYMMDD.log, mcli_trace_YYYYMMDD.log.
+    This command has been moved to 'mcli logs' with enhanced features.
     """
-    import re
-    import subprocess
-    from datetime import datetime
-    from pathlib import Path
-
-    # Import get_logs_dir to get the correct logs directory
-    from mcli.lib.paths import get_logs_dir
-
-    # Get the logs directory (creates it if it doesn't exist)
-    logs_dir = get_logs_dir()
-
-    if not logs_dir.exists():
-        click.echo("❌ Logs directory not found", err=True)
-        click.echo(f"Expected location: {logs_dir}", err=True)
-        return
-
-    # Determine which log files to read
-    log_files = []
-
-    if type == "all":
-        # Get all log files for the specified date or latest
-        if date:
-            # Look for files like mcli_20250709.log, mcli_system_20250709.log, mcli_trace_20250709.log
-            patterns = [f"mcli_{date}.log", f"mcli_system_{date}.log", f"mcli_trace_{date}.log"]
-        else:
-            # Get the most recent log files
-            patterns = ["mcli_*.log"]
-
-        log_files = []
-        for pattern in patterns:
-            files = list(logs_dir.glob(pattern))
-            if files:
-                # Sort by modification time (newest first)
-                files.sort(key=lambda x: x.stat().st_mtime, reverse=True)
-                log_files.extend(files)
-
-        # Remove duplicates and take only the most recent files of each type
-        seen_types = set()
-        filtered_files = []
-        for log_file in log_files:
-            # Extract log type from filename
-            # mcli_20250709 -> main
-            # mcli_system_20250709 -> system
-            # mcli_trace_20250709 -> trace
-            if log_file.name.startswith("mcli_system_"):
-                log_type = "system"
-            elif log_file.name.startswith("mcli_trace_"):
-                log_type = "trace"
-            else:
-                log_type = "main"
-
-            if log_type not in seen_types:
-                seen_types.add(log_type)
-                filtered_files.append(log_file)
-
-        log_files = filtered_files
-    else:
-        # Get specific log type
-        if date:
-            if type == "main":
-                filename = f"mcli_{date}.log"
-            else:
-                filename = f"mcli_{type}_{date}.log"
-        else:
-            # Find the most recent file for this type
-            if type == "main":
-                pattern = "mcli_*.log"
-                # Exclude system and trace files
-                exclude_patterns = ["mcli_system_*.log", "mcli_trace_*.log"]
-            else:
-                pattern = f"mcli_{type}_*.log"
-                exclude_patterns = []
-
-            files = list(logs_dir.glob(pattern))
-
-            # Filter out excluded patterns
-            if exclude_patterns:
-                filtered_files = []
-                for file in files:
-                    excluded = False
-                    for exclude_pattern in exclude_patterns:
-                        if file.match(exclude_pattern):
-                            excluded = True
-                            break
-                    if not excluded:
-                        filtered_files.append(file)
-                files = filtered_files
-
-            if files:
-                # Sort by modification time and take the most recent
-                files.sort(key=lambda x: x.stat().st_mtime, reverse=True)
-                filename = files[0].name
-            else:
-                click.echo(f"❌ No {type} log files found", err=True)
-                return
-
-        log_file = logs_dir / filename
-        if log_file.exists():
-            log_files = [log_file]
-        else:
-            click.echo(f"❌ Log file not found: {filename}", err=True)
-            return
-
-    if not log_files:
-        click.echo("❌ No log files found", err=True)
-        return
-
-    # Display log file information
-    click.echo(f"📋 Showing logs from {len(log_files)} file(s):")
-    for log_file in log_files:
-        size_mb = log_file.stat().st_size / (1024 * 1024)
-        modified = datetime.fromtimestamp(log_file.stat().st_mtime)
-        click.echo(
-            f"   📄 {log_file.name} ({size_mb:.1f}MB, modified {modified.strftime('%Y-%m-%d %H:%M:%S')})"
-        )
-    click.echo()
-
-    # Process each log file
-    for log_file in log_files:
-        click.echo(f"🔍 Reading: {log_file.name}")
-        click.echo("─" * 80)
-
-        try:
-            # Read the file content
-            with open(log_file, "r") as f:
-                content = f.readlines()
-
-            # Apply filters
-            filtered_lines = []
-            for line in content:
-                # Apply grep filter
-                if grep and grep.lower() not in line.lower():
-                    continue
-
-                # Apply level filter
-                if level:
-                    level_pattern = rf"\b{level}\b"
-                    if not re.search(level_pattern, line, re.IGNORECASE):
-                        # Check if line has a lower level than requested
-                        level_order = {
-                            "DEBUG": 0,
-                            "INFO": 1,
-                            "WARNING": 2,
-                            "ERROR": 3,
-                            "CRITICAL": 4,
-                        }
-                        requested_level = level_order.get(level.upper(), 0)
-
-                        # Check if line contains any log level
-                        found_level = None
-                        for log_level in level_order:
-                            if log_level in line.upper():
-                                found_level = level_order[log_level]
-                                break
-
-                        if found_level is None or found_level < requested_level:
-                            continue
-
-                filtered_lines.append(line)
-
-            # Show the last N lines
-            if lines > 0:
-                filtered_lines = filtered_lines[-lines:]
-
-            # Display the lines
-            for line in filtered_lines:
-                # Colorize log levels
-                colored_line = line
-                if "ERROR" in line or "CRITICAL" in line:
-                    colored_line = click.style(line, fg="red")
-                elif "WARNING" in line:
-                    colored_line = click.style(line, fg="yellow")
-                elif "INFO" in line:
-                    colored_line = click.style(line, fg="green")
-                elif "DEBUG" in line:
-                    colored_line = click.style(line, fg="blue")
-
-                click.echo(colored_line.rstrip())
-
-            if not filtered_lines:
-                click.echo("(No matching log entries found)")
-
-        except Exception as e:
-            click.echo(f"❌ Error reading log file {log_file.name}: {e}", err=True)
-
-        click.echo()
-
-    if follow:
-        click.echo("🔄 Following log output... (Press Ctrl+C to stop)")
-        try:
-            # Use tail -f for real-time following
-            for log_file in log_files:
-                click.echo(f"📡 Following: {log_file.name}")
-                process = subprocess.Popen(
-                    ["tail", "-f", str(log_file)],
-                    stdout=subprocess.PIPE,
-                    stderr=subprocess.PIPE,
-                    text=True,
-                )
-
-                try:
-                    if process.stdout:
-                        for line in process.stdout:
-                            # Apply filters to real-time output
-                            if grep and grep.lower() not in line.lower():
-                                continue
-
-                            if level:
-                                level_pattern = rf"\b{level}\b"
-                                if not re.search(level_pattern, line, re.IGNORECASE):
-                                    continue
-
-                            # Colorize and display
-                            colored_line = line
-                            if "ERROR" in line or "CRITICAL" in line:
-                                colored_line = click.style(line, fg="red")
-                            elif "WARNING" in line:
-                                colored_line = click.style(line, fg="yellow")
-                            elif "INFO" in line:
-                                colored_line = click.style(line, fg="green")
-                            elif "DEBUG" in line:
-                                colored_line = click.style(line, fg="blue")
-
-                            click.echo(colored_line.rstrip())
-
-                except KeyboardInterrupt:
-                    process.terminate()
-                    break
-
-        except KeyboardInterrupt:
-            click.echo("\n🛑 Stopped following logs")
-        except Exception as e:
-            click.echo(f"❌ Error following logs: {e}", err=True)
+    console.print("\n[yellow]⚠️  DEPRECATED:[/yellow] This command has been moved.")
+    console.print("\n[cyan]New usage:[/cyan]")
+    console.print("  mcli logs [bold]stream[/bold]    - Stream logs in real-time")
+    console.print("  mcli logs [bold]list[/bold]      - List available log files")
+    console.print("  mcli logs [bold]tail[/bold]      - Tail recent log entries")
+    console.print("  mcli logs [bold]grep[/bold]      - Search in log files")
+    console.print("  mcli logs [bold]location[/bold]  - Show logs directory")
+    console.print("  mcli logs [bold]clear[/bold]     - Clear old log files")
+    console.print("\n[dim]Run 'mcli logs --help' for more information[/dim]\n")
 
 
 @self_app.command("performance")
@@ -1557,234 +1230,6 @@ 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")
-@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):
-    """
-    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 self import-script my_script.py
-        mcli self import-script my_script.py --name custom-cmd --interactive
-    """
-    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")
-@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):
-    """
-    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 self export-script my-command
-        mcli self export-script my-command --output my_script.py --standalone
-    """
-    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")
-@click.argument("command_name")
-@click.option("--editor", "-e", help="Editor to use (defaults to $EDITOR)")
-def edit_command(command_name, editor):
-    """
-    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 self edit-command my-command
-        mcli self edit-command my-command --editor code
-    """
-    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: