clm-kernel 0.0.24

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
#![allow(unused_imports)]
use clm_rust_core::layer0::vocabulary::{URI_SCHEME_MCARD};
use super::*;

pub fn handle_workflow_cmd(args: &[String], json_flag: bool, stdout: &mut String, stderr: &mut String) -> i32 {
    let has_help = args.iter().any(|a| a == "--help" || a == "-h");
    if has_help {
        stdout.push_str("Usage: clm workflow <run|validate|status> <dag.yaml> [options]\n");
        return 0;
    }
    if args.is_empty() {
        stderr.push_str("Usage: clm workflow <run|validate|status> <dag.yaml> [options]\n");
        return 2;
    }

    let subcmd = args[0].as_str();
    let as_json = json_flag || args.iter().any(|a| a == "--json");

    match subcmd {
        "run" => {
            let mut dag_path: Option<String> = None;
            let mut bindings: Vec<String> = Vec::new();

            let mut i = 1;
            while i < args.len() {
                let arg = &args[i];
                if arg == "--bind" || arg == "-b" {
                    if i + 1 < args.len() {
                        bindings.push(args[i + 1].clone());
                        i += 2;
                        continue;
                    }
                } else if arg.starts_with("--bind=") {
                    bindings.push(arg.trim_start_matches("--bind=").to_string());
                } else if arg == "--json" {
                    // skip
                } else if !arg.starts_with('-') && dag_path.is_none() {
                    dag_path = Some(arg.clone());
                }
                i += 1;
            }

            let path_str = match dag_path {
                Some(p) => p,
                None => {
                    stderr.push_str("Usage: clm workflow run <dag.yaml> [options]\n");
                    return 2;
                }
            };

            let manifest = match clm_rust_core::layer1::WorkflowManifest::from_yaml_file(&path_str) {
                Ok(m) => m,
                Err(e) => {
                    if as_json {
                        stdout.push_str(&serde_json::to_string_pretty(&serde_json::json!({
                            "status": "error", "error": e
                        })).unwrap());
                        stdout.push('\n');
                    } else {
                        stderr.push_str(&format!("❌ {}\n", e));
                    }
                    return 1;
                }
            };

            let mut input_map = std::collections::HashMap::new();
            for b in bindings {
                if let Some((k, v)) = b.split_once('=') {
                    let key = k.trim().to_string();
                    let val = v.trim();
                    let content = if std::path::Path::new(val).is_file() {
                        std::fs::read_to_string(val).unwrap_or_else(|_| val.to_string())
                    } else {
                        val.to_string()
                    };
                    input_map.insert(key, content);
                }
            }

            let base_dir = std::path::Path::new(&path_str).parent().unwrap_or(std::path::Path::new("."));
            let orchestrator = clm_rust_core::layer1::PocketFlowWorkflowOrchestrator::new(base_dir);
            let result = orchestrator.execute(&manifest, &input_map);

            if result.status == "success" {
                let mut output_uris = serde_json::Map::new();
                for name in result.outputs.keys() {
                    output_uris.insert(name.clone(), serde_json::Value::String(format!("{URI_SCHEME_MCARD}{}", name)));
                }

                if as_json {
                    let out_json = serde_json::json!({
                        "status": "success",
                        "workflow": result.workflow_name,
                        "outputs": output_uris,
                        "receipts": result.receipts,
                        "metrics": result.metrics,
                    });
                    stdout.push_str(&serde_json::to_string_pretty(&out_json).unwrap());
                    stdout.push('\n');
                } else {
                    stdout.push_str(&format!("🚀 Workflow '{}' completed successfully.\n", result.workflow_name));
                    for (k, v) in &output_uris {
                        stdout.push_str(&format!("   Terminal Output [{}]: {}\n", k, v.as_str().unwrap_or("")));
                    }
                }
                0
            } else {
                if as_json {
                    let out_json = serde_json::json!({
                        "status": "failed",
                        "workflow": result.workflow_name,
                        "failed_step": result.failed_step,
                        "error": result.error,
                    });
                    stdout.push_str(&serde_json::to_string_pretty(&out_json).unwrap());
                    stdout.push('\n');
                } else {
                    stderr.push_str(&format!("❌ Workflow '{}' failed at step '{:?}': {:?}\n", result.workflow_name, result.failed_step, result.error));
                }
                1
            }
        }
        "validate" => {
            let dag_path = args.get(1);
            let path_str = match dag_path {
                Some(p) => p,
                None => {
                    stderr.push_str("Usage: clm workflow validate <dag.yaml> [--json]\n");
                    return 2;
                }
            };
            match clm_rust_core::layer1::WorkflowManifest::from_yaml_file(path_str) {
                Ok(manifest) => {
                    if as_json {
                        let out_json = serde_json::json!({
                            "status": "valid",
                            "name": manifest.clm.name,
                            "steps": manifest.steps.len(),
                            "outputs": manifest.outputs.len(),
                        });
                        stdout.push_str(&serde_json::to_string_pretty(&out_json).unwrap());
                        stdout.push('\n');
                    } else {
                        stdout.push_str(&format!("✅ Workflow manifest '{}' is valid.\n", path_str));
                    }
                    0
                }
                Err(e) => {
                    if as_json {
                        let out_json = serde_json::json!({
                            "status": "invalid",
                            "file": path_str,
                            "error": e,
                        });
                        stdout.push_str(&serde_json::to_string_pretty(&out_json).unwrap());
                        stdout.push('\n');
                    } else {
                        stderr.push_str(&format!("❌ Validation failed for '{}': {}\n", path_str, e));
                    }
                    1
                }
            }
        }
        other => {
            stderr.push_str(&format!("Unknown workflow subcommand: {}\n", other));
            2
        }
    }
}

pub fn handle_layer5_cmd(args: &[String], json_flag: bool, stdout: &mut String, stderr: &mut String) -> i32 {
    let has_help = args.iter().any(|a| a == "--help" || a == "-h");
    if has_help || args.is_empty() {
        stdout.push_str("Usage: clm layer5 <delta-e|verify-lattice|quarantine-test> [options]\n");
        return if has_help { 0 } else { 2 };
    }

    let subcmd = args[0].as_str();
    let as_json = json_flag || args.iter().any(|a| a == "--json");

    match subcmd {
        "delta-e" | "delta_e" => {
            let mut baseline: Option<f64> = None;
            let mut candidate: Option<f64> = None;

            let mut i = 1;
            while i < args.len() {
                let arg = &args[i];
                if (arg == "--baseline" || arg == "-b") && i + 1 < args.len() {
                    baseline = args[i + 1].parse::<f64>().ok();
                    i += 2;
                    continue;
                } else if arg.starts_with("--baseline=") {
                    baseline = arg.trim_start_matches("--baseline=").parse::<f64>().ok();
                } else if (arg == "--candidate" || arg == "-c") && i + 1 < args.len() {
                    candidate = args[i + 1].parse::<f64>().ok();
                    i += 2;
                    continue;
                } else if arg.starts_with("--candidate=") {
                    candidate = arg.trim_start_matches("--candidate=").parse::<f64>().ok();
                } else if !arg.starts_with('-') {
                    if baseline.is_none() {
                        baseline = arg.parse::<f64>().ok();
                    } else if candidate.is_none() {
                        candidate = arg.parse::<f64>().ok();
                    }
                }
                i += 1;
            }

            let b = baseline.unwrap_or(1.0);
            let c = candidate.unwrap_or(1.0);
            let delta = clm_rust_core::layer5::compute_delta_e(b, c);
            let monotonic = delta >= 0.0;

            if as_json {
                let resp = serde_json::json!({
                    "status": "success",
                    "data": {
                        "baseline": b,
                        "candidate": c,
                        "delta_e": delta,
                        "monotonic": monotonic,
                        "verdict": if monotonic { "COMMITTED" } else { "REJECTED_REGRESSION" }
                    },
                    "meta": {
                        "runtime": "rust",
                        "stratum": "L5"
                    }
                });
                stdout.push_str(&serde_json::to_string_pretty(&resp).unwrap());
                stdout.push('\n');
            } else {
                stdout.push_str(&format!("{:.6}\n", delta));
            }
            0
        }
        "verify-lattice" | "coordinates" => {
            let coords = clm_rust_core::layer5::get_universe_coordinates();
            if as_json {
                let resp = serde_json::json!({
                    "status": "success",
                    "data": {
                        "coordinates": coords
                    },
                    "meta": {
                        "runtime": "rust",
                        "stratum": "L5"
                    }
                });
                stdout.push_str(&serde_json::to_string_pretty(&resp).unwrap());
                stdout.push('\n');
            } else {
                for c in coords {
                    stdout.push_str(&format!("{}: {} ({})\n", c.identifier, c.stratum_name, c.description));
                }
            }
            0
        }
        "quarantine-test" => {
            let mut baseline: f64 = 1.0;
            let mut candidate: f64 = 1.0;

            let mut i = 1;
            while i < args.len() {
                let arg = &args[i];
                if (arg == "--baseline" || arg == "-b") && i + 1 < args.len() {
                    if let Ok(v) = args[i + 1].parse::<f64>() { baseline = v; }
                    i += 2;
                    continue;
                } else if arg.starts_with("--baseline=") {
                    if let Ok(v) = arg.trim_start_matches("--baseline=").parse::<f64>() { baseline = v; }
                } else if (arg == "--candidate" || arg == "-c") && i + 1 < args.len() {
                    if let Ok(v) = args[i + 1].parse::<f64>() { candidate = v; }
                    i += 2;
                    continue;
                } else if arg.starts_with("--candidate=") {
                    if let Ok(v) = arg.trim_start_matches("--candidate=").parse::<f64>() { candidate = v; }
                } else if !arg.starts_with('-') {
                    if baseline == 1.0 && candidate == 1.0 {
                        if let Ok(v) = arg.parse::<f64>() { baseline = v; }
                    } else {
                        if let Ok(v) = arg.parse::<f64>() { candidate = v; }
                    }
                }
                i += 1;
            }

            let delta = clm_rust_core::layer5::compute_delta_e(baseline, candidate);
            if delta <= 0.0 {
                stderr.push_str(&format!(
                    "KARPATHY_QUARANTINE_VIOLATION: Uncommitted hypothesis regression (ΔE = {:.6} <= 0). Mutation blocked from handle_registry.\n",
                    delta
                ));
                1
            } else {
                stdout.push_str(&format!(
                    "COMMITTED: Monotonic epistemic advancement (ΔE = +{:.6}). Mutation integrated.\n",
                    delta
                ));
                0
            }
        }
        other => {
            stderr.push_str(&format!("Unknown layer5 subcommand: {}\n", other));
            2
        }
    }
}