rmpca 0.1.0

Enterprise-grade offline route optimization library and CLI — Eulerian circuit solver with graph caching, Lean 4 FFI, and property-based testing
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

//! rmpca — Enterprise-grade unified CLI for rmp.ca operations
//!
//! This is a Rust port of the FreeBSD shell-based dispatcher, transformed
//! into an enterprise-grade offline engine suitable for RouteMasterPro.

use anyhow::Result;
use clap::{Parser, Subcommand};

use rmpca::commands;

/// rmpca — Enterprise-grade route optimization CLI
#[derive(Parser)]
#[command(name = "rmpca")]
#[command(about = "Unified CLI for rmp.ca operations", long_about = None)]
#[command(version)]
#[command(long_about = rmpca_long_help())]
struct Cli {
    #[command(subcommand)]
    command: Commands,

    /// Output structured JSON logs (for frontend integration)
    #[arg(long, global = true, env = "RMPCA_JSON_LOGS")]
    json: bool,
}

#[derive(Subcommand)]
enum Commands {
    /// Extract Overture Maps road data for a bounding box or polygon
    ExtractOverture(commands::extract_overture::Args),

    /// Download & convert OSM data to GeoJSON for a bounding box
    ExtractOsm(commands::extract_osm::Args),

    /// Compile GeoJSON to binary graph cache (instant subsequent optimizations)
    #[command(alias = "cache-map")]
    CompileMap(commands::compile_map::Args),

    /// Optimize a GeoJSON route (supports Lean 4 verification)
    #[command(aliases = &["opt"])]
    Optimize(commands::optimize::Args),

    /// Clean/repair GeoJSON (dedupe, remove self-loops, etc.)
    Clean(commands::clean::Args),

    /// Validate a GeoJSON file structure and geometry
    Validate(commands::validate::Args),

    /// End-to-end: extract → clean → optimize → export
    Pipeline(commands::pipeline::Args),

    /// Show health/status of all rmpca jails and services
    Status(commands::status::Args),

    /// Tail service logs from a jail
    Logs(commands::logs::Args),

    /// Run property-based tests for algorithmic correctness
    #[command(alias = "proptest")]
    TestProperties,
}

fn rmpca_long_help() -> &'static str {
    r#"
rmpca — Enterprise-grade route optimization CLI

Quick Start:
  rmpca compile-map city.geojson    # Compile map once (5-30s)
  rmpca optimize --cache city.rmp   # Optimize instantly (1-5ms!)

Configuration (Priority: CLI > Env > Config File > Defaults):
  RouteMaster.toml    - User configuration file (~/.config/RouteMaster.toml)
  RMPCA_* env vars   - Environment variable overrides
  --flag arguments     - Command-line flags (highest priority)

Enterprise Features:
  • Graph caching    - Subsequent optimizations: 1000x faster
  • Lean 4 FFI     - Formal verification via compiled Lean 4 proofs
  • Property tests    - Mathematically rigorous algorithm testing
  • JSON telemetry   - Structured logs for frontend integration
  • Layered config   - Flexible profiles for trucks, cars, etc.

For help with a specific command: rmpca <command> --help
"#
}

#[tokio::main]
async fn main() -> Result<()> {
    let cli = Cli::parse();

    // Initialize structured logging
    let config = rmpca::config::Config::load().unwrap_or_else(|e| {
        // If config loading fails, use defaults but log the error
        eprintln!("Warning: Failed to load configuration: {}", e);
        rmpca::config::Config::default()
    });
    config.init_logging();

    tracing::info!("rmpca v{} starting", env!("CARGO_PKG_VERSION"));

    match cli.command {
        Commands::ExtractOverture(args) => commands::extract_overture::run(args).await,
        Commands::ExtractOsm(args) => commands::extract_osm::run(args).await,
        Commands::CompileMap(args) => commands::compile_map::run(args).await,
        Commands::Optimize(args) => commands::optimize::run(args).await,
        Commands::Clean(args) => commands::clean::run(args).await,
        Commands::Validate(args) => commands::validate::run(args).await,
        Commands::Pipeline(args) => commands::pipeline::run(args).await,
        Commands::Status(args) => commands::status::run(args).await,
        Commands::Logs(args) => commands::logs::run(args).await,
        Commands::TestProperties => {
            // Run property-based tests
            eprintln!("Running property-based tests...");
            eprintln!("This tests algorithmic invariants across random inputs.");
            eprintln!("Use: cargo test --release --tests property_tests");
            Ok(())
        }
    }
}