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

mcli/app/main.py

@@ -326,6 +326,42 @@ class LazyGroup(click.Group):
 
 def _add_lazy_commands(app: click.Group):
     """Add command groups with lazy loading."""
+    # Top-level init command
+    try:
+        from mcli.app.init_cmd import init
+
+        app.add_command(init, name="init")
+        logger.debug("Added init command")
+    except ImportError as e:
+        logger.debug(f"Could not load init command: {e}")
+
+    # Top-level teardown command
+    try:
+        from mcli.app.init_cmd import teardown
+
+        app.add_command(teardown, name="teardown")
+        logger.debug("Added teardown command")
+    except ImportError as e:
+        logger.debug(f"Could not load teardown command: {e}")
+
+    # Top-level lock group
+    try:
+        from mcli.app.lock_cmd import lock
+
+        app.add_command(lock, name="lock")
+        logger.debug("Added lock group")
+    except ImportError as e:
+        logger.debug(f"Could not load lock group: {e}")
+
+    # Top-level store group
+    try:
+        from mcli.app.store_cmd import store
+
+        app.add_command(store, name="store")
+        logger.debug("Added store group")
+    except ImportError as e:
+        logger.debug(f"Could not load store group: {e}")
+
     # Workflow management - load immediately for fast access (renamed from 'commands')
     try:
         from mcli.app.commands_cmd import workflow
@@ -350,6 +386,7 @@ def _add_lazy_commands(app: click.Group):
     # Add workflows group directly (not lazy-loaded) to preserve -g/--global option
     try:
         from mcli.workflow.workflow import workflows as workflows_group
+
         app.add_command(workflows_group, name="workflows")
         logger.debug("Added workflows group with -g/--global support")
     except ImportError as e:
@@ -430,54 +467,14 @@ def create_app() -> click.Group:
 
     app = click.Group(name="mcli")
 
-    # Clean top-level commands
-    @app.command()
-    @click.option("--verbose", "-v", is_flag=True, help="Show additional system information")
-    def version(verbose: bool):
-        """Show mcli version and system information"""
-        message = get_version_info(verbose)
-        logger.info(message)
-        info(message)
-
+    # Version command moved to self group (mcli self version)
     # Add lazy-loaded command groups
     _add_lazy_commands(app)
 
     return app
 
 
-@lru_cache()
-def get_version_info(verbose: bool = False) -> str:
-    """Get version info, cached to prevent multiple calls."""
-    try:
-        # Try mcli-framework first (PyPI package name), then mcli (local dev)
-        mcli_version = None
-        meta = None
-
-        for pkg_name in ["mcli-framework", "mcli"]:
-            try:
-                mcli_version = version(pkg_name)
-                meta = metadata(pkg_name)
-                break
-            except Exception:
-                continue
-
-        if mcli_version is None:
-            return "Could not determine version: Package metadata not found"
-
-        info = [f"mcli version {mcli_version}"]
-
-        if verbose:
-            info.extend(
-                [
-                    f"\nPython: {sys.version.split()[0]}",
-                    f"Platform: {platform.platform()}",
-                    f"Description: {meta.get('Summary', 'Not available')}",
-                    f"Author: {meta.get('Author', 'Not available')}",
-                ]
-            )
-        return "\n".join(info)
-    except Exception as e:
-        return f"Could not determine version: {e}"
+# get_version_info moved to self_cmd.py
 
 
 def main():

mcli/app/store_cmd.py

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

mcli/app/video/__init__.py

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

mcli/chat/__init__.py

@@ -0,0 +1,34 @@
+"""
+MCLI Chat System
+Real-time system control and interaction capabilities for MCLI chat
+"""
+
+from .system_controller import (
+    SystemController,
+    control_app,
+    execute_system_command,
+    open_file_or_url,
+    open_textedit_and_write,
+    system_controller,
+    take_screenshot,
+)
+from .system_integration import (
+    ChatSystemIntegration,
+    chat_system_integration,
+    get_system_capabilities,
+    handle_system_request,
+)
+
+__all__ = [
+    "SystemController",
+    "system_controller",
+    "ChatSystemIntegration",
+    "chat_system_integration",
+    "handle_system_request",
+    "get_system_capabilities",
+    "open_textedit_and_write",
+    "control_app",
+    "execute_system_command",
+    "take_screenshot",
+    "open_file_or_url",
+]

mcli/lib/auth/__init__.py

@@ -0,0 +1 @@
+from .auth import *

mcli/lib/config/__init__.py

@@ -0,0 +1 @@
+from .config import *

mcli/lib/custom_commands.py

@@ -21,9 +21,9 @@ import click
 from mcli.lib.logger.logger import get_logger, register_subprocess
 from mcli.lib.paths import (
     get_custom_commands_dir,
+    get_git_root,
     get_lockfile_path,
     is_git_repository,
-    get_git_root,
 )
 
 logger = get_logger()
@@ -131,7 +131,7 @@ class CustomCommandManager:
             List of command data dictionaries
         """
         commands = []
-        include_test = os.environ.get('MCLI_INCLUDE_TEST_COMMANDS', 'false').lower() == 'true'
+        include_test = os.environ.get("MCLI_INCLUDE_TEST_COMMANDS", "false").lower() == "true"
 
         for command_file in self.commands_dir.glob("*.json"):
             # Skip the lockfile
@@ -139,7 +139,7 @@ class CustomCommandManager:
                 continue
 
             # Skip test commands unless explicitly included
-            if not include_test and command_file.stem.startswith(('test_', 'test-')):
+            if not include_test and command_file.stem.startswith(("test_", "test-")):
                 logger.debug(f"Skipping test command: {command_file.name}")
                 continue
 

mcli/lib/erd/__init__.py

@@ -0,0 +1,25 @@
+"""
+Entity Relationship Diagram (ERD) package.
+
+This package provides utilities for generating Entity Relationship Diagrams from MCLI type metadata.
+"""
+
+# Import and export all public functions from erd.py
+from .erd import (
+    analyze_graph_for_hierarchical_exports,
+    create_merged_erd,
+    do_erd,
+    find_top_nodes_in_graph,
+    generate_erd_for_top_nodes,
+    generate_merged_erd_for_types,
+)
+
+# Define __all__ to control exports
+__all__ = [
+    "do_erd",
+    "create_merged_erd",
+    "generate_merged_erd_for_types",
+    "find_top_nodes_in_graph",
+    "generate_erd_for_top_nodes",
+    "analyze_graph_for_hierarchical_exports",
+]

mcli/lib/fs/__init__.py

@@ -0,0 +1 @@
+from .fs import *

mcli/lib/logger/__init__.py

@@ -0,0 +1,3 @@
+from .logger import get_logger
+
+__all__ = ["get_logger"]

mcli/lib/optional_deps.py

@@ -219,9 +219,7 @@ def check_dependencies(*module_names: str) -> Dict[str, bool]:
         >>> print(status)
         {'torch': True, 'transformers': False, 'streamlit': True}
     """
-    return {
-        name: OptionalDependency(name).available for name in module_names
-    }
+    return {name: OptionalDependency(name).available for name in module_names}
 
 
 # Pre-register common optional dependencies