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_replace/src/lib.rs

@@ -1,28 +1,65 @@
 //! Workflow plugin: replace in string.
 
 use serde_json::Value;
+use std::any::Any;
 use std::collections::HashMap;
 
-/// Replace occurrences in 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 old: String = inputs
-        .get("old")
-        .and_then(|v| serde_json::from_value(v.clone()).ok())
-        .unwrap_or_default();
-    let new: String = inputs
-        .get("new")
-        .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 result = string.replace(&old, &new);
+/// StringReplace implements the NodeExecutor trait for replacing in strings.
+pub struct StringReplace {
+    pub node_type: &'static str,
+    pub category: &'static str,
+    pub description: &'static str,
+}
 
-    let mut output = HashMap::new();
-    output.insert("result".to_string(), serde_json::json!(result));
-    Ok(output)
+impl StringReplace {
+    /// Creates a new StringReplace instance.
+    pub fn new() -> Self {
+        Self {
+            node_type: "string.replace",
+            category: "string",
+            description: "Replace occurrences in a string",
+        }
+    }
+}
+
+impl Default for StringReplace {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl NodeExecutor for StringReplace {
+    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 old: String = inputs
+            .get("old")
+            .and_then(|v| serde_json::from_value(v.clone()).ok())
+            .unwrap_or_default();
+        let new: String = inputs
+            .get("new")
+            .and_then(|v| serde_json::from_value(v.clone()).ok())
+            .unwrap_or_default();
+
+        let replaced = string.replace(&old, &new);
+
+        let mut result = HashMap::new();
+        result.insert("result".to_string(), serde_json::json!(replaced));
+        result
+    }
+}
+
+/// Creates a new StringReplace instance.
+pub fn create() -> StringReplace {
+    StringReplace::new()
 }
 
 #[cfg(test)]
@@ -31,13 +68,20 @@ mod tests {
 
     #[test]
     fn test_replace() {
-        let mut runtime = HashMap::new();
+        let executor = StringReplace::new();
         let mut inputs = HashMap::new();
         inputs.insert("string".to_string(), serde_json::json!("hello world"));
         inputs.insert("old".to_string(), serde_json::json!("world"));
         inputs.insert("new".to_string(), serde_json::json!("rust"));
 
-        let result = run(&mut runtime, &inputs).unwrap();
+        let result = executor.execute(inputs, None);
         assert_eq!(result.get("result"), Some(&serde_json::json!("hello rust")));
     }
+
+    #[test]
+    fn test_factory() {
+        let executor = create();
+        assert_eq!(executor.node_type, "string.replace");
+        assert_eq!(executor.category, "string");
+    }
 }