clm-kernel 0.0.9

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

pub(super) fn run_logic_part2(command: Commands, clm_root: &str, mut stdout: String, mut stderr: String) -> (i32, String, String) {
    match command {
        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)
                }
            }
        }
        other => run_logic_part3(other, clm_root, stdout, stderr),
    }
}