juglans 0.2.16

Compiler and runtime for Juglans Workflow Language
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253

// src/lib.rs

// Suppress lints that became -W warn or fire on new-in-1.95 patterns in
// pre-existing code. These are not real correctness issues and were green
// under earlier clippy versions; keep clippy green across toolchains
// without a churn-y refactor.
#![allow(clippy::collapsible_match)]
#![allow(clippy::collapsible_if)]

// ============================================================================
// Module Definitions
// ============================================================================

pub mod core;

#[cfg(not(target_arch = "wasm32"))]
pub mod adapters;

#[cfg(not(target_arch = "wasm32"))]
pub mod services;

#[cfg(not(target_arch = "wasm32"))]
pub mod builtins;

#[cfg(not(target_arch = "wasm32"))]
pub mod templates;

#[cfg(not(target_arch = "wasm32"))]
pub mod ui;

#[cfg(not(target_arch = "wasm32"))]
pub mod registry;

#[cfg(not(target_arch = "wasm32"))]
pub mod runtime;

#[cfg(not(target_arch = "wasm32"))]
pub mod providers;

#[cfg(not(target_arch = "wasm32"))]
pub mod lsp;

#[cfg(not(target_arch = "wasm32"))]
pub mod testing;

#[cfg(not(target_arch = "wasm32"))]
pub mod doctest;

#[cfg(not(target_arch = "wasm32"))]
pub mod runner;

#[cfg(target_arch = "wasm32")]
pub mod wasm;

// ============================================================================
// Public Exports
// ============================================================================

pub use core::context::WorkflowContext;
pub use core::graph::WorkflowGraph;
pub use core::parser::GraphParser;
pub use core::prompt_parser::{PromptParser, PromptResource};
pub use core::renderer::JwlRenderer;

#[cfg(not(target_arch = "wasm32"))]
pub use core::executor::WorkflowExecutor;

#[cfg(not(target_arch = "wasm32"))]
pub use services::local_runtime::{ChatOutput, ChatRequest, ChatToolHandler, LocalRuntime};

#[cfg(not(target_arch = "wasm32"))]
pub use services::prompt_loader::PromptRegistry;

#[cfg(not(target_arch = "wasm32"))]
pub use services::config::JuglansConfig;

#[cfg(not(target_arch = "wasm32"))]
pub use runtime::python::{PythonRuntime, PythonWorkerPool};

// ============================================================================
// WASM-only Interface (compiled only for wasm32 target)
// ============================================================================

#[cfg(target_arch = "wasm32")]
use wasm_bindgen::prelude::*;

#[cfg(target_arch = "wasm32")]
use std::collections::{HashMap, HashSet};

#[cfg(target_arch = "wasm32")]
#[wasm_bindgen]
pub struct JuglansEngine {
    workflow: Option<crate::core::graph::WorkflowGraph>,
    files: HashMap<String, String>,
    tool_handler: Option<js_sys::Function>,
    tool_names: HashSet<String>,
}

#[cfg(target_arch = "wasm32")]
#[wasm_bindgen]
impl JuglansEngine {
    #[wasm_bindgen(constructor)]
    pub fn new() -> Self {
        Self {
            workflow: None,
            files: HashMap::new(),
            tool_handler: None,
            tool_names: HashSet::new(),
        }
    }

    /// Parse a .jg workflow source
    pub fn parse(&mut self, source: &str) -> Result<(), JsValue> {
        let wf = crate::core::parser::GraphParser::parse(source)
            .map_err(|e| JsValue::from_str(&e.to_string()))?;
        self.workflow = Some(wf);
        Ok(())
    }

    /// Parse a .jgx template
    pub fn parse_prompt(&self, content: &str) -> Result<JsValue, JsValue> {
        let resource = crate::core::prompt_parser::PromptParser::parse(content)
            .map_err(|e| JsValue::from_str(&e.to_string()))?;
        serde_wasm_bindgen::to_value(&resource).map_err(|e| JsValue::from_str(&e.to_string()))
    }

    /// Render a .jgx template with context
    pub fn render_prompt(&self, content: &str, context_json: &str) -> Result<String, JsValue> {
        let resource = crate::core::prompt_parser::PromptParser::parse(content)
            .map_err(|e| JsValue::from_str(&format!("Parse Error: {}", e)))?;
        let context: serde_json::Value = serde_json::from_str(context_json)
            .map_err(|e| JsValue::from_str(&format!("JSON Error: {}", e)))?;
        let renderer = crate::core::renderer::JwlRenderer::new();
        renderer
            .render(&resource.ast, &context)
            .map_err(|e| JsValue::from_str(&format!("Render Error: {}", e)))
    }

    /// Register a file for flow/lib imports
    pub fn register_file(&mut self, path: &str, content: &str) {
        self.files.insert(path.to_string(), content.to_string());
    }

    /// Set the tool handler callback: (name: string, params: object) → Promise<result>
    pub fn set_tool_handler(&mut self, handler: js_sys::Function) {
        self.tool_handler = Some(handler);
    }

    /// Register known tool names (for expression disambiguation)
    pub fn set_tool_names(&mut self, names: JsValue) -> Result<(), JsValue> {
        let names_vec: Vec<String> = serde_wasm_bindgen::from_value(names)
            .map_err(|e| JsValue::from_str(&format!("Expected string array: {}", e)))?;
        self.tool_names = names_vec.into_iter().collect();
        Ok(())
    }

    /// Execute the parsed workflow with input data
    pub async fn run(&self, input: JsValue) -> Result<JsValue, JsValue> {
        let workflow = self
            .workflow
            .as_ref()
            .ok_or_else(|| JsValue::from_str("No workflow parsed. Call parse() first."))?;

        let handler = self.tool_handler.as_ref().ok_or_else(|| {
            JsValue::from_str("No tool handler set. Call setToolHandler() first.")
        })?;

        let executor = crate::wasm::WasmExecutor::new(handler.clone(), self.tool_names.clone());
        let context = crate::core::context::WorkflowContext::new();

        // Set input data
        if !input.is_undefined() && !input.is_null() {
            let input_val: serde_json::Value = serde_wasm_bindgen::from_value(input)
                .map_err(|e| JsValue::from_str(&format!("Invalid input: {}", e)))?;
            if let Some(obj) = input_val.as_object() {
                for (key, val) in obj {
                    context
                        .set(format!("input.{}", key), val.clone())
                        .map_err(|e| JsValue::from_str(&e.to_string()))?;
                }
            }
            context
                .set("input".to_string(), input_val)
                .map_err(|e| JsValue::from_str(&e.to_string()))?;
        }

        executor
            .execute_graph(workflow, &context)
            .await
            .map_err(|e| JsValue::from_str(&e.to_string()))?;

        // Return the final context output
        let output = context
            .resolve_path("output")
            .ok()
            .flatten()
            .unwrap_or(serde_json::Value::Null);
        serde_wasm_bindgen::to_value(&output).map_err(|e| JsValue::from_str(&e.to_string()))
    }

    /// Validate the parsed workflow
    pub fn validate(&self) -> Result<JsValue, JsValue> {
        let workflow = self
            .workflow
            .as_ref()
            .ok_or_else(|| JsValue::from_str("No workflow parsed"))?;
        let result = crate::core::validator::WorkflowValidator::validate(workflow);
        serde_wasm_bindgen::to_value(&result).map_err(|e| JsValue::from_str(&e.to_string()))
    }

    /// Evaluate a standalone expression (for debugging)
    pub fn eval_expr(&self, expr: &str, context_json: &str) -> Result<JsValue, JsValue> {
        let context: serde_json::Value = serde_json::from_str(context_json)
            .map_err(|e| JsValue::from_str(&format!("JSON Error: {}", e)))?;
        let evaluator = crate::core::expr_eval::ExprEvaluator::new();
        let resolver = |path: &str| -> Option<serde_json::Value> {
            let pointer = format!("/{}", path.replace('.', "/"));
            context.pointer(&pointer).cloned()
        };
        let result = evaluator
            .eval(expr, &resolver)
            .map_err(|e| JsValue::from_str(&e.to_string()))?;
        serde_wasm_bindgen::to_value(&result).map_err(|e| JsValue::from_str(&e.to_string()))
    }

    // ================================================================
    // LSP Intelligence (for Monaco Editor)
    // ================================================================

    /// Compute diagnostics (parse errors + validation warnings)
    pub fn diagnostics(&self, source: &str) -> Result<JsValue, JsValue> {
        let result = crate::wasm::language::compute_diagnostics(source);
        serde_wasm_bindgen::to_value(&result).map_err(|e| JsValue::from_str(&e.to_string()))
    }

    /// Get completions at cursor position
    pub fn completions(&self, source: &str, line: u32, col: u32) -> Result<JsValue, JsValue> {
        let result = crate::wasm::language::completions(source, line, col);
        serde_wasm_bindgen::to_value(&result).map_err(|e| JsValue::from_str(&e.to_string()))
    }

    /// Get hover info at cursor position
    pub fn hover(&self, source: &str, line: u32, col: u32) -> Result<JsValue, JsValue> {
        let result = crate::wasm::language::hover(source, line, col);
        serde_wasm_bindgen::to_value(&result).map_err(|e| JsValue::from_str(&e.to_string()))
    }

    /// Go-to-definition at cursor position
    pub fn definition(&self, source: &str, line: u32, col: u32) -> Result<JsValue, JsValue> {
        let result = crate::wasm::language::goto_definition(source, line, col);
        serde_wasm_bindgen::to_value(&result).map_err(|e| JsValue::from_str(&e.to_string()))
    }
}