use crate::Commands;
use clm_rust_core::evaluator;
use super::helpers::resolve_json_ast;
pub fn run_evaluate_cli(command: Commands, _clm_root: &str) {
match command {
Commands::Evaluate { clm_file, payload, post_rc, quiet, instance_id, batch, batch_parallel, json } => {
let clm_root_path = match evaluator::resolve_clm_root() {
Ok(p) => p,
Err(e) => {
eprintln!("FATAL: {}", e);
std::process::exit(1);
}
};
if !batch.is_empty() {
let n = if batch_parallel == 0 { 1 } else { batch_parallel };
match evaluator::run_batch_evaluation_parallel(&clm_root_path, &batch, quiet, n) {
Ok(exit_code) => {
std::process::exit(exit_code);
}
Err(e) => {
eprintln!("{}", e);
std::process::exit(1);
}
}
}
if let Some(ref path_str) = clm_file {
let resolved_path = clm_root_path.join(path_str);
let actual_path = if resolved_path.exists() {
resolved_path
} else {
std::path::PathBuf::from(path_str)
};
if let Ok(content) = std::fs::read_to_string(&actual_path)
&& (content.contains("petri_net:") || content.contains("petriNet:")) {
let (exit_code, out_str, err_str) = run_logic(
Commands::PetriRunNet { topo_file: path_str.clone(), json },
&clm_root_path.to_string_lossy(),
);
if !out_str.is_empty() {
println!("{}", out_str);
}
if !err_str.is_empty() {
eprintln!("{}", err_str);
}
std::process::exit(exit_code);
}
}
match evaluator::run_evaluation(
&clm_root_path,
clm_file.as_deref(),
payload.as_deref(),
post_rc,
quiet || json,
instance_id.as_deref(),
) {
Ok(exit_code) => {
if json {
let status = if exit_code == 0 { "success" } else { "failure" };
let envelope = serde_json::json!({
"status": status,
"data": {
"manifest": clm_file.unwrap_or_default(),
"exit_code": exit_code
}
});
println!("{}", envelope);
}
std::process::exit(exit_code);
}
Err(e) => {
if json {
let envelope = serde_json::json!({
"status": "failure",
"error": e
});
println!("{}", envelope);
} else {
eprintln!("{}", e);
}
std::process::exit(1);
}
}
}
Commands::DispatchRuntime { runtime, script } => {
let dispatcher = clm_rust_core::runtime_adapter::RuntimeDispatcher::with_defaults();
let input = serde_json::Value::Null;
match dispatcher.dispatch(&runtime, &script, &input) {
Ok(result) => {
println!("{}", result);
std::process::exit(0);
}
Err(e) => {
eprintln!("[dispatch-runtime] error: {}", e);
std::process::exit(1);
}
}
}
_ => std::process::exit(0),
}
}
pub fn run_logic(command: Commands, clm_root: &str) -> (i32, String, String) {
let mut stdout = String::new();
let mut stderr = String::new();
match command {
Commands::ProveTests { b_file } => {
match clm_rust_core::prove::prove_tests(&b_file, clm_root) {
Ok(out) => {
stdout.push_str(&out);
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&e);
(1, stdout, stderr)
}
}
}
Commands::Compile { a_mcard_path, target, output_dir } => {
match clm_rust_core::compile::compile_a_mcard(&a_mcard_path, &target, output_dir.as_deref(), clm_root) {
Ok(out) => {
stdout.push_str(&out);
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&e);
(1, stdout, stderr)
}
}
}
Commands::UpgradeEvaluator { candidate_yaml } => {
match clm_rust_core::compile::run_self_evolution(clm_root, &candidate_yaml) {
Ok(out) => {
stdout.push_str(&out);
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&e);
(1, stdout, stderr)
}
}
}
Commands::RunTest { test_name } => {
if test_name == "integration_past_execution" {
match clm_rust_core::integration::run_integration_past_execution() {
Ok(out) => {
stdout.push_str(&out);
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&e);
(1, stdout, stderr)
}
}
} else {
stderr.push_str(&format!("Unknown test: {}", test_name));
(1, stdout, stderr)
}
}
Commands::PetriRunNet { topo_file, json } => {
match clm_rust_core::runtime_dispatch::petri_run_net(&topo_file, clm_root) {
Ok(out) => {
if json {
let mut fire_count: i64 = 0;
let mut final_marking: serde_json::Map<String, serde_json::Value> = serde_json::Map::new();
for line in out.lines() {
if let Some(pos) = line.find("marking[")
&& let Some(end_pos) = line[pos..].find(']') {
let place_id = &line[pos + 8..pos + end_pos];
if let Some(colon_pos) = line[pos + end_pos..].find(':') {
let rest = line[pos + end_pos + colon_pos + 1..].trim();
let num_str = rest.split_whitespace().next().unwrap_or("0");
if let Ok(num) = num_str.parse::<i64>() {
final_marking.insert(place_id.to_string(), serde_json::Value::Number(num.into()));
}
}
}
if let Some(firings_pos) = line.find(" firings)")
&& let Some(start_paren) = line[..firings_pos].rfind('(') {
let num_str = line[start_paren + 1..firings_pos].trim();
if let Ok(num) = num_str.parse::<i64>() {
fire_count = num;
}
}
}
if let Some(pos) = out.find("[FINAL_MARKING] ")
&& let Some(line) = out[pos + 16..].lines().next()
&& let Ok(serde_json::Value::Object(map)) = serde_json::from_str(line.trim()) {
final_marking = map;
}
let topo_name = {
let mut name = std::path::Path::new(&topo_file)
.file_stem()
.and_then(|s| s.to_str())
.unwrap_or("")
.to_string();
let file_path = std::path::Path::new(clm_root).join(&topo_file);
let actual_path = if file_path.exists() { file_path } else { std::path::PathBuf::from(&topo_file) };
if let Ok(content) = std::fs::read_to_string(&actual_path) {
if let Ok(val) = serde_yaml::from_str::<serde_json::Value>(&content) {
if let Some(n) = val.get("petri_net").and_then(|pn| pn.get("name")).and_then(|n| n.as_str()) {
name = n.to_string();
}
}
}
name
};
let envelope = serde_json::json!({
"status": "success",
"data": {
"topology": topo_name,
"fireCount": fire_count,
"finalMarking": final_marking,
},
"meta": {
"runtime": "rust",
"version": env!("CARGO_PKG_VERSION")
}
});
stdout.push_str(&envelope.to_string());
} else {
stdout.push_str(&out);
}
(0, stdout, stderr)
}
Err(e) => {
if json {
let envelope = serde_json::json!({
"status": "failure",
"error": e
});
stdout.push_str(&envelope.to_string());
} else {
stderr.push_str(&e);
}
(1, stdout, stderr)
}
}
}
Commands::ComposeNets {
net_path,
output_path,
telemetry_path,
db_path,
} => {
match clm_rust_core::cpn::compiler::compose_nets(&net_path, &output_path, &telemetry_path, &db_path, clm_root) {
Ok(out) => {
stdout.push_str(&out);
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("{}\n", e));
(1, stdout, stderr)
}
}
}
Commands::Classify { json_or_file } => {
let json_str = resolve_json_ast(&json_or_file);
if let Ok(json_val) = serde_json::from_str(&json_str) {
let classification = clm_rust_core::classifier::classify(&json_val);
stdout.push_str(&classification);
stdout.push('\n');
(0, stdout, stderr)
} else {
stdout.push_str("Number\n");
(0, stdout, stderr)
}
}
Commands::DetectDialect { json_or_file, classification } => {
let json_str = resolve_json_ast(&json_or_file);
if let Ok(json_val) = serde_json::from_str(&json_str) {
let dialect = clm_rust_core::classifier::detect_dialect(&json_val, &classification);
stdout.push_str(&dialect);
stdout.push('\n');
(0, stdout, stderr)
} else {
stdout.push_str("UNKNOWN\n");
(0, stdout, stderr)
}
}
Commands::AssessEquivalence { spec_file } => {
match clm_rust_core::invariants::assess_equivalence(clm_root, &spec_file) {
Ok((exit_code, out)) => {
stdout.push_str(&out);
(exit_code, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[ASSESS_EQUIV] ❌ Error: {}\n", e));
(1, stdout, stderr)
}
}
}
_ => (0, String::new(), String::new()),
}
}