# Run any script directly - no registration needed!
mcli run ./backup.py --target /data
mcli run ./deploy.sh production
mcli run ./.mcli/workflows/analysis.ipynb

# Intelligent tab completion shows all files and directories
mcli run ./<TAB>
# Shows: ./scripts/, ./.mcli/, ./backup.py, ./README.md

# Navigate hidden directories like .mcli
mcli run ./.mcli/<TAB>
# Shows: ./.mcli/workflows/, ./.mcli/commands/

# Execute notebooks directly
mcli run ./notebooks/analysis.ipynb cell-1

# From VSCode Marketplace (pending publication)
code --install-extension gwicho38.mcli-framework

# Or install from VSIX
code --install-extension vscode-extension/mcli-framework-1.0.3.vsix

# Install from PyPI
pip install mcli-framework

# Or with UV (recommended)
uv pip install mcli-framework

# 1. Create a script with metadata comments
cat > ~/.mcli/commands/backup.sh <<'EOF'
#!/usr/bin/env bash
# @description: Backup files to S3
# @version: 1.0.0
# @requires: aws-cli

aws s3 sync /data/ s3://my-bucket/backup/
EOF

# 2. Sync scripts to lockfile (auto-runs on startup)
mcli sync update -g

# 3. Run it!
mcli run -g backup

# Initialize workflows in current git repository
mcli init

# Or initialize global workflows
mcli init --global

# Initialize with git repository for workflows
mcli init --git

# Write your script directly to workflows directory
cat > ~/.mcli/workflows/my-task.py << 'EOF'
#!/usr/bin/env python
# @description: My custom workflow
# @version: 1.0.0

import click

@click.command()
@click.option('--message', default='Hello', help='Message to display')
def app(message):
    """My custom workflow"""
    click.echo(f"{message} from my workflow!")

if __name__ == "__main__":
    app()
EOF

# Run it
mcli run -g my-task --message "Hi"

# Create workflow interactively
mcli new my-task

# Edit in your $EDITOR, then run
mcli run my-task

# Create new workflow interactively (opens in $EDITOR)
mcli new my-workflow

# Or drop a script directly into workflows directory
cp script.py ~/.mcli/workflows/

# List all workflows
mcli list -g        # Global workflows
mcli list           # Local workflows (in git repo)

# Edit workflow in $EDITOR
mcli edit my-workflow

# Search workflows by name or description
mcli search "backup"

# Remove workflow
mcli rm my-workflow

$ ls ~/.mcli/workflows/
backup.py
data-sync.sh
git-commit.py
commands.lock.json  # Version lockfile

# Update lockfile with current workflow versions
mcli sync update

# Show lockfile status
mcli sync status

# Show differences between scripts and lockfile
mcli sync diff

# Add lockfile to git
git add ~/.mcli/workflows/commands.lock.json ~/.mcli/workflows/*.py ~/.mcli/workflows/*.sh
git commit -m "Update workflows"

# On another machine
git pull
mcli sync status  # Check consistency

# Push your workflows to IPFS
mcli sync push -g -d "Production workflows v1.0"
# → Returns: QmXyZ123... (immutable CID)

# Anyone can pull your exact workflow state
mcli sync pull QmXyZ123...

# View sync history
mcli sync history

# Verify a CID is accessible
mcli sync verify QmXyZ123...

# Migrate directory structure AND push to IPFS
mcli self migrate --to-ipfs -d "Production migration"
# → Moves commands/ to workflows/ AND pushes to IPFS

# Just push existing workflows to IPFS
mcli sync push -g -d "Production v1.0"

# Run directly with mcli
mcli run -g my-task

# Or run the script directly
python ~/.mcli/workflows/my-task.py

# Schedule with cron
crontab -e
# Add: 0 * * * * mcli run -g my-task

# Run in background with nohup
nohup mcli run -g my-task &

# Drop your PDF processing script into workflows
cp pdf_tool.py ~/.mcli/workflows/pdf.py

# Use it
mcli run -g pdf extract ~/Documents/report.pdf
mcli run -g pdf compress ~/Documents/*.pdf --output compressed/
mcli run -g pdf split large.pdf --pages 10

# Create sync workflow directly in workflows directory
cat > ~/.mcli/workflows/sync.py << 'EOF'
#!/usr/bin/env python
# @description: Multi-cloud sync workflow
# @version: 1.0.0

import click
import subprocess

@click.group()
def app():
    """Multi-cloud sync workflow"""
    pass

@app.command()
@click.argument('source')
@click.argument('dest')
def backup(source, dest):
    """Backup data to cloud"""
    subprocess.run(['rclone', 'sync', source, dest])
    click.echo(f"Synced {source} to {dest}")

@app.command()
def status():
    """Check sync status"""
    click.echo("Checking sync status...")

if __name__ == "__main__":
    app()
EOF

# Run manually
mcli run -g sync backup ~/data remote:backup

# Create a custom git helper
mcli new -g git-helper

# Edit it in your $EDITOR, then run it
mcli run -g git-helper

#!/usr/bin/env bash
# @description: Does something useful
# @version: 1.0.0
# @requires: curl, jq

echo "Hello from my workflow!"

mcli list -g

# Install completion for your shell
mcli self completion install

# Now use tab completion
mcli run <TAB>                # Shows all workflows
mcli run pdf <TAB>            # Shows pdf subcommands

# Check version
mcli self version

# Update MCLI to latest version
mcli self update

# View health and performance
mcli self health
mcli self performance

# Clone repository
git clone https://github.com/gwicho38/mcli.git
cd mcli

# Setup with UV
uv venv
uv pip install -e ".[dev]"

# Run tests
make test

# Build wheel
make wheel

# Create your daily automation
mcli new -g daily-tasks  # Add your tasks in $EDITOR

# Schedule with cron
crontab -e
# Add: 0 9 * * * mcli run -g daily-tasks

# On your machine - push workflows to IPFS
mcli sync push -g -d "Team workflows v1.0"
# → Returns: QmXyZ123... (share this CID)

# On teammate's machine
mcli sync pull QmXyZ123...
mcli sync status  # Verify workflows loaded

# In your CI pipeline
- pip install mcli-framework
- mcli sync pull $WORKFLOW_CID  # Pull from IPFS
- mcli run -g build-and-test
- mcli run -g deploy --env production

# GPU support (CUDA required)
pip install "mcli-framework[gpu]"

# Development tools
pip install "mcli-framework[dev]"

pip install mcli-framework
mcli new my-first-workflow