use std::path::Path;
use crate::Commands;
use clm_rust_core::evaluator;
pub fn run_compose_cli(command: Commands, _clm_root: &str) {
match command {
Commands::ComposeConditions { clm_file, phase, exit_code, json } => {
let clm_root_path = match evaluator::resolve_clm_root() {
Ok(p) => p,
Err(e) => {
if json {
let envelope = serde_json::json!({
"status": "failure",
"error": { "code": "RESOLVE_ROOT_FAILED", "message": e.to_string() }
});
println!("{}", serde_json::to_string_pretty(&envelope).unwrap());
} else {
eprintln!("FATAL: {}", e);
}
std::process::exit(1);
}
};
match evaluator::compose::compose_conditions(&clm_root_path, &clm_file, &phase, exit_code, json) {
Ok(code) => {
if json {
if code == 0 {
let envelope = serde_json::json!({
"status": "success",
"data": {
"verdict": true,
"phase": phase,
"manifest": clm_file,
},
"meta": {
"runtime": "rust",
"version": env!("CARGO_PKG_VERSION"),
}
});
println!("{}", serde_json::to_string_pretty(&envelope).unwrap());
} else {
let envelope = serde_json::json!({
"status": "failure",
"error": { "code": "CONDITION_REJECTED", "message": format!("Phase '{}' conditions rejected", phase) }
});
println!("{}", serde_json::to_string_pretty(&envelope).unwrap());
}
}
std::process::exit(code);
}
Err(e) => {
if json {
let envelope = serde_json::json!({
"status": "failure",
"error": { "code": "COMPOSITION_EXCEPTION", "message": e.to_string() }
});
println!("{}", serde_json::to_string_pretty(&envelope).unwrap());
} else {
eprintln!("FATAL: {}", 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::Substitute { clm_file, new_impl } => {
match clm_rust_core::baldwin::substitute(&clm_file, &new_impl, clm_root) {
Ok(out) => {
stdout.push_str(&out);
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&e);
(1, stdout, stderr)
}
}
}
Commands::Augment { clm_file, aug_source } => {
match clm_rust_core::baldwin::augment(&clm_file, &aug_source, clm_root) {
Ok(out) => {
stdout.push_str(&out);
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&e);
(1, stdout, stderr)
}
}
}
Commands::Hmr { fiber_id, new_clm_file } => {
let ctx = clm_rust_core::fiber::Context::root();
if ctx.get_fiber(&fiber_id).is_none() {
let fib = ctx.create_fiber(&fiber_id, vec![]).unwrap();
let candidate_path = Path::new(clm_root).join(&fiber_id);
let actual_path = if candidate_path.exists() {
candidate_path
} else if Path::new(&fiber_id).exists() {
Path::new(&fiber_id).to_path_buf()
} else {
Path::new(clm_root).join(&new_clm_file)
};
if actual_path.exists()
&& let Ok(content) = std::fs::read_to_string(&actual_path)
&& let Ok(val) = serde_yaml::from_str::<serde_json::Value>(&content)
{
fib.set_ast(val);
}
}
match clm_rust_core::baldwin::substitute_fiber(&ctx, &fiber_id, &new_clm_file, clm_root) {
Ok(report) => {
let json = serde_json::to_string_pretty(&report).unwrap_or_default();
stdout.push_str(&json);
stdout.push('\n');
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[HMR_ERR] Hot Module Replacement failed: {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::SatoriParse { xml, id, channel, user } => {
if let (Some(id), Some(channel), Some(user)) = (id, channel, user) {
match clm_rust_core::satori::parse_satori_message(&id, &channel, &user, &xml) {
Ok(msg) => {
let mcard = msg.to_mcard();
let json = serde_json::to_string_pretty(&mcard).unwrap_or_default();
stdout.push_str(&json);
stdout.push('\n');
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[SATORI_PARSE_ERR] {}\n", e));
(1, stdout, stderr)
}
}
} else {
match clm_rust_core::satori::parse_satori_xml(&xml) {
Ok(elems) => {
let json = serde_json::to_string_pretty(&elems).unwrap_or_default();
stdout.push_str(&json);
stdout.push('\n');
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[SATORI_PARSE_ERR] {}\n", e));
(1, stdout, stderr)
}
}
}
}
Commands::SatoriFormat { json } => {
if let Ok(val) = serde_json::from_str::<serde_json::Value>(&json) {
if let Ok(msg) = clm_rust_core::satori::SatoriMessage::from_mcard(&val) {
let xml = msg.to_xml();
stdout.push_str(&xml);
stdout.push('\n');
return (0, stdout, stderr);
} else if let Some(elems_val) = val.get("elements") {
if let Ok(elems) = serde_json::from_value::<Vec<clm_rust_core::satori::SatoriElement>>(elems_val.clone()) {
let xml = clm_rust_core::satori::serialize_satori_xml(&elems);
stdout.push_str(&xml);
stdout.push('\n');
return (0, stdout, stderr);
}
} else if let Ok(elems) = serde_json::from_value::<Vec<clm_rust_core::satori::SatoriElement>>(val.clone()) {
let xml = clm_rust_core::satori::serialize_satori_xml(&elems);
stdout.push_str(&xml);
stdout.push('\n');
return (0, stdout, stderr);
} else if let Ok(msg) = serde_json::from_value::<clm_rust_core::satori::SatoriMessage>(val) {
let xml = msg.to_xml();
stdout.push_str(&xml);
stdout.push('\n');
return (0, stdout, stderr);
}
}
stderr.push_str("[SATORI_FORMAT_ERR] Invalid JSON for Satori elements or message\n");
(1, stdout, stderr)
}
Commands::SatoriIngest { xml, id, channel, user, db } => {
match clm_rust_core::satori::parse_satori_message(&id, &channel, &user, &xml) {
Ok(msg) => {
let db_path = if Path::new(&db).is_absolute() {
Path::new(&db).to_path_buf()
} else {
Path::new(clm_root).join(&db)
};
match clm_rust_core::satori::ingest_satori_message(&db_path, &msg) {
Ok(hash) => {
let resp = serde_json::json!({
"status": "ingested",
"mcard_uri": format!("mcard:chat/message/{}", id),
"hash": hash,
"channel_id": channel,
"user_did": user
});
stdout.push_str(&serde_json::to_string_pretty(&resp).unwrap_or_default());
stdout.push('\n');
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[SATORI_INGEST_ERR] {}\n", e));
(1, stdout, stderr)
}
}
}
Err(e) => {
stderr.push_str(&format!("[SATORI_INGEST_ERR] Failed to parse message: {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::SatoriPrompt { fiber_id, channel, prompt, reply, timeout_ms } => {
let ctx = clm_rust_core::fiber::Context::root();
let fiber = ctx.get_fiber(&fiber_id).unwrap_or_else(|| {
ctx.create_fiber(&fiber_id, vec![]).unwrap()
});
let continuation = clm_rust_core::satori::DelimitedContinuation::new(
&fiber_id,
&channel,
&prompt,
timeout_ms,
);
if let Some(reply_xml) = reply {
let user_did = "did:key:z6MkuUser";
match clm_rust_core::satori::parse_satori_message("reply_test", &channel, user_did, &reply_xml) {
Ok(user_msg) => {
match clm_rust_core::satori::resume_continuation(&fiber, &continuation, user_msg) {
Ok(receipt) => {
let resp = serde_json::json!({
"status": "resumed",
"fiber_id": fiber_id,
"fiber_state": format!("{:?}", fiber.get_state()),
"maxwell_receipt": receipt
});
stdout.push_str(&serde_json::to_string_pretty(&resp).unwrap_or_default());
stdout.push('\n');
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[SATORI_PROMPT_ERR] Maxwell Demon rejection: {}\n", e));
(1, stdout, stderr)
}
}
}
Err(e) => {
stderr.push_str(&format!("[SATORI_PROMPT_ERR] Invalid reply XML: {}\n", e));
(1, stdout, stderr)
}
}
} else {
match clm_rust_core::satori::timeout_continuation(&fiber) {
Ok(()) => {
let resp = serde_json::json!({
"status": "timed_out",
"fiber_id": fiber_id,
"fiber_state": format!("{:?}", fiber.get_state()),
"unwound": true
});
stdout.push_str(&serde_json::to_string_pretty(&resp).unwrap_or_default());
stdout.push('\n');
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[SATORI_PROMPT_ERR] Timeout failure: {}\n", e));
(1, stdout, stderr)
}
}
}
}
Commands::Split { clm_file } => {
match clm_rust_core::baldwin::split(&clm_file, clm_root) {
Ok(res) => {
stdout.push_str(&res);
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&e);
stderr.push('\n');
(1, stdout, stderr)
}
}
}
Commands::Merge { a_file, c_file, b_file } => {
match clm_rust_core::baldwin::merge(&a_file, &c_file, b_file.as_deref()) {
Ok(res) => {
stdout.push_str(&res);
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&e);
stderr.push('\n');
(1, stdout, stderr)
}
}
}
Commands::Tool { cmd } => {
match clm_rust_core::evaluator::cli::run_tool_dispatcher(cmd, clm_root) {
Ok(out) => {
stdout.push_str(&out);
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&e);
stderr.push('\n');
(1, stdout, stderr)
}
}
}
Commands::Evolve { cmd } => {
match clm_rust_core::evaluator::cli::run_evolve_dispatcher(cmd, clm_root) {
Ok(out) => {
stdout.push_str(&out);
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&e);
(1, stdout, stderr)
}
}
}
Commands::NormalizeSyntax { target_file } => {
match clm_rust_core::normalizer::normalize_syntax(&target_file, clm_root) {
Ok(path) => {
stdout.push_str(&path);
stdout.push('\n');
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&e);
stderr.push('\n');
(1, stdout, stderr)
}
}
}
Commands::FileToMcard { source_file, output_dir } => {
match clm_rust_core::mcard_encoder::file_to_mcard(&source_file, &output_dir, clm_root) {
Ok(path) => {
stdout.push_str(&path);
stdout.push('\n');
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&e);
stderr.push('\n');
(1, stdout, stderr)
}
}
}
Commands::ComposeConditions { clm_file, phase, exit_code, json } => {
let clm_root_path = match evaluator::resolve_clm_root() {
Ok(p) => p,
Err(e) => {
if json {
let envelope = serde_json::json!({
"status": "failure",
"error": { "code": "RESOLVE_ROOT_FAILED", "message": e.to_string() }
});
return (1, serde_json::to_string_pretty(&envelope).unwrap(), String::new());
} else {
return (1, stdout, format!("FATAL: {}", e));
}
}
};
match evaluator::compose::compose_conditions(&clm_root_path, &clm_file, &phase, exit_code, json) {
Ok(code) => {
if json {
if code == 0 {
let envelope = serde_json::json!({
"status": "success",
"data": {
"verdict": true,
"phase": phase,
"manifest": clm_file,
},
"meta": {
"runtime": "rust",
"version": env!("CARGO_PKG_VERSION"),
}
});
stdout.push_str(&serde_json::to_string_pretty(&envelope).unwrap());
stdout.push('\n');
} else {
let envelope = serde_json::json!({
"status": "failure",
"error": { "code": "CONDITION_REJECTED", "message": format!("Phase '{}' conditions rejected", phase) }
});
stdout.push_str(&serde_json::to_string_pretty(&envelope).unwrap());
stdout.push('\n');
}
}
(code, stdout, stderr)
}
Err(e) => {
if json {
let envelope = serde_json::json!({
"status": "failure",
"error": { "code": "COMPOSITION_EXCEPTION", "message": e.to_string() }
});
(1, serde_json::to_string_pretty(&envelope).unwrap(), String::new())
} else {
(1, stdout, format!("FATAL: {}", e))
}
}
}
}
_ => (0, String::new(), String::new()),
}
}