jorm 0.1.1

A lightweight DAG execution engine with natural language processing
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

use crate::core::error::JormError;
use crate::executor::TaskExecutor;
use crate::nlp::generator::{DagEdit, DagPreview, NlpProcessor};
use crate::parser::dag_parser::DagParser;

#[derive(Debug, serde::Serialize)]
pub struct ExecutionResult {
    pub success: bool,
    pub message: String,
    pub task_results: Vec<TaskResult>,
}

#[derive(Debug, serde::Serialize)]
pub struct TaskResult {
    pub task_name: String,
    pub success: bool,
    pub output: String,
    pub error: Option<String>,
}

pub struct JormEngine {
    nlp_processor: NlpProcessor,
    dag_parser: DagParser,
    task_executor: TaskExecutor,
}

impl JormEngine {
    pub async fn new() -> Result<Self, JormError> {
        Ok(Self {
            nlp_processor: NlpProcessor::new().await?,
            dag_parser: DagParser::new(),
            task_executor: TaskExecutor::new(),
        })
    }

    pub async fn execute_from_file(&self, path: &str) -> Result<ExecutionResult, JormError> {
        // Parse the DAG file
        let dag = self.dag_parser.parse_file(path).await?;

        // Validate the DAG
        dag.validate()?;

        // Execute the DAG
        self.task_executor.execute_dag(&dag).await
    }

    pub async fn execute_from_natural_language(
        &self,
        description: &str,
    ) -> Result<ExecutionResult, JormError> {
        // Generate DAG from natural language
        let dag_content = self.nlp_processor.generate_dag(description).await?;

        // Parse the generated DAG
        let dag = self.dag_parser.parse_content(&dag_content)?;

        // Validate the DAG
        dag.validate()?;

        // Execute the DAG
        self.task_executor.execute_dag(&dag).await
    }

    pub async fn generate_dag_from_nl(&self, description: &str) -> Result<String, JormError> {
        self.nlp_processor.generate_dag(description).await
    }

    pub async fn generate_dag_with_preview(
        &self,
        description: &str,
    ) -> Result<DagPreview, JormError> {
        self.nlp_processor
            .generate_dag_with_preview(description)
            .await
    }

    pub async fn execute_with_preview(
        &self,
        description: &str,
        auto_execute: bool,
    ) -> Result<(DagPreview, Option<ExecutionResult>), JormError> {
        let preview = self.generate_dag_with_preview(description).await?;

        if auto_execute {
            let execution_result = self
                .execute_from_dag_content(&preview.generated_dag_content)
                .await?;
            Ok((preview, Some(execution_result)))
        } else {
            Ok((preview, None))
        }
    }

    pub async fn execute_from_dag_content(
        &self,
        dag_content: &str,
    ) -> Result<ExecutionResult, JormError> {
        // Parse the DAG content
        let dag = self.dag_parser.parse_content(dag_content)?;

        // Validate the DAG
        dag.validate()?;

        // Execute the DAG
        self.task_executor.execute_dag(&dag).await
    }

    pub fn edit_generated_dag(
        &self,
        dag_content: &str,
        edits: Vec<DagEdit>,
    ) -> Result<String, JormError> {
        self.nlp_processor.edit_generated_dag(dag_content, edits)
    }

    pub async fn execute_edited_dag(
        &self,
        original_dag: &str,
        edits: Vec<DagEdit>,
    ) -> Result<ExecutionResult, JormError> {
        let edited_dag = self.edit_generated_dag(original_dag, edits)?;
        self.execute_from_dag_content(&edited_dag).await
    }
}