clm-kernel 0.0.1

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
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 } => {
            let clm_root_path = match evaluator::resolve_clm_root() {
                Ok(p) => p,
                Err(e) => {
                    eprintln!("FATAL: {}", e);
                    std::process::exit(1);
                }
            };
            match evaluator::compose::compose_conditions(&clm_root_path, &clm_file, &phase, exit_code, false) {
                Ok(code) => std::process::exit(code),
                Err(e) => {
                    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 } => {
            let clm_root_path = match evaluator::resolve_clm_root() {
                Ok(p) => p,
                Err(e) => return (1, stdout, format!("FATAL: {}", e)),
            };
            match evaluator::compose::compose_conditions(&clm_root_path, &clm_file, &phase, exit_code, false) {
                Ok(code) => (code, stdout, stderr),
                Err(e) => (1, stdout, format!("FATAL: {}", e)),
            }
        }
        _ => (0, String::new(), String::new()),
    }
}