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

mcli/app/init_cmd.py

@@ -0,0 +1,391 @@
+"""
+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
+
+from mcli.lib.logger.logger import get_logger
+from mcli.lib.ui.styling import console
+
+logger = get_logger(__name__)
+
+
+@click.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(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 init              # Initialize local workflows (if in git repo)
+        mcli init --global     # Initialize global workflows
+        mcli init --git        # Also initialize git repository
+    """
+    from mcli.lib.paths import get_git_root, get_local_mcli_dir, get_mcli_home, 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
+
+    # Explicitly create workflows directory (not commands)
+    # This bypasses the migration logic that would check for old commands/ directory
+    if not is_global and in_git_repo:
+        local_mcli = get_local_mcli_dir()
+        workflows_dir = local_mcli / "workflows"
+    else:
+        workflows_dir = get_mcli_home() / "workflows"
+
+    lockfile_path = workflows_dir / "commands.lock.json"
+
+    # 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
+    from rich.table import Table
+
+    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 init' inside repos.[/dim]"
+        )
+
+    return 0
+
+
+@click.command("teardown")
+@click.option(
+    "--global",
+    "-g",
+    "is_global",
+    is_flag=True,
+    help="Teardown global workflows directory instead of local",
+)
+@click.option("--force", "-f", is_flag=True, help="Skip all confirmation prompts")
+def teardown(is_global, force):
+    """
+    Remove all local MCLI artifacts.
+
+    This command deletes the workflows directory and all associated files.
+    By default, operates on local workflows (if in git repo), use --global for
+    global workflows.
+
+    For safety, you must type the name of the current directory to confirm.
+
+    Examples:
+        mcli teardown              # Remove local workflows (requires confirmation)
+        mcli teardown --global     # Remove global workflows (requires confirmation)
+        mcli teardown --force      # Skip confirmations (dangerous!)
+    """
+    from mcli.lib.paths import get_git_root, get_local_mcli_dir, get_mcli_home, is_git_repository
+
+    # Determine which directory to teardown
+    in_git_repo = is_git_repository() and not is_global
+    git_root = get_git_root() if in_git_repo else None
+
+    if not is_global and in_git_repo:
+        local_mcli = get_local_mcli_dir()
+        workflows_dir = local_mcli / "workflows"
+        scope = "local"
+        scope_display = git_root.name if git_root else "current repository"
+    else:
+        workflows_dir = get_mcli_home() / "workflows"
+        scope = "global"
+        scope_display = "global (~/.mcli)"
+
+    # Check if workflows directory exists
+    if not workflows_dir.exists():
+        console.print(f"[yellow]No workflows directory found at:[/yellow] {workflows_dir}")
+        console.print("[dim]Nothing to teardown.[/dim]")
+        return 0
+
+    # Display what will be removed
+    console.print(f"[bold red]⚠ WARNING: This will delete all {scope} MCLI artifacts[/bold red]")
+    console.print()
+    console.print(f"[bold]Scope:[/bold] {scope_display}")
+    console.print(f"[bold]Directory:[/bold] {workflows_dir}")
+
+    # Count files
+    try:
+        file_count = sum(1 for _ in workflows_dir.rglob("*") if _.is_file())
+        console.print(f"[bold]Files to delete:[/bold] {file_count}")
+    except Exception:
+        file_count = "unknown"
+        console.print(f"[bold]Files to delete:[/bold] {file_count}")
+
+    console.print()
+
+    # Safety confirmation
+    if not force:
+        console.print("[yellow]This action cannot be undone![/yellow]")
+        console.print()
+
+        if in_git_repo and git_root:
+            # For local repos, require typing the repo name
+            expected_name = git_root.name
+            console.print(
+                f"[bold]To confirm, type the repository name:[/bold] [cyan]{expected_name}[/cyan]"
+            )
+        else:
+            # For global, require typing "global"
+            expected_name = "global"
+            console.print(f"[bold]To confirm, type:[/bold] [cyan]{expected_name}[/cyan]")
+
+        confirmation = Prompt.ask("Confirmation")
+
+        if confirmation != expected_name:
+            console.print("[red]Confirmation failed. Teardown cancelled.[/red]")
+            return 1
+
+    # Perform teardown
+    try:
+        console.print()
+        console.print("[yellow]Removing workflows directory...[/yellow]")
+
+        shutil.rmtree(workflows_dir)
+
+        console.print(f"[green]✓[/green] Removed: {workflows_dir}")
+
+        # Also remove parent .mcli directory if empty (local only)
+        if not is_global and in_git_repo:
+            try:
+                parent_dir = workflows_dir.parent
+                if parent_dir.exists() and not any(parent_dir.iterdir()):
+                    parent_dir.rmdir()
+                    console.print(f"[green]✓[/green] Removed empty directory: {parent_dir}")
+            except OSError:
+                pass  # Directory not empty, that's fine
+
+        console.print()
+        console.print("[bold green]Teardown complete![/bold green]")
+
+        if in_git_repo:
+            console.print(
+                "[dim]Local workflows removed. Global workflows (if any) are still available.[/dim]"
+            )
+        else:
+            console.print(
+                "[dim]Global workflows removed. Local workflows (if any) are still available.[/dim]"
+            )
+
+        return 0
+
+    except Exception as e:
+        console.print(f"[red]Error during teardown: {e}[/red]")
+        logger.exception(e)
+        return 1

mcli/app/lock_cmd.py

@@ -0,0 +1,288 @@
+"""
+Top-level lock management commands for MCLI.
+Manages workflow lockfile and verification.
+"""
+import hashlib
+import json
+from datetime import datetime
+from pathlib import Path
+
+import click
+from rich.table import Table
+
+from mcli.lib.custom_commands import get_command_manager
+from mcli.lib.logger.logger import get_logger
+from mcli.lib.ui.styling import console
+
+logger = get_logger(__name__)
+
+# Command state lockfile configuration
+LOCKFILE_PATH = Path.home() / ".local" / "mcli" / "command_lock.json"
+
+
+def load_lockfile():
+    """Load the command state lockfile."""
+    if LOCKFILE_PATH.exists():
+        with open(LOCKFILE_PATH, "r") as f:
+            return json.load(f)
+    return []
+
+
+def save_lockfile(states):
+    """Save states to the command state lockfile."""
+    LOCKFILE_PATH.parent.mkdir(parents=True, exist_ok=True)
+    with open(LOCKFILE_PATH, "w") as f:
+        json.dump(states, f, indent=2, default=str)
+
+
+def append_lockfile(new_state):
+    """Append a new state to the lockfile."""
+    states = load_lockfile()
+    states.append(new_state)
+    save_lockfile(states)
+
+
+def find_state_by_hash(hash_value):
+    """Find a state by its hash value."""
+    states = load_lockfile()
+    for state in states:
+        if state["hash"] == hash_value:
+            return state
+    return None
+
+
+def restore_command_state(hash_value):
+    """Restore to a previous command state."""
+    state = find_state_by_hash(hash_value)
+    if not state:
+        return False
+    # Here you would implement logic to restore the command registry to this state
+    # For now, just print the commands
+    print(json.dumps(state["commands"], indent=2))
+    return True
+
+
+def get_current_command_state():
+    """Collect all command metadata (names, groups, etc.)"""
+    # Import here to avoid circular imports
+    import importlib
+    import inspect
+    import os
+    from pathlib import Path
+
+    commands = []
+
+    # Look for command modules in the mcli package
+    mcli_path = Path(__file__).parent.parent
+
+    # This finds command groups as directories under mcli
+    for item in mcli_path.iterdir():
+        if item.is_dir() and not item.name.startswith("__") and not item.name.startswith("."):
+            group_name = item.name
+
+            # Recursively find all Python files that might define commands
+            for py_file in item.glob("**/*.py"):
+                if py_file.name.startswith("__"):
+                    continue
+
+                # Convert file path to module path
+                relative_path = py_file.relative_to(mcli_path.parent)
+                module_name = str(relative_path.with_suffix("")).replace(os.sep, ".")
+
+                try:
+                    # Try to import the module
+                    module = importlib.import_module(module_name)
+
+                    # Suppress Streamlit logging noise during command collection
+                    if "streamlit" in module_name or "dashboard" in module_name:
+                        # Suppress streamlit logger to avoid noise
+                        import logging
+
+                        streamlit_logger = logging.getLogger("streamlit")
+                        original_level = streamlit_logger.level
+                        streamlit_logger.setLevel(logging.CRITICAL)
+
+                        try:
+                            # Import and extract commands
+                            pass
+                        finally:
+                            # Restore original logging level
+                            streamlit_logger.setLevel(original_level)
+
+                    # Extract command and group objects
+                    for name, obj in inspect.getmembers(module):
+                        # Handle Click commands and groups
+                        if isinstance(obj, click.Command):
+                            if isinstance(obj, click.Group):
+                                # Found a Click group
+                                app_info = {
+                                    "name": obj.name,
+                                    "group": group_name,
+                                    "path": module_name,
+                                    "help": obj.help,
+                                }
+                                commands.append(app_info)
+
+                                # Add subcommands if any
+                                for cmd_name, cmd in obj.commands.items():
+                                    commands.append(
+                                        {
+                                            "name": cmd_name,
+                                            "group": f"{group_name}.{app_info['name']}",
+                                            "path": f"{module_name}.{cmd_name}",
+                                            "help": cmd.help,
+                                        }
+                                    )
+                            else:
+                                # Found a standalone Click command
+                                commands.append(
+                                    {
+                                        "name": obj.name,
+                                        "group": group_name,
+                                        "path": f"{module_name}.{obj.name}",
+                                        "help": obj.help,
+                                    }
+                                )
+                except (ImportError, AttributeError) as e:
+                    logger.debug(f"Skipping {module_name}: {e}")
+
+    return commands
+
+
+def hash_command_state(commands):
+    """Hash the command state for fast comparison."""
+    # Sort for deterministic hash
+    commands_sorted = sorted(commands, key=lambda c: (c.get("group") or "", c["name"]))
+    state_json = json.dumps(commands_sorted, sort_keys=True)
+    return hashlib.sha256(state_json.encode("utf-8")).hexdigest()
+
+
+@click.group(name="lock")
+def lock():
+    """Manage workflow lockfile and verification."""
+    pass
+
+
+@lock.command("list")
+def list_states():
+    """List all saved command states (hash, timestamp, #commands)."""
+    states = load_lockfile()
+    if not states:
+        click.echo("No command states found.")
+        return
+
+    table = Table(title="Command States")
+    table.add_column("Hash", style="cyan")
+    table.add_column("Timestamp", style="green")
+    table.add_column("# Commands", style="yellow")
+
+    for state in states:
+        table.add_row(state["hash"][:8], state["timestamp"], str(len(state["commands"])))
+
+    console.print(table)
+
+
+@lock.command("restore")
+@click.argument("hash_value")
+def restore_state(hash_value):
+    """Restore to a previous command state by hash."""
+    if restore_command_state(hash_value):
+        click.echo(f"Restored to state {hash_value[:8]}")
+    else:
+        click.echo(f"State {hash_value[:8]} not found.", err=True)
+
+
+@lock.command("write")
+@click.argument("json_file", required=False, type=click.Path(exists=False))
+def write_state(json_file):
+    """Write a new command state to the lockfile from a JSON file or the current app state."""
+    import traceback
+
+    print("[DEBUG] write_state called")
+    print(f"[DEBUG] LOCKFILE_PATH: {LOCKFILE_PATH}")
+    try:
+        if json_file:
+            print(f"[DEBUG] Loading command state from file: {json_file}")
+            with open(json_file, "r") as f:
+                commands = json.load(f)
+            click.echo(f"Loaded command state from {json_file}.")
+        else:
+            print("[DEBUG] Snapshotting current command state.")
+            commands = get_current_command_state()
+
+        state_hash = hash_command_state(commands)
+        new_state = {
+            "hash": state_hash,
+            "timestamp": datetime.utcnow().isoformat() + "Z",
+            "commands": commands,
+        }
+        append_lockfile(new_state)
+        print(f"[DEBUG] Wrote new command state {state_hash[:8]} to lockfile at {LOCKFILE_PATH}")
+        click.echo(f"Wrote new command state {state_hash[:8]} to lockfile.")
+    except Exception as e:
+        print(f"[ERROR] Exception in write_state: {e}")
+        print(traceback.format_exc())
+        click.echo(f"[ERROR] Failed to write command state: {e}", err=True)
+
+
+@lock.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(global_mode=is_global)
+
+    # First, ensure lockfile is up to date
+    manager.update_lockfile()
+
+    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}")
+
+    console.print("\n[dim]Run 'mcli lock update' to sync the lockfile[/dim]")
+
+    return 1
+
+
+@lock.command("update")
+@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(global_mode=is_global)
+
+    if manager.update_lockfile():
+        console.print(f"[green]Updated lockfile: {manager.lockfile_path}[/green]")
+        return 0
+    else:
+        console.print("[red]Failed to update lockfile.[/red]")
+        return 1