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_substring/package.json

@@ -1,14 +1,16 @@
 {
   "name": "@metabuilder/string_substring",
-  "version": "0.1.0",
+  "version": "1.0.0",
   "description": "Extract a substring from a string",
   "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.substring",
     "category": "string",
-    "runtime": "rust"
+    "struct": "StringSubstring",
+    "entrypoint": "execute"
   }
 }

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

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

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

@@ -1,42 +1,79 @@
 //! Workflow plugin: substring.
 
 use serde_json::Value;
+use std::any::Any;
 use std::collections::HashMap;
 
-/// Extract a substring from a string.
-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();
-    let start: i64 = inputs
-        .get("start")
-        .and_then(|v| serde_json::from_value(v.clone()).ok())
-        .unwrap_or(0);
-    let end: Option<i64> = inputs
-        .get("end")
-        .and_then(|v| serde_json::from_value(v.clone()).ok());
+/// 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 chars: Vec<char> = string.chars().collect();
-    let len = chars.len() as i64;
+/// StringSubstring implements the NodeExecutor trait for extracting substrings.
+pub struct StringSubstring {
+    pub node_type: &'static str,
+    pub category: &'static str,
+    pub description: &'static str,
+}
 
-    // Handle negative indices
-    let start_idx = if start < 0 { (len + start).max(0) } else { start.min(len) } as usize;
-    let end_idx = match end {
-        Some(e) if e < 0 => (len + e).max(0) as usize,
-        Some(e) => e.min(len) as usize,
-        None => len as usize,
-    };
+impl StringSubstring {
+    /// Creates a new StringSubstring instance.
+    pub fn new() -> Self {
+        Self {
+            node_type: "string.substring",
+            category: "string",
+            description: "Extract a substring from a string",
+        }
+    }
+}
 
-    let result: String = if start_idx < end_idx {
-        chars[start_idx..end_idx].iter().collect()
-    } else {
-        String::new()
-    };
+impl Default for StringSubstring {
+    fn default() -> Self {
+        Self::new()
+    }
+}
 
-    let mut output = HashMap::new();
-    output.insert("result".to_string(), serde_json::json!(result));
-    Ok(output)
+impl NodeExecutor for StringSubstring {
+    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 start: i64 = inputs
+            .get("start")
+            .and_then(|v| serde_json::from_value(v.clone()).ok())
+            .unwrap_or(0);
+        let end: Option<i64> = inputs
+            .get("end")
+            .and_then(|v| serde_json::from_value(v.clone()).ok());
+
+        let chars: Vec<char> = string.chars().collect();
+        let len = chars.len() as i64;
+
+        // Handle negative indices
+        let start_idx = if start < 0 { (len + start).max(0) } else { start.min(len) } as usize;
+        let end_idx = match end {
+            Some(e) if e < 0 => (len + e).max(0) as usize,
+            Some(e) => e.min(len) as usize,
+            None => len as usize,
+        };
+
+        let substring: String = if start_idx < end_idx {
+            chars[start_idx..end_idx].iter().collect()
+        } else {
+            String::new()
+        };
+
+        let mut result = HashMap::new();
+        result.insert("result".to_string(), serde_json::json!(substring));
+        result
+    }
+}
+
+/// Creates a new StringSubstring instance.
+pub fn create() -> StringSubstring {
+    StringSubstring::new()
 }
 
 #[cfg(test)]
@@ -45,13 +82,20 @@ mod tests {
 
     #[test]
     fn test_substring() {
-        let mut runtime = HashMap::new();
+        let executor = StringSubstring::new();
         let mut inputs = HashMap::new();
         inputs.insert("string".to_string(), serde_json::json!("hello world"));
         inputs.insert("start".to_string(), serde_json::json!(0));
         inputs.insert("end".to_string(), serde_json::json!(5));
 
-        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.substring");
+        assert_eq!(executor.category, "string");
+    }
 }