includeblock support

Signed-off-by: Nick Mitchell <[email protected]>

Author: starpit

pdl-live-react/src-tauri/src/pdl/ast.rs

@@ -476,13 +476,21 @@ pub struct ArrayBlock {
     pub array: Vec<PdlBlock>,
 }
 
+/// Include a PDL file
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct IncludeBlock {
+    /// Name of the file to include.
+    pub include: String,
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(untagged)]
 pub enum PdlBlock {
     Bool(bool),
     Number(Number),
     String(String),
     If(IfBlock),
+    Include(IncludeBlock),
     Object(ObjectBlock),
     Call(CallBlock),
     Array(ArrayBlock),

pdl-live-react/src-tauri/src/pdl/interpreter.rs

@@ -25,9 +25,9 @@ use serde_json::{from_str, to_string, Value};
 use serde_norway::{from_reader, from_str as from_yaml_str};
 
 use crate::pdl::ast::{
-    ArrayBlock, CallBlock, Closure, FunctionBlock, IfBlock, ListOrString, MessageBlock, ModelBlock,
-    ObjectBlock, PdlBlock, PdlParser, PdlResult, PdlUsage, PythonCodeBlock, ReadBlock, RepeatBlock,
-    Role, Scope, SequencingBlock, StringOrBoolean,
+    ArrayBlock, CallBlock, Closure, FunctionBlock, IfBlock, IncludeBlock, ListOrString,
+    MessageBlock, ModelBlock, ObjectBlock, PdlBlock, PdlParser, PdlResult, PdlUsage,
+    PythonCodeBlock, ReadBlock, RepeatBlock, Role, Scope, SequencingBlock, StringOrBoolean,
 };
 
 type Context = Vec<ChatMessage>;
@@ -100,6 +100,7 @@ impl<'a> Interpreter<'a> {
             PdlBlock::String(s) => self.run_string(s, context).await,
             PdlBlock::Call(block) => self.run_call(block, context).await,
             PdlBlock::If(block) => self.run_if(block, context).await,
+            PdlBlock::Include(block) => self.run_include(block, context).await,
             PdlBlock::Model(block) => self.run_model(block, context).await,
             PdlBlock::Object(block) => self.run_object(block, context).await,
             PdlBlock::PythonCode(block) => self.run_python_code(block, context).await,
@@ -356,6 +357,16 @@ impl<'a> Interpreter<'a> {
         res
     }
 
+    /// Run a PdlBlock::Include
+    async fn run_include(&mut self, block: &IncludeBlock, context: Context) -> Interpretation {
+        if self.debug {
+            eprintln!("Include {:?}", block.include);
+        }
+
+        self.run_quiet(&parse_file(&self.path_to(&block.include))?, context.clone())
+            .await
+    }
+
     fn to_ollama_model_options(
         &self,
         maybe_parameters: &Option<HashMap<String, Value>>,
@@ -824,19 +835,25 @@ pub async fn run(program: &PdlBlock, cwd: Option<PathBuf>, debug: bool) -> Inter
 
 pub fn run_sync(program: &PdlBlock, cwd: Option<PathBuf>, debug: bool) -> InterpretationSync {
     tauri::async_runtime::block_on(run(program, cwd, debug))
-        .map_err(|err| Box::<dyn ::std::error::Error>::from(err.to_string()))
+        .map_err(|err| Box::<dyn Error>::from(err.to_string()))
+}
+
+fn parse_file(path: &PathBuf) -> Result<PdlBlock, PdlError> {
+    from_reader(File::open(path)?)
+        .map_err(|err| Box::<dyn Error + Send + Sync>::from(err.to_string()))
 }
 
 pub async fn run_file(source_file_path: &str, debug: bool) -> Interpretation {
-    let cwd = PathBuf::from(source_file_path)
-        .parent()
-        .and_then(|cwd| Some(cwd.to_path_buf()));
-    run(&from_reader(File::open(source_file_path)?)?, cwd, debug).await
+    let path = PathBuf::from(source_file_path);
+    let cwd = path.parent().and_then(|cwd| Some(cwd.to_path_buf()));
+    let program = parse_file(&path)?;
+
+    run(&program, cwd, debug).await
 }
 
 pub fn run_file_sync(source_file_path: &str, debug: bool) -> InterpretationSync {
     tauri::async_runtime::block_on(run_file(source_file_path, debug))
-        .map_err(|err| Box::<dyn ::std::error::Error>::from(err.to_string()))
+        .map_err(|err| Box::<dyn Error>::from(err.to_string()))
 }
 
 pub async fn run_string(source: &str, debug: bool) -> Interpretation {
@@ -849,7 +866,7 @@ pub async fn run_json(source: Value, debug: bool) -> Interpretation {
 
 pub fn run_json_sync(source: Value, debug: bool) -> InterpretationSync {
     tauri::async_runtime::block_on(run_json(source, debug))
-        .map_err(|err| Box::<dyn ::std::error::Error>::from(err.to_string()))
+        .map_err(|err| Box::<dyn Error>::from(err.to_string()))
 }
 
 pub fn pretty_print(messages: &Vec<ChatMessage>) -> String {

pdl-live-react/src-tauri/src/pdl/interpreter_tests.rs

@@ -456,4 +456,17 @@ mod tests {
         assert_eq!(messages[0].content, "good on object");
         Ok(())
     }
+
+    #[test]
+    fn text_include() -> Result<(), Box<dyn Error>> {
+        let program = json!({
+            "include": "./tests/cli/call-with-args.pdl"
+        });
+
+        let (_, messages, _) = run_json(program, false)?;
+        assert_eq!(messages.len(), 1);
+        assert_eq!(messages[0].role, MessageRole::User);
+        assert_eq!(messages[0].content, "hello world 4 bye");
+        Ok(())
+    }
 }

pdl-live-react/src-tauri/tests/cli/include1.pdl

@@ -0,0 +1 @@
+include: ./call-with-args.pdl