pub mod ast;
pub mod check;
mod collector;
pub mod eval;
pub mod parse;
pub mod render;
use std::collections::{BTreeSet, HashMap};
use std::path::Path;
use crate::domain::Registry;
use crate::types::{Param, Type};
pub use ast::{AccessKey, BinOp, Expr, Statement, Workflow};
pub use check::{check, specialist_return_type, TypeEnv, TypeError};
pub use eval::{eval, AskHandler, AskOutcome, WorkflowError};
pub use parse::{parse, ParseError};
pub use render::mermaid;
pub fn source(dir: &Path, name: &str) -> Result<String, String> {
let matches = crate::store::entries_with_stem(dir, name)
.map_err(|e| format!("can't read workflows dir {}: {e}", dir.display()))?;
match matches.len() {
0 => Err(format!("unknown workflow: {name}")),
1 => {
let path = &matches[0];
std::fs::read_to_string(path)
.map_err(|e| format!("workflow '{name}' at {} can't be read: {e}", path.display()))
}
n => Err(format!(
"workflow '{name}' is ambiguous: {n} files in {} share that name; keep one",
dir.display()
)),
}
}
pub fn resolve_inputs(
inputs: &[Param],
provided: &HashMap<String, String>,
) -> Result<HashMap<String, serde_json::Value>, String> {
for key in provided.keys() {
if !inputs.iter().any(|p| &p.name == key) {
return Err(format!("workflow has no input `{key}`"));
}
}
let mut resolved = HashMap::new();
for param in inputs {
let raw = provided.get(¶m.name).ok_or_else(|| {
format!(
"missing required input `{0}`; supply it with --arg {0}=<value>",
param.name
)
})?;
let value =
coerce_input(raw, ¶m.ty).map_err(|e| format!("input `{}`: {e}", param.name))?;
resolved.insert(param.name.clone(), value);
}
Ok(resolved)
}
fn coerce_input(raw: &str, ty: &Type) -> Result<serde_json::Value, String> {
match ty {
Type::String => Ok(serde_json::Value::String(raw.to_string())),
Type::Number => raw
.trim()
.parse::<f64>()
.map(|n| serde_json::json!(n))
.map_err(|_| format!("expected a number, got `{raw}`")),
Type::Bool => match raw.trim() {
"true" => Ok(serde_json::Value::Bool(true)),
"false" => Ok(serde_json::Value::Bool(false)),
_ => Err(format!("expected `true` or `false`, got `{raw}`")),
},
Type::Array(_) => {
let value: serde_json::Value =
serde_json::from_str(raw).map_err(|e| format!("expected JSON array: {e}"))?;
if value.is_array() {
Ok(value)
} else {
Err(format!("expected a JSON array, got `{raw}`"))
}
}
Type::Object(_) => {
let value: serde_json::Value =
serde_json::from_str(raw).map_err(|e| format!("expected JSON object: {e}"))?;
if value.is_object() {
Ok(value)
} else {
Err(format!("expected a JSON object, got `{raw}`"))
}
}
}
}
#[derive(Debug, Default, PartialEq, Eq)]
pub struct Referenced {
pub tools: BTreeSet<String>,
pub specialists: BTreeSet<String>,
pub workflows: BTreeSet<String>,
}
pub fn referenced(workflow: &Workflow, registry: &Registry) -> Referenced {
let mut refs = Referenced::default();
for stmt in &workflow.statements {
collect(&stmt.expr, registry, &mut refs);
}
refs
}
fn collect(expr: &Expr, registry: &Registry, refs: &mut Referenced) {
match expr {
Expr::Str(_) | Expr::Num(_) | Expr::Bool(_) | Expr::Var(_) => {}
Expr::Object(fields) => {
for (_, e) in fields {
collect(e, registry, refs);
}
}
Expr::Not(inner) => collect(inner, registry, refs),
Expr::BinOp { lhs, rhs, .. } => {
collect(lhs, registry, refs);
collect(rhs, registry, refs);
}
Expr::Access { base, keys } => {
collect(base, registry, refs);
for key in keys {
if let AccessKey::Computed(e) = key {
collect(e, registry, refs);
}
}
}
Expr::If { branches, default } => {
for (cond, result) in branches {
collect(cond, registry, refs);
collect(result, registry, refs);
}
collect(default, registry, refs);
}
Expr::For { array, body, .. } => {
collect(array, registry, refs);
collect(body, registry, refs);
}
Expr::Do {
body, cond, max, ..
} => {
collect(body, registry, refs);
collect(cond, registry, refs);
collect(max, registry, refs);
}
Expr::RunTool {
tool,
args,
recover,
recover_default,
} => {
refs.tools.insert(tool.clone());
for (_, e) in args {
collect(e, registry, refs);
}
for (_, e) in recover {
collect(e, registry, refs);
}
if let Some(e) = recover_default {
collect(e, registry, refs);
}
}
Expr::RunWorkflow { workflow, args } => {
refs.workflows.insert(workflow.clone());
for (_, e) in args {
collect(e, registry, refs);
}
}
Expr::RunSpecialist { specialist, prompt } => {
refs.specialists.insert(specialist.clone());
if let Some(spec) = registry.specialists.get(specialist) {
for tool in spec.tool_names() {
refs.tools.insert(tool.clone());
}
}
collect(prompt, registry, refs);
}
Expr::Ask { prompt, fallback } => {
collect(prompt, registry, refs);
if let Some(fallback) = fallback {
collect(fallback, registry, refs);
}
}
}
}
#[cfg(test)]
#[path = "mod_tests.rs"]
mod tests;