clm-kernel 0.0.14

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

pub fn handle_action_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 action <apply|run|validate|diff|list> <spec.yaml> [options]\n");
        return 0;
    }
    if args.is_empty() {
        stderr.push_str("Usage: clm action <apply|run|validate|diff|list> <spec.yaml> [options]\n");
        return 2;
    }

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

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

            let mut i = 1;
            while i < args.len() {
                let arg = &args[i];
                if arg == "--input" || arg == "-i" {
                    if i + 1 < args.len() {
                        input_uri = Some(args[i + 1].clone());
                        i += 2;
                        continue;
                    }
                } else 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" || arg == "--dry-run" {
                    // flag
                } else if !arg.starts_with('-') && manifest_path.is_none() {
                    manifest_path = Some(arg.clone());
                }
                i += 1;
            }

            let path_str = match manifest_path {
                Some(p) => p,
                None => {
                    let err = "No action manifest path specified";
                    if as_json {
                        stdout.push_str(&serde_json::to_string_pretty(&serde_json::json!({
                            "status": "error", "error": err
                        })).unwrap());
                        stdout.push('\n');
                    } else {
                        stderr.push_str(&format!("❌ Error: {}\n", err));
                    }
                    return 2;
                }
            };

            let manifest = match clm_rust_core::layer1::ActionManifest::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();
            if let Some(uri) = input_uri {
                let content = if std::path::Path::new(&uri).is_file() {
                    std::fs::read_to_string(&uri).unwrap_or(uri)
                } else {
                    uri
                };
                if let Some(inp) = manifest.inputs.first() {
                    input_map.insert(inp.name.clone(), content.clone());
                }
                input_map.insert("input".to_string(), content.clone());
                input_map.insert("dataset".to_string(), content);
            }

            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 result = clm_rust_core::layer1::HoareSandwichEngine::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!("mcard://{}", name)));
                }
                let receipt_uri = result.receipt.as_ref().map(|r| r.uri.clone());

                if as_json {
                    let out_json = serde_json::json!({
                        "status": "success",
                        "action": result.action_name,
                        "outputs": output_uris,
                        "receipt": receipt_uri,
                        "metrics": result.metrics,
                    });
                    stdout.push_str(&serde_json::to_string_pretty(&out_json).unwrap());
                    stdout.push('\n');
                } else {
                    stdout.push_str(&format!("🚀 Action '{}' executed successfully.\n", result.action_name));
                    for (k, v) in &output_uris {
                        stdout.push_str(&format!("   Output [{}]: {}\n", k, v.as_str().unwrap_or("")));
                    }
                    if let Some(r) = &receipt_uri {
                        stdout.push_str(&format!("   VCard Receipt: {}\n", r));
                    }
                }
                0
            } else {
                if as_json {
                    let out_json = serde_json::json!({
                        "status": "failed",
                        "action": result.action_name,
                        "error": result.error,
                        "rollback_occurred": result.rollback_occurred,
                        "rollback_time_ms": result.rollback_time_ms,
                    });
                    stdout.push_str(&serde_json::to_string_pretty(&out_json).unwrap());
                    stdout.push('\n');
                } else {
                    stderr.push_str(&format!("❌ Action '{}' failed: {}\n", result.action_name, result.error.unwrap_or_default()));
                }
                1
            }
        }
        "validate" => {
            let manifest_path = args.get(1);
            let path_str = match manifest_path {
                Some(p) => p,
                None => {
                    stderr.push_str("Usage: clm action validate <spec.yaml> [--json]\n");
                    return 2;
                }
            };
            match clm_rust_core::layer1::ActionManifest::from_yaml_file(path_str) {
                Ok(manifest) => {
                    if as_json {
                        let out_json = serde_json::json!({
                            "status": "valid",
                            "name": manifest.clm.name,
                            "operator": manifest.clm.operator.to_string(),
                            "inputs": manifest.inputs.iter().map(|i| &i.name).collect::<Vec<_>>(),
                            "outputs": manifest.outputs.iter().map(|o| &o.name).collect::<Vec<_>>(),
                            "preconditions": manifest.preconditions.len(),
                            "postconditions": manifest.postconditions.len(),
                        });
                        stdout.push_str(&serde_json::to_string_pretty(&out_json).unwrap());
                        stdout.push('\n');
                    } else {
                        stdout.push_str(&format!("✅ Action 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
                }
            }
        }
        "list" => {
            if as_json {
                stdout.push_str("{\n  \"status\": \"success\",\n  \"actions\": []\n}\n");
            } else {
                stdout.push_str("Available actions: []\n");
            }
            0
        }
        other => {
            stderr.push_str(&format!("Unknown action subcommand: {}\n", other));
            2
        }
    }
}