mcli-framework 7.12.1__py3-none-any.whl → 7.12.3__py3-none-any.whl

mcli/app/__init__.py

@@ -1,6 +1,4 @@
 # src/mcli/app/__init__.py
-import importlib
-from pathlib import Path
 
 from mcli.lib.logger.logger import get_logger
 

mcli/app/commands_cmd.py

@@ -4,7 +4,6 @@ import inspect
 import json
 import os
 import re
-import shutil
 import subprocess
 import tempfile
 from datetime import datetime
@@ -12,16 +11,13 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 import click
-import tomli
-from rich.console import Console
 from rich.prompt import Prompt
-from rich.table import Table
 
 from mcli.lib.api.daemon_client import get_daemon_client
 from mcli.lib.custom_commands import get_command_manager
 from mcli.lib.discovery.command_discovery import get_command_discovery
 from mcli.lib.logger.logger import get_logger
-from mcli.lib.ui.styling import console, error, info, success, warning
+from mcli.lib.ui.styling import console
 
 logger = get_logger(__name__)
 
@@ -78,7 +74,7 @@ def collect_commands() -> List[Dict[str, Any]]:
                             streamlit_logger.setLevel(original_level)
 
                     # Extract command and group objects
-                    for name, obj in inspect.getmembers(module):
+                    for _name, obj in inspect.getmembers(module):
                         # Handle Click commands and groups
                         if isinstance(obj, click.Command):
                             if isinstance(obj, click.Group):
@@ -118,7 +114,7 @@ def collect_commands() -> List[Dict[str, Any]]:
 
 
 def get_current_command_state():
-    """Collect all command metadata (names, groups, etc.)"""
+    """Collect all command metadata (names, groups, etc.)."""
     return collect_commands()
 
 
@@ -134,7 +130,11 @@ def load_lockfile():
     """Load the command state lockfile."""
     if LOCKFILE_PATH.exists():
         with open(LOCKFILE_PATH, "r") as f:
-            return json.load(f)
+            data = json.load(f)
+            # Handle both old format (array) and new format (object with "states" key)
+            if isinstance(data, dict) and "states" in data:
+                return data["states"]
+            return data if isinstance(data, list) else []
     return []
 
 
@@ -175,7 +175,6 @@ def restore_command_state(hash_value):
 @click.group(name="workflow")
 def workflow():
     """Manage workflows - create, edit, import, export workflow commands."""
-    pass
 
 
 # For backward compatibility, keep commands as an alias
@@ -397,7 +396,7 @@ def search_commands(query: str, daemon_only: bool, as_json: bool, is_global: boo
 @click.option("--json", "as_json", is_flag=True, help="Output as JSON")
 @click.option("--timeout", type=int, help="Execution timeout in seconds")
 def execute_command(command_name: str, args: tuple, as_json: bool, timeout: Optional[int]):
-    """Execute a command by name"""
+    """Execute a command by name."""
     try:
         client = get_daemon_client()
         result = client.execute_command(command_name=command_name, args=list(args), timeout=timeout)
@@ -425,7 +424,7 @@ def execute_command(command_name: str, args: tuple, as_json: bool, timeout: Opti
 @click.argument("command_name")
 @click.option("--json", "as_json", is_flag=True, help="Output as JSON")
 def command_info(command_name: str, as_json: bool):
-    """Show detailed information about a command"""
+    """Show detailed information about a command."""
     try:
         client = get_daemon_client()
         result = client.list_commands(all=True)
@@ -466,7 +465,7 @@ def command_info(command_name: str, as_json: bool):
             console.print(f"Last Executed: {command['last_executed']}")
 
         if command.get("code"):
-            console.print(f"\n[bold]Code:[/bold]")
+            console.print("\n[bold]Code:[/bold]")
             console.print(f"```{command['language']}")
             console.print(command["code"])
             console.print("```")
@@ -703,7 +702,7 @@ logger = get_logger()
         return None
     finally:
         # Clean up temporary file
-        try:
+        try:  # noqa: SIM105
             os.unlink(temp_file_path)
         except OSError:
             pass
@@ -807,7 +806,7 @@ def add_command(command_name, group, description, template, language, shell, is_
     language = language.lower()
 
     # Determine shell type for shell commands
-    if language == "shell":
+    if language == "shell":  # noqa: SIM102
         if not shell:
             # Default to $SHELL environment variable or bash
             shell_env = os.environ.get("SHELL", "/bin/bash")
@@ -890,7 +889,7 @@ def add_command(command_name, group, description, template, language, shell, is_
         )
     else:
         console.print(
-            f"[dim]This command is local to this git repository. Use --global/-g to create global commands.[/dim]"
+            "[dim]This command is local to this git repository. Use --global/-g to create global commands.[/dim]"
         )
 
     return 0
@@ -988,7 +987,7 @@ def export_commands(target, script, standalone, output, is_global):
             return 1
 
         # Add standalone wrapper if requested
-        if standalone:
+        if standalone:  # noqa: SIM102
             # Check if already has if __name__ == '__main__'
             if "if __name__" not in code:
                 code += "\n\nif __name__ == '__main__':\n    app()\n"
@@ -1153,7 +1152,7 @@ def import_commands(source, script, overwrite, name, group, description, interac
             try:
                 tree = ast.parse(code)
                 description = ast.get_docstring(tree) or f"Imported from {source_path.name}"
-            except:
+            except Exception:
                 description = f"Imported from {source_path.name}"
 
         # Save as JSON command
@@ -1199,9 +1198,9 @@ def import_commands(source, script, overwrite, name, group, description, interac
                 f"[yellow]Skipped {failed_count} command(s) (already exist, use --overwrite to replace)[/yellow]"
             )
             console.print("Skipped commands:")
-            for name, success in results.items():
-                if not success:
-                    console.print(f"  - {name}")
+            for cmd_name, cmd_success in results.items():
+                if not cmd_success:
+                    console.print(f"  - {cmd_name}")
 
         return 0
 
@@ -1357,9 +1356,6 @@ def extract_workflow_commands(output):
                     }
 
                     # Create a template based on command type
-                    # Replace hyphens with underscores for valid Python function names
-                    safe_name = cmd_name.replace("-", "_")
-
                     if isinstance(cmd_obj, click.Group):
                         # For groups, create a template
                         command_info[

mcli/app/completion_helpers.py

@@ -2,7 +2,7 @@
 Completion helpers for MCLI that provide tab completion without loading heavy modules
 """
 
-from typing import Any, Dict, List
+from typing import List
 
 import click
 from click.shell_completion import CompletionItem
@@ -103,7 +103,7 @@ LAZY_COMMAND_COMPLETIONS = {
 
 
 def get_completion_items(cmd_path: List[str], incomplete: str = "") -> List[CompletionItem]:
-    """Get completion items for a given command path without loading modules"""
+    """Get completion items for a given command path without loading modules."""
     items = []
 
     # Navigate to the completion data for this path
@@ -131,7 +131,7 @@ def get_completion_items(cmd_path: List[str], incomplete: str = "") -> List[Comp
 
 
 class CompletionAwareLazyGroup(click.Group):
-    """A Click group that provides completion without loading modules"""
+    """A Click group that provides completion without loading modules."""
 
     def __init__(self, name, import_path, *args, **kwargs):
         self.import_path = import_path
@@ -147,7 +147,7 @@ class CompletionAwareLazyGroup(click.Group):
                 module_path, attr_name = self.import_path.rsplit(".", 1)
                 module = importlib.import_module(module_path)
                 self._loaded_group = getattr(module, attr_name)
-            except Exception as e:
+            except Exception:
                 # Return a dummy group that shows an error
                 def error_callback():
                     click.echo(f"Error: Command group {self.name} is not available")
@@ -201,5 +201,5 @@ class CompletionAwareLazyGroup(click.Group):
 def create_completion_aware_lazy_group(
     name: str, import_path: str, help_text: str = None
 ) -> CompletionAwareLazyGroup:
-    """Create a completion-aware lazy group"""
+    """Create a completion-aware lazy group."""
     return CompletionAwareLazyGroup(name, import_path, help=help_text)

mcli/app/init_cmd.py

@@ -1,11 +1,11 @@
 """
 Top-level initialization and teardown commands for MCLI.
 """
+
 import json
 import shutil
 import subprocess
 from datetime import datetime
-from pathlib import Path
 
 import click
 from rich.prompt import Prompt
@@ -56,12 +56,12 @@ def init(is_global, git, force):
     lockfile_path = workflows_dir / "commands.lock.json"
 
     # Check if already initialized
-    if workflows_dir.exists() and not force:
+    if workflows_dir.exists() and not force:  # noqa: SIM102
         if lockfile_path.exists():
             console.print(
                 f"[yellow]Workflows directory already initialized at:[/yellow] {workflows_dir}"
             )
-            console.print(f"[dim]Use --force to reinitialize[/dim]")
+            console.print("[dim]Use --force to reinitialize[/dim]")
 
             should_continue = Prompt.ask("Continue anyway?", choices=["y", "n"], default="n")
             if should_continue.lower() != "y":
@@ -74,7 +74,7 @@ def init(is_global, git, force):
     # Create README.md
     readme_path = workflows_dir / "README.md"
     if not readme_path.exists() or force:
-        scope = "local" if in_git_repo else "global"
+        "local" if in_git_repo else "global"
         scope_desc = f"for repository: {git_root.name}" if in_git_repo else "globally"
 
         readme_content = f"""# MCLI Custom Workflows
@@ -203,13 +203,13 @@ Thumbs.db
 .idea/
 """
         gitignore_path.write_text(gitignore_content)
-        console.print(f"[green]✓[/green] Created .gitignore")
+        console.print("[green]✓[/green] Created .gitignore")
 
     # Initialize git if requested
     if git and not (workflows_dir / ".git").exists():
         try:
             subprocess.run(["git", "init"], cwd=workflows_dir, check=True, capture_output=True)
-            console.print(f"[green]✓[/green] Initialized git repository in workflows directory")
+            console.print("[green]✓[/green] Initialized git repository in workflows directory")
 
             # Create initial commit
             subprocess.run(["git", "add", "."], cwd=workflows_dir, check=True, capture_output=True)
@@ -219,12 +219,12 @@ Thumbs.db
                 check=True,
                 capture_output=True,
             )
-            console.print(f"[green]✓[/green] Created initial commit")
+            console.print("[green]✓[/green] Created initial commit")
 
         except subprocess.CalledProcessError as e:
             console.print(f"[yellow]⚠[/yellow] Git initialization failed: {e}")
         except FileNotFoundError:
-            console.print(f"[yellow]⚠[/yellow] Git not found. Skipping git initialization.")
+            console.print("[yellow]⚠[/yellow] Git not found. Skipping git initialization.")
 
     # Summary
     from rich.table import Table
@@ -258,11 +258,11 @@ Thumbs.db
 
     if in_git_repo:
         console.print(
-            f"[dim]Tip: Workflows are local to this repository. Use --global for user-wide workflows.[/dim]"
+            "[dim]Tip: Workflows are local to this repository. Use --global for user-wide workflows.[/dim]"
         )
     else:
         console.print(
-            f"[dim]Tip: Use workflows in any git repository, or create local ones with 'mcli init' inside repos.[/dim]"
+            "[dim]Tip: Use workflows in any git repository, or create local ones with 'mcli init' inside repos.[/dim]"
         )
 
     return 0

mcli/app/lock_cmd.py

@@ -2,6 +2,7 @@
 Top-level lock management commands for MCLI.
 Manages workflow lockfile and verification.
 """
+
 import hashlib
 import json
 from datetime import datetime
@@ -24,7 +25,11 @@ def load_lockfile():
     """Load the command state lockfile."""
     if LOCKFILE_PATH.exists():
         with open(LOCKFILE_PATH, "r") as f:
-            return json.load(f)
+            data = json.load(f)
+            # Handle both old format (array) and new format (object with "states" key)
+            if isinstance(data, dict) and "states" in data:
+                return data["states"]
+            return data if isinstance(data, list) else []
     return []
 
 
@@ -63,7 +68,7 @@ def restore_command_state(hash_value):
 
 
 def get_current_command_state():
-    """Collect all command metadata (names, groups, etc.)"""
+    """Collect all command metadata (names, groups, etc.)."""
     # Import here to avoid circular imports
     import importlib
     import inspect
@@ -110,7 +115,7 @@ def get_current_command_state():
                             streamlit_logger.setLevel(original_level)
 
                     # Extract command and group objects
-                    for name, obj in inspect.getmembers(module):
+                    for _name, obj in inspect.getmembers(module):
                         # Handle Click commands and groups
                         if isinstance(obj, click.Command):
                             if isinstance(obj, click.Group):
@@ -160,7 +165,6 @@ def hash_command_state(commands):
 @click.group(name="lock")
 def lock():
     """Manage workflow lockfile and verification."""
-    pass
 
 
 @lock.command("list")
@@ -229,11 +233,13 @@ def write_state(json_file):
 @click.option(
     "--global", "-g", "is_global", is_flag=True, help="Verify global commands instead of local"
 )
-def verify_commands(is_global):
+@click.option("--code", "-c", is_flag=True, help="Also validate that workflow code is executable")
+def verify_commands(is_global, code):
     """
-    Verify that custom commands match the lockfile.
+    Verify that custom commands match the lockfile and optionally validate code.
 
     By default verifies local commands (if in git repo), use --global/-g for global commands.
+    Use --code/-c to also validate that workflow code is valid and executable.
     """
     manager = get_command_manager(global_mode=is_global)
 
@@ -242,28 +248,77 @@ def verify_commands(is_global):
 
     verification = manager.verify_lockfile()
 
-    if verification["valid"]:
-        console.print("[green]All custom commands are in sync with the lockfile.[/green]")
-        return 0
-
-    console.print("[yellow]Commands are out of sync with the lockfile:[/yellow]\n")
-
-    if verification["missing"]:
-        console.print("Missing commands (in lockfile but not found):")
-        for name in verification["missing"]:
-            console.print(f"  - {name}")
-
-    if verification["extra"]:
-        console.print("\nExtra commands (not in lockfile):")
-        for name in verification["extra"]:
-            console.print(f"  - {name}")
-
-    if verification["modified"]:
-        console.print("\nModified commands:")
-        for name in verification["modified"]:
-            console.print(f"  - {name}")
+    has_issues = False
+
+    if not verification["valid"]:
+        has_issues = True
+        console.print("[yellow]Commands are out of sync with the lockfile:[/yellow]\n")
+
+        if verification["missing"]:
+            console.print("Missing commands (in lockfile but not found):")
+            for name in verification["missing"]:
+                console.print(f"  - {name}")
+
+        if verification["extra"]:
+            console.print("\nExtra commands (not in lockfile):")
+            for name in verification["extra"]:
+                console.print(f"  - {name}")
+
+        if verification["modified"]:
+            console.print("\nModified commands:")
+            for name in verification["modified"]:
+                console.print(f"  - {name}")
+
+        console.print("\n[dim]Run 'mcli lock update' to sync the lockfile[/dim]\n")
+
+    # Validate workflow code if requested
+    if code:
+        console.print("[cyan]Validating workflow code...[/cyan]\n")
+
+        commands = manager.load_all_commands()
+        invalid_workflows = []
+
+        for cmd_data in commands:
+            if cmd_data.get("group") != "workflow":
+                continue
+
+            cmd_name = cmd_data.get("name")
+            temp_group = click.Group()
+            language = cmd_data.get("language", "python")
+
+            try:
+                if language == "shell":
+                    success = manager.register_shell_command_with_click(cmd_data, temp_group)
+                else:
+                    success = manager.register_command_with_click(cmd_data, temp_group)
+
+                if not success or not temp_group.commands.get(cmd_name):
+                    invalid_workflows.append(
+                        {"name": cmd_name, "reason": "Code does not define a valid Click command"}
+                    )
+            except SyntaxError as e:
+                invalid_workflows.append({"name": cmd_name, "reason": f"Syntax error: {e}"})
+            except Exception as e:
+                invalid_workflows.append({"name": cmd_name, "reason": f"Failed to load: {e}"})
+
+        if invalid_workflows:
+            has_issues = True
+            console.print("[red]Invalid workflows found:[/red]\n")
+
+            for item in invalid_workflows:
+                console.print(f"  [red]✗[/red] {item['name']}")
+                console.print(f"    [dim]{item['reason']}[/dim]")
+
+            console.print("\n[yellow]Fix with:[/yellow] mcli workflow edit <workflow-name>")
+            console.print(
+                "[dim]Tip: Workflow code must define a Click command decorated with @click.command()[/dim]\n"
+            )
+        else:
+            console.print("[green]✓ All workflow code is valid[/green]\n")
 
-    console.print("\n[dim]Run 'mcli lock update' to sync the lockfile[/dim]")
+    if not has_issues:
+        console.print("[green]✓ All custom commands are verified[/green]")
+        return 0
 
     return 1
 

mcli/app/main.py

@@ -1,19 +1,13 @@
-import functools
 import importlib
-import inspect
 import os
-import platform
-import sys
-from functools import lru_cache
-from importlib.metadata import metadata, version
 from pathlib import Path
 from typing import List, Optional
 
 import click
 import tomli
 
+from mcli.lib.api.api import register_command_as_api
 from mcli.lib.logger.logger import disable_runtime_tracing, enable_runtime_tracing, get_logger
-from mcli.lib.ui.styling import info, success
 
 # Defer performance optimizations until needed
 _optimization_results = None
@@ -78,7 +72,7 @@ def discover_modules(base_path: Path, config_path: Optional[Path] = None) -> Lis
             logger.warning(f"Error reading config file {config_path}: {e}")
             config = {"paths": {"included_dirs": ["app", "self", "workflow", "public"]}}
     else:
-        logger.warning(f"Config file not found, using default configuration")
+        logger.warning("Config file not found, using default configuration")
         config = {"paths": {"included_dirs": ["app", "self", "workflow", "public"]}}
     excluded_files = {"setup.py", "__init__.py"}
     excluded_dirs = {"resources", "models", "scripts", "private", "venv", ".venv", "__pycache__"}

mcli/app/model/model.py

@@ -2,14 +2,10 @@ import base64
 import json
 import os
 import queue
-import shutil
-import sys
-import tempfile
 import threading
 import time
 import uuid
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Tuple
 
 import click
 import cv2
@@ -323,7 +319,7 @@ class ComfyUIClient:
             "subfolder": "v2v_input",  # Custom subfolder for our workflow
             "type": "input",
         }
-        response = self.session.post(f"{self.api_url}/upload/image", json=data)
+        self.session.post(f"{self.api_url}/upload/image", json=data)
         return filename, "v2v_input"
 
     def wait_for_prompt(self, prompt_id: str) -> Dict[str, Any]:
@@ -418,7 +414,7 @@ class ComfyUIClient:
 
         # Get the output image
         output_node = None
-        for node_id, node_output in result["outputs"].items():
+        for _node_id, node_output in result["outputs"].items():
             if "images" in node_output:
                 output_node = node_output
                 break
@@ -678,7 +674,7 @@ class VideoToVideoGenerator:
             with click.progressbar(
                 enumerate(frame_paths), length=len(frame_paths), label="Processing frames"
             ) as bar:
-                for i, frame_path in bar:
+                for _i, frame_path in bar:
                     processed_frame_path = self.comfyui_client.process_frame(
                         frame_path=frame_path,
                         prompt=prompt,
@@ -795,7 +791,6 @@ class VideoToVideoGenerator:
 @click.group(name="model")
 def model():
     """Video-to-video generation workflow using ComfyUI and Hunyuan video models."""
-    pass
 
 
 @model.command()
@@ -1012,7 +1007,7 @@ def check_comfyui():
 
                 # Check for hunyuan models
                 hunyuan_found = False
-                for model_type, models in models_info.items():
+                for _model_type, models in models_info.items():
                     for model in models:
                         if "hunyuan" in model.lower():
                             hunyuan_found = True

mcli/app/store_cmd.py

@@ -2,6 +2,7 @@
 Top-level store management commands for MCLI.
 Manages command store - sync ~/.mcli/commands/ to git.
 """
+
 import shutil
 import subprocess
 from datetime import datetime
@@ -20,7 +21,7 @@ COMMANDS_PATH = Path.home() / ".mcli" / "commands"
 
 
 def _get_store_path() -> Path:
-    """Get store path from config or default"""
+    """Get store path from config or default."""
     config_file = Path.home() / ".mcli" / "store.conf"
 
     if config_file.exists():
@@ -34,15 +35,14 @@ def _get_store_path() -> Path:
 
 @click.group(name="store")
 def store():
-    """Manage command store - sync ~/.mcli/commands/ to git"""
-    pass
+    """Manage command store - sync ~/.mcli/commands/ to git."""
 
 
 @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"""
+    """Initialize command store with git."""
     store_path = Path(path) if path else DEFAULT_STORE_PATH
 
     try:
@@ -305,7 +305,7 @@ def sync_commands(message, is_global):
 
 @store.command(name="status")
 def store_status():
-    """Show git status of command store"""
+    """Show git status of command store."""
     try:
         store_path = _get_store_path()
 
@@ -341,7 +341,7 @@ def store_status():
 @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"""
+    """Configure store settings."""
     try:
         store_path = _get_store_path()
 
@@ -377,7 +377,7 @@ def configure_store(remote, path):
 @store.command(name="list")
 @click.option("--store-dir", "-s", is_flag=True, help="List store instead of local")
 def list_commands(store_dir):
-    """List all commands"""
+    """List all commands."""
     try:
         if store_dir:
             store_path = _get_store_path()
@@ -421,7 +421,7 @@ def list_commands(store_dir):
 @click.argument("command_name")
 @click.option("--store-dir", "-s", is_flag=True, help="Show from store instead of local")
 def show_command(command_name, store_dir):
-    """Show command file contents"""
+    """Show command file contents."""
     try:
         if store_dir:
             store_path = _get_store_path()

mcli/app/video/__init__.py

@@ -1,5 +1,3 @@
 """
 Video processing commands for mcli.
 """
-
-from .video import *

mcli/app/video/video.py

@@ -1,23 +1,11 @@
-import base64
-import json
 import os
-import queue
-import shutil
-import sys
-import tempfile
-import threading
-import time
-import uuid
-from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
 import click
 import cv2
 import numpy as np
-import requests
 from PIL import Image
-from scipy import ndimage, spatial
-from skimage import feature, morphology, restoration
+from skimage import morphology
 
 # Add this to your existing CONFIG
 CONFIG = {"temp_dir": "./temp", "output_dir": "./output"}
@@ -1105,7 +1093,6 @@ def remove_overlay(input_video, output, fps, output_fps, context, method):
 @click.group()
 def main():
     """Advanced video overlay removal tool with intelligent content reconstruction."""
-    pass
 
 
 main.add_command(remove_overlay)