use std::env;
use std::path::{Path, PathBuf};
use std::process::Command;
use serde_yaml::Value;
pub fn compose_conditions(
clm_root: &Path,
clm_file: &str,
phase: &str,
exit_code: i32,
quiet: bool,
) -> Result<i32, String> {
let clm_path = Path::new(clm_file);
let mut custom_pcard = None;
if clm_path.exists()
&& let Ok(content) = std::fs::read_to_string(clm_path)
&& let Ok(yaml) = serde_yaml::from_str::<Value>(&content) {
let root = yaml.get("clm").unwrap_or(&yaml);
if let Some(concrete) = root.get("concrete_impl") {
if phase == "pre" {
if let Some(pre) = concrete.get("precondition")
&& let Some(v) = pre.get("vcard_pre")
&& let Some(s) = v.as_str() {
custom_pcard = Some(s.to_string());
}
} else if phase == "post"
&& let Some(post) = concrete.get("postcondition")
&& let Some(v) = post.get("vcard_post")
&& let Some(s) = v.as_str() {
custom_pcard = Some(s.to_string());
}
}
}
if let Some(ref mut pcard) = custom_pcard {
if pcard.starts_with("gate:") {
let gate_name = pcard.trim_start_matches("gate:");
*pcard = format!("computable_knowledge/Abstract/layer5_system/bootstrap/governance/gates/{}.yaml", gate_name);
} else if pcard.starts_with(crate::hash::DEFAULT_HASH_PREFIX)
|| pcard.starts_with("blake3:")
|| pcard.starts_with("sha256:")
|| pcard.starts_with("sha512:")
|| pcard.starts_with("custom-")
{
let clm_root_str = clm_root.to_str().unwrap_or("");
if let Ok(Some(content)) = crate::db::get_card_content("content_memory", clm_root_str, pcard) {
let temp_dir = std::env::temp_dir().join("clm_execution_logs/.tmp");
let _ = std::fs::create_dir_all(&temp_dir);
let safe_hash = pcard.replace([':', '/', '\\'], "_");
let temp_file = temp_dir.join(format!("handle_mat_{}.yaml", safe_hash));
if std::fs::write(&temp_file, &content).is_ok() {
if !quiet {
eprintln!("[COMPOSE] Resolved {} gate reference: {} -> {:?}", phase, pcard, temp_file);
}
*pcard = temp_file.to_string_lossy().to_string();
}
}
}
}
if let Some(ref pcard_str) = custom_pcard {
let resolved_path = if Path::new(pcard_str).is_absolute() {
if Path::new(pcard_str).exists() { Some(PathBuf::from(pcard_str)) } else { None }
} else {
let joined = clm_root.join(pcard_str);
if joined.exists() {
Some(joined)
} else if let Some(suffix) = pcard_str.strip_prefix("clm/") {
let joined_suffix = clm_root.join(suffix);
if joined_suffix.exists() {
Some(joined_suffix)
} else {
None
}
} else {
None
}
};
let mut custom_gate_name = None;
if let Some(ref path) = resolved_path
&& let Ok(content) = std::fs::read_to_string(path)
&& let Ok(yaml) = serde_yaml::from_str::<Value>(&content) {
let root = yaml.get("clm").unwrap_or(&yaml);
if let Some(concrete) = root.get("concrete_impl")
&& let Some(op) = concrete.get("operation")
&& let Some(s) = op.as_str() {
custom_gate_name = Some(s.to_string());
}
}
if let Some(gate_name) = custom_gate_name
&& !quiet {
eprintln!("[COMPOSE] Discovered custom {} gate: {} (from {})", phase, gate_name, pcard_str);
}
}
let expr;
let override_gate = env::var("CLM_GATE_OVERRIDE").unwrap_or_else(|_| "0".to_string()) == "1";
if phase == "pre" {
if let Some(custom) = custom_pcard {
if override_gate {
expr = custom;
} else if custom == "computable_knowledge/Abstract/layer5_system/bootstrap/evaluator/verify_precondition.yaml"
|| custom == "computable_knowledge/Abstract/layer5_system/bootstrap/governance/gates/payload_nonempty.yaml"
|| custom == "computable_knowledge/Abstract/layer5_system/bootstrap/governance/gates/agent_authorized.yaml"
|| custom == "computable_knowledge/Abstract/layer5_system/bootstrap/governance/gates/db_accessible.yaml"
|| custom == "computable_knowledge/Abstract/layer5_system/bootstrap/governance/gates/file_exists.yaml"
|| custom == "computable_knowledge/Abstract/layer5_system/bootstrap/governance/gates/hash_matches.yaml"
|| custom == "computable_knowledge/Abstract/layer5_system/bootstrap/governance/gates/valid_yaml.yaml"
|| custom == "computable_knowledge/Abstract/layer5_system/bootstrap/governance/gates/valid_clm.yaml"
|| custom == "computable_knowledge/Abstract/layer5_system/bootstrap/governance/gates/type_conforms.yaml"
{
expr = "computable_knowledge/Abstract/layer5_system/bootstrap/evaluator/verify_precondition.yaml".to_string();
} else {
expr = format!("computable_knowledge/Abstract/layer5_system/bootstrap/evaluator/verify_precondition.yaml >>> {}", custom);
}
} else {
expr = "computable_knowledge/Abstract/layer5_system/bootstrap/evaluator/verify_precondition.yaml".to_string();
}
} else {
if let Some(custom) = custom_pcard {
if override_gate {
expr = custom;
} else if custom == "computable_knowledge/Abstract/layer5_system/bootstrap/evaluator/validate_postcondition.yaml"
|| custom == "computable_knowledge/Abstract/layer5_system/bootstrap/governance/gates/result_sealed.yaml"
|| custom == "computable_knowledge/Abstract/layer5_system/bootstrap/governance/gates/refinement_loop_sealed.yaml"
{
expr = "computable_knowledge/Abstract/layer5_system/bootstrap/evaluator/validate_postcondition.yaml".to_string();
} else {
expr = format!("computable_knowledge/Abstract/layer5_system/bootstrap/evaluator/validate_postcondition.yaml >>> {}", custom);
}
} else {
expr = "computable_knowledge/Abstract/layer5_system/bootstrap/evaluator/validate_postcondition.yaml".to_string();
}
}
execute_composed_pcard(clm_root, &expr, phase, exit_code, clm_file, quiet)
}
fn execute_composed_pcard(
clm_root: &Path,
expr: &str,
phase: &str,
exit_code: i32,
payload: &str,
quiet: bool,
) -> Result<i32, String> {
let seq_gates: Vec<&str> = expr.split(">>>").map(|s| s.trim()).collect();
if seq_gates.len() > 1 {
for gate in seq_gates {
if !quiet {
eprintln!("[COMPOSE] Executing Sequential Step: {}", gate);
}
let rc = execute_composed_pcard(clm_root, gate, phase, exit_code, payload, quiet)?;
if rc != 0 {
return Ok(rc);
}
}
return Ok(0);
}
let gate = expr.trim();
if gate.is_empty() {
return Ok(0);
}
if gate == "computable_knowledge/Abstract/layer5_system/bootstrap/evaluator/verify_precondition.yaml" {
if !quiet {
eprintln!("[COMPOSE] Executing verify_precondition natively (zero-fork)");
}
match crate::evaluator::verify::verify_precondition_internal(clm_root, payload, quiet) {
Ok(_) => return Ok(0),
Err(e) => {
eprintln!("[COMPOSE] verify_precondition failed: {}", e);
return Ok(1);
}
}
}
if gate == "computable_knowledge/Abstract/layer5_system/bootstrap/evaluator/validate_postcondition.yaml" {
if !quiet {
eprintln!("[COMPOSE] Executing validate_postcondition natively (zero-fork)");
}
let content = format!("exit code: {}", exit_code);
let content_hash = crate::hash::raw_hash_string(&content);
let extra_yaml = format!("content: \"{}\"", content);
let operation = "validate_postcondition";
match crate::db::emit_exec_mcard(operation, &content_hash, &extra_yaml, "", "", &clm_root.display().to_string()) {
Ok(mcard_path) => {
if !quiet {
eprintln!("[VCARD POST] ✅ Execution MCard generated: {}", mcard_path);
eprintln!("[VCARD POST] content_hash: {}", content_hash);
}
}
Err(e) => {
eprintln!("[VCARD POST] ❌ Failed to emit execution MCard: {}", e);
}
}
return Ok(0);
}
if !quiet {
eprintln!("[COMPOSE] Executing Base Gate: {}", gate);
}
let gate_path = if gate.starts_with("clm/") {
&gate[4..]
} else {
gate
};
let mut args = vec![gate_path.to_string()];
if phase == "pre" {
args.push(payload.to_string());
} else {
args.push(payload.to_string());
args.push(exit_code.to_string());
}
let clm_eval_rs = {
#[cfg(not(windows))]
let p1 = clm_root.join("kernel/scripts/clmEval-rs");
#[cfg(not(windows))]
let p2 = clm_root.join("kernel/clm_rust_core/target/release/clm_rust_core");
#[cfg(not(windows))]
let p3 = clm_root.join("kernel/clm_rust_core/target/debug/clm_rust_core");
#[cfg(windows)]
let p1 = clm_root.join("kernel/scripts/clmEval-rs.exe");
#[cfg(windows)]
let p2 = clm_root.join("kernel/clm_rust_core/target/release/clm_rust_core.exe");
#[cfg(windows)]
let p3 = clm_root.join("kernel/clm_rust_core/target/debug/clm_rust_core.exe");
if p1.exists() { p1 } else if p2.exists() { p2 } else if p3.exists() { p3 } else { std::path::PathBuf::from("clmEval-rs") }
};
let mut cmd = Command::new(&clm_eval_rs);
cmd.current_dir(clm_root);
cmd.arg("evaluate");
for arg in args {
cmd.arg(arg);
}
cmd.env("CLM_NESTED_EXEC", "1");
cmd.env("CLM_SKIP_CONDITIONS", "1");
if quiet {
cmd.env("CLM_QUIET", "1");
}
for (key, value) in std::env::vars() {
if key.starts_with("CLM_") || key == "ACTIVE_AGENT_DID" {
cmd.env(key, value);
}
}
match cmd.status() {
Ok(status) => Ok(status.code().unwrap_or(1)),
Err(e) => {
eprintln!("[COMPOSE] Failed to execute gate {}: {}", gate, e);
Ok(1)
}
}
}