refactor(workflow): convert all plugins to class/struct + factory pattern

- Python: class extending NodeExecutor + factory.py (80+ plugins)
- TypeScript: class implements NodeExecutor + factory.ts (7 groups, 116 classes)
- Go: struct with methods + factory.go (36 plugins)
- Rust: struct impl NodeExecutor trait + factory.rs (54 plugins)
- Mojo: struct + factory.mojo (11 plugins)

All package.json files now include:
- files array listing source files
- metadata.class/struct field
- metadata.entrypoint field

This enables a unified plugin loading system across all languages
with no import side effects (Spring-style DI pattern).

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

workflow/plugins/rust/string/string_upper/package.json

@@ -1,14 +1,16 @@
 {
   "name": "@metabuilder/string_upper",
-  "version": "0.1.0",
+  "version": "1.0.0",
   "description": "Convert string to uppercase",
   "author": "MetaBuilder",
   "license": "MIT",
-  "keywords": ["string", "workflow", "plugin", "rust"],
+  "keywords": ["string", "workflow", "plugin"],
   "main": "src/lib.rs",
+  "files": ["src/lib.rs", "src/factory.rs"],
   "metadata": {
     "plugin_type": "string.upper",
     "category": "string",
-    "runtime": "rust"
+    "struct": "StringUpper",
+    "entrypoint": "execute"
   }
 }

workflow/plugins/rust/string/string_upper/src/factory.rs

@@ -0,0 +1,8 @@
+//! Factory for StringUpper plugin.
+
+use super::StringUpper;
+
+/// Creates a new StringUpper instance.
+pub fn create() -> StringUpper {
+    StringUpper::new()
+}

workflow/plugins/rust/string/string_upper/src/lib.rs

@@ -1,18 +1,55 @@
 //! Workflow plugin: uppercase string.
 
 use serde_json::Value;
+use std::any::Any;
 use std::collections::HashMap;
 
-/// Convert string to uppercase.
-pub fn run(_runtime: &mut HashMap<String, Value>, inputs: &HashMap<String, Value>) -> Result<HashMap<String, Value>, String> {
-    let string: String = inputs
-        .get("string")
-        .and_then(|v| serde_json::from_value(v.clone()).ok())
-        .unwrap_or_default();
+/// Trait for workflow node executors.
+pub trait NodeExecutor {
+    /// Execute the node with given inputs and optional runtime context.
+    fn execute(&self, inputs: HashMap<String, Value>, runtime: Option<&dyn Any>) -> HashMap<String, Value>;
+}
 
-    let mut output = HashMap::new();
-    output.insert("result".to_string(), serde_json::json!(string.to_uppercase()));
-    Ok(output)
+/// StringUpper implements the NodeExecutor trait for converting strings to uppercase.
+pub struct StringUpper {
+    pub node_type: &'static str,
+    pub category: &'static str,
+    pub description: &'static str,
+}
+
+impl StringUpper {
+    /// Creates a new StringUpper instance.
+    pub fn new() -> Self {
+        Self {
+            node_type: "string.upper",
+            category: "string",
+            description: "Convert string to uppercase",
+        }
+    }
+}
+
+impl Default for StringUpper {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl NodeExecutor for StringUpper {
+    fn execute(&self, inputs: HashMap<String, Value>, _runtime: Option<&dyn Any>) -> HashMap<String, Value> {
+        let string: String = inputs
+            .get("string")
+            .and_then(|v| serde_json::from_value(v.clone()).ok())
+            .unwrap_or_default();
+
+        let mut result = HashMap::new();
+        result.insert("result".to_string(), serde_json::json!(string.to_uppercase()));
+        result
+    }
+}
+
+/// Creates a new StringUpper instance.
+pub fn create() -> StringUpper {
+    StringUpper::new()
 }
 
 #[cfg(test)]
@@ -21,11 +58,18 @@ mod tests {
 
     #[test]
     fn test_upper() {
-        let mut runtime = HashMap::new();
+        let executor = StringUpper::new();
         let mut inputs = HashMap::new();
         inputs.insert("string".to_string(), serde_json::json!("hello"));
 
-        let result = run(&mut runtime, &inputs).unwrap();
+        let result = executor.execute(inputs, None);
         assert_eq!(result.get("result"), Some(&serde_json::json!("HELLO")));
     }
+
+    #[test]
+    fn test_factory() {
+        let executor = create();
+        assert_eq!(executor.node_type, "string.upper");
+        assert_eq!(executor.category, "string");
+    }
 }