#![allow(unused_imports)]
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" {
} 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!("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
}
}
}