use std::env;
use std::fs;
use std::io::{BufRead, BufReader, Write};
use std::path::{Path, PathBuf};
use std::process::{Child, Command, Stdio};
pub mod cli;
pub mod dispatch;
pub mod compose;
pub mod verify;
pub(crate) use dispatch::{get_internal_registry, try_internal_dispatch};
pub use crate::db::{thread_local_depth_get, thread_local_depth_increment, thread_local_depth_decrement};
fn copy_directory_recursive(src: &Path, dst: &Path) -> std::io::Result<()> {
fs::create_dir_all(dst)?;
for entry in fs::read_dir(src)? {
let entry = entry?;
let source = entry.path();
let target = dst.join(entry.file_name());
if source.is_dir() {
copy_directory_recursive(&source, &target)?;
} else {
fs::copy(source, target)?;
}
}
Ok(())
}
#[cfg(unix)]
fn create_symlink(src: &Path, dst: &Path) -> std::io::Result<()> {
std::os::unix::fs::symlink(src, dst)
}
#[cfg(windows)]
fn create_symlink(src: &Path, dst: &Path) -> std::io::Result<()> {
if src.is_dir() {
std::os::windows::fs::symlink_dir(src, dst)
} else {
std::os::windows::fs::symlink_file(src, dst)
}
}
pub fn resolve_clm_root() -> Result<PathBuf, String> {
if let Ok(val) = env::var("CLM_ROOT") {
let path = crate::fs_utils::normalize_windows_path(Path::new(&val));
if path.is_absolute() {
return Ok(path);
} else if let Ok(curr) = env::current_dir() {
return Ok(curr.join(path));
} else {
return Ok(path);
}
}
let mut dir = env::current_dir().map_err(|e| format!("Failed to get current dir: {}", e))?;
loop {
if dir.join("computable_knowledge/Concrete/layer5_system/bootstrap/evaluator").is_dir()
|| dir.join("computable_knowledge/Abstract/layer5_system/bootstrap/evaluator").is_dir() {
return Ok(dir);
}
if dir.join("clm/computable_knowledge/Concrete/layer5_system/bootstrap/evaluator").is_dir()
|| dir.join("clm/computable_knowledge/Abstract/layer5_system/bootstrap/evaluator").is_dir() {
return Ok(dir.join("clm"));
}
if let Some(parent) = dir.parent() {
dir = parent.to_path_buf();
} else {
break;
}
}
Err("Cannot resolve CLM_ROOT. Please set CLM_ROOT environment variable.".to_string())
}
pub fn run_batch_evaluation(
clm_root: &Path,
files: &[String],
quiet: bool,
) -> Result<i32, String> {
run_batch_evaluation_impl(clm_root, files, quiet, 1)
}
pub fn run_batch_evaluation_parallel(
clm_root: &Path,
files: &[String],
quiet: bool,
threads: usize,
) -> Result<i32, String> {
run_batch_evaluation_impl(clm_root, files, quiet, threads)
}
fn run_batch_evaluation_impl(
clm_root: &Path,
files: &[String],
quiet: bool,
threads: usize,
) -> Result<i32, String> {
use std::time::Instant;
use std::thread;
#[cfg(windows)]
let threads = 1;
if let Ok(mut lock) = crate::cpn::vm::EVAL_CALLBACK.write() {
*lock = Some(run_evaluation);
}
verify::verify_integrity(clm_root)?;
cli::compile_evaluator_cache(clm_root, quiet)?;
if threads <= 1 {
let mut passed = 0usize;
let mut failed = 0usize;
let mut first_failure_code = 1;
for file in files {
let start = Instant::now();
let file_name = file.rsplit('/').next().unwrap_or(file);
match dispatch::try_internal_dispatch(clm_root, file, None, None, quiet) {
Ok(exit_code) => {
let elapsed = start.elapsed();
if exit_code == 0 {
if !quiet {
eprintln!("[BATCH] ✅ PASS {} ({:.0}ms)", file_name, elapsed.as_millis());
}
passed += 1;
} else {
if !quiet {
eprintln!("[BATCH] ❌ FAIL {} rc={} ({:.0}ms)", file_name, exit_code, elapsed.as_millis());
}
failed += 1;
if first_failure_code == 1 {
first_failure_code = exit_code;
}
}
}
Err(_) => {
crate::utils::set_env_var("CLM_NESTED_EXEC", "1");
match run_evaluation(clm_root, Some(file), None, None, quiet, None) {
Ok(exit_code) => {
let elapsed = start.elapsed();
if exit_code == 0 {
if !quiet {
eprintln!("[BATCH] ✅ PASS {} ({:.0}ms, fallback)", file_name, elapsed.as_millis());
}
passed += 1;
} else {
if !quiet {
eprintln!("[BATCH] ❌ FAIL {} rc={} ({:.0}ms, fallback)", file_name, exit_code, elapsed.as_millis());
}
failed += 1;
if first_failure_code == 1 {
first_failure_code = exit_code;
}
}
}
Err(e) => {
let elapsed = start.elapsed();
if !quiet {
eprintln!("[BATCH] ❌ ERROR {} {} ({:.0}ms, fallback)", file_name, e, elapsed.as_millis());
}
failed += 1;
}
}
crate::utils::set_env_var("CLM_NESTED_EXEC", "");
}
}
}
let total = passed + failed;
eprintln!("[BATCH] Done: {} passed, {} failed (of {})", passed, failed, total);
if failed > 0 {
Ok(first_failure_code)
} else {
Ok(0)
}
} else {
let clm_root = clm_root.to_path_buf();
let self_exe = env::current_exe().unwrap_or_else(|_| std::path::PathBuf::from("clmEval-rs"));
let pid = std::process::id();
let chunk_size = files.len().div_ceil(threads);
let mut handles = Vec::new();
for (idx, chunk) in files.chunks(chunk_size).enumerate() {
let chunk = chunk.to_vec();
let clm_root = clm_root.clone();
let self_exe = self_exe.clone();
let handle = thread::spawn(move || {
let snap_dir = format!("/tmp/clm_batch_proc_{}_{}", pid, idx);
let _ = fs::remove_dir_all(&snap_dir);
let _ = fs::create_dir_all(&snap_dir);
if let Ok(entries) = fs::read_dir(&clm_root) {
for entry in entries.flatten() {
let name = entry.file_name();
let name_str = name.to_string_lossy();
if name_str == "db" {
let src_db = clm_root.join("db");
let dst_db = format!("{}/db", snap_dir);
let _ = fs::create_dir_all(&dst_db);
if let Ok(db_entries) = fs::read_dir(&src_db) {
for db_entry in db_entries.flatten() {
let _ = fs::copy(
db_entry.path(),
format!("{}/{}", dst_db, db_entry.file_name().to_string_lossy()),
);
}
}
} else if name_str == "data" {
let src_data = clm_root.join("data");
let dst_data = format!("{}/data", snap_dir);
let _ = fs::create_dir_all(&dst_data);
if let Ok(data_entries) = fs::read_dir(&src_data) {
for data_entry in data_entries.flatten() {
let dname = data_entry.file_name();
let dname_str = dname.to_string_lossy();
let is_writable = dname_str == "execution_logs"
|| dname_str == "execution_data"
|| dname_str == "ipc"
|| dname_str == "logs"
|| dname_str == "content_memory"
|| dname_str == "agent_identity";
if is_writable {
let dst_sub = format!("{}/{}", dst_data, dname_str);
let _ = fs::create_dir_all(&dst_sub);
if dname_str == "execution_data" {
let _ = fs::create_dir_all(format!("{}/logs/.tmp", dst_sub));
} else if dname_str == "ipc" {
let _ = copy_directory_recursive(&data_entry.path(), &PathBuf::from(&dst_sub));
}
} else {
let _ = create_symlink(
&data_entry.path(),
&PathBuf::from(format!("{}/{}", dst_data, dname_str)),
);
}
}
}
} else if name_str == "types" {
let src_types = clm_root.join("types");
let dst_types = PathBuf::from(&snap_dir).join("types");
let _ = copy_directory_recursive(&src_types, &dst_types);
} else {
let _ = create_symlink(
&entry.path(),
&PathBuf::from(format!("{}/{}", snap_dir, name_str)),
);
}
}
}
let snap_path = PathBuf::from(&snap_dir);
let mut cmd = Command::new(&self_exe);
cmd.current_dir(&snap_path);
cmd.arg("evaluate").arg("--batch");
for f in &chunk {
cmd.arg(f);
}
if quiet { cmd.arg("--quiet"); }
cmd.env("CLM_CACHE_FRESH", "1");
cmd.env("CLM_ROOT", &snap_dir);
cmd.env("CLM_NESTED_EXEC", "");
if let Ok(v) = env::var("CLM_PETRI_KENOTIC") { cmd.env("CLM_PETRI_KENOTIC", v); }
let log_path = format!("{}/chunk_output.log", snap_dir);
let log_file = fs::File::create(&log_path).ok();
if let Some(ref f) = log_file {
cmd.stderr(f.try_clone().unwrap_or_else(|_| f.try_clone().unwrap()));
} else {
cmd.stderr(Stdio::inherit());
}
cmd.stdout(Stdio::inherit());
let start = Instant::now();
let status = cmd.status();
let elapsed = start.elapsed();
let exit_code = status.map(|s| s.code().unwrap_or(1)).unwrap_or(1);
(idx, exit_code, elapsed.as_millis(), snap_dir)
});
handles.push(handle);
}
let mut passed = 0usize;
let mut failed = 0usize;
let mut first_failure_code = 1;
for handle in handles {
match handle.join() {
Ok((idx, exit_code, elapsed_ms, snap_dir)) => {
let log_path = format!("{}/chunk_output.log", snap_dir);
if let Ok(log_content) = fs::read_to_string(&log_path) {
for line in log_content.lines() {
if line.starts_with("[BATCH]") {
if !quiet {
eprintln!("{}", line);
}
if line.contains("✅ PASS") {
passed += 1;
} else if line.contains("❌ FAIL") {
failed += 1;
if first_failure_code == 1 {
first_failure_code = exit_code;
}
}
}
}
} else if !quiet {
eprintln!("[BATCH] ❌ Chunk {} — no output log", idx);
}
if !quiet {
eprintln!("[BATCH] Chunk {} finished rc={} ({:.0}ms)", idx, exit_code, elapsed_ms);
}
let _ = fs::remove_dir_all(&snap_dir);
}
Err(_) => {
if !quiet {
eprintln!("[BATCH] ❌ Chunk thread panicked");
}
failed += 1;
}
}
}
eprintln!("[BATCH] Done: {} passed, {} failed ({} processes)", passed, failed, threads);
if failed > 0 {
Ok(first_failure_code)
} else {
Ok(0)
}
}
}
pub fn run_evaluation(
clm_root: &Path,
clm_file: Option<&str>,
payload: Option<&str>,
post_rc: Option<i32>,
quiet: bool,
instance_id: Option<&str>,
) -> Result<i32, String> {
if let Ok(mut lock) = crate::cpn::vm::EVAL_CALLBACK.write() {
*lock = Some(run_evaluation);
}
let current_depth = thread_local_depth_get();
if current_depth > 3 {
return Err(format!("Maximum evaluation nesting depth of 3 exceeded (current depth: {})", current_depth));
}
if current_depth > 0 {
crate::utils::set_env_var("CLM_NESTED_EXEC", "1");
}
verify::verify_integrity(clm_root)?;
cli::compile_evaluator_cache(clm_root, quiet)?;
let shell_script_raw = cli::extract_bootstrap_script(clm_root)?;
let shell_script = shell_script_raw.replace("\r", "");
let mut remaining_args = Vec::new();
if let Some(file) = clm_file {
remaining_args.push(file.to_string());
}
if let Some(pay) = payload {
remaining_args.push(pay.to_string());
}
if let Some(rc) = post_rc {
remaining_args.push(rc.to_string());
}
if let Some(file) = clm_file
&& let Ok(exit_code) = dispatch::try_internal_dispatch(clm_root, file, payload, post_rc, quiet) {
return Ok(exit_code);
}
let mut daemon_child: Option<Child> = None;
let mut rust_port_file = None;
let mut daemon_port = None;
if env::var("CLM_RUNTIME_BACKEND").as_deref() == Ok("rust")
&& env::var("CLM_NESTED_EXEC").as_deref() != Ok("1")
&& env::var("CLM_RUST_DAEMON_PORT").is_err()
{
if !quiet {
eprintln!("[clmEval-rs] Waking up Swappable Parity Engine (Rust Core)...");
}
let mut self_exe = env::current_exe().map_err(|e| format!("Failed to get current exe: {}", e))?;
if self_exe.to_string_lossy().contains("deps") {
let alt_exe = clm_root.join({
#[cfg(windows)] { "kernel/clm_rust_core/target/debug/clm_rust_core.exe" }
#[cfg(not(windows))] { "kernel/clm_rust_core/target/debug/clm_rust_core" }
});
if alt_exe.exists() {
self_exe = alt_exe;
} else {
let alt_exe_release = clm_root.join({
#[cfg(windows)] { "kernel/clm_rust_core/target/release/clm_rust_core.exe" }
#[cfg(not(windows))] { "kernel/clm_rust_core/target/release/clm_rust_core" }
});
if alt_exe_release.exists() {
self_exe = alt_exe_release;
}
}
}
let pid = std::process::id();
let unique_id = if let Some(id) = instance_id {
format!("{}_{}", pid, id)
} else {
use std::sync::atomic::{AtomicUsize, Ordering};
static COUNTER: AtomicUsize = AtomicUsize::new(0);
let count = COUNTER.fetch_add(1, Ordering::SeqCst);
format!("{}_{}", pid, count)
};
let port_file_path = clm_root.join(format!("data/ipc/rust_daemon.port.{}", unique_id));
if port_file_path.exists() {
let _ = fs::remove_file(&port_file_path);
}
let _ = fs::create_dir_all(clm_root.join("data/ipc"));
let log_file_path = clm_root.join(format!("data/ipc/rust_daemon.log.{}", unique_id));
let log_file = fs::File::create(&log_file_path)
.map_err(|e| format!("Failed to create daemon log file: {}", e))?;
let mut daemon_cmd = Command::new(self_exe);
daemon_cmd.current_dir(clm_root);
daemon_cmd.arg("daemon")
.arg("--port")
.arg("0")
.env("CLM_RUST_PORT_FILE", &port_file_path)
.stdout(Stdio::from(log_file.try_clone().unwrap()))
.stderr(Stdio::from(log_file));
daemon_cmd.env_remove("CLM_MOCK_LLM_BEHAVIOR");
daemon_cmd.env_remove("CLM_MOCK_OI_BEHAVIOR");
daemon_cmd.env_remove("CLM_MOCK_COMPILER_BEHAVIOR");
let snap_dir = if let Some(id) = instance_id {
format!("/tmp/{}", id)
} else {
format!("/tmp/clm_daemon_{}", pid)
};
let _ = fs::remove_dir_all(&snap_dir);
let _ = fs::create_dir_all(&snap_dir);
daemon_cmd.env("CLM_MEMBROKER_SNAP_DIR", &snap_dir);
let mut child = daemon_cmd.spawn()
.map_err(|e| format!("Failed to spawn daemon process: {}", e))?;
let mut timeout = 20;
while !port_file_path.exists() && timeout > 0 {
std::thread::sleep(std::time::Duration::from_millis(100));
timeout -= 1;
}
if !port_file_path.exists() {
if !quiet {
eprintln!("[clmEval-rs] ⚠️ Daemon failed to start. Falling back to standard CLI mode.");
}
let _ = child.kill();
} else {
let port_str = fs::read_to_string(&port_file_path)
.map_err(|e| format!("Failed to read port file: {}", e))?;
let port = port_str.trim().to_string();
daemon_port = Some(port.clone());
rust_port_file = Some(port_file_path.clone());
daemon_child = Some(child);
let mut reg_cmd = Command::new(crate::fs_utils::get_bash_command());
if env::var("CLM_ZERO_FS").as_deref() == Ok("true") {
let register_script = clm_root.join("tests/runners/register_test_handles.sh");
if register_script.exists() {
let _ = reg_cmd
.arg(®ister_script)
.env("CLM_RUST_DAEMON_PORT", &port)
.env("CLM_RUST_PORT_FILE", &port_file_path)
.stdout(Stdio::null())
.stderr(Stdio::null())
.status();
}
}
}
}
let mut cmd = Command::new(crate::fs_utils::get_bash_command());
cmd.current_dir(clm_root);
cmd.arg("-c");
cmd.arg(&shell_script);
cmd.arg("clmEval");
for arg in &remaining_args {
cmd.arg(arg);
}
for (key, val) in env::vars() {
cmd.env(key, val);
}
if let Some(port) = &daemon_port {
cmd.env("CLM_RUST_DAEMON_PORT", port);
}
if let Some(port_file) = &rust_port_file {
cmd.env("CLM_RUST_PORT_FILE", port_file);
}
cmd.env("CLM_ROOT", clm_root);
if let Some(proj_root) = clm_root.parent() {
cmd.env("PROJECT_ROOT", proj_root);
} else {
cmd.env("PROJECT_ROOT", clm_root);
}
cmd.env("SELF", "clmEval");
if quiet {
cmd.env("CLM_QUIET", "true");
}
let snap_dir = if let Some(id) = instance_id {
format!("/tmp/{}", id)
} else if let Ok(existing) = env::var("CLM_MEMBROKER_SNAP_DIR") {
existing
} else {
format!("/tmp/clm_daemon_{}", std::process::id())
};
cmd.env("CLM_MEMBROKER_SNAP_DIR", &snap_dir);
let exit_status = if quiet {
let mut child = cmd
.stdout(Stdio::piped())
.stderr(Stdio::null())
.spawn()
.map_err(|e| format!("Failed to spawn bash: {}", e))?;
let stdout = child.stdout.take().ok_or("Failed to open stdout")?;
let reader = BufReader::new(stdout);
let quiet_filter = regex::Regex::new(
r"^(?:\[clmEval\]|\[VERIFY\]|\[VCARD POST\]|PASS: |\[TYPE_REG\]|\[POST\]|━+$|[[:space:]]*clmEval[[:space:]]+—|[[:space:]]*Evaluating:)"
).unwrap();
for line_res in reader.lines() {
if let Ok(line) = line_res
&& !quiet_filter.is_match(&line) {
println!("{}", line);
}
}
child.wait().map_err(|e| format!("Failed to wait for bash: {}", e))?
} else {
cmd.stdout(Stdio::inherit())
.stderr(Stdio::inherit())
.status()
.map_err(|e| format!("Failed to execute bash: {}", e))?
};
let exit_code = exit_status.code().unwrap_or(1);
if let Some(mut child) = daemon_child {
if let Some(ref port) = daemon_port
&& let Ok(mut stream) = std::net::TcpStream::connect(format!("127.0.0.1:{}", port)) {
let _ = stream.write_all(b"RSTQ\tshutdown\t0\n");
let _ = stream.flush();
}
let _ = child.kill();
let _ = child.wait();
if let Some(ref path) = rust_port_file {
let _ = fs::remove_file(path);
}
let pid = std::process::id();
let log_file_path = clm_root.join(format!("data/ipc/rust_daemon.log.{}", pid));
let _ = fs::remove_file(&log_file_path);
let snap_dir = if let Some(id) = instance_id {
format!("/tmp/{}", id)
} else {
format!("/tmp/clm_daemon_{}", pid)
};
let _ = fs::remove_dir_all(&snap_dir);
}
Ok(exit_code)
}