mcli-framework 7.10.2__py3-none-any.whl → 7.11.1__py3-none-any.whl

mcli/app/commands_cmd.py

@@ -172,38 +172,303 @@ 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("init")
+@click.option(
+    "--global", "-g", "is_global", is_flag=True, help="Initialize global workflows directory instead of local"
+)
+@click.option(
+    "--git", is_flag=True, help="Initialize git repository in workflows directory"
+)
+@click.option(
+    "--force", "-f", is_flag=True, help="Force initialization even if directory exists"
+)
+def init_workflows(is_global, git, force):
+    """
+    Initialize workflows directory structure.
+
+    Creates the necessary directories and configuration files for managing
+    custom workflows. By default, creates a local .mcli/workflows/ directory
+    if in a git repository, otherwise uses ~/.mcli/workflows/.
+
+    Examples:
+        mcli workflow init              # Initialize local workflows (if in git repo)
+        mcli workflow init --global     # Initialize global workflows
+        mcli workflow init --git        # Also initialize git repository
+    """
+    from mcli.lib.paths import (
+        get_custom_commands_dir,
+        get_lockfile_path,
+        get_git_root,
+        is_git_repository,
+    )
+
+    # Determine if we're in a git repository
+    in_git_repo = is_git_repository() and not is_global
+    git_root = get_git_root() if in_git_repo else None
+
+    # Get the workflows directory
+    workflows_dir = get_custom_commands_dir(global_mode=is_global)
+    lockfile_path = get_lockfile_path(global_mode=is_global)
+
+    # Check if already initialized
+    if workflows_dir.exists() and not force:
+        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]")
+
+            should_continue = Prompt.ask(
+                "Continue anyway?", choices=["y", "n"], default="n"
+            )
+            if should_continue.lower() != "y":
+                return 0
+
+    # Create workflows directory
+    workflows_dir.mkdir(parents=True, exist_ok=True)
+    console.print(f"[green]✓[/green] Created workflows directory: {workflows_dir}")
+
+    # Create README.md
+    readme_path = workflows_dir / "README.md"
+    if not readme_path.exists() or force:
+        scope = "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
+
+This directory contains custom workflow commands {scope_desc}.
+
+## Quick Start
+
+### Create a New Workflow
+
+```bash
+# Python workflow
+mcli workflow add my-workflow
+
+# Shell workflow
+mcli workflow add my-script --language shell
+```
+
+### List Workflows
+
+```bash
+mcli workflow list --custom-only
+```
+
+### Execute a Workflow
+
+```bash
+mcli workflows my-workflow
+```
+
+### Edit a Workflow
+
+```bash
+mcli workflow edit my-workflow
+```
+
+### Export/Import Workflows
+
+```bash
+# Export all workflows
+mcli workflow export workflows-backup.json
+
+# Import workflows
+mcli workflow import workflows-backup.json
+```
+
+## Directory Structure
+
+```
+{workflows_dir.name}/
+├── README.md              # This file
+├── commands.lock.json     # Lockfile for workflow state
+└── *.json                 # Individual workflow definitions
+```
+
+## Workflow Format
+
+Workflows are stored as JSON files with the following structure:
+
+```json
+{{
+  "name": "workflow-name",
+  "description": "Workflow description",
+  "code": "Python or shell code",
+  "language": "python",
+  "group": "workflow",
+  "version": "1.0",
+  "created_at": "2025-10-30T...",
+  "updated_at": "2025-10-30T..."
+}}
+```
+
+## Scope
+
+- **Scope**: {'Local (repository-specific)' if in_git_repo else 'Global (user-wide)'}
+- **Location**: `{workflows_dir}`
+{f"- **Git Repository**: `{git_root}`" if git_root else ""}
+
+## Documentation
+
+- [MCLI Documentation](https://github.com/gwicho38/mcli)
+- [Workflow Guide](https://github.com/gwicho38/mcli/blob/main/docs/features/LOCAL_VS_GLOBAL_COMMANDS.md)
+
+---
+
+*Initialized: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}*
+"""
+
+        readme_path.write_text(readme_content)
+        console.print(f"[green]✓[/green] Created README: {readme_path.name}")
+
+    # Initialize lockfile
+    if not lockfile_path.exists() or force:
+        lockfile_data = {
+            "version": "1.0",
+            "initialized_at": datetime.now().isoformat(),
+            "scope": "local" if in_git_repo else "global",
+            "commands": {}
+        }
+
+        with open(lockfile_path, "w") as f:
+            json.dump(lockfile_data, f, indent=2)
+
+        console.print(f"[green]✓[/green] Initialized lockfile: {lockfile_path.name}")
+
+    # Create .gitignore if in workflows directory
+    gitignore_path = workflows_dir / ".gitignore"
+    if not gitignore_path.exists() or force:
+        gitignore_content = """# Backup files
+*.backup
+*.bak
+
+# Temporary files
+*.tmp
+*.temp
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Editor files
+*.swp
+*.swo
+*~
+.vscode/
+.idea/
+"""
+        gitignore_path.write_text(gitignore_content)
+        console.print(f"[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")
+
+            # Create initial commit
+            subprocess.run(
+                ["git", "add", "."],
+                cwd=workflows_dir,
+                check=True,
+                capture_output=True
+            )
+            subprocess.run(
+                ["git", "commit", "-m", "Initial commit: Initialize workflows directory"],
+                cwd=workflows_dir,
+                check=True,
+                capture_output=True
+            )
+            console.print(f"[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.")
+
+    # Summary
+    console.print()
+    console.print("[bold green]Workflows directory initialized successfully![/bold green]")
+    console.print()
+
+    # Display summary table
+    table = Table(title="Initialization Summary", show_header=False)
+    table.add_column("Property", style="cyan")
+    table.add_column("Value", style="green")
+
+    table.add_row("Scope", "Local (repository-specific)" if in_git_repo else "Global (user-wide)")
+    table.add_row("Location", str(workflows_dir))
+    if git_root:
+        table.add_row("Git Repository", str(git_root))
+    table.add_row("Lockfile", str(lockfile_path))
+    table.add_row("Git Initialized", "Yes" if git and (workflows_dir / ".git").exists() else "No")
+
+    console.print(table)
+    console.print()
+
+    # Next steps
+    console.print("[bold]Next Steps:[/bold]")
+    console.print("  1. Create a workflow:  [cyan]mcli workflow add my-workflow[/cyan]")
+    console.print("  2. List workflows:     [cyan]mcli workflow list --custom-only[/cyan]")
+    console.print("  3. Execute workflow:   [cyan]mcli workflows my-workflow[/cyan]")
+    console.print("  4. View README:        [cyan]cat {}/README.md[/cyan]".format(workflows_dir))
+    console.print()
+
+    if in_git_repo:
+        console.print(f"[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 workflow init' inside repos.[/dim]")
+
+    return 0
+
+
+@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 +497,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 +559,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 +637,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 +667,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 +955,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 +978,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 +1031,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 +1112,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 +1173,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 +1182,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 +1193,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 +1274,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 +1287,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 +1298,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 +1448,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 +1491,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 +1511,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 +1525,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 +1614,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 +1699,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 +1786,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 +1850,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 +1907,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 +2116,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)"
 )