use std::collections::{BTreeSet, HashMap};
use crate::workflow::ast::{AccessKey, Expr, Workflow};
pub fn mermaid(workflow: &Workflow) -> String {
let mut nodes = String::new();
let mut edges = String::new();
let mut defs: HashMap<String, String> = HashMap::new();
let mut counter = 0usize;
for input in &workflow.inputs {
let id = format!("n{counter}");
counter += 1;
nodes.push_str(&format!(" {id}{}\n", shape(Kind::Input, &input.name)));
defs.insert(input.name.clone(), id);
}
for stmt in &workflow.statements {
let id = format!("n{counter}");
counter += 1;
let mut vars = BTreeSet::new();
free_vars(&stmt.expr, &mut vars);
for v in &vars {
if let Some(src) = defs.get(v) {
edges.push_str(&format!(" {src} --{v}--> {id}\n"));
}
}
let label = node_label(&stmt.name, &stmt.expr);
nodes.push_str(&format!(" {id}{}\n", shape(kind(&stmt.expr), &label)));
defs.insert(stmt.name.clone(), id);
}
let mut out = String::from("flowchart TD\n");
out.push_str(&nodes);
out.push_str(&edges);
out
}
fn free_vars(expr: &Expr, out: &mut BTreeSet<String>) {
match expr {
Expr::Str(_) | Expr::Num(_) | Expr::Bool(_) => {}
Expr::Var(name) => {
out.insert(name.clone());
}
Expr::Object(fields) => {
for (_, e) in fields {
free_vars(e, out);
}
}
Expr::Not(inner) => free_vars(inner, out),
Expr::BinOp { lhs, rhs, .. } => {
free_vars(lhs, out);
free_vars(rhs, out);
}
Expr::Access { base, keys } => {
free_vars(base, out);
for key in keys {
if let AccessKey::Computed(e) = key {
free_vars(e, out);
}
}
}
Expr::If { branches, default } => {
for (cond, result) in branches {
free_vars(cond, out);
free_vars(result, out);
}
free_vars(default, out);
}
Expr::For { item, array, body } => {
free_vars(array, out);
let mut inner = BTreeSet::new();
free_vars(body, &mut inner);
inner.remove(item);
out.extend(inner);
}
Expr::Do {
var,
body,
cond,
max,
} => {
free_vars(body, out);
free_vars(max, out);
let mut inner = BTreeSet::new();
free_vars(cond, &mut inner);
inner.remove(var);
out.extend(inner);
}
Expr::RunTool {
args,
recover,
recover_default,
..
} => {
for (_, e) in args {
free_vars(e, out);
}
for (_, e) in recover {
free_vars(e, out);
}
if let Some(e) = recover_default {
free_vars(e, out);
}
}
Expr::RunWorkflow { args, .. } => {
for (_, e) in args {
free_vars(e, out);
}
}
Expr::RunSpecialist { prompt, .. } => free_vars(prompt, out),
Expr::Ask { prompt, fallback } => {
free_vars(prompt, out);
if let Some(fallback) = fallback {
free_vars(fallback, out);
}
}
}
}
fn node_label(name: &str, expr: &Expr) -> String {
match expr {
Expr::RunTool { tool, .. } => tool.clone(),
Expr::RunSpecialist { specialist, .. } => specialist.clone(),
Expr::RunWorkflow { workflow, .. } => workflow.clone(),
_ => name.to_string(),
}
}
enum Kind {
Input,
Tool,
Specialist,
Workflow,
Pure,
}
fn kind(expr: &Expr) -> Kind {
match expr {
Expr::RunTool { .. } => Kind::Tool,
Expr::RunSpecialist { .. } => Kind::Specialist,
Expr::RunWorkflow { .. } => Kind::Workflow,
_ => Kind::Pure,
}
}
fn shape(kind: Kind, label: &str) -> String {
let l = escape(label);
match kind {
Kind::Input => format!("[/\"{l}\"/]"),
Kind::Tool => format!("[\"{l}\"]"),
Kind::Specialist => format!("([\"{l}\"])"),
Kind::Workflow => format!("[[\"{l}\"]]"),
Kind::Pure => format!("(\"{l}\")"),
}
}
fn escape(s: &str) -> String {
s.replace('"', """).replace('\n', " ")
}
#[cfg(test)]
#[path = "render_tests.rs"]
mod tests;