mcli-framework 7.10.1__py3-none-any.whl → 7.11.0__py3-none-any.whl

mcli/app/commands_cmd.py

@@ -172,38 +172,48 @@ def restore_command_state(hash_value):
     return True
 
 
-@click.group()
-def commands():
-    """Manage and execute available commands."""
+@click.group(name="workflow")
+def workflow():
+    """Manage workflows - create, edit, import, export workflow commands."""
     pass
 
 
-@commands.command("list")
+# For backward compatibility, keep commands as an alias
+commands = workflow
+
+
+@workflow.command("list")
 @click.option("--include-groups", is_flag=True, help="Include command groups in listing")
 @click.option("--daemon-only", is_flag=True, help="Show only daemon database commands")
 @click.option(
-    "--custom-only", is_flag=True, help="Show only custom commands from ~/.mcli/commands/"
+    "--custom-only", is_flag=True, help="Show only custom commands from command directory"
 )
 @click.option("--json", "as_json", is_flag=True, help="Output as JSON")
-def list_commands(include_groups: bool, daemon_only: bool, custom_only: bool, as_json: bool):
+@click.option(
+    "--global", "-g", "is_global", is_flag=True, help="Use global commands (~/.mcli/commands/) instead of local (.mcli/commands/)"
+)
+def list_commands(include_groups: bool, daemon_only: bool, custom_only: bool, as_json: bool, is_global: bool):
     """
     List all available commands.
 
     By default, shows all discovered Click commands. Use flags to filter:
-    - --custom-only: Show only custom commands from ~/.mcli/commands/
+    - --custom-only: Show only custom commands
     - --daemon-only: Show only daemon database commands
+    - --global/-g: Use global commands directory instead of local
 
     Examples:
-        mcli commands list                  # Show all commands
-        mcli commands list --custom-only    # Show only custom commands
+        mcli commands list                  # Show all commands (local if in git repo)
+        mcli commands list --custom-only    # Show only custom commands (local if in git repo)
+        mcli commands list --global         # Show all global commands
+        mcli commands list --custom-only -g # Show only global custom commands
         mcli commands list --json           # Output as JSON
     """
     from rich.table import Table
 
     try:
         if custom_only:
-            # Show only custom commands from ~/.mcli/commands/
-            manager = get_command_manager()
+            # Show only custom commands
+            manager = get_command_manager(global_mode=is_global)
             cmds = manager.load_all_commands()
 
             if not cmds:
@@ -232,7 +242,14 @@ def list_commands(include_groups: bool, daemon_only: bool, custom_only: bool, as
                 )
 
             console.print(table)
-            console.print(f"\n[dim]Commands directory: {manager.commands_dir}[/dim]")
+
+            # Show context information
+            scope = "global" if is_global or not manager.is_local else "local"
+            scope_color = "yellow" if scope == "local" else "cyan"
+            console.print(f"\n[dim]Scope: [{scope_color}]{scope}[/{scope_color}][/dim]")
+            if manager.is_local and manager.git_root:
+                console.print(f"[dim]Git repository: {manager.git_root}[/dim]")
+            console.print(f"[dim]Commands directory: {manager.commands_dir}[/dim]")
             console.print(f"[dim]Lockfile: {manager.lockfile_path}[/dim]")
 
             return 0
@@ -287,12 +304,19 @@ def list_commands(include_groups: bool, daemon_only: bool, custom_only: bool, as
         console.print(f"[red]Error: {e}[/red]")
 
 
-@commands.command("search")
+@workflow.command("search")
 @click.argument("query")
 @click.option("--daemon-only", is_flag=True, help="Search only daemon database commands")
 @click.option("--json", "as_json", is_flag=True, help="Output as JSON")
-def search_commands(query: str, daemon_only: bool, as_json: bool):
-    """Search commands by name, description, or tags"""
+@click.option(
+    "--global", "-g", "is_global", is_flag=True, help="Search global commands instead of local"
+)
+def search_commands(query: str, daemon_only: bool, as_json: bool, is_global: bool):
+    """
+    Search commands by name, description, or tags.
+
+    By default searches local commands (if in git repo), use --global/-g for global commands.
+    """
     try:
         if daemon_only:
             # Search only daemon database commands
@@ -358,7 +382,7 @@ def search_commands(query: str, daemon_only: bool, as_json: bool):
         console.print(f"[red]Error: {e}[/red]")
 
 
-@commands.command("execute")
+@workflow.command("execute")
 @click.argument("command_name")
 @click.argument("args", nargs=-1)
 @click.option("--json", "as_json", is_flag=True, help="Output as JSON")
@@ -388,7 +412,7 @@ def execute_command(command_name: str, args: tuple, as_json: bool, timeout: Opti
         console.print(f"[red]Error: {e}[/red]")
 
 
-@commands.command("info")
+@workflow.command("info")
 @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):
@@ -676,9 +700,9 @@ logger = get_logger()
             pass
 
 
-@commands.command("add")
+@workflow.command("add")
 @click.argument("command_name", required=True)
-@click.option("--group", "-g", help="Command group (defaults to 'workflow')", default="workflow")
+@click.option("--group", help="Command group (defaults to 'workflow')", default="workflow")
 @click.option("--description", "-d", help="Description for the command", default="Custom command")
 @click.option(
     "--template",
@@ -699,7 +723,10 @@ logger = get_logger()
     type=click.Choice(["bash", "zsh", "fish", "sh"], case_sensitive=False),
     help="Shell type for shell commands (defaults to $SHELL)",
 )
-def add_command(command_name, group, description, template, language, shell):
+@click.option(
+    "--global", "-g", "is_global", is_flag=True, help="Add to global commands (~/.mcli/commands/) instead of local (.mcli/commands/)"
+)
+def add_command(command_name, group, description, template, language, shell, is_global):
     """
     Generate a new portable custom command saved to ~/.mcli/commands/.
 
@@ -749,7 +776,7 @@ def add_command(command_name, group, description, template, language, shell):
         command_group = "workflow"  # Default to workflow group
 
     # Get the command manager
-    manager = get_command_manager()
+    manager = get_command_manager(global_mode=is_global)
 
     # Check if command already exists
     command_file = manager.commands_dir / f"{command_name}.json"
@@ -830,29 +857,45 @@ def add_command(command_name, group, description, template, language, shell):
     )
 
     lang_display = f"{language}" if language == "python" else f"{language} ({shell})"
-    logger.info(f"Created portable custom command: {command_name} ({lang_display})")
+    scope = "global" if is_global or not manager.is_local else "local"
+    scope_display = f"[cyan]{scope}[/cyan]" if scope == "global" else f"[yellow]{scope}[/yellow]"
+
+    logger.info(f"Created portable custom command: {command_name} ({lang_display}) [{scope}]")
     console.print(
-        f"[green]Created portable custom command: {command_name}[/green] [dim]({lang_display})[/dim]"
+        f"[green]Created portable custom command: {command_name}[/green] [dim]({lang_display}) [Scope: {scope_display}][/dim]"
     )
     console.print(f"[dim]Saved to: {saved_path}[/dim]")
+    if manager.is_local and manager.git_root:
+        console.print(f"[dim]Git repository: {manager.git_root}[/dim]")
     console.print(f"[dim]Group: {command_group}[/dim]")
     console.print(f"[dim]Execute with: mcli {command_group} {command_name}[/dim]")
     console.print("[dim]Command will be automatically loaded on next mcli startup[/dim]")
-    console.print(
-        f"[dim]You can share this command by copying {saved_path} to another machine's ~/.mcli/commands/ directory[/dim]"
-    )
+
+    if scope == "global":
+        console.print(
+            f"[dim]You can share this command by copying {saved_path} to another machine's ~/.mcli/commands/ directory[/dim]"
+        )
+    else:
+        console.print(
+            f"[dim]This command is local to this git repository. Use --global/-g to create global commands.[/dim]"
+        )
 
     return 0
 
 
-@commands.command("remove")
+@workflow.command("remove")
 @click.argument("command_name", required=True)
 @click.option("--yes", "-y", is_flag=True, help="Skip confirmation prompt")
-def remove_command(command_name, yes):
+@click.option(
+    "--global", "-g", "is_global", is_flag=True, help="Remove from global commands instead of local"
+)
+def remove_command(command_name, yes, is_global):
     """
-    Remove a custom command from ~/.mcli/commands/.
+    Remove a custom command.
+
+    By default removes from local commands (if in git repo), use --global/-g for global commands.
     """
-    manager = get_command_manager()
+    manager = get_command_manager(global_mode=is_global)
     command_file = manager.commands_dir / f"{command_name}.json"
 
     if not command_file.exists():
@@ -875,7 +918,7 @@ def remove_command(command_name, yes):
         return 1
 
 
-@commands.command("export")
+@workflow.command("export")
 @click.argument("target", type=click.Path(), required=False)
 @click.option(
     "--script", "-s", is_flag=True, help="Export as Python script (requires command name)"
@@ -884,7 +927,10 @@ def remove_command(command_name, yes):
     "--standalone", is_flag=True, help="Make script standalone (add if __name__ == '__main__')"
 )
 @click.option("--output", "-o", type=click.Path(), help="Output file path")
-def export_commands(target, script, standalone, output):
+@click.option(
+    "--global", "-g", "is_global", is_flag=True, help="Export from global commands instead of local"
+)
+def export_commands(target, script, standalone, output, is_global):
     """
     Export custom commands to JSON file or export a single command to Python script.
 
@@ -892,12 +938,13 @@ def export_commands(target, script, standalone, output):
     With --script/-s: Export a single command to Python script
 
     Examples:
-        mcli commands export                    # Export all to commands-export.json
+        mcli commands export                    # Export all local commands
+        mcli commands export --global           # Export all global commands
         mcli commands export my-export.json     # Export all to specified file
         mcli commands export my-cmd -s          # Export command to my-cmd.py
         mcli commands export my-cmd -s -o out.py --standalone
     """
-    manager = get_command_manager()
+    manager = get_command_manager(global_mode=is_global)
 
     if script:
         # Export single command to Python script
@@ -972,12 +1019,12 @@ def export_commands(target, script, standalone, output):
             return 1
 
 
-@commands.command("import")
+@workflow.command("import")
 @click.argument("source", type=click.Path(exists=True), required=True)
 @click.option("--script", "-s", is_flag=True, help="Import from Python script")
 @click.option("--overwrite", is_flag=True, help="Overwrite existing commands")
 @click.option("--name", "-n", help="Command name (for script import, defaults to script filename)")
-@click.option("--group", "-g", default="workflow", help="Command group (for script import)")
+@click.option("--group", default="workflow", help="Command group (for script import)")
 @click.option("--description", "-d", help="Command description (for script import)")
 @click.option(
     "--interactive",
@@ -985,7 +1032,10 @@ def export_commands(target, script, standalone, output):
     is_flag=True,
     help="Open in $EDITOR for review/editing (for script import)",
 )
-def import_commands(source, script, overwrite, name, group, description, interactive):
+@click.option(
+    "--global", "-g", "is_global", is_flag=True, help="Import to global commands instead of local"
+)
+def import_commands(source, script, overwrite, name, group, description, interactive, is_global):
     """
     Import custom commands from JSON file or import a Python script as a command.
 
@@ -993,13 +1043,14 @@ def import_commands(source, script, overwrite, name, group, description, interac
     With --script/-s: Import a Python script as a command
 
     Examples:
-        mcli commands import commands-export.json
+        mcli commands import commands-export.json        # Import to local (if in git repo)
+        mcli commands import commands-export.json --global  # Import to global
         mcli commands import my_script.py -s
         mcli commands import my_script.py -s --name custom-cmd --interactive
     """
     import subprocess
 
-    manager = get_command_manager()
+    manager = get_command_manager(global_mode=is_global)
     source_path = Path(source)
 
     if script:
@@ -1142,12 +1193,17 @@ def import_commands(source, script, overwrite, name, group, description, interac
         return 0
 
 
-@commands.command("verify")
-def verify_commands():
+@workflow.command("verify")
+@click.option(
+    "--global", "-g", "is_global", is_flag=True, help="Verify global commands instead of local"
+)
+def verify_commands(is_global):
     """
     Verify that custom commands match the lockfile.
+
+    By default verifies local commands (if in git repo), use --global/-g for global commands.
     """
-    manager = get_command_manager()
+    manager = get_command_manager(global_mode=is_global)
 
     # First, ensure lockfile is up to date
     manager.update_lockfile()
@@ -1180,12 +1236,17 @@ def verify_commands():
     return 1
 
 
-@commands.command("update-lockfile")
-def update_lockfile():
+@workflow.command("update-lockfile")
+@click.option(
+    "--global", "-g", "is_global", is_flag=True, help="Update global lockfile instead of local"
+)
+def update_lockfile(is_global):
     """
     Update the commands lockfile with current state.
+
+    By default updates local lockfile (if in git repo), use --global/-g for global lockfile.
     """
-    manager = get_command_manager()
+    manager = get_command_manager(global_mode=is_global)
 
     if manager.update_lockfile():
         console.print(f"[green]Updated lockfile: {manager.lockfile_path}[/green]")
@@ -1195,10 +1256,13 @@ def update_lockfile():
         return 1
 
 
-@commands.command("edit")
+@workflow.command("edit")
 @click.argument("command_name")
 @click.option("--editor", "-e", help="Editor to use (defaults to $EDITOR)")
-def edit_command(command_name, editor):
+@click.option(
+    "--global", "-g", "is_global", is_flag=True, help="Edit global command instead of local"
+)
+def edit_command(command_name, editor, is_global):
     """
     Edit a command interactively using $EDITOR.
 
@@ -1206,12 +1270,13 @@ def edit_command(command_name, editor):
     allows you to make changes, and saves the updated version.
 
     Examples:
-        mcli commands edit my-command
+        mcli commands edit my-command            # Edit local command (if in git repo)
+        mcli commands edit my-command --global   # Edit global command
         mcli commands edit my-command --editor code
     """
     import subprocess
 
-    manager = get_command_manager()
+    manager = get_command_manager(global_mode=is_global)
 
     # Load the command
     command_file = manager.commands_dir / f"{command_name}.json"
@@ -1294,7 +1359,7 @@ def edit_command(command_name, editor):
 # Moved from mcli.self for better organization
 
 
-@commands.group("state")
+@workflow.group("state")
 def command_state():
     """Manage command state lockfile and history."""
     pass
@@ -1379,7 +1444,7 @@ def _get_store_path() -> Path:
     return DEFAULT_STORE_PATH
 
 
-@commands.group("store")
+@workflow.group("store")
 def store():
     """Manage command store - sync ~/.mcli/commands/ to git"""
     pass
@@ -1466,10 +1531,19 @@ Last updated: {datetime.now().isoformat()}
 @store.command(name="push")
 @click.option("--message", "-m", help="Commit message")
 @click.option("--all", "-a", is_flag=True, help="Push all files (including backups)")
-def push_commands(message, all):
-    """Push commands from ~/.mcli/commands/ to git store"""
+@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}...")
@@ -1521,10 +1595,19 @@ def push_commands(message, all):
 
 @store.command(name="pull")
 @click.option("--force", "-f", is_flag=True, help="Overwrite local commands without backup")
-def pull_commands(force):
-    """Pull commands from git store to ~/.mcli/commands/"""
+@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:
@@ -1569,10 +1652,19 @@ def pull_commands(force):
 
 @store.command(name="sync")
 @click.option("--message", "-m", help="Commit message if pushing")
-def sync_commands(message):
-    """Sync commands bidirectionally (pull then push if changes)"""
+@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...")
@@ -1769,7 +1861,7 @@ def show_command(command_name, store):
 # Moved from mcli.self for better organization
 
 
-@commands.command("extract-workflow-commands")
+@workflow.command("extract-workflow-commands")
 @click.option(
     "--output", "-o", type=click.Path(), help="Output file (default: workflow-commands.json)"
 )

mcli/app/main.py

@@ -326,14 +326,14 @@ class LazyGroup(click.Group):
 
 def _add_lazy_commands(app: click.Group):
     """Add command groups with lazy loading."""
-    # Essential commands - load immediately for fast access
+    # Workflow management - load immediately for fast access (renamed from 'commands')
     try:
-        from mcli.app.commands_cmd import commands
+        from mcli.app.commands_cmd import workflow
 
-        app.add_command(commands, name="commands")
-        logger.debug("Added commands group")
+        app.add_command(workflow, name="workflow")
+        logger.debug("Added workflow management group")
     except ImportError as e:
-        logger.debug(f"Could not load commands group: {e}")
+        logger.debug(f"Could not load workflow management group: {e}")
 
     # Self management - load immediately as it's commonly used
     try:
@@ -344,35 +344,29 @@ def _add_lazy_commands(app: click.Group):
     except Exception as e:
         logger.debug(f"Could not load self commands: {e}")
 
-    # Library utilities and secrets management
-    try:
-        from mcli.lib.lib import lib
-
-        app.add_command(lib, name="lib")
-        logger.debug("Added lib commands")
-    except Exception as e:
-        logger.debug(f"Could not load lib commands: {e}")
+    # Note: lib group removed - secrets moved to workflows
+    # Previous: mcli lib secrets -> Now: mcli workflows secrets
 
-    # Add workflow with completion-aware lazy loading
+    # Add workflows group (renamed from 'workflow') with completion-aware lazy loading
     try:
         from mcli.app.completion_helpers import create_completion_aware_lazy_group
 
-        workflow_group = create_completion_aware_lazy_group(
-            "workflow",
-            "mcli.workflow.workflow.workflow",
-            "Workflow commands for automation, video processing, and daemon management",
+        workflows_group = create_completion_aware_lazy_group(
+            "workflows",
+            "mcli.workflow.workflow.workflows",
+            "Runnable workflows for automation, video processing, and daemon management",
         )
-        app.add_command(workflow_group, name="workflow")
-        logger.debug("Added completion-aware workflow group")
+        app.add_command(workflows_group, name="workflows")
+        logger.debug("Added completion-aware workflows group")
     except ImportError as e:
         logger.debug(f"Could not load completion helpers, using standard lazy group: {e}")
         # Fallback to standard lazy group
-        workflow_group = LazyGroup(
-            "workflow",
-            "mcli.workflow.workflow.workflow",
-            help="Workflow commands for automation, video processing, and daemon management",
+        workflows_group = LazyGroup(
+            "workflows",
+            "mcli.workflow.workflow.workflows",
+            help="Runnable workflows for automation, video processing, and daemon management",
         )
-        app.add_command(workflow_group, name="workflow")
+        app.add_command(workflows_group, name="workflows")
 
     # Lazy load other heavy commands that are used less frequently
     # NOTE: chat and model commands have been removed
@@ -382,8 +376,8 @@ def _add_lazy_commands(app: click.Group):
     lazy_commands = {}
 
     for cmd_name, cmd_info in lazy_commands.items():
-        # Skip workflow since we already added it with completion support
-        if cmd_name == "workflow":
+        # Skip workflows since we already added it with completion support
+        if cmd_name == "workflows":
             continue
 
         if cmd_name in ["model"]:

mcli/lib/custom_commands.py

@@ -19,7 +19,12 @@ from typing import Any, Dict, List, Optional
 import click
 
 from mcli.lib.logger.logger import get_logger, register_subprocess
-from mcli.lib.paths import get_custom_commands_dir
+from mcli.lib.paths import (
+    get_custom_commands_dir,
+    get_lockfile_path,
+    is_git_repository,
+    get_git_root,
+)
 
 logger = get_logger()
 
@@ -27,10 +32,22 @@ logger = get_logger()
 class CustomCommandManager:
     """Manages custom user commands stored in JSON format."""
 
-    def __init__(self):
-        self.commands_dir = get_custom_commands_dir()
+    def __init__(self, global_mode: bool = False):
+        """
+        Initialize the custom command manager.
+
+        Args:
+            global_mode: If True, use global commands directory (~/.mcli/commands/).
+                        If False, use local directory (.mcli/commands/) when in a git repository.
+        """
+        self.global_mode = global_mode
+        self.commands_dir = get_custom_commands_dir(global_mode=global_mode)
         self.loaded_commands: Dict[str, Any] = {}
-        self.lockfile_path = self.commands_dir / "commands.lock.json"
+        self.lockfile_path = get_lockfile_path(global_mode=global_mode)
+
+        # Store context information for display
+        self.is_local = not global_mode and is_git_repository()
+        self.git_root = get_git_root() if self.is_local else None
 
     def save_command(
         self,
@@ -107,15 +124,25 @@ class CustomCommandManager:
         """
         Load all custom commands from the commands directory.
 
+        Automatically filters out test commands (starting with 'test_' or 'test-')
+        unless MCLI_INCLUDE_TEST_COMMANDS=true is set.
+
         Returns:
             List of command data dictionaries
         """
         commands = []
+        include_test = os.environ.get('MCLI_INCLUDE_TEST_COMMANDS', 'false').lower() == 'true'
+
         for command_file in self.commands_dir.glob("*.json"):
             # Skip the lockfile
             if command_file.name == "commands.lock.json":
                 continue
 
+            # Skip test commands unless explicitly included
+            if not include_test and command_file.stem.startswith(('test_', 'test-')):
+                logger.debug(f"Skipping test command: {command_file.name}")
+                continue
+
             command_data = self.load_command(command_file)
             if command_data:
                 commands.append(command_data)
@@ -476,16 +503,39 @@ class CustomCommandManager:
             return results
 
 
-# Global instance
-_command_manager: Optional[CustomCommandManager] = None
+# Global and local instances
+_global_command_manager: Optional[CustomCommandManager] = None
+_local_command_manager: Optional[CustomCommandManager] = None
+
+
+def get_command_manager(global_mode: bool = False) -> CustomCommandManager:
+    """
+    Get the custom command manager instance.
 
+    Args:
+        global_mode: If True, return global manager. If False, return local manager (if in git repo).
 
-def get_command_manager() -> CustomCommandManager:
-    """Get the global custom command manager instance."""
-    global _command_manager
-    if _command_manager is None:
-        _command_manager = CustomCommandManager()
-    return _command_manager
+    Returns:
+        CustomCommandManager instance for the appropriate scope
+    """
+    global _global_command_manager, _local_command_manager
+
+    if global_mode:
+        if _global_command_manager is None:
+            _global_command_manager = CustomCommandManager(global_mode=True)
+        return _global_command_manager
+    else:
+        # Use local manager if in git repository
+        if is_git_repository():
+            # Recreate local manager if git root changed (e.g., changed directory)
+            if _local_command_manager is None or _local_command_manager.git_root != get_git_root():
+                _local_command_manager = CustomCommandManager(global_mode=False)
+            return _local_command_manager
+        else:
+            # Fallback to global manager when not in a git repository
+            if _global_command_manager is None:
+                _global_command_manager = CustomCommandManager(global_mode=True)
+            return _global_command_manager
 
 
 def load_custom_commands(target_group: click.Group) -> int: