mirror of
https://github.com/johndoe6345789/metabuilder.git
synced 2026-04-25 14:25:02 +00:00
johndoe6345789
48135c81e6
Multi-language workflow plugin system following Python's structure: - Each plugin in its own directory with implementation + package.json - Category-level package.json manifests listing all plugins - Consistent interface: run(runtime, inputs) -> outputs Languages added: - Go: math, string, logic, list, dict, var, convert (25+ plugins) - Rust: math, string, logic, list, convert, var (50+ functions) - C++: header-only math, string, logic, var, convert (30+ plugins) - Mojo: math, string, list with systems programming features Python structure fixed: - Reorganized flat files into plugin subdirectories - Added package.json metadata to all 120+ plugins - Added missing backend category (15 plugins) - Category manifests with plugin lists Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
167 lines
4.5 KiB
Markdown
167 lines
4.5 KiB
Markdown
# 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:
|
|
|
|
```mojo
|
|
# 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:
|
|
|
|
```json
|
|
{
|
|
"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
|
|
# 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:
|
|
|
|
```bash
|
|
# 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:
|
|
|
|
```bash
|
|
# 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
|