metabuilder/workflow/plugins/mojo

Mojo Workflow Plugins

This directory contains workflow plugins implemented in Mojo, a Python superset with systems programming capabilities.

Overview

Mojo plugins provide high-performance implementations for workflow operations while maintaining Python interoperability. This allows seamless integration with the existing Python-based workflow system while enabling performance-critical optimizations.

Directory Structure

mojo/
├── plugin.mojo          # Base types and traits for all plugins
├── README.md            # This file
├── math/                # Mathematical operation plugins
│   ├── package.json     # Category manifest
│   ├── math_add.mojo
│   ├── math_subtract.mojo
│   ├── math_multiply.mojo
│   └── math_divide.mojo
├── string/              # String manipulation plugins
│   ├── package.json     # Category manifest
│   ├── string_concat.mojo
│   ├── string_upper.mojo
│   ├── string_lower.mojo
│   └── string_length.mojo
└── list/                # List operation plugins
    ├── package.json     # Category manifest
    ├── list_concat.mojo
    ├── list_length.mojo
    └── list_reverse.mojo

Plugin Pattern

Each plugin follows a standard pattern:

# Workflow plugin: <description>

from collections import Dict
from python import PythonObject

fn run(inputs: Dict[String, PythonObject]) -> Dict[String, PythonObject]:
    """<Plugin description>."""
    # Extract inputs
    var value = inputs.get("key", default_value)

    # Perform operation
    var result = compute(value)

    # Return result
    return Dict[String, PythonObject]{"result": result}

Categories

Math Plugins

Mathematical operations on numbers:

Plugin	Type	Description
math_add.mojo	math.add	Add two or more numbers
math_subtract.mojo	math.subtract	Subtract numbers sequentially
math_multiply.mojo	math.multiply	Multiply two or more numbers
math_divide.mojo	math.divide	Divide numbers sequentially

String Plugins

String manipulation operations:

Plugin	Type	Description
string_concat.mojo	string.concat	Concatenate strings
string_upper.mojo	string.upper	Convert string to uppercase
string_lower.mojo	string.lower	Convert string to lowercase
string_length.mojo	string.length	Get string length

List Plugins

List/array operations:

Plugin	Type	Description
list_concat.mojo	list.concat	Concatenate multiple lists
list_length.mojo	list.length	Get list length
list_reverse.mojo	list.reverse	Reverse a list

Package Manifest

Each category has a package.json manifest:

{
  "name": "category_name",
  "version": "1.0.0",
  "description": "Category description",
  "metadata": {
    "plugin_type": "category.operation",
    "language": "mojo"
  },
  "plugins": [
    {
      "name": "plugin_name",
      "file": "plugin_file.mojo",
      "type": "category.operation",
      "description": "Plugin description"
    }
  ]
}

Mojo Advantages

Mojo provides several advantages for workflow plugins:

1. Performance: Systems-level performance with SIMD and parallel processing
2. Python Interop: Seamless integration with Python objects and libraries
3. Type Safety: Strong typing with compile-time checks
4. Memory Safety: Ownership and borrowing model for safe memory management
5. Hardware Access: Direct access to hardware features when needed

Usage

Plugins can be loaded and executed by the workflow runtime:

# Python integration example
from workflow.loader import load_mojo_plugin

plugin = load_mojo_plugin("math/math_add.mojo")
result = plugin.run({"numbers": [1, 2, 3, 4, 5]})
print(result["result"])  # Output: 15.0

Building Plugins

To compile Mojo plugins:

# Compile a single plugin
mojo build math/math_add.mojo

# Compile all plugins in a category
for f in math/*.mojo; do mojo build "$f"; done

Testing

Each plugin can be tested independently:

# Run plugin tests
mojo test math/math_add.mojo

Contributing

When adding new plugins:

1. Follow the standard plugin pattern
2. Implement the run function with proper input/output handling
3. Add the plugin to the category's package.json
4. Update this README with the new plugin information
5. Add appropriate tests