clm-kernel 0.0.2

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
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:")) {
                        match clm_rust_core::runtime_dispatch::petri_run_net(path_str, &clm_root_path.to_string_lossy()) {
                            Ok(out) => {
                                if json {
                                    let envelope = serde_json::json!({
                                        "status": "success",
                                        "data": {
                                            "manifest": path_str,
                                            "result": "certified",
                                            "output": out
                                        },
                                        "meta": {
                                            "runtime": "rust",
                                            "version": "0.4.0"
                                        }
                                    });
                                    println!("{}", envelope);
                                } else {
                                    print!("{}", out);
                                }
                                std::process::exit(0);
                            }
                            Err(e) => {
                                if json {
                                    let envelope = serde_json::json!({
                                        "status": "failure",
                                        "error": e
                                    });
                                    println!("{}", envelope);
                                } else {
                                    eprintln!("{}", e);
                                }
                                std::process::exit(1);
                            }
                        }
                    }
            }
            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 envelope = serde_json::json!({
                            "status": "success",
                            "data": {
                                "topology": std::path::Path::new(&topo_file).file_stem().and_then(|s| s.to_str()).unwrap_or(""),
                                "fireCount": fire_count,
                                "finalMarking": final_marking,
                                "output": out,
                                "manifest": topo_file
                            },
                            "meta": {
                                "runtime": "rust",
                                "version": "0.4.0"
                            }
                        });
                        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()),
    }
}