fix(deps): update all dependencies

.env

@@ -3,3 +3,5 @@ FOREST_S3_BUCKET=forest
 FOREST_S3_REGION=eu-west-1
 FOREST_S3_USER=forestadmin
 FOREST_S3_PASSWORD=forestadmin
+
+FOREST_LOG_LEVEL=forest=trace

.forest-ci/workflows/build.yaml

@@ -0,0 +1,41 @@
+name: Build Forest
+
+on:
+  - push
+  - pull_request
+
+env:
+  CARGO_TERM_COLOR: always
+  RUST_BACKTRACE: 1
+
+jobs:
+  build:
+    env:
+      RUSTFLAGS: -D warnings
+    timeout_minutes: 30
+    steps:
+          
+      - name: Build application
+        uses: rustlang/rust:nightly
+        run:
+          - export SQLX_OFFLINE=true
+          - cargo build --release
+          
+      - name: Run tests
+        uses: rustlang/rust:nightly
+        run:
+          - cargo test
+        
+      - name: Check code formatting
+        uses: rustlang/rust:nightly
+        run:
+          - cargo fmt -- --check
+        continue_on_error: true
+      
+      - name: Run clippy lints
+        uses: rustlang/rust:nightly
+        run:
+          - rustup component add clippy
+          - cargo clippy -- -D warnings
+        continue_on_error: true
+

Cargo.toml

@@ -3,13 +3,12 @@ members = ["crates/*"]
 resolver = "2"
 
 [workspace.dependencies]
-forest = { path = "crates/forest" }
 
 anyhow = { version = "1" }
 tokio = { version = "1", features = ["full"] }
 tracing = { version = "0.1", features = ["log"] }
-tracing-subscriber = { version = "0.3.18" }
-clap = { version = "4", features = ["derive", "env"] }
+tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
+clap = { version = "4", features = ["derive", "env", "cargo", "string"] }
 dotenvy = { version = "0.15" }
 serde = { version = "1", features = ["derive"] }
 uuid = { version = "1.7", features = ["v4"] }

crates/forest/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "forest"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 [dependencies]
 anyhow.workspace = true
@@ -13,7 +13,11 @@ dotenvy.workspace = true
 serde.workspace = true
 uuid.workspace = true
 
-rusty-s3 = "0.7.0"
-url = "2.5.4"
-kdl = "6.3.3"
-walkdir = "2.5.0"
+rusty-s3 = "0.8"
+url = "2.5"
+kdl = "6.3"
+walkdir = "2.5"
+minijinja = "2.7"
+glob = "0.3"
+serde_json = "1"
+colored_json = "5"

crates/forest/src/cli.rs

@@ -1,33 +1,26 @@
 use std::{net::SocketAddr, path::PathBuf};
 
-use clap::{Parser, Subcommand};
+use anyhow::Context as AnyContext;
+use clap::{FromArgMatches, Parser, Subcommand, crate_authors, crate_description, crate_version};
+use colored_json::ToColoredJson;
 use kdl::KdlDocument;
 use rusty_s3::{Bucket, Credentials, S3Action};
 
 use crate::{
-    model::{Context, Plan, Project},
+    model::{Context, ForestFile, Plan, Project, WorkspaceProject},
     plan_reconciler::PlanReconciler,
     state::SharedState,
 };
 
-#[derive(Parser)]
-#[command(author, version, about, long_about = None, subcommand_required = true)]
-struct Command {
-    #[command(subcommand)]
-    command: Option<Commands>,
-}
+mod run;
+mod template;
 
 #[derive(Subcommand)]
 enum Commands {
-    Init {
-        #[arg(
-            env = "FOREST_PROJECT_PATH",
-            long = "project-path",
-            default_value = "."
-        )]
-        project_path: PathBuf,
-    },
-
+    Init {},
+    Template(template::Template),
+    Info {},
+    Clean {},
     Serve {
         #[arg(env = "FOREST_HOST", long, default_value = "127.0.0.1:3000")]
         host: SocketAddr,
@@ -49,29 +42,226 @@ enum Commands {
     },
 }
 
+fn get_root(include_run: bool) -> clap::Command {
+    let mut root_cmd = clap::Command::new("forest")
+        .subcommand_required(true)
+        .author(crate_authors!())
+        .version(crate_version!())
+        .about(crate_description!())
+        .ignore_errors(include_run)
+        .arg(
+            clap::Arg::new("project_path")
+                .long("project-path")
+                .env("FOREST_PROJECT_PATH")
+                .default_value("."),
+        );
+
+    if include_run {
+        root_cmd = root_cmd.subcommand(clap::Command::new("run").allow_external_subcommands(true))
+    }
+    Commands::augment_subcommands(root_cmd)
+}
+
 pub async fn execute() -> anyhow::Result<()> {
-    let cli = Command::parse();
+    let matches = get_root(true).get_matches();
+    let project_path = PathBuf::from(
+        &matches
+            .get_one::<String>("project_path")
+            .expect("project path always to be set"),
+    )
+    .canonicalize()?;
+    let project_file_path = project_path.join("forest.kdl");
+    if !project_file_path.exists() {
+        anyhow::bail!(
+            "no 'forest.kdl' file was found at: {}",
+            project_file_path.display().to_string()
+        );
+    }
 
-    match cli.command.unwrap() {
-        Commands::Init { project_path } => {
-            tracing::info!("initializing project");
+    let project_file = tokio::fs::read_to_string(&project_file_path).await?;
+    let doc: KdlDocument = project_file.parse()?;
+    let project: ForestFile = doc.try_into()?;
 
-            let project_file_path = project_path.join("forest.kdl");
-            if !project_file_path.exists() {
-                anyhow::bail!(
-                    "no 'forest.kdl' file was found at: {}",
-                    project_file_path.display().to_string()
-                );
+    match project {
+        ForestFile::Workspace(workspace) => {
+            tracing::trace!("running as workspace");
+
+            // 1. For each member load the project
+
+            let mut workspace_members = Vec::new();
+
+            for member in workspace.members {
+                let workspace_member_path = project_path.join(&member.path);
+
+                let project_file_path = workspace_member_path.join("forest.kdl");
+                if !project_file_path.exists() {
+                    anyhow::bail!(
+                        "no 'forest.kdl' file was found at: {}",
+                        workspace_member_path.display().to_string()
+                    );
+                }
+
+                let project_file = tokio::fs::read_to_string(&project_file_path).await?;
+                let doc: KdlDocument = project_file.parse()?;
+                let project: WorkspaceProject = doc.try_into().context(format!(
+                    "workspace member: {} failed to parse",
+                    &member.path
+                ))?;
+
+                workspace_members.push((workspace_member_path, project));
             }
 
-            let project_file = tokio::fs::read_to_string(&project_file_path).await?;
-            let project_doc: KdlDocument = project_file.parse()?;
+            // TODO: 1a (optional). Resolve dependencies
+            // 2. Reconcile plans
 
-            let project: Project = project_doc.try_into()?;
+            let mut member_contexts = Vec::new();
+
+            for (member_path, member) in &workspace_members {
+                match member {
+                    WorkspaceProject::Plan(_plan) => {
+                        tracing::warn!("skipping reconcile for plans for now")
+                    }
+                    WorkspaceProject::Project(project) => {
+                        let plan = if let Some(plan_file_path) = PlanReconciler::new()
+                            .reconcile(
+                                project,
+                                member_path,
+                                Some(workspace_members.as_ref()),
+                                Some(&project_path),
+                            )
+                            .await?
+                        {
+                            let plan_file = tokio::fs::read_to_string(&plan_file_path)
+                                .await
+                                .context(format!(
+                                    "failed to read file at: {}",
+                                    project_path.to_string_lossy()
+                                ))?;
+                            let plan_doc: KdlDocument = plan_file.parse()?;
+
+                            let plan: Plan = plan_doc.try_into()?;
+                            tracing::trace!("found a plan name: {}", project.name);
+
+                            Some(plan)
+                        } else {
+                            None
+                        };
+
+                        let context = Context {
+                            project: project.clone(),
+                            plan,
+                        };
+                        member_contexts.push((member_path, context));
+                    }
+                }
+            }
+
+            tracing::debug!("run is called, building extra commands, rerunning the parser");
+            let mut run_cmd = clap::Command::new("run").subcommand_required(true);
+
+            // 3. Provide context and aggregated commands for projects
+            for (_, context) in &member_contexts {
+                let commands = run::Run::augment_workspace_command(context, &context.project.name);
+                run_cmd = run_cmd.subcommands(commands);
+            }
+
+            run_cmd =
+                run_cmd.subcommand(clap::Command::new("all").allow_external_subcommands(true));
+
+            let mut root = get_root(false).subcommand(run_cmd);
+            let matches = root.get_matches_mut();
+
+            if matches.subcommand().is_none() {
+                root.print_help()?;
+                anyhow::bail!("failed to find command");
+            }
+
+            match matches
+                .subcommand()
+                .expect("forest requires a command to be passed")
+            {
+                ("run", args) => {
+                    let (run_args, args) = args.subcommand().expect("run must have subcommands");
+
+                    match run_args {
+                        "all" => {
+                            let (all_cmd, _args) = args
+                                .subcommand()
+                                .expect("to be able to get a subcommand (todo: might not work)");
+
+                            for (member_path, context) in member_contexts {
+                                run::Run::execute_command_if_exists(all_cmd, member_path, &context)
+                                    .await?;
+                            }
+                        }
+                        _ => {
+                            let (project_name, command) = run_args
+                                .split_once("::")
+                                .expect("commands to always be pairs for workspaces");
+
+                            let mut found_context = false;
+                            for (member_path, context) in &member_contexts {
+                                if project_name == context.project.name {
+                                    run::Run::execute_command(command, member_path, context)
+                                        .await?;
+
+                                    found_context = true;
+                                }
+                            }
+
+                            if !found_context {
+                                anyhow::bail!("no matching context was found")
+                            }
+                        }
+                    }
+                }
+                _ => match Commands::from_arg_matches(&matches).unwrap() {
+                    Commands::Init {} => {
+                        tracing::info!("initializing project");
+                    }
+                    Commands::Info {} => {
+                        let output = serde_json::to_string_pretty(&member_contexts)?;
+                        println!("{}", output.to_colored_json_auto().unwrap_or(output));
+                    }
+                    Commands::Template(template) => {
+                        //template.execute(&project_path, &context).await?;
+                    }
+                    Commands::Serve {
+                        s3_endpoint,
+                        s3_bucket,
+                        s3_region,
+                        s3_user,
+                        s3_password,
+                        ..
+                    } => {
+                        tracing::info!("Starting server");
+                        let creds = Credentials::new(s3_user, s3_password);
+                        let bucket = Bucket::new(
+                            url::Url::parse(&s3_endpoint)?,
+                            rusty_s3::UrlStyle::Path,
+                            s3_bucket,
+                            s3_region,
+                        )?;
+                        let put_object = bucket.put_object(Some(&creds), "some-object");
+                        let _url = put_object.sign(std::time::Duration::from_secs(30));
+                        let _state = SharedState::new().await?;
+                    }
+                    Commands::Clean {} => {
+                        todo!();
+                        // let forest_path = project_path.join(".forest");
+                        // if forest_path.exists() {
+                        //     tokio::fs::remove_dir_all(forest_path).await?;
+                        //     tracing::info!("removed .forest");
+                        // }
+                    }
+                },
+            }
+        }
+        ForestFile::Project(project) => {
             tracing::trace!("found a project name: {}", project.name);
 
             let plan = if let Some(plan_file_path) = PlanReconciler::new()
-                .reconcile(&project, &project_path)
+                .reconcile(&project, &project_path, None, None)
                 .await?
             {
                 let plan_file = tokio::fs::read_to_string(&plan_file_path).await?;
@@ -87,28 +277,64 @@ pub async fn execute() -> anyhow::Result<()> {
 
             let context = Context { project, plan };
 
-            tracing::info!("context: {:+?}", context);
-        }
+            let matches = if matches.subcommand_matches("run").is_some() {
+                tracing::debug!("run is called, building extra commands, rerunning the parser");
+                let root = get_root(false);
 
-        Commands::Serve {
-            host,
-            s3_endpoint,
-            s3_bucket,
-            s3_region,
-            s3_user,
-            s3_password,
-        } => {
-            tracing::info!("Starting server");
-            let creds = Credentials::new(s3_user, s3_password);
-            let bucket = Bucket::new(
-                url::Url::parse(&s3_endpoint)?,
-                rusty_s3::UrlStyle::Path,
-                s3_bucket,
-                s3_region,
-            )?;
-            let put_object = bucket.put_object(Some(&creds), "some-object");
-            let _url = put_object.sign(std::time::Duration::from_secs(30));
-            let _state = SharedState::new().await?;
+                let run_cmd = run::Run::augment_command(&context);
+                root.subcommand(run_cmd).get_matches()
+            } else {
+                matches
+            };
+
+            match matches
+                .subcommand()
+                .expect("forest requires a command to be passed")
+            {
+                ("run", args) => {
+                    run::Run::execute(args, &project_path, &context).await?;
+                }
+                _ => match Commands::from_arg_matches(&matches).unwrap() {
+                    Commands::Init {} => {
+                        tracing::info!("initializing project");
+                        tracing::trace!("found context: {:?}", context);
+                    }
+                    Commands::Info {} => {
+                        let output = serde_json::to_string_pretty(&context)?;
+                        println!("{}", output.to_colored_json_auto().unwrap_or(output));
+                    }
+                    Commands::Template(template) => {
+                        template.execute(&project_path, &context).await?;
+                    }
+                    Commands::Serve {
+                        s3_endpoint,
+                        s3_bucket,
+                        s3_region,
+                        s3_user,
+                        s3_password,
+                        ..
+                    } => {
+                        tracing::info!("Starting server");
+                        let creds = Credentials::new(s3_user, s3_password);
+                        let bucket = Bucket::new(
+                            url::Url::parse(&s3_endpoint)?,
+                            rusty_s3::UrlStyle::Path,
+                            s3_bucket,
+                            s3_region,
+                        )?;
+                        let put_object = bucket.put_object(Some(&creds), "some-object");
+                        let _url = put_object.sign(std::time::Duration::from_secs(30));
+                        let _state = SharedState::new().await?;
+                    }
+                    Commands::Clean {} => {
+                        let forest_path = project_path.join(".forest");
+                        if forest_path.exists() {
+                            tokio::fs::remove_dir_all(forest_path).await?;
+                            tracing::info!("removed .forest");
+                        }
+                    }
+                },
+            }
         }
     }
 

crates/forest/src/cli/run.rs

@@ -0,0 +1,166 @@
+use std::path::Path;
+
+use crate::{model::Context, script::ScriptExecutor};
+
+// Run is a bit special in that because the arguments dynamically render, we need to do some special magic in
+// clap to avoid having to do hacks to register clap subcommands midcommand. As such instead, we opt to simply
+// create a new sub command that encapsulates all the run complexities
+pub struct Run {}
+impl Run {
+    pub fn augment_command(ctx: &Context) -> clap::Command {
+        let mut run_cmd = clap::Command::new("run")
+            .subcommand_required(true)
+            .about("runs any kind of script from either the project or plan");
+
+        if let Some(scripts) = &ctx.project.scripts {
+            for name in scripts.items.keys() {
+                let cmd = clap::Command::new(name.to_string());
+                run_cmd = run_cmd.subcommand(cmd);
+            }
+        }
+
+        if let Some(plan) = &ctx.plan {
+            if let Some(scripts) = &plan.scripts {
+                let existing_cmds = run_cmd
+                    .get_subcommands()
+                    .map(|s| s.get_name().to_string())
+                    .collect::<Vec<_>>();
+
+                for name in scripts.items.keys() {
+                    if existing_cmds.contains(name) {
+                        continue;
+                    }
+
+                    let cmd = clap::Command::new(name.to_string());
+                    run_cmd = run_cmd.subcommand(cmd);
+                }
+            }
+        }
+
+        run_cmd
+    }
+
+    pub fn augment_workspace_command(ctx: &Context, prefix: &str) -> Vec<clap::Command> {
+        let mut commands = Vec::new();
+        if let Some(scripts) = &ctx.project.scripts {
+            for name in scripts.items.keys() {
+                let cmd = clap::Command::new(format!("{prefix}::{name}"));
+                commands.push(cmd);
+            }
+        }
+
+        if let Some(plan) = &ctx.plan {
+            if let Some(scripts) = &plan.scripts {
+                let existing_cmds = commands
+                    .iter()
+                    .map(|s| format!("{prefix}::{}", s.get_name()))
+                    .collect::<Vec<_>>();
+
+                for name in scripts.items.keys() {
+                    if existing_cmds.contains(name) {
+                        continue;
+                    }
+
+                    let cmd = clap::Command::new(format!("{prefix}::{name}"));
+                    commands.push(cmd)
+                }
+            }
+        }
+
+        commands
+    }
+
+    pub async fn execute(
+        args: &clap::ArgMatches,
+        project_path: &Path,
+        ctx: &Context,
+    ) -> anyhow::Result<()> {
+        let Some((name, args)) = args.subcommand() else {
+            anyhow::bail!("failed to find a matching run command")
+        };
+
+        if let Some(scripts_ctx) = &ctx.project.scripts {
+            if let Some(script_ctx) = scripts_ctx.items.get(name) {
+                ScriptExecutor::new(project_path.into(), ctx.clone())
+                    .run(script_ctx, name)
+                    .await?;
+
+                return Ok(());
+            }
+        }
+
+        if let Some(plan) = &ctx.plan {
+            if let Some(scripts_ctx) = &plan.scripts {
+                if let Some(script_ctx) = scripts_ctx.items.get(name) {
+                    ScriptExecutor::new(project_path.into(), ctx.clone())
+                        .run(script_ctx, name)
+                        .await?;
+
+                    return Ok(());
+                }
+            }
+        }
+
+        anyhow::bail!("no scripts were found for command: {}", name)
+    }
+
+    pub async fn execute_command(
+        command: &str,
+        project_path: &Path,
+        ctx: &Context,
+    ) -> anyhow::Result<()> {
+        if let Some(scripts_ctx) = &ctx.project.scripts {
+            if let Some(script_ctx) = scripts_ctx.items.get(command) {
+                ScriptExecutor::new(project_path.into(), ctx.clone())
+                    .run(script_ctx, command)
+                    .await?;
+
+                return Ok(());
+            }
+        }
+
+        if let Some(plan) = &ctx.plan {
+            if let Some(scripts_ctx) = &plan.scripts {
+                if let Some(script_ctx) = scripts_ctx.items.get(command) {
+                    ScriptExecutor::new(project_path.into(), ctx.clone())
+                        .run(script_ctx, command)
+                        .await?;
+
+                    return Ok(());
+                }
+            }
+        }
+
+        anyhow::bail!("no scripts were found for command: {}", command)
+    }
+
+    pub async fn execute_command_if_exists(
+        command: &str,
+        project_path: &Path,
+        ctx: &Context,
+    ) -> anyhow::Result<()> {
+        if let Some(scripts_ctx) = &ctx.project.scripts {
+            if let Some(script_ctx) = scripts_ctx.items.get(command) {
+                ScriptExecutor::new(project_path.into(), ctx.clone())
+                    .run(script_ctx, command)
+                    .await?;
+
+                return Ok(());
+            }
+        }
+
+        if let Some(plan) = &ctx.plan {
+            if let Some(scripts_ctx) = &plan.scripts {
+                if let Some(script_ctx) = scripts_ctx.items.get(command) {
+                    ScriptExecutor::new(project_path.into(), ctx.clone())
+                        .run(script_ctx, command)
+                        .await?;
+
+                    return Ok(());
+                }
+            }
+        }
+
+        Ok(())
+    }
+}

crates/forest/src/cli/template.rs

@@ -0,0 +1,206 @@
+use std::path::Path;
+
+use tokio::io::AsyncWriteExt;
+
+use crate::model::{Context, TemplateType};
+
+#[derive(clap::Parser)]
+pub struct Template {}
+
+impl Template {
+    pub async fn execute(self, project_path: &Path, context: &Context) -> anyhow::Result<()> {
+        tracing::info!("templating");
+
+        self.execute_plan(project_path, context).await?;
+        self.execute_project(project_path, context).await?;
+
+        Ok(())
+    }
+
+    async fn execute_plan(&self, project_path: &Path, context: &Context) -> anyhow::Result<()> {
+        let plan_path = &project_path.join(".forest").join("plan");
+
+        let Some(Some(template)) = &context.plan.as_ref().map(|p| &p.templates) else {
+            return Ok(());
+        };
+
+        match template.ty {
+            TemplateType::Jinja2 => {
+                for entry in glob::glob(&format!(
+                    "{}/{}",
+                    plan_path.display().to_string().trim_end_matches("/"),
+                    template.path.trim_start_matches("./"),
+                ))
+                .map_err(|e| anyhow::anyhow!("failed to read glob pattern: {}", e))?
+                {
+                    let entry = entry.map_err(|e| anyhow::anyhow!("failed to read path: {}", e))?;
+                    let entry_name = entry.display().to_string();
+
+                    let entry_rel = if entry.is_absolute() {
+                        entry.strip_prefix(plan_path).map(|e| e.to_path_buf())
+                    } else {
+                        Ok(entry.clone())
+                    };
+
+                    let rel_file_path = entry_rel
+                        .map(|p| {
+                            if p.file_name()
+                                .map(|f| f.to_string_lossy().ends_with(".jinja2"))
+                                .unwrap_or(false)
+                            {
+                                p.with_file_name(
+                                    p.file_stem().expect("to be able to find a filename"),
+                                )
+                            } else {
+                                p.to_path_buf()
+                            }
+                        })
+                        .map_err(|e| {
+                            anyhow::anyhow!(
+                                "failed to find relative file: {}, project: {}, file: {}",
+                                e,
+                                plan_path.display(),
+                                entry_name
+                            )
+                        })?;
+
+                    let output_file_path = project_path
+                        .join(".forest/temp")
+                        .join(&template.output)
+                        .join(rel_file_path);
+
+                    let contents = tokio::fs::read_to_string(&entry).await.map_err(|e| {
+                        anyhow::anyhow!("failed to read template: {}, err: {}", entry.display(), e)
+                    })?;
+
+                    let mut env = minijinja::Environment::new();
+                    env.add_template(&entry_name, &contents)?;
+                    env.add_global("global", &context.project.global);
+
+                    let tmpl = env.get_template(&entry_name)?;
+
+                    let output = tmpl
+                        .render(minijinja::context! {})
+                        .map_err(|e| anyhow::anyhow!("failed to render template: {}", e))?;
+
+                    tracing::info!("rendered template: {}", output);
+
+                    if let Some(parent) = output_file_path.parent() {
+                        tokio::fs::create_dir_all(parent).await.map_err(|e| {
+                            anyhow::anyhow!(
+                                "failed to create directory (path: {}) for output: {}",
+                                parent.display(),
+                                e
+                            )
+                        })?;
+                    }
+
+                    let mut output_file = tokio::fs::File::create(&output_file_path)
+                        .await
+                        .map_err(|e| {
+                            anyhow::anyhow!(
+                                "failed to create file: {}, error: {}",
+                                output_file_path.display(),
+                                e
+                            )
+                        })?;
+                    output_file.write_all(output.as_bytes()).await?;
+                }
+            }
+        }
+
+        Ok(())
+    }
+    async fn execute_project(&self, project_path: &Path, context: &Context) -> anyhow::Result<()> {
+        let Some(template) = &context.project.templates else {
+            return Ok(());
+        };
+
+        match template.ty {
+            TemplateType::Jinja2 => {
+                for entry in glob::glob(&format!(
+                    "{}/{}",
+                    project_path.display().to_string().trim_end_matches("/"),
+                    template.path.trim_start_matches("./"),
+                ))
+                .map_err(|e| anyhow::anyhow!("failed to read glob pattern: {}", e))?
+                {
+                    let entry = entry.map_err(|e| anyhow::anyhow!("failed to read path: {}", e))?;
+                    let entry_name = entry.display().to_string();
+
+                    let entry_rel = if entry.is_absolute() {
+                        entry.strip_prefix(project_path).map(|e| e.to_path_buf())
+                    } else {
+                        Ok(entry.clone())
+                    };
+
+                    let rel_file_path = entry_rel
+                        .map(|p| {
+                            if p.file_name()
+                                .map(|f| f.to_string_lossy().ends_with(".jinja2"))
+                                .unwrap_or(false)
+                            {
+                                p.with_file_name(
+                                    p.file_stem().expect("to be able to find a filename"),
+                                )
+                            } else {
+                                p.to_path_buf()
+                            }
+                        })
+                        .map_err(|e| {
+                            anyhow::anyhow!(
+                                "failed to find relative file: {}, project: {}, file: {}",
+                                e,
+                                project_path.display(),
+                                entry_name
+                            )
+                        })?;
+
+                    let output_file_path = project_path
+                        .join(".forest/temp")
+                        .join(&template.output)
+                        .join(rel_file_path);
+
+                    let contents = tokio::fs::read_to_string(&entry).await.map_err(|e| {
+                        anyhow::anyhow!("failed to read template: {}, err: {}", entry.display(), e)
+                    })?;
+
+                    let mut env = minijinja::Environment::new();
+                    env.add_template(&entry_name, &contents)?;
+                    env.add_global("global", &context.project.global);
+
+                    let tmpl = env.get_template(&entry_name)?;
+
+                    let output = tmpl
+                        .render(minijinja::context! {})
+                        .map_err(|e| anyhow::anyhow!("failed to render template: {}", e))?;
+
+                    tracing::info!("rendered template: {}", output);
+
+                    if let Some(parent) = output_file_path.parent() {
+                        tokio::fs::create_dir_all(parent).await.map_err(|e| {
+                            anyhow::anyhow!(
+                                "failed to create directory (path: {}) for output: {}",
+                                parent.display(),
+                                e
+                            )
+                        })?;
+                    }
+
+                    let mut output_file = tokio::fs::File::create(&output_file_path)
+                        .await
+                        .map_err(|e| {
+                            anyhow::anyhow!(
+                                "failed to create file: {}, error: {}",
+                                output_file_path.display(),
+                                e
+                            )
+                        })?;
+                    output_file.write_all(output.as_bytes()).await?;
+                }
+            }
+        }
+
+        Ok(())
+    }
+}

crates/forest/src/main.rs

@@ -1,12 +1,23 @@
+use tracing::level_filters::LevelFilter;
+use tracing_subscriber::EnvFilter;
+
 pub mod cli;
 pub mod model;
 pub mod plan_reconciler;
+pub mod script;
 pub mod state;
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     dotenvy::dotenv().ok();
-    tracing_subscriber::fmt::init();
+    tracing_subscriber::fmt()
+        .with_env_filter(
+            EnvFilter::builder()
+                .with_default_directive(LevelFilter::WARN.into())
+                .with_env_var("FOREST_LOG_LEVEL")
+                .from_env()?,
+        )
+        .init();
 
     cli::execute().await?;
 

crates/forest/src/model.rs

@@ -1,16 +1,21 @@
 use std::{collections::BTreeMap, fmt::Debug, path::PathBuf};
 
-use kdl::{KdlDocument, KdlEntry, KdlNode, KdlValue};
+use kdl::{KdlDocument, KdlNode, KdlValue};
+use serde::Serialize;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize)]
 pub struct Context {
     pub project: Project,
     pub plan: Option<Plan>,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize)]
 pub struct Plan {
     pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub templates: Option<Templates>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub scripts: Option<Scripts>,
 }
 
 impl TryFrom<KdlDocument> for Plan {
@@ -34,13 +39,24 @@ impl TryFrom<KdlDocument> for Plan {
                 })
                 .cloned()
                 .ok_or(anyhow::anyhow!("a forest kuddle plan must have a name"))?,
+            templates: plan_children
+                .get("templates")
+                .map(|t| t.try_into())
+                .transpose()?,
+            scripts: plan_children
+                .get("scripts")
+                .map(|m| m.try_into())
+                .transpose()?,
         })
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize)]
+#[serde(untagged)]
 pub enum ProjectPlan {
     Local { path: PathBuf },
+    Git { url: String, path: Option<PathBuf> },
+    Workspace { name: String },
     NoPlan,
 }
 
@@ -62,11 +78,41 @@ impl TryFrom<&KdlNode> for ProjectPlan {
             });
         }
 
+        if let Some(git) = children.get_arg("git") {
+            return Ok(Self::Git {
+                url: git
+                    .as_string()
+                    .map(|l| l.to_string())
+                    .ok_or(anyhow::anyhow!("a git url is required"))?,
+                path: children
+                    .get("git")
+                    .and_then(|git| {
+                        git.entries()
+                            .iter()
+                            .filter(|i| i.name().is_some())
+                            .find(|i| i.name().expect("to have a value").to_string() == "path")
+                    })
+                    .and_then(|i| i.value().as_string().map(|p| p.to_string().into())),
+            });
+        }
+
+        if let Some(workspace) = children.get_arg("workspace") {
+            return Ok(Self::Workspace {
+                name: workspace
+                    .as_string()
+                    .map(|w| w.to_string())
+                    .ok_or(anyhow::anyhow!(
+                        "workspace requires a project name in the same project"
+                    ))?,
+            });
+        }
+
         Ok(Self::NoPlan)
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize)]
+#[serde(untagged)]
 pub enum GlobalVariable {
     Map(BTreeMap<String, GlobalVariable>),
     String(String),
@@ -125,11 +171,24 @@ impl TryFrom<&KdlValue> for GlobalVariable {
     }
 }
 
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone, Serialize, Default)]
 pub struct Global {
+    #[serde(flatten)]
     items: BTreeMap<String, GlobalVariable>,
 }
 
+impl Global {
+    fn is_empty(&self) -> bool {
+        self.items.is_empty()
+    }
+}
+
+impl From<&Global> for minijinja::Value {
+    fn from(value: &Global) -> Self {
+        Self::from_serialize(&value.items)
+    }
+}
+
 impl TryFrom<&KdlNode> for Global {
     type Error = anyhow::Error;
 
@@ -153,12 +212,136 @@ impl TryFrom<&KdlNode> for Global {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize, Default)]
+pub enum TemplateType {
+    #[default]
+    Jinja2,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct Templates {
+    #[serde(rename = "type")]
+    pub ty: TemplateType,
+    pub path: String,
+    pub output: PathBuf,
+}
+
+impl Default for Templates {
+    fn default() -> Self {
+        Self {
+            ty: TemplateType::default(),
+            path: "./templates/*.jinja2".into(),
+            output: "output/".into(),
+        }
+    }
+}
+
+impl TryFrom<&KdlNode> for Templates {
+    type Error = anyhow::Error;
+
+    fn try_from(value: &KdlNode) -> Result<Self, Self::Error> {
+        let mut templates = Templates::default();
+
+        for entry in value.entries() {
+            let Some(name) = entry.name() else { continue };
+            match name.value() {
+                "type" => {
+                    let Some(val) = entry.value().as_string() else {
+                        anyhow::bail!("type is not a valid string")
+                    };
+
+                    match val.to_lowercase().as_str() {
+                        "jinja2" => templates.ty = TemplateType::Jinja2,
+                        e => {
+                            anyhow::bail!(
+                                "failed to find a template matching the required type: {}, only 'jinja2' is supported",
+                                e
+                            );
+                        }
+                    }
+                }
+                "path" => {
+                    let Some(val) = entry.value().as_string() else {
+                        anyhow::bail!("failed to parse path as a valid string")
+                    };
+
+                    templates.path = val.to_string();
+                }
+                "output" => {
+                    let Some(val) = entry.value().as_string() else {
+                        anyhow::bail!("failed to parse val as a valid string")
+                    };
+
+                    templates.output = PathBuf::from(val);
+                }
+                _ => continue,
+            }
+        }
+
+        Ok(templates)
+    }
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(tag = "type")]
+pub enum Script {
+    Shell {},
+}
+
+impl TryFrom<&KdlNode> for Script {
+    type Error = anyhow::Error;
+
+    fn try_from(value: &KdlNode) -> Result<Self, Self::Error> {
+        Ok(Self::Shell {})
+    }
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct Scripts {
+    #[serde(flatten)]
+    pub items: BTreeMap<String, Script>,
+}
+
+impl TryFrom<&KdlNode> for Scripts {
+    type Error = anyhow::Error;
+
+    fn try_from(value: &KdlNode) -> Result<Self, Self::Error> {
+        let val = Self {
+            items: {
+                let mut out = BTreeMap::default();
+                if let Some(children) = value.children() {
+                    for entry in children.nodes() {
+                        let name = entry.name().value();
+                        let val = entry.try_into()?;
+
+                        out.insert(name.to_string(), val);
+                    }
+
+                    out
+                } else {
+                    out
+                }
+            },
+        };
+
+        Ok(val)
+    }
+}
+
+#[derive(Debug, Clone, Serialize)]
 pub struct Project {
     pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub description: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub plan: Option<ProjectPlan>,
+
+    #[serde(skip_serializing_if = "Global::is_empty")]
     pub global: Global,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub templates: Option<Templates>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub scripts: Option<Scripts>,
 }
 
 impl TryFrom<KdlDocument> for Project {
@@ -203,6 +386,122 @@ impl TryFrom<KdlDocument> for Project {
                 }),
             plan: project_plan,
             global: global.unwrap_or_default(),
+            templates: project_children
+                .get("templates")
+                .map(|t| t.try_into())
+                .transpose()?,
+            scripts: project_children
+                .get("scripts")
+                .map(|m| m.try_into())
+                .transpose()?,
         })
     }
 }
+
+#[derive(Debug, Clone, Serialize)]
+pub struct WorkspaceMember {
+    pub path: String,
+}
+
+impl TryFrom<&kdl::KdlNode> for WorkspaceMember {
+    type Error = anyhow::Error;
+
+    fn try_from(value: &kdl::KdlNode) -> Result<Self, Self::Error> {
+        Ok(Self {
+            path: value
+                .entries()
+                .first()
+                .ok_or(anyhow::anyhow!(
+                    "is supposed to have a path `member ./some-path`"
+                ))?
+                .value()
+                .as_string()
+                .ok_or(anyhow::anyhow!("value is required to be a string"))?
+                .to_string(),
+        })
+    }
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct Workspace {
+    pub members: Vec<WorkspaceMember>,
+}
+
+impl TryFrom<KdlDocument> for Workspace {
+    type Error = anyhow::Error;
+
+    fn try_from(value: KdlDocument) -> Result<Self, Self::Error> {
+        let workspace = value
+            .get("workspace")
+            .expect("to have a workspace at this point")
+            .children()
+            .ok_or(anyhow::anyhow!("workspace to be a section"))?;
+
+        Ok(Self {
+            members: workspace
+                .get("members")
+                .ok_or(anyhow::anyhow!(
+                    "a members section is required for a workspace"
+                ))?
+                .children()
+                .ok_or(anyhow::anyhow!("a members is required to have children"))?
+                .nodes()
+                .iter()
+                .map(|m| m.try_into())
+                .collect::<anyhow::Result<Vec<_>>>()?,
+        })
+    }
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub enum ForestFile {
+    Workspace(Workspace),
+    Project(Project),
+}
+
+impl TryFrom<KdlDocument> for ForestFile {
+    type Error = anyhow::Error;
+
+    fn try_from(value: KdlDocument) -> Result<Self, Self::Error> {
+        if value.get("workspace").is_some() && value.get("project").is_some() {
+            anyhow::bail!("a forest.kdl file cannot contain both a workspace and project")
+        }
+
+        if value.get("project").is_some() {
+            return Ok(Self::Project(value.try_into()?));
+        }
+
+        if value.get("workspace").is_some() {
+            return Ok(Self::Workspace(value.try_into()?));
+        }
+
+        anyhow::bail!("a forest.kdl file must be either a project, workspace or plan")
+    }
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(tag = "type")]
+pub enum WorkspaceProject {
+    Plan(Plan),
+    Project(Project),
+}
+
+impl TryFrom<KdlDocument> for WorkspaceProject {
+    type Error = anyhow::Error;
+
+    fn try_from(value: KdlDocument) -> Result<Self, Self::Error> {
+        if value.get("plan").is_some() && value.get("project").is_some() {
+            anyhow::bail!("a forest.kdl file cannot contain both a plan and project")
+        }
+
+        if value.get("project").is_some() {
+            return Ok(Self::Project(value.try_into()?));
+        }
+
+        if value.get("plan").is_some() {
+            return Ok(Self::Plan(value.try_into()?));
+        }
+
+        anyhow::bail!("a forest.kdl file must be either a project, workspace or plan")
+    }
+}

crates/forest/src/plan_reconciler.rs

@@ -2,10 +2,13 @@ use std::path::{Path, PathBuf};
 
 use anyhow::Context;
 
-use crate::model::Project;
+use crate::model::{Project, WorkspaceProject};
 
+pub mod git;
 pub mod local;
 
+mod cache;
+
 #[derive(Default)]
 pub struct PlanReconciler {}
 
@@ -18,17 +21,25 @@ impl PlanReconciler {
         &self,
         project: &Project,
         destination: &Path,
+        workspace_members: Option<&Vec<(PathBuf, WorkspaceProject)>>,
+        workspace_root: Option<&Path>,
     ) -> anyhow::Result<Option<PathBuf>> {
         tracing::info!("reconciling project");
         if project.plan.is_none() {
             tracing::debug!("no plan, returning");
             return Ok(None);
         }
+        let cache = cache::Cache::new(destination);
 
         // prepare the plan dir
         // TODO: We're always deleting, consider some form of caching
         let plan_dir = destination.join(".forest").join("plan");
         if plan_dir.exists() {
+            if let Some(secs) = cache.is_cache_valid().await? {
+                tracing::debug!("cache is valid for {} seconds", secs);
+                return Ok(Some(plan_dir.join("forest.kdl")));
+            }
+
             tokio::fs::remove_dir_all(&plan_dir).await?;
         }
         tokio::fs::create_dir_all(&plan_dir)
@@ -43,6 +54,24 @@ impl PlanReconciler {
                 let source = &destination.join(path);
                 local::reconcile(source, &plan_dir).await?;
             }
+            crate::model::ProjectPlan::Git { url, path } => {
+                git::reconcile(url, path, &plan_dir).await?;
+            }
+            crate::model::ProjectPlan::Workspace { name } => {
+                let workspace_root = workspace_root.expect("to have workspace root available");
+
+                if let Some(workspace_members) = workspace_members {
+                    for (member_path, member) in workspace_members {
+                        if let WorkspaceProject::Plan(plan) = member {
+                            if &plan.name == name {
+                                tracing::debug!("found workspace project: {}", name);
+                                local::reconcile(&workspace_root.join(member_path), &plan_dir)
+                                    .await?;
+                            }
+                        }
+                    }
+                }
+            }
             crate::model::ProjectPlan::NoPlan => {
                 tracing::debug!("no plan, returning");
                 return Ok(None);
@@ -51,6 +80,8 @@ impl PlanReconciler {
 
         tracing::info!("reconciled project");
 
+        cache.upsert_cache().await?;
+
         Ok(Some(plan_dir.join("forest.kdl")))
     }
 }

crates/forest/src/plan_reconciler/cache.rs

@@ -0,0 +1,68 @@
+use std::{
+    path::{Path, PathBuf},
+    time::UNIX_EPOCH,
+};
+
+use serde::{Deserialize, Serialize};
+use tokio::io::AsyncWriteExt;
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+struct CacheFile {
+    last_update: u64,
+}
+
+pub struct Cache {
+    path: PathBuf,
+}
+
+impl Cache {
+    pub fn new(destination: &Path) -> Self {
+        Self {
+            path: destination.join(".forest").join("plan.cache.json"),
+        }
+    }
+
+    pub async fn is_cache_valid(&self) -> anyhow::Result<Option<u64>> {
+        if !self.path.exists() {
+            return Ok(None);
+        }
+
+        if let Ok(cache_config) = std::env::var("FOREST_CACHE").map(|c| c.trim().to_lowercase()) {
+            if cache_config.eq("no") || cache_config.eq("false") || cache_config.eq("0") {
+                return Ok(None);
+            }
+        }
+
+        let file = tokio::fs::read_to_string(&self.path).await?;
+        let cache_file: CacheFile = serde_json::from_str(&file)?;
+        let unix_cache = std::time::Duration::from_secs(cache_file.last_update);
+        let now = std::time::SystemTime::now().duration_since(UNIX_EPOCH)?;
+
+        let cache_expire = now
+            .as_secs()
+            .saturating_sub(std::time::Duration::from_secs(60 * 60).as_secs()); // cache lasts an hour
+
+        if unix_cache.as_secs() > cache_expire {
+            return Ok(Some(unix_cache.as_secs().saturating_sub(cache_expire)));
+        }
+
+        Ok(None)
+    }
+
+    pub async fn upsert_cache(&self) -> anyhow::Result<()> {
+        if let Some(parent) = self.path.parent() {
+            tokio::fs::create_dir_all(parent).await?;
+        }
+
+        let unix = std::time::SystemTime::now().duration_since(UNIX_EPOCH)?;
+        let cache_file = CacheFile {
+            last_update: unix.as_secs(),
+        };
+        let val = serde_json::to_string_pretty(&cache_file)?;
+
+        let mut file = tokio::fs::File::create(&self.path).await?;
+        file.write_all(val.as_bytes()).await?;
+
+        Ok(())
+    }
+}

crates/forest/src/plan_reconciler/git.rs

@@ -0,0 +1,53 @@
+use std::{
+    env::temp_dir,
+    path::{Path, PathBuf},
+};
+
+use super::local;
+
+pub async fn reconcile(url: &str, path: &Option<PathBuf>, plan_dir: &Path) -> anyhow::Result<()> {
+    let temp = TempDir::new();
+    tokio::fs::create_dir_all(&temp.0).await?;
+
+    let mut cmd = tokio::process::Command::new("git");
+    cmd.args(["clone", url, &temp.0.display().to_string(), "--depth=1"]);
+
+    tracing::info!("cloning plan: {}", url);
+    let out = cmd.output().await?;
+    if !out.status.success() {
+        let stdout = std::str::from_utf8(&out.stdout).unwrap_or_default();
+        let stderr = std::str::from_utf8(&out.stderr).unwrap_or_default();
+
+        anyhow::bail!("failed to process git plan: {}, {}", stdout, stderr)
+    }
+
+    let temp_plan_dir = if let Some(path) = path {
+        temp.0.join(path)
+    } else {
+        temp.0.to_path_buf()
+    };
+
+    local::reconcile(&temp_plan_dir, plan_dir).await?;
+
+    drop(temp);
+
+    Ok(())
+}
+
+struct TempDir(PathBuf);
+
+impl TempDir {
+    fn new() -> Self {
+        Self(
+            temp_dir()
+                .join("forest")
+                .join(uuid::Uuid::new_v4().to_string()),
+        )
+    }
+}
+
+impl Drop for TempDir {
+    fn drop(&mut self) {
+        std::fs::remove_dir_all(&self.0).expect("to be able to remove temp dir");
+    }
+}

crates/forest/src/script.rs

@@ -0,0 +1,61 @@
+use std::path::PathBuf;
+
+use shell::ShellExecutor;
+
+use crate::model::{Context, Script};
+
+pub mod shell;
+
+#[derive(Clone)]
+pub struct ScriptExecutor {
+    project_path: PathBuf,
+    ctx: Context,
+}
+
+impl ScriptExecutor {
+    pub fn new(project_path: PathBuf, ctx: Context) -> Self {
+        Self { project_path, ctx }
+    }
+
+    pub async fn run(&self, script_ctx: &Script, name: &str) -> anyhow::Result<()> {
+        if self.run_project(script_ctx, name).await? {
+            return Ok(());
+        }
+
+        if self.run_plan(script_ctx, name).await? {
+            return Ok(());
+        }
+
+        anyhow::bail!("script was not found for name: {}", name)
+    }
+
+    async fn run_project(&self, script_ctx: &Script, name: &str) -> anyhow::Result<bool> {
+        match script_ctx {
+            Script::Shell {} => {
+                if matches!(
+                    ShellExecutor::from(self).execute(name).await?,
+                    shell::ScriptStatus::Found
+                ) {
+                    Ok(true)
+                } else {
+                    Ok(false)
+                }
+            }
+        }
+    }
+
+    async fn run_plan(&self, script_ctx: &Script, name: &str) -> anyhow::Result<bool> {
+        match script_ctx {
+            Script::Shell {} => {
+                if matches!(
+                    ShellExecutor::from_plan(self).execute(name).await?,
+                    shell::ScriptStatus::Found
+                ) {
+                    Ok(true)
+                } else {
+                    Ok(false)
+                }
+            }
+        }
+    }
+}

crates/forest/src/script/shell.rs

@@ -0,0 +1,77 @@
+use std::{path::PathBuf, process::Stdio};
+
+use anyhow::Context;
+
+use super::ScriptExecutor;
+
+pub struct ShellExecutor {
+    root: ScriptExecutor,
+    ty: ShellType,
+}
+
+pub enum ScriptStatus {
+    Found,
+    NotFound,
+}
+
+enum ShellType {
+    Plan,
+    Project,
+}
+
+impl ShellExecutor {
+    pub async fn execute(&self, name: &str) -> anyhow::Result<ScriptStatus> {
+        let path = &self.get_path();
+        let script_path = path.join("scripts").join(format!("{name}.sh"));
+
+        if !script_path.exists() {
+            return Ok(ScriptStatus::NotFound);
+        }
+
+        let mut cmd = tokio::process::Command::new(&script_path);
+        let cmd = cmd.current_dir(&self.root.project_path);
+        cmd.stdin(Stdio::inherit());
+        cmd.stdout(Stdio::inherit());
+        cmd.stderr(Stdio::inherit());
+
+        let mut proc = cmd.spawn().context(format!(
+            "failed to spawn process: {}",
+            script_path.display()
+        ))?;
+
+        let exit = proc.wait().await?;
+
+        if !exit.success() {
+            anyhow::bail!(
+                "command: {name} failed with status: {}",
+                exit.code().unwrap_or(-1)
+            )
+        }
+
+        Ok(ScriptStatus::Found)
+    }
+
+    fn get_path(&self) -> PathBuf {
+        match self.ty {
+            //ShellType::Plan => self.root.project_path.join(".forest").join("plan"),
+            ShellType::Plan => self.root.project_path.join(".forest").join("plan"),
+            ShellType::Project => self.root.project_path.clone(),
+        }
+    }
+
+    pub fn from_plan(value: &ScriptExecutor) -> Self {
+        Self {
+            root: value.clone(),
+            ty: ShellType::Plan,
+        }
+    }
+}
+
+impl From<&ScriptExecutor> for ShellExecutor {
+    fn from(value: &ScriptExecutor) -> Self {
+        Self {
+            root: value.clone(),
+            ty: ShellType::Project,
+        }
+    }
+}

examples/plan/forest.kdl

@@ -1,3 +1,13 @@
 plan {
 	name project
+	
+	templates type=jinja2 {
+		path "templates/*.jinja2"
+		output "output/"
+	}
+
+	scripts {
+		world type=shell {}
+		hello type=shell {}
+	}
 }

examples/plan/scripts/hello.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env zsh
+
+set -e
+
+echo "hello plan"

examples/plan/scripts/world.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env zsh
+
+set -e
+
+echo "hello plan world"

examples/plan/templates/something.plan.yaml.jinja2

@@ -0,0 +1,3 @@
+something plan
+
+val is mapping: {{ global.someKey.some.key.val is mapping  }}

examples/plan/templates/something.yaml.jinja2

@@ -0,0 +1,3 @@
+something plan
+
+val is mapping: {{ global.someKey.some.key.val is mapping  }}

examples/project/forest.kdl

@@ -20,4 +20,14 @@ project {
 			}
 		}
 	}
+
+	templates type=jinja2 {
+		path "templates/*.jinja2"
+		output "output/"
+	}
+
+	scripts {
+		hello type=shell {}
+	}
 }
+

examples/project/scripts/hello.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env zsh
+
+set -e
+
+echo "hello world"

examples/project/templates/something.yaml.jinja2

@@ -0,0 +1,3 @@
+something
+
+val is mapping: {{ global.someKey.some.key.val is mapping  }}

examples/project_git/forest.kdl

@@ -0,0 +1,33 @@
+project {
+	name local
+	description """
+		A simple local project that depends on ../plan for its utility scripts
+	"""
+
+	plan {
+		git "ssh://git@git.front.kjuulh.io/kjuulh/forest" path="examples/plan"
+	}
+
+	global {
+		someName "name"
+		someKey {
+			someNestedKey "somevalue"
+			some {
+				key {
+					val
+					val
+				}
+			}
+		}
+	}
+
+	templates type=jinja2 {
+		path "templates/*.jinja2"
+		output "output/"
+	}
+
+	scripts {
+		hello type=shell {}
+	}
+}
+

examples/project_git/scripts/hello.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env zsh
+
+set -e
+
+echo "hello world"

examples/project_git/templates/something.yaml.jinja2

@@ -0,0 +1,3 @@
+something
+
+val is mapping: {{ global.someKey.some.key.val is mapping  }}

examples/workspace/forest.kdl

@@ -0,0 +1,9 @@
+workspace {
+	members {
+		member "projects/a"
+		member "projects/b"
+		member "plan/a"
+		member "plan/b"
+		// member "components/*"
+	}
+}

examples/workspace/plan/a/forest.kdl

@@ -0,0 +1,7 @@
+plan {
+	name a
+
+	scripts {
+		hello_plan type=shell {}
+	}
+}

examples/workspace/plan/a/scripts/hello_plan.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env zsh
+
+set -e
+
+echo "hello from plan"
+
+echo "i am here: $PWD"

examples/workspace/plan/b/forest.kdl

@@ -0,0 +1,3 @@
+plan {
+	name b
+}

examples/workspace/projects/a/forest.kdl

@@ -0,0 +1,11 @@
+project {
+	name a
+
+	plan {
+		workspace a
+	}
+
+	scripts {
+		hello type=shell {}
+	}
+}

examples/workspace/projects/a/scripts/hello.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env zsh
+
+set -e
+
+echo "hello from a"
+
+echo "i am here: $PWD"

examples/workspace/projects/b/forest.kdl

@@ -0,0 +1,7 @@
+project {
+	name b
+
+	scripts {
+		hello type=shell {}
+	}
+}

examples/workspace/projects/b/scripts/hello.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env zsh
+
+set -e
+
+echo "hello from b"

todos/hyperlog/graph.json

@@ -15,19 +15,19 @@
           "type": "item",
           "title": "should be able to download a remote plan",
           "description": "",
-          "state": "not-done"
+          "state": "done"
         },
         "should be able to template from a remote plan": {
           "type": "item",
           "title": "should be able to template from a remote plan",
           "description": "",
-          "state": "not-done"
+          "state": "done"
         },
         "should be able to use scripts from a remote plan": {
           "type": "item",
           "title": "should be able to use scripts from a remote plan",
           "description": "",
-          "state": "not-done"
+          "state": "done"
         }
       }
     }

todos/hyperlog/graph.lock

@@ -1 +0,0 @@
-hyperlog-lock