clm-kernel 0.0.22

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
#![allow(clippy::items_after_test_module)]
#![allow(clippy::needless_borrow)]
#![allow(clippy::useless_conversion)]
#![allow(clippy::too_many_arguments)]
#![allow(clippy::type_complexity)]
#![allow(clippy::manual_strip)]
#![allow(clippy::collapsible_if)]
#![allow(clippy::if_same_then_else)]
#![allow(clippy::should_implement_trait)]
#![allow(clippy::format_in_format_args)]
#![allow(clippy::unnecessary_unwrap)]
#![allow(clippy::regex_creation_in_loops)]
#![allow(clippy::bool_assert_comparison)]
#![allow(clippy::needless_range_loop)]

use clap::{Parser, Subcommand};
use std::env;
use std::path::Path;

mod commands;

use clm_rust_core::evaluator;

#[derive(Parser)]
#[command(name = "clm_rust_core", version = env!("CARGO_PKG_VERSION"), about = "CLM Compiled Core Migration Engine")]
pub struct Cli {
    #[arg(long, global = true)]
    pub clm_root: Option<String>,

    #[command(subcommand)]
    pub command: Commands,
}

#[derive(Subcommand, Debug, Clone)]
pub enum DbCommands {
    #[command(name = "compact", about = "Run WAL checkpoint TRUNCATE, FTS5 optimize, and VACUUM across Tri-DB")]
    Compact {
        #[arg(long)]
        json: bool,
    },
    #[command(name = "prune", about = "Prune historical execution logs older than keep-days")]
    Prune {
        #[arg(long, default_value = "7")]
        keep_days: u64,
        #[arg(long)]
        json: bool,
    },
}

#[derive(Subcommand)]
pub enum Commands {
    #[command(name = "db", about = "Tri-Database maintenance, compaction, and retention pruning")]
    Db {
        #[command(subcommand)]
        action: DbCommands,
    },
    #[command(name = "db-compact")]
    DbCompact {
        #[arg(long)]
        json: bool,
    },
    #[command(name = "db-prune")]
    DbPrune {
        #[arg(long, default_value = "7")]
        keep_days: u64,
        #[arg(long)]
        json: bool,
    },
    #[command(name = "compose-conditions")] ComposeConditions { clm_file: String, phase: String, #[arg(default_value = "0")] exit_code: i32, #[arg(long)] json: bool, },
    #[command(name = "init-tridb")] InitTridb { #[arg(long)] memory: bool, #[arg(long)] path: Option<String>, #[arg(long)] json: bool, },
    #[command(name = "yaml-load-once")] YamlLoadOnce { file: String, },
    #[command(name = "yaml-get-field")] YamlGetField { json_or_file: String, jq_path: String, },
    #[command(name = "yaml-get-array-length")] YamlGetArrayLength { json_or_file: String, jq_path: String, },
    #[command(name = "yaml-get-array-item")] YamlGetArrayItem { json_or_file: String, jq_path: String, index: usize, },
    #[command(name = "classify")] Classify { json_or_file: String, },
    #[command(name = "detect-dialect")] DetectDialect { json_or_file: String, classification: String, },
    #[command(name = "get-file-handle")] GetFileHandle { raw_path: String, },
    #[command(name = "check-and-register-file-mcard")] CheckAndRegisterFileMcard { file_path: String, },
    #[command(name = "memorize-mcard")] MemorizeMcard { mcard_file: String, pillar_pos: Option<String>, #[arg(short, long, default_value = "auto")] pillar: String, #[arg(long)] handle: Option<String>, #[arg(long)] json: bool, },
    #[command(name = "jsonl-emit")] JsonlEmit { event_type: String, #[arg(num_args = 0..)] kv_args: Vec<String>, },
    #[command(name = "sql-query-parameterized", alias = "sql")] SqlQueryParameterized { pillar: String, query: String, #[arg(num_args = 0..)] params: Vec<String>, #[arg(long)] json: bool, },
    #[command(name = "handle-register-batch")] HandleRegisterBatch { pillar: String, handle: String, hash_val: String, content: String, },
    #[command(name = "handle-delete-batch")] HandleDeleteBatch { pillar: String, handle: String, },
    #[command(name = "daemon")] Daemon { #[arg(long, default_value = "0")] port: u16, },
    #[command(name = "petri-run-net", alias = "run-net")] PetriRunNet { topo_file: String, #[arg(long)] json: bool, },
    #[command(name = "version")] Version { #[arg(long)] json: bool, },
    #[command(name = "check")] Check { #[arg(long)] invariants: bool, #[arg(long)] schema: bool, #[arg(long)] all: bool, #[arg(long)] function_handle: Option<String>, #[arg(long)] json: bool, },
    #[command(name = "action")] Action { #[arg(trailing_var_arg = true, allow_hyphen_values = true, num_args = 0..)] args: Vec<String>, #[arg(long)] json: bool, },
    #[command(name = "workflow")] Workflow { #[arg(trailing_var_arg = true, allow_hyphen_values = true, num_args = 0..)] args: Vec<String>, #[arg(long)] json: bool, },
    #[command(name = "layer5")] Layer5 { #[arg(trailing_var_arg = true, allow_hyphen_values = true, num_args = 0..)] args: Vec<String>, #[arg(long)] json: bool, },
    #[command(name = "mcard")] Mcard { #[arg(trailing_var_arg = true, allow_hyphen_values = true, num_args = 0..)] args: Vec<String>, #[arg(long)] json: bool, },
    #[command(name = "resolve-handle")] ResolveHandle { handle: String, pillar_pos: Option<String>, #[arg(short, long, default_value = clm_rust_core::layer0::vocabulary_env::PILLAR_CONTENT_MEMORY)] pillar: String, #[arg(long)] hash_only: bool, #[arg(long)] json: bool, },
    #[command(name = "compose-nets")] ComposeNets { net_path: String, output_path: String, telemetry_path: String, db_path: String, },
    #[command(name = "normalize-syntax")] NormalizeSyntax { target_file: String, },
    #[command(name = "file-to-mcard")] FileToMcard { source_file: String, output_dir: String, },
    #[command(name = "directory-fs-scan")] DirectoryFsScan { spec_file: String, },
    #[command(name = "directory-to-db")] DirectoryToDb { spec_file: String, },
    #[command(name = "assess-equivalence")] AssessEquivalence { spec_file: String, },
    #[command(name = "split")] Split { clm_file: String, },
    #[command(name = "merge")] Merge { a_file: String, c_file: String, b_file: Option<String>, },
    #[command(name = "hmr", about = "Hot Module Replacement (HMR) for active Cordis fibers")] Hmr { fiber_id: String, new_clm_file: String, },
    #[command(name = "satori-parse", about = "Parse Satori XML elements into normalized AST / MCard")] SatoriParse { #[arg(long)] xml: String, #[arg(long)] id: Option<String>, #[arg(long)] channel: Option<String>, #[arg(long)] user: Option<String>, },
    #[command(name = "satori-format", about = "Serialize Satori AST into normalized XML")] SatoriFormat { #[arg(long)] json: String, },
    #[command(name = "satori-ingest", about = "Ingest Satori message into content_memory.db")] SatoriIngest { #[arg(long)] xml: String, #[arg(long)] id: String, #[arg(long)] channel: String, #[arg(long)] user: String, #[arg(long, default_value = "content_memory.db")] db: String, },
    #[command(name = "satori-prompt", about = "Delimited continuation prompter test")] SatoriPrompt { #[arg(long)] fiber_id: String, #[arg(long)] channel: String, #[arg(long)] prompt: String, #[arg(long)] reply: Option<String>, #[arg(long, default_value = "5000")] timeout_ms: u64, },
    #[command(name = "mdns-discovery")] MdnsDiscovery { #[arg(long, default_value = "both")] mode: String, #[arg(long)] port: Option<u16>, #[arg(long)] name: Option<String>, #[arg(long)] did: Option<String>, #[arg(long)] db: Option<String>, },
    #[command(name = "discovery-node")] DiscoveryNode { #[arg(long)] port: Option<u16>, #[arg(long)] db: Option<String>, },
    #[command(name = "discover")] Discover { #[arg(long)] handshake: Option<String>, #[arg(long)] did: Option<String>, #[arg(long)] key: Option<String>, #[arg(long)] test: bool, },
    #[command(name = "chat-gateway")] ChatGateway { #[arg(long)] port: Option<u16>, #[arg(long)] timeout: Option<u64>, },
    #[command(name = "exec-polyglot")] ExecPolyglot { file: String, payload: Option<String>, },
    #[command(name = "exec-runtime-script")] ExecRuntimeScript,
    #[command(name = "evaluate")] Evaluate { clm_file: Option<String>, payload: Option<String>, post_rc: Option<i32>, #[arg(short, long)] quiet: bool, #[arg(long)] instance_id: Option<String>, #[arg(long, num_args = 0..)] batch: Vec<String>, #[arg(long, default_value = "1")] batch_parallel: usize, #[arg(long)] function_handle: Option<String>, #[arg(long)] json: bool, },
    #[command(name = "prove-tests")] ProveTests { b_file: String, },
    #[command(name = "run-test")] RunTest { test_name: String, },
    #[command(name = "compile")] Compile { a_mcard_path: String, #[arg(long, default_value = "rust")] target: String, #[arg(long)] output_dir: Option<String>, },
    #[command(name = "archive-create")] ArchiveCreate { #[arg(long)] dir: String, #[arg(long)] output: String, #[arg(long)] did: Option<String>, },
    #[command(name = "archive-restore")] ArchiveRestore { #[arg(long)] input: String, #[arg(long)] dir: String, },
    #[command(name = "archive-verify")] ArchiveVerify { #[arg(long)] input: String, #[arg(long)] dir: String, },
    #[command(name = "sync-delta-compute")] SyncDeltaCompute { #[arg(long)] local: String, #[arg(long)] peer: String, },
    #[command(name = "sync-merge")] SyncMerge { #[arg(long)] target_db: Option<String>, #[arg(long, default_value = "full_sovereign")] sharing_mode: String, #[arg(long)] hash: String, #[arg(long)] content: String, },
    #[command(name = "substrate-write")] SubstrateWrite { #[arg(long)] uri: String, #[arg(long)] content: String, },
    #[command(name = "substrate-read")] SubstrateRead { #[arg(long)] uri: String, #[arg(long)] hash: String, },
    #[command(name = "substrate-list")] SubstrateList { #[arg(long)] uri: String, },
    #[command(name = "substrate-migrate")] SubstrateMigrate { #[arg(long)] from: String, #[arg(long)] to: String, #[arg(long)] hash: String, },
    #[command(name = "did-generate")] DidGenerate,
    #[command(name = "did-register")] DidRegister { #[arg(long)] did: String, #[arg(long)] public_key: String, #[arg(long, default_value = "agent_identities.db")] db: String, },
    #[command(name = "sbt-issue")] SbtIssue { #[arg(long)] did: String, #[arg(long)] sbt_type: String, #[arg(long)] capability: String, #[arg(long, default_value = "agent_identities.db")] db: String, },
    #[command(name = "sbt-verify")] SbtVerify { #[arg(long)] did: String, #[arg(long)] sbt_type: String, #[arg(long, default_value = "agent_identities.db")] db: String, },
    #[command(name = "auth-config-mint")] AuthConfigMint { #[arg(long)] handle: String, #[arg(long)] content: String, #[arg(long, default_value = "content_memory.db")] db: String, },
    #[command(name = "auth-config-list")] AuthConfigList { #[arg(long, default_value = "")] pattern: String, #[arg(long, default_value = "content_memory.db")] db: String, },
    #[command(name = "auth-challenge")] AuthChallenge { #[arg(long)] did: String, },
    #[command(name = "auth-sign")] AuthSign { #[arg(long)] challenge: String, #[arg(long)] private_key: String, },
    #[command(name = "auth-verify")] AuthVerify { #[arg(long)] did: String, #[arg(long)] public_key: String, #[arg(long)] challenge: String, #[arg(long)] signature: String, #[arg(long, default_value = "content_memory.db")] db: String, },
    #[command(name = "auth-token-verify")] AuthTokenVerify { #[arg(long)] session_id: String, #[arg(long, default_value = "content_memory.db")] db: String, },
    #[command(name = "idp-register")] IdpRegister { #[arg(long)] provider_id: String, #[arg(long)] provider_type: String, #[arg(long)] issuer_url: String, #[arg(long)] client_id: String, #[arg(long, default_value = "content_memory.db")] db: String, },
    #[command(name = "idp-list")] IdpList { #[arg(long, default_value = "content_memory.db")] db: String, },
    #[command(name = "auth-oidc-exchange")] AuthOidcExchange { #[arg(long)] provider_id: String, #[arg(long)] sub: String, #[arg(long)] email: Option<String>, #[arg(long, default_value = "content_memory.db")] db: String, },
    #[command(name = "auth-siwe-exchange")] AuthSiweExchange { #[arg(long)] wallet: String, #[arg(long, default_value = "0xmock_sig")] signature: String, #[arg(long, default_value = "SIWE_message")] message: String, #[arg(long, default_value = "content_memory.db")] db: String, },
    #[command(name = "payment-rail-register")] PaymentRailRegister { #[arg(long)] rail_id: String, #[arg(long)] rail_type: String, #[arg(long, default_value = "content_memory.db")] db: String, },
    #[command(name = "payment-invoice-create")] PaymentInvoiceCreate { #[arg(long)] buyer: String, #[arg(long)] merchant: String, #[arg(long)] amount: f64, #[arg(long, default_value = "USD")] currency: String, #[arg(long, default_value = "content_memory.db")] db: String, },
    #[command(name = "payment-process")] PaymentProcess { #[arg(long)] invoice_id: String, #[arg(long)] rail_id: String, #[arg(long, default_value = "content_memory.db")] db: String, },
    #[command(name = "payment-receipt-verify")] PaymentReceiptVerify { #[arg(long)] tx_id: String, #[arg(long, default_value = "content_memory.db")] db: String, },
    #[command(name = "obs-config")] ObsConfig { #[arg(long, default_value = clm_rust_core::layer0::provider_profiles::provider_str(clm_rust_core::layer0::vocabulary_types::PROVIDER_OBSERVABILITY, clm_rust_core::layer0::vocabulary_types::PROVIDER_FIELD_OTLP_ENDPOINT))] tempo: String, #[arg(long, default_value = clm_rust_core::layer0::provider_profiles::provider_str(clm_rust_core::layer0::vocabulary_types::PROVIDER_OBSERVABILITY, clm_rust_core::layer0::vocabulary_types::PROVIDER_FIELD_LOKI_ENDPOINT))] loki: String, #[arg(long, default_value = clm_rust_core::layer0::provider_profiles::provider_str(clm_rust_core::layer0::vocabulary_types::PROVIDER_OBSERVABILITY, clm_rust_core::layer0::vocabulary_types::PROVIDER_FIELD_MIMIR_ENDPOINT))] mimir: String, #[arg(long, default_value = "1.0")] sampling_rate: f64, #[arg(long, default_value = "content_memory.db")] db: String, },
    #[command(name = "obs-trace-emit")] ObsTraceEmit { #[arg(long)] trace_id: String, #[arg(long)] span_id: String, #[arg(long)] parent_span_id: Option<String>, #[arg(long)] pcard: String, #[arg(long)] vcard_hash: String, #[arg(long, default_value = "0")] duration_ms: u64, #[arg(long, default_value = "content_memory.db")] db: String, },
    #[command(name = "obs-metric-record")] ObsMetricRecord { #[arg(long)] metric_name: String, #[arg(long)] value: f64, #[arg(long)] labels: Option<String>, #[arg(long, default_value = "content_memory.db")] db: String, },
    #[command(name = "obs-log-emit")] ObsLogEmit { #[arg(long)] trace_id: String, #[arg(long, default_value = "INFO")] level: String, #[arg(long)] vcard_hash: String, #[arg(long)] eoa_did: String, #[arg(long)] message: String, #[arg(long, default_value = "content_memory.db")] db: String, },
    #[command(name = "obs-trace-get")] ObsTraceGet { #[arg(long)] trace_id: String, #[arg(long, default_value = "content_memory.db")] db: String, },
    #[command(name = "obs-metric-get")] ObsMetricGet { #[arg(long)] metric_name: String, #[arg(long, default_value = "content_memory.db")] db: String, },
    #[command(name = "backup-create")] BackupCreate { #[arg(long, default_value = "warm")] tier: String, #[arg(long, default_value = "backups")] output_dir: String, #[arg(long, default_value = "content_memory.db")] db: String, },
    #[command(name = "backup-restore")] BackupRestore { #[arg(long)] snapshot_id: String, #[arg(long, default_value = "backups")] input_dir: String, #[arg(long, default_value = "content_memory.db")] db: String, },
    #[command(name = "backup-verify")] BackupVerify { #[arg(long)] snapshot_id: String, #[arg(long, default_value = "content_memory.db")] db: String, },
    #[command(name = "backup-shard-generate")] BackupShardGenerate { #[arg(long)] did: String, #[arg(long)] secret: String, #[arg(long, default_value = "5")] guardians: u8, #[arg(long, default_value = "3")] threshold: u8, #[arg(long, default_value = "content_memory.db")] db: String, },
    #[command(name = "backup-key-reassemble")] BackupKeyReassemble { #[arg(long)] shards: String, },
    #[command(name = "dca-mint")] DcaMint { #[arg(long)] content_hash: String, #[arg(long)] owner: String, #[arg(long, default_value = "content_memory.db")] db: String, },
    #[command(name = "nft-transfer")] NftTransfer { #[arg(long)] token_id: String, #[arg(long)] current_owner: String, #[arg(long)] new_owner: String, #[arg(long, default_value = "content_memory.db")] db: String, },
    #[command(name = "sbt-mint")] SbtMint { #[arg(long)] recipient: String, #[arg(long)] role: String, #[arg(long, default_value = "content_memory.db")] db: String, },
    #[command(name = "credits-mint")] CreditsMint { #[arg(long)] recipient: String, #[arg(long)] amount: f64, #[arg(long, default_value = "content_memory.db")] db: String, },
    #[command(name = "edition-mint")] EditionMint { #[arg(long)] asset_id: String, #[arg(long)] owner: String, #[arg(long)] edition_no: u32, #[arg(long)] max_editions: u32, #[arg(long, default_value = "content_memory.db")] db: String, },
    #[command(name = "substitute")] Substitute { clm_file: String, new_impl: String, },
    #[command(name = "augment")] Augment { clm_file: String, aug_source: String, },
    #[command(name = "upgrade-evaluator")] UpgradeEvaluator { candidate_yaml: String, },
    #[command(name = "tool")] Tool { #[command(subcommand)] cmd: evaluator::cli::ToolCommands, },
    #[command(name = "evolve")] Evolve { #[command(subcommand)] cmd: evaluator::cli::EvolveCommands, },
    #[command(name = "dispatch-runtime")] DispatchRuntime { #[arg(long)] runtime: String, #[arg(long)] script: String, },
    #[command(name = "okf-mount")] OkfMount { #[arg(long)] path: String, #[arg(long, default_value = "instead")] mode: String, },
    #[command(name = "okf-unmount")] OkfUnmount { #[arg(long)] path: String, },
    #[command(name = "okf-sync")] OkfSync { #[arg(long)] path: String, },
    #[command(name = "cross-pkc-dispatch")] CrossPkcDispatch { #[arg(long)] pcard: String, #[arg(long)] target: String, #[arg(long, default_value = "{}")] input: String, #[arg(long)] endpoint: Option<String>, },
    #[command(name = "resolve-binary")] ResolveBinary { #[arg(long, default_value = "runtime:clm_rust_core")] handle: String, #[arg(long)] self_test: bool, },
    #[command(name = "dependency-graph")] DependencyGraph { #[arg(long)] topo: bool, #[arg(long)] graph: bool, },
    #[command(name = "coherence-audit")] CoherenceAudit { #[arg(long)] json: bool, },
    #[command(name = "gate")] Gate { #[arg(long)] self_test: bool, #[arg(long)] pre: bool, #[arg(long)] post: bool, #[arg(long)] scope: Option<String>, },
    #[command(name = "migrate-meta")] MigrateMeta { #[arg(long)] dry_run: bool, #[arg(long)] apply: bool, },
    #[command(name = "vcard-gate")] VcardGate { #[arg(long)] self_test: bool, #[arg(trailing_var_arg = true, allow_hyphen_values = true, num_args = 0..)] args: Vec<String>, },
    #[command(name = "runtime", about = "Formal runtime registry listing, probing, and execution")]
    Runtime {
        #[command(subcommand)]
        action: commands::helpers_formal::RuntimeSubcommand,
    },
    #[command(name = "hash")] Hash { #[arg(long, default_value = clm_rust_core::layer0::vocabulary::HASH_ALGORITHM_BLAKE3)] algo: String, #[arg(long)] prefixed: bool, #[arg(long)] file: Option<String>, input: Option<String>, },
}

fn main() {
    let mut raw_args = env::args_os();
    let _ = raw_args.next();
    let first = raw_args.next();
    let second = raw_args.next();
    if raw_args.next().is_none() {
        match (
            first.as_deref().and_then(|s| s.to_str()),
            second.as_deref().and_then(|s| s.to_str()),
        ) {
            (Some("version"), Some("--json")) | (Some("--json"), Some("version")) => {
                print!(
                    concat!(
                        "{{\n  \"status\": \"success\",\n  \"data\": {{\n    \"runtime\": \"rust\",\n    \"version\": \"",
                        env!("CARGO_PKG_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\": \"",
                        env!("CARGO_PKG_VERSION"),
                        "\"\n  }}\n}}\n"
                    )
                );
                return;
            }
            (Some("version"), None) => {
                print!(
                    concat!(
                        "clm (runtime: rust, version: ",
                        env!("CARGO_PKG_VERSION"),
                        ", layers: [0, 1, 2, 3, 4, 5], blake3: true)\n"
                    )
                );
                return;
            }
            _ => {}
        }
    }

    if let Ok(mut lock) = clm_rust_core::cpn::vm::EVAL_CALLBACK.write() {
        *lock = Some(clm_rust_core::evaluator::run_evaluation);
    }
    let cli = Cli::parse();

    let clm_root_raw = cli.clm_root.clone().unwrap_or_else(|| {
        clm_rust_core::layer0::environment::var(clm_rust_core::layer0::vocabulary_env::ENV_CLM_ROOT).unwrap_or_else(|_| {
            env::current_dir()
                .map(|p| p.to_string_lossy().to_string())
                .unwrap_or_else(|_| ".".to_string())
        })
    });
    let clm_root = clm_rust_core::fs_utils::normalize_windows_path(Path::new(&clm_root_raw))
        .to_string_lossy()
        .into_owned();

    if !matches!(
        cli.command,
        Commands::Daemon { .. }
            | Commands::Version { .. }
            | Commands::Runtime { .. }
            | Commands::Hash { .. }
            | Commands::MdnsDiscovery { .. }
            | Commands::DiscoveryNode { .. }
            | Commands::Discover { .. }
            | Commands::ChatGateway { .. }
            | Commands::Evaluate { .. }
            | Commands::DependencyGraph { .. }
            | Commands::CoherenceAudit { .. }
            | Commands::Gate { .. }
            | Commands::MigrateMeta { .. }
            | Commands::VcardGate { .. }
            | Commands::ResolveBinary { self_test: true, .. }
    ) {
        let _ = clm_rust_core::layer2::record_store::mcard_cache_prepopulate(&clm_root);
    }

    commands::run_cli(cli.command, &clm_root);
}