#![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),
}
}