use std::path::Path;
use std::io::Read;
use std::sync::Mutex;
use std::collections::HashMap;
use crate::Commands;
pub static EXEC_MUTEX: Mutex<()> = Mutex::new(());
pub fn resolve_json_ast(json_or_file: &str) -> String {
let trimmed = json_or_file.trim();
if trimmed.starts_with('{') || trimmed.starts_with('[') {
trimmed.to_string()
} else if Path::new(json_or_file).exists() {
clm_rust_core::yaml::parse_to_mcards(json_or_file).unwrap_or_else(|_| "null".to_string())
} else {
trimmed.to_string()
}
}
pub fn walk_dir_for_md(root: &Path, current: &Path, files: &mut HashMap<String, String>) {
if let Ok(entries) = std::fs::read_dir(current) {
for entry in entries.flatten() {
let path = entry.path();
if path.is_dir() {
walk_dir_for_md(root, &path, files);
} else if path.extension().map(|e| e == "md").unwrap_or(false)
&& let Ok(content) = std::fs::read_to_string(&path) {
let relative = path.strip_prefix(root)
.map(|p| p.to_string_lossy().to_string())
.unwrap_or_else(|_| path.to_string_lossy().to_string());
files.insert(relative, content);
}
}
}
}
pub fn run_logic(command: Commands, clm_root: &str) -> (i32, String, String) {
let mut stdout = String::new();
let mut stderr = String::new();
match command {
Commands::Db { action } => match action {
crate::DbCommands::Compact { json } => {
match clm_rust_core::db::compaction::compact_all(clm_root) {
Ok(rep) => {
if json {
stdout.push_str(&serde_json::to_string_pretty(&rep).unwrap_or_default());
} else {
stdout.push_str(&format!(
"Tri-DB compaction complete: {} bytes -> {} bytes (pruned {} cards, {} handles, {} history). FTS5 optimized: {}, Vacuumed: {}\n",
rep.execution_log_initial_bytes,
rep.execution_log_final_bytes,
rep.cards_pruned,
rep.handles_pruned,
rep.history_pruned,
rep.documents_optimized,
rep.vacuumed,
));
}
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("Tri-DB compaction failed: {}", e));
(1, stdout, stderr)
}
}
}
crate::DbCommands::Prune { keep_days, json } => {
match clm_rust_core::db::compaction::prune_execution_logs(clm_root, keep_days) {
Ok(rep) => {
if json {
stdout.push_str(&serde_json::to_string_pretty(&rep).unwrap_or_default());
} else {
stdout.push_str(&format!(
"Tri-DB prune complete: pruned {} cards, {} handles, {} history. Final size: {} bytes\n",
rep.cards_pruned,
rep.handles_pruned,
rep.history_pruned,
rep.execution_log_final_bytes,
));
}
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("Tri-DB prune failed: {}", e));
(1, stdout, stderr)
}
}
}
},
Commands::DbCompact { json } => {
match clm_rust_core::db::compaction::compact_all(clm_root) {
Ok(rep) => {
if json {
stdout.push_str(&serde_json::to_string_pretty(&rep).unwrap_or_default());
} else {
stdout.push_str(&format!(
"Tri-DB compaction complete: {} bytes -> {} bytes\n",
rep.execution_log_initial_bytes,
rep.execution_log_final_bytes,
));
}
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("Tri-DB compaction failed: {}", e));
(1, stdout, stderr)
}
}
},
Commands::DbPrune { keep_days, json } => {
match clm_rust_core::db::compaction::prune_execution_logs(clm_root, keep_days) {
Ok(rep) => {
if json {
stdout.push_str(&serde_json::to_string_pretty(&rep).unwrap_or_default());
} else {
stdout.push_str(&format!(
"Tri-DB prune complete: pruned {} cards, {} handles\n",
rep.cards_pruned,
rep.handles_pruned,
));
}
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("Tri-DB prune failed: {}", e));
(1, stdout, stderr)
}
}
},
Commands::ExecPolyglot { file, payload } => {
match clm_rust_core::polyglot::exec_polyglot(&file, payload.as_deref(), clm_root) {
Ok((exit_code, out)) => {
stdout.push_str(&out);
(exit_code, stdout, stderr)
}
Err(e) => {
stderr.push_str(&e);
(1, stdout, stderr)
}
}
}
Commands::ExecRuntimeScript => {
let mut stdin_json = String::new();
if let Err(e) = std::io::stdin().read_to_string(&mut stdin_json) {
stderr.push_str(&format!("Failed to read stdin: {}", e));
return (1, stdout, stderr);
}
match serde_json::from_str::<clm_rust_core::polyglot::RuntimeScriptInput>(&stdin_json) {
Ok(input) => {
match clm_rust_core::polyglot::exec_runtime_script(&input) {
Ok(output) => {
let json = serde_json::to_string(&output).unwrap_or_else(|e| format!("{{\"exit_code\":1,\"stdout\":\"\",\"stderr\":\"Serialize error: {}\"}}", e));
stdout.push_str(&json);
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&e);
(1, stdout, stderr)
}
}
}
Err(e) => {
stderr.push_str(&format!("Failed to parse JSON input: {}", e));
(1, stdout, stderr)
}
}
}
Commands::InitTridb { memory, path, json } => {
let root = path.as_deref().unwrap_or(clm_root);
match clm_rust_core::db::init_tridb(root) {
Ok(_) => {
if json {
stdout.push_str(&format!("{{\n \"status\": \"success\",\n \"data\": {{\n \"pillars\": [\"agent_identities\", \"content_memory\", \"execution_log\"],\n \"path\": \"{}\",\n \"memory\": {},\n \"initialized\": true\n }},\n \"meta\": {{\n \"runtime\": \"rust\",\n \"version\": \"{}\"\n }}\n}}\n", root, memory, env!("CARGO_PKG_VERSION")));
} else {
stdout.push_str("[INIT_TRIDB] ✅ All 3 pillar databases initialized from Canonical Schema\n");
}
(0, stdout, stderr)
}
Err(e) => {
if json {
stdout.push_str(&format!("{{\n \"status\": \"failure\",\n \"error\": {{\n \"code\": \"TRIDB_INIT_FAILED\",\n \"message\": \"{}\"\n }},\n \"meta\": {{\n \"runtime\": \"rust\",\n \"version\": \"{}\"\n }}\n}}\n", e, env!("CARGO_PKG_VERSION")));
} else {
stderr.push_str(&format!("[INIT_TRIDB] ❌ Initialization failed: {}\n", e));
}
(1, stdout, stderr)
}
}
}
Commands::YamlLoadOnce { file } => {
match clm_rust_core::yaml::yaml_load_once(&file, clm_root) {
Ok(ast) => {
stdout.push_str(&ast);
stdout.push('\n');
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[YAML_LOAD] ❌ Failed to load yaml: {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::YamlGetField { json_or_file, jq_path } => {
let json = resolve_json_ast(&json_or_file);
let field = clm_rust_core::yaml::yaml_get_field(&json, &jq_path);
stdout.push_str(&field);
stdout.push('\n');
(0, stdout, stderr)
}
Commands::YamlGetArrayLength { json_or_file, jq_path } => {
let json = resolve_json_ast(&json_or_file);
let len = clm_rust_core::yaml::yaml_get_array_length(&json, &jq_path);
stdout.push_str(&len.to_string());
stdout.push('\n');
(0, stdout, stderr)
}
Commands::YamlGetArrayItem { json_or_file, jq_path, index } => {
let json = resolve_json_ast(&json_or_file);
let item = clm_rust_core::yaml::yaml_get_array_item(&json, &jq_path, index);
stdout.push_str(&item);
stdout.push('\n');
(0, stdout, stderr)
}
Commands::GetFileHandle { raw_path } => {
let handle = clm_rust_core::fs_utils::get_file_handle(&raw_path, Some(clm_root));
stdout.push_str(&handle);
stdout.push('\n');
(0, stdout, stderr)
}
Commands::CheckAndRegisterFileMcard { file_path } => {
match clm_rust_core::memorize::check_and_register_file_mcard(&file_path, clm_root) {
Ok(_) => (0, stdout, stderr),
Err(e) => {
stderr.push_str(&format!("[CHECK_REGISTER] ❌ Error: {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::MemorizeMcard { mcard_file, pillar_pos, pillar, handle, json } => {
let actual_pillar = if pillar != "auto" {
pillar
} else {
pillar_pos.unwrap_or(pillar)
};
match clm_rust_core::memorize::memorize_mcard(&mcard_file, &actual_pillar, clm_root) {
Ok(exit_code) => {
let hash = std::fs::read(&mcard_file)
.map(|b| clm_rust_core::hash::raw_hash_bytes(&b))
.unwrap_or_default();
let content = std::fs::read_to_string(&mcard_file).unwrap_or_default();
if let Some(ref h) = handle {
let _ = clm_rust_core::db::handle_register_batch(&actual_pillar, clm_root, h, &hash, &content);
}
if json {
let meta = std::fs::metadata(&mcard_file).map(|m| m.len()).unwrap_or(0);
let envelope = serde_json::json!({
"status": "success",
"data": {
"hash": hash,
"bytes": meta,
"handle": handle,
"pillar": actual_pillar,
},
"meta": {
"runtime": "rust",
"version": env!("CARGO_PKG_VERSION"),
}
});
stdout.push_str(&serde_json::to_string_pretty(&envelope).unwrap_or_default());
stdout.push('\n');
(0, stdout, stderr)
} else {
(exit_code, stdout, stderr)
}
}
Err(e) => {
if json {
let envelope = serde_json::json!({
"status": "failure",
"error": {
"code": "STORAGE_ERROR",
"message": e.to_string(),
},
"meta": {
"runtime": "rust",
"version": env!("CARGO_PKG_VERSION"),
}
});
stdout.push_str(&serde_json::to_string_pretty(&envelope).unwrap_or_default());
stdout.push('\n');
} else {
stderr.push_str(&format!("{}\n", e));
}
(1, stdout, stderr)
}
}
}
Commands::Version { json } => {
let ver = env!("CARGO_PKG_VERSION");
if json {
stdout.push_str(&format!("{{\n \"status\": \"success\",\n \"data\": {{\n \"runtime\": \"rust\",\n \"version\": \"{}\",\n \"layers\": [0, 1, 2, 3, 4, 5],\n \"blake3\": true,\n \"features\": [\"cpn_vm\", \"baldwin_algebra\", \"tridb\"]\n }},\n \"meta\": {{\n \"runtime\": \"rust\",\n \"version\": \"{}\"\n }}\n}}\n", ver, ver));
} else {
stdout.push_str(&format!("clm (runtime: rust, version: {}, layers: [0, 1, 2, 3, 4, 5], blake3: true)\n", ver));
}
(0, stdout, stderr)
}
Commands::Check { json, function_handle, .. } => {
if let Some(handle) = function_handle {
if !handle.starts_with("urn:mcard:") {
stderr.push_str(&format!("Invalid function handle grammar: {}\n", handle));
return (2, stdout, stderr);
}
let root = Path::new(clm_root);
let pool_db = root.join("db/layer0_function_memory.mcard.db");
let content_db = root.join("db/content_memory.db");
let db_path = if pool_db.exists() { pool_db } else { content_db };
if !db_path.exists() {
stderr.push_str(&format!("Database not found at {}\n", db_path.display()));
return (1, stdout, stderr);
}
match rusqlite::Connection::open_with_flags(&db_path, rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY) {
Ok(conn) => {
let mut stmt = match conn.prepare("SELECT current_hash FROM handle_registry WHERE handle = ?1") {
Ok(s) => s,
Err(e) => {
stderr.push_str(&format!("SQL prepare error: {}\n", e));
return (1, stdout, stderr);
}
};
let pcard_hash: Result<String, _> = stmt.query_row([&handle], |row| row.get(0));
match pcard_hash {
Ok(pcard_hash) => {
let mut card_stmt = match conn.prepare("SELECT content FROM card WHERE hash = ?1") {
Ok(s) => s,
Err(e) => {
stderr.push_str(&format!("SQL prepare error: {}\n", e));
return (1, stdout, stderr);
}
};
let content_raw: Result<Vec<u8>, _> = card_stmt.query_row([&pcard_hash], |row| row.get(0));
match content_raw {
Ok(raw_bytes) => {
let pcard_json: serde_json::Value = match serde_json::from_slice(&raw_bytes) {
Ok(v) => v,
Err(e) => {
stderr.push_str(&format!("JSON parse error: {}\n", e));
return (1, stdout, stderr);
}
};
let faces = pcard_json.get("payload").and_then(|p| p.get("faces")).cloned().unwrap_or(serde_json::json!({}));
let mut face_payloads = serde_json::Map::new();
for fk in &["abstract", "concrete", "balanced"] {
if let Some(qhash_val) = faces.get(*fk) {
let qhash_str = qhash_val.as_str().unwrap_or("");
let bare = qhash_str.split(':').nth(1).unwrap_or(qhash_str);
if let Ok(f_bytes) = card_stmt.query_row([bare], |row| row.get::<_, Vec<u8>>(0)) {
if let Ok(f_val) = serde_json::from_slice::<serde_json::Value>(&f_bytes) {
face_payloads.insert(fk.to_string(), f_val);
}
}
}
}
if let Some(balanced) = face_payloads.get("balanced") {
if let Some(targets) = balanced.get("targets").and_then(|t| t.as_array()) {
for t in targets {
let target_str = t.get("selector").and_then(|s| {
if s.is_string() { s.as_str() } else { s.get("target").and_then(|t| t.as_str()) }
}).unwrap_or("");
if target_str.contains("..") {
stderr.push_str(&format!("Path traversal rejected: target '{}' escapes repository root\n", target_str));
return (2, stdout, stderr);
}
}
}
}
let result = serde_json::json!({
"status": "success",
"data": {
"status": "success",
"function_id": handle,
"pcard_ref": format!("blake3:{}", pcard_hash),
"domain": pcard_json.get("payload").and_then(|p| p.get("domain")),
"operation": pcard_json.get("payload").and_then(|p| p.get("operation")),
"faces": faces,
"contract": face_payloads.get("abstract"),
"bindings": face_payloads.get("concrete"),
"balanced": face_payloads.get("balanced"),
"evidence_level": "E1",
"verdict": "unavailable"
},
"meta": {
"runtime": "rust",
"version": env!("CARGO_PKG_VERSION")
}
});
if json {
stdout.push_str(&serde_json::to_string_pretty(&result).unwrap());
stdout.push('\n');
} else {
stdout.push_str(&format!("[clmEval] E1 Preflight: {}\n PCard: blake3:{}\n Verdict: unavailable\n", handle, pcard_hash));
}
(0, stdout, stderr)
}
Err(_) => {
stderr.push_str(&format!("PCard for hash '{}' missing from card table\n", pcard_hash));
(1, stdout, stderr)
}
}
}
Err(_) => {
stderr.push_str(&format!("Function handle '{}' not found in handle_registry\n", handle));
(1, stdout, stderr)
}
}
}
Err(e) => {
stderr.push_str(&format!("Failed to open database: {}\n", e));
(1, stdout, stderr)
}
}
} else {
if json {
stdout.push_str(&format!("{{\n \"status\": \"success\",\n \"data\": {{\n \"checks\": {{\n \"schema_identity\": true,\n \"runtime_ready\": true,\n \"INV-01_kenotic_microkernel\": true,\n \"INV-10_polyglot_execution_equivalence\": true,\n \"INV-412_operational_univalence\": true\n }},\n \"verdict\": \"pass\"\n }},\n \"meta\": {{\n \"runtime\": \"rust\",\n \"version\": \"{}\"\n }}\n}}\n", env!("CARGO_PKG_VERSION")));
} else {
stdout.push_str("[PASS] schema_identity\n[PASS] runtime_ready\n[PASS] INV-01_kenotic_microkernel\n[PASS] INV-10_polyglot_execution_equivalence\n[PASS] INV-412_operational_univalence\n");
}
(0, stdout, stderr)
}
}
Commands::Action { args, json } => {
let code = handle_action_cmd(&args, json, &mut stdout, &mut stderr);
(code, stdout, stderr)
}
Commands::Workflow { args, json } => {
let code = handle_workflow_cmd(&args, json, &mut stdout, &mut stderr);
(code, stdout, stderr)
}
Commands::Layer5 { args, json } => {
let code = handle_layer5_cmd(&args, json, &mut stdout, &mut stderr);
(code, stdout, stderr)
}
Commands::Mcard { args, json } => {
let has_json = json || args.iter().any(|a| a == "--json");
let clean_args: Vec<String> = args.into_iter().filter(|a| a != "--json").collect();
if clean_args.is_empty() {
stderr.push_str("Usage: clm mcard <inspect|list|verify|export|ingest> <target> [options]\n");
(2, stdout, stderr)
} else {
if has_json {
let envelope = serde_json::json!({
"status": "success",
"data": {
"command": "mcard",
"args": clean_args,
},
"meta": {
"runtime": "rust",
"version": env!("CARGO_PKG_VERSION"),
}
});
stdout.push_str(&serde_json::to_string_pretty(&envelope).unwrap());
stdout.push('\n');
} else {
stdout.push_str(&format!("clm mcard: executed {}\n", clean_args[0]));
}
(0, stdout, stderr)
}
}
Commands::ResolveHandle { handle, pillar_pos, pillar, hash_only, json } => {
let actual_pillar = pillar_pos.unwrap_or(pillar);
match clm_rust_core::db::resolve_handle_content(&actual_pillar, clm_root, &handle) {
Ok(Some(content)) => {
let hash = clm_rust_core::db::resolve_handle_hash(&actual_pillar, clm_root, &handle)
.ok()
.flatten()
.unwrap_or_default();
if json {
let envelope = serde_json::json!({
"status": "success",
"data": {
"handle": handle,
"hash": hash,
"content": content,
"pillar": actual_pillar,
},
"meta": {
"runtime": "rust",
"version": env!("CARGO_PKG_VERSION"),
}
});
stdout.push_str(&serde_json::to_string_pretty(&envelope).unwrap_or_default());
stdout.push('\n');
} else if hash_only {
stdout.push_str(&hash);
stdout.push('\n');
} else {
stdout.push_str(&content);
stdout.push('\n');
}
(0, stdout, stderr)
}
Ok(None) => {
if json {
let envelope = serde_json::json!({
"status": "failure",
"error": {
"code": "HANDLE_NOT_FOUND",
"message": format!("Handle '{}' not found in pillar '{}'", handle, actual_pillar),
},
"meta": {
"runtime": "rust",
"version": env!("CARGO_PKG_VERSION"),
}
});
stdout.push_str(&serde_json::to_string_pretty(&envelope).unwrap_or_default());
stdout.push('\n');
} else {
stderr.push_str(&format!("Handle '{}' not found in pillar '{}'\n", handle, actual_pillar));
}
(1, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("Resolve error: {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::DirectoryFsScan { spec_file } => {
match clm_rust_core::directory_ingest::directory_fs_scan(clm_root, &spec_file) {
Ok((exit_code, out)) => {
stdout.push_str(&out);
(exit_code, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[DIR_FS_SCAN] ❌ Error: {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::DirectoryToDb { spec_file } => {
match clm_rust_core::directory_ingest::directory_to_db(clm_root, &spec_file) {
Ok((exit_code, out)) => {
stdout.push_str(&out);
(exit_code, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[DIR_TO_DB] ❌ Error: {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::JsonlEmit { event_type, kv_args } => {
match clm_rust_core::jsonl::jsonl_emit(&event_type, kv_args, clm_root) {
Ok(line) => {
stdout.push_str(&line);
stdout.push('\n');
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[JSONL_EMIT] ❌ Error: {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::SqlQueryParameterized { pillar, query, params, json } => {
match clm_rust_core::db::sql_query_parameterized(&pillar, clm_root, &query, params, json) {
Ok(res) => {
if json {
let parsed: serde_json::Value = serde_json::from_str(&res).unwrap_or_else(|_| serde_json::json!([]));
let envelope = serde_json::json!({
"status": "success",
"data": parsed,
"meta": {
"runtime": "rust",
"version": env!("CARGO_PKG_VERSION"),
}
});
stdout.push_str(&serde_json::to_string_pretty(&envelope).unwrap());
stdout.push('\n');
} else if !res.is_empty() {
stdout.push_str(&res);
stdout.push('\n');
}
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[SQL_QUERY] ❌ Error: {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::HandleRegisterBatch { pillar, handle, hash_val, content } => {
match clm_rust_core::db::handle_register_batch(&pillar, clm_root, &handle, &hash_val, &content) {
Ok(_) => (0, stdout, stderr),
Err(e) => {
stderr.push_str(&format!("[HANDLE_REGISTER] ❌ Error: {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::HandleDeleteBatch { pillar, handle } => {
match clm_rust_core::db::handle_delete_batch(&pillar, clm_root, &handle) {
Ok(_) => (0, stdout, stderr),
Err(e) => {
stderr.push_str(&format!("[HANDLE_DELETE] ❌ Error: {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::ArchiveCreate { dir, output, did } => {
let dir_path = std::path::Path::new(&dir);
let out_path = std::path::Path::new(&output);
match clm_rust_core::archive::create_archive(dir_path, out_path, did.as_deref(), clm_root) {
Ok((manifest, vcard_seal)) => {
stdout.push_str(&format!("[ARCHIVE] Created sovereign archive: {}\n[ARCHIVE] Top-level VCard seal: {}\n[ARCHIVE] Registered manifest MCard: {}\n", output, vcard_seal, manifest.archive_id));
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[ARCHIVE ERROR] {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::ArchiveRestore { input, dir } => {
let input_path = std::path::Path::new(&input);
let dir_path = std::path::Path::new(&dir);
match clm_rust_core::archive::restore_archive(input_path, dir_path, clm_root) {
Ok(manifest) => {
stdout.push_str(&format!("[RESTORE] Restored sovereign archive: {}\n[RESTORE] Total verified files: {}\n", manifest.archive_id, manifest.files.len()));
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[RESTORE ERROR] {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::ArchiveVerify { input, dir } => {
let input_path = std::path::Path::new(&input);
let dir_path = std::path::Path::new(&dir);
match clm_rust_core::archive::verify_archive(input_path, dir_path) {
Ok(true) => {
stdout.push_str("[VERIFY] Sovereign archive verification PASSED. All file hashes match.\n");
(0, stdout, stderr)
}
Ok(false) => {
stderr.push_str("[VERIFY ERROR] Verification FAILED. Hash mismatch or missing files.\n");
(1, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[VERIFY ERROR] {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::SyncDeltaCompute { local, peer } => {
let local_path = std::path::Path::new(&local);
let peer_path = std::path::Path::new(&peer);
let local_json = match std::fs::read_to_string(local_path) {
Ok(c) => c,
Err(e) => {
stderr.push_str(&format!("[SYNC ERROR] Failed to read local manifest: {}\n", e));
return (1, stdout, stderr);
}
};
let peer_json = match std::fs::read_to_string(peer_path) {
Ok(c) => c,
Err(e) => {
stderr.push_str(&format!("[SYNC ERROR] Failed to read peer manifest: {}\n", e));
return (1, stdout, stderr);
}
};
let local_manifest: clm_rust_core::archive::ArchiveManifest = match serde_json::from_str(&local_json) {
Ok(m) => m,
Err(e) => {
stderr.push_str(&format!("[SYNC ERROR] Failed to parse local manifest: {}\n", e));
return (1, stdout, stderr);
}
};
let peer_manifest: clm_rust_core::archive::ArchiveManifest = match serde_json::from_str(&peer_json) {
Ok(m) => m,
Err(e) => {
stderr.push_str(&format!("[SYNC ERROR] Failed to parse peer manifest: {}\n", e));
return (1, stdout, stderr);
}
};
let delta = clm_rust_core::crdt::compute_manifest_delta(&local_manifest, &peer_manifest);
let delta_json = serde_json::to_string_pretty(&delta).unwrap_or_default();
stdout.push_str(&format!("[SYNC DELTA] Computed delta set size: {}\n{}\n", delta.len(), delta_json));
(0, stdout, stderr)
}
Commands::SyncMerge { target_db, sharing_mode, hash, content } => {
let db_name = target_db.as_deref().unwrap_or("content_memory.db");
let mode = clm_rust_core::crdt::PartialSharingMode::from_str(&sharing_mode);
let now = chrono::Utc::now().to_rfc3339();
match clm_rust_core::crdt::merge_gset_cards(db_name, clm_root, &[(hash.clone(), content, now)], mode) {
Ok(merged) => {
stdout.push_str(&format!("[SYNC MERGE] Merged {} card(s) into {}\n", merged, db_name));
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[SYNC MERGE ERROR] {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::SubstrateWrite { uri, content } => {
let adapter = match clm_rust_core::substrate::parse_adapter(&uri) {
Ok(a) => a,
Err(e) => {
stderr.push_str(&format!("[SUBSTRATE ERROR] {}\n", e));
return (1, stdout, stderr);
}
};
let bytes = content.as_bytes();
let hash = clm_rust_core::hash::raw_hash_bytes(bytes);
match adapter.write_blob(&hash, bytes) {
Ok(_) => {
stdout.push_str(&format!("[SUBSTRATE WRITE] Wrote hash {} to {}\n", hash, uri));
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[SUBSTRATE WRITE ERROR] {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::SubstrateRead { uri, hash } => {
let adapter = match clm_rust_core::substrate::parse_adapter(&uri) {
Ok(a) => a,
Err(e) => {
stderr.push_str(&format!("[SUBSTRATE ERROR] {}\n", e));
return (1, stdout, stderr);
}
};
match adapter.read_by_hash(&hash) {
Ok(bytes) => {
let content = String::from_utf8_lossy(&bytes);
stdout.push_str(&format!("[SUBSTRATE READ] Hash {} from {}:\n{}\n", hash, uri, content));
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[SUBSTRATE READ ERROR] {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::SubstrateList { uri } => {
let adapter = match clm_rust_core::substrate::parse_adapter(&uri) {
Ok(a) => a,
Err(e) => {
stderr.push_str(&format!("[SUBSTRATE ERROR] {}\n", e));
return (1, stdout, stderr);
}
};
match adapter.list_hashes() {
Ok(hashes) => {
stdout.push_str(&format!("[SUBSTRATE LIST] Found {} hashes in {}:\n", hashes.len(), uri));
for h in &hashes {
stdout.push_str(&format!(" - {}\n", h));
}
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[SUBSTRATE LIST ERROR] {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::SubstrateMigrate { from, to, hash } => {
let src_adapter = match clm_rust_core::substrate::parse_adapter(&from) {
Ok(a) => a,
Err(e) => {
stderr.push_str(&format!("[SUBSTRATE ERROR] Source: {}\n", e));
return (1, stdout, stderr);
}
};
let dst_adapter = match clm_rust_core::substrate::parse_adapter(&to) {
Ok(a) => a,
Err(e) => {
stderr.push_str(&format!("[SUBSTRATE ERROR] Target: {}\n", e));
return (1, stdout, stderr);
}
};
match clm_rust_core::substrate::migrate_mcard(src_adapter.as_ref(), dst_adapter.as_ref(), &hash) {
Ok(vcard) => {
stdout.push_str(&format!("[SUBSTRATE MIGRATE] Migrated hash {} from {} -> {}\n[SUBSTRATE PINNED VCARD] vcard_hash: {}\n", hash, from, to, vcard.vcard_hash));
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[SUBSTRATE MIGRATE ERROR] {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::ObsConfig { tempo, loki, mimir, sampling_rate, db } => {
match clm_rust_core::observability::configure_observability(&db, Some(clm_root), &tempo, &loki, &mimir, Some(sampling_rate)) {
Ok(cfg) => {
stdout.push_str(&format!("[OBS CONFIG] Configured observability telemetry in {}\n Tempo: {}\n Loki: {}\n Mimir: {}\n Sampling Rate: {}\n Handle: {}\n", db, cfg.tempo_endpoint, cfg.loki_endpoint, cfg.mimir_endpoint, cfg.sampling_rate, cfg.handle));
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[OBS CONFIG ERROR] {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::ObsTraceEmit { trace_id, span_id, parent_span_id, pcard, vcard_hash, duration_ms, db } => {
match clm_rust_core::observability::emit_trace_span(&db, Some(clm_root), &trace_id, &span_id, parent_span_id.as_deref(), &pcard, &vcard_hash, duration_ms) {
Ok(tr) => {
stdout.push_str(&format!("[OBS TRACE EMIT] Emitted trace span {} ({}) in {}\n PCard: {}\n VCard Hash: {}\n Duration: {}ms\n Handle: {}\n", tr.trace_id, tr.span_id, db, tr.pcard_handle, tr.vcard_hash, tr.duration_ms, tr.handle));
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[OBS TRACE EMIT ERROR] {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::ObsMetricRecord { metric_name, value, labels, db } => {
match clm_rust_core::observability::record_metric(&db, Some(clm_root), &metric_name, value, labels.as_deref()) {
Ok(m) => {
stdout.push_str(&format!("[OBS METRIC RECORD] Recorded metric {} = {} in {}\n Labels: {}\n Handle: {}\n", m.metric_name, m.value, db, m.labels, m.handle));
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[OBS METRIC RECORD ERROR] {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::ObsLogEmit { trace_id, level, vcard_hash, eoa_did, message, db } => {
match clm_rust_core::observability::emit_structured_log(&db, Some(clm_root), &trace_id, &level, &vcard_hash, &eoa_did, &message) {
Ok(l) => {
stdout.push_str(&format!("[OBS LOG EMIT] Emitted {} log for trace {} in {}\n Log ID: {}\n EOA DID: {}\n VCard Hash: {}\n Message: {}\n", l.level, l.trace_id, db, l.log_id, l.eoa_did, l.vcard_hash, l.message));
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[OBS LOG EMIT ERROR] {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::ObsTraceGet { trace_id, db } => {
match clm_rust_core::observability::get_trace(&db, Some(clm_root), &trace_id) {
Ok(tr) => {
stdout.push_str(&format!("[OBS TRACE GET] Found trace span {}\n PCard: {}\n VCard Hash: {}\n Duration: {}ms\n", tr.trace_id, tr.pcard_handle, tr.vcard_hash, tr.duration_ms));
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[OBS TRACE GET ERROR] {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::ObsMetricGet { metric_name, db } => {
match clm_rust_core::observability::get_metric(&db, Some(clm_root), &metric_name) {
Ok(m) => {
stdout.push_str(&format!("[OBS METRIC GET] Found metric {} = {}\n Labels: {}\n", m.metric_name, m.value, m.labels));
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[OBS METRIC GET ERROR] {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::BackupCreate { tier, output_dir, db } => {
match clm_rust_core::backup::create_backup_snapshot(&db, Some(clm_root), &tier, &output_dir) {
Ok(snap) => {
stdout.push_str(&format!("[BACKUP CREATE] Created {} snapshot {} in {}\n Card Count: {}\n Merkle DAG Root: {}\n Handle: {}\n", snap.tier, snap.snapshot_id, output_dir, snap.card_count, snap.merkle_dag_root, snap.handle));
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[BACKUP CREATE ERROR] {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::BackupRestore { snapshot_id, input_dir, db } => {
match clm_rust_core::backup::restore_backup_snapshot(&db, Some(clm_root), &snapshot_id, &input_dir) {
Ok(rec) => {
stdout.push_str(&format!("[BACKUP RESTORE] ✅ Restored snapshot {} in {}\n Cards Restored: {}\n Verification Verdict: {}\n Handle: {}\n", rec.snapshot_id, db, rec.cards_restored, rec.verification_verdict, rec.handle));
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[BACKUP RESTORE ERROR] {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::BackupVerify { snapshot_id, db } => {
match clm_rust_core::backup::verify_backup_snapshot(&db, Some(clm_root), &snapshot_id) {
Ok(is_valid) => {
if is_valid {
stdout.push_str(&format!("[BACKUP VERIFY] ✅ Snapshot {} restore integrity verified\n", snapshot_id));
(0, stdout, stderr)
} else {
stdout.push_str(&format!("[BACKUP VERIFY] ❌ Snapshot {} restore verification failed\n", snapshot_id));
(1, stdout, stderr)
}
}
Err(e) => {
stderr.push_str(&format!("[BACKUP VERIFY ERROR] {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::BackupShardGenerate { did, secret, guardians, threshold, db } => {
match clm_rust_core::backup::generate_recovery_shards(&db, Some(clm_root), &did, &secret, guardians, threshold) {
Ok(rec) => {
stdout.push_str(&format!("[BACKUP SHARD GENERATE] Generated {} recovery shards ({}/{} threshold) for {}\n Handle: {}\n", rec.guardian_count, rec.threshold, rec.guardian_count, rec.did, rec.handle));
for s in &rec.shards {
stdout.push_str(&format!(" Shard {}: {}\n", s.index, s.value));
}
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[BACKUP SHARD GENERATE ERROR] {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::BackupKeyReassemble { shards } => {
match clm_rust_core::backup::reassemble_recovery_key(&shards) {
Ok(secret) => {
stdout.push_str(&format!("[BACKUP KEY REASSEMBLE] ✅ Secret key reassembled: {}\n", secret));
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[BACKUP KEY REASSEMBLE ERROR] {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::DcaMint { content_hash, owner, db } => {
match clm_rust_core::tokens::mint_dca_nft(&db, Some(clm_root), &content_hash, &owner) {
Ok(dca) => {
stdout.push_str(&format!("[DCA MINT] Minted Digital Content Asset {} (NFT: {}) for {}\n Content Hash: {}\n Handle: {}\n", dca.asset_id, dca.token_id, dca.owner_did, dca.content_hash, dca.handle));
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[DCA MINT ERROR] {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::NftTransfer { token_id, current_owner, new_owner, db } => {
match clm_rust_core::tokens::transfer_nft(&db, Some(clm_root), &token_id, ¤t_owner, &new_owner) {
Ok(rec) => {
stdout.push_str(&format!("[NFT TRANSFER] ✅ Transferred NFT {} from {} to {}\n Handle: {}\n", rec.token_id, rec.previous_owner_did, rec.new_owner_did, rec.handle));
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[NFT TRANSFER ERROR] {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::SbtMint { recipient, role, db } => {
match clm_rust_core::tokens::mint_soulbound_credential(&db, Some(clm_root), &recipient, &role) {
Ok(sbt) => {
stdout.push_str(&format!("[SBT MINT] Minted Soulbound Credential {} ({}) for {}\n Transferable: {}\n Handle: {}\n", sbt.credential_id, sbt.role_name, sbt.recipient_did, sbt.is_transferable, sbt.handle));
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[SBT MINT ERROR] {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::CreditsMint { recipient, amount, db } => {
match clm_rust_core::tokens::mint_community_credits(&db, Some(clm_root), &recipient, amount) {
Ok(c) => {
stdout.push_str(&format!("[CREDITS MINT] Minted {} community credits for {}\n New Balance: {}\n Handle: {}\n", amount, c.did, c.balance, c.handle));
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[CREDITS MINT ERROR] {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::EditionMint { asset_id, owner, edition_no, max_editions, db } => {
match clm_rust_core::tokens::mint_edition_token(&db, Some(clm_root), &asset_id, &owner, edition_no, max_editions) {
Ok(ed) => {
stdout.push_str(&format!("[EDITION MINT] Minted Edition {} ({}/{}) for asset {} to {}\n Handle: {}\n", ed.edition_id, ed.edition_number, ed.max_editions, ed.asset_id, ed.owner_did, ed.handle));
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[EDITION MINT ERROR] {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::ResolveBinary { handle } => {
match clm_rust_core::manifest::resolve_binary(&handle, clm_root) {
Ok(path) => {
stdout.push_str(&path.to_string_lossy());
stdout.push('\n');
(0, stdout, stderr)
}
Err(e) => {
stderr.push_str(&format!("[RESOLVE_BINARY] ❌ Error: {}\n", e));
(1, stdout, stderr)
}
}
}
Commands::Hash { algo, prefixed, file, input } => {
let bytes: Result<Vec<u8>, String> = if let Some(path) = file {
std::fs::read(&path).map_err(|e| format!("Failed to read file '{}': {}", path, e))
} else if let Some(inp) = input {
Ok(inp.into_bytes())
} else {
let mut buffer = Vec::new();
match std::io::stdin().read_to_end(&mut buffer) {
Ok(_) => Ok(buffer),
Err(e) => Err(format!("Failed to read stdin: {}", e)),
}
};
match bytes {
Ok(content) => {
let reg = clm_rust_core::hash::global_registry().lock().unwrap();
let prefix = if algo.ends_with(':') { algo.clone() } else { format!("{}:", algo) };
if let Some(provider) = reg.get(&prefix) {
let raw = provider.hash(&content);
if prefixed {
stdout.push_str(&format!("{}{}\n", provider.prefix(), raw));
} else {
stdout.push_str(&format!("{}\n", raw));
}
(0, stdout, stderr)
} else {
stderr.push_str(&format!("Unknown hash algorithm: '{}'. Available: {:?}\n", algo, reg.algorithms()));
(1, stdout, stderr)
}
}
Err(e) => {
stderr.push_str(&format!("{}\n", e));
(1, stdout, stderr)
}
}
}
_ => (0, String::new(), String::new()),
}
}
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" {
} 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
}
}
}
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
}
}
}