OxyJen

Installation

Build from Source

git clone https://github.com/11divyansh/OxyJen.git
cd OxyJen
mvn clean install

After installation, verify by importing:

```java import io.oxyjen.core.; import io.oxyjen.llm.; import io.oxyjen.tools.*;

Quick Example

// Build a 3-step text processing pipeline
Graph pipeline = GraphBuilder.named("text-processor")
    .addNode(new UppercaseNode())
    .addNode(new ReverseNode())
    .addNode(new PrefixNode("OUTPUT: "))
    .build();

// Execute with context
NodeContext context = new NodeContext();
Executor executor = new Executor();

String result = executor.run(pipeline, "hello world", context);
System.out.println(result);
// Output: OUTPUT: DLROW OLLEH

That's it! Clean, simple, powerful.

---

Complete Working Example

package examples;

import io.oxyjen.core.*;

public class ContentPipeline {
    
    public static void main(String[] args) {
        // Step 1: Define your nodes
        NodePlugin<String, String> validator = new ValidationNode();
        NodePlugin<String, String> processor = new ProcessingNode();
        NodePlugin<String, String> formatter = new FormatterNode();
        
        // Step 2: Build your graph
        Graph pipeline = GraphBuilder.named("content-pipeline")
            .addNode(validator)
            .addNode(processor)
            .addNode(formatter)
            .build();
        
        // Step 3: Create execution context
        NodeContext context = new NodeContext();
        context.set("max_length", 100);
        
        // Step 4: Execute
        Executor executor = new Executor();
        String result = executor.run(pipeline, "Raw input text", context);
        
        System.out.println("Final output: " + result);
        System.out.println("Word count: " + context.get("word_count"));
    }
}

// Example node implementations
class ValidationNode implements NodePlugin<String, String> {
    @Override
    public String process(String input, NodeContext ctx) {
        if (input == null || input.isEmpty()) {
            throw new IllegalArgumentException("Input cannot be empty");
        }
        ctx.getLogger().info("✓ Input validated");
        return input;
    }
}

class ProcessingNode implements NodePlugin<String, String> {
    @Override
    public String process(String input, NodeContext ctx) {
        String processed = input.toUpperCase().trim();
        ctx.set("word_count", processed.split(" ").length);
        ctx.getLogger().info("✓ Text processed");
        return processed;
    }
}

class FormatterNode implements NodePlugin<String, String> {
    @Override
    public String process(String input, NodeContext ctx) {
        Integer maxLength = ctx.get("max_length");
        String formatted = input.length() > maxLength 
            ? input.substring(0, maxLength) + "..." 
            : input;
        ctx.getLogger().info("✓ Text formatted");
        return formatted;
    }
}

---

1️**Graph** - The Pipeline Blueprint

A Graph defines the structure of your pipeline - which nodes run in what order.

public class Graph {
    private final String name;
    private final List<NodePlugin<?, ?>> nodes;
    
    // Add nodes to your pipeline
    public Graph addNode(NodePlugin<?, ?> node);
    
    // Get all nodes in execution order
    public List<NodePlugin<?, ?>> getNodes();
}

Think of it as: Your pipeline's DNA - it knows what needs to happen, but doesn't execute anything.

2️**NodePlugin** - The Processing Unit

A NodePlugin is a single step in your pipeline. Each node transforms input into output.

public interface NodePlugin<I, O> {
    // Core processing logic
    O process(I input, NodeContext context);
    
    // Unique identifier for this node
    default String getName() { 
        return this.getClass().getSimpleName(); 
    }
    
    // Lifecycle hooks for setup/cleanup
    default void onStart(NodeContext context) {}
    default void onFinish(NodeContext context) {}
    default void onError(Exception e, NodeContext context) {}
}

Think of it as: A Lego brick - small, focused, composable.

Example node:

public class SummarizerNode implements NodePlugin<String, String> {
    @Override
    public String process(String input, NodeContext context) {
        context.getLogger().info("Summarizing text...");
        // Your logic here (will be LLM call in v0.2)
        return "Summary: " + input.substring(0, 100);
    }
    
    @Override
    public void onStart(NodeContext context) {
        context.getLogger().info("Summarizer node starting");
    }
}