meld 1.1.5

Deterministic filesystem state management using Merkle trees
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164

//! Meld CLI Binary
//!
//! Command-line interface for the Meld filesystem state management system.

use clap::Parser;
use meld::cli::{Cli, RunContext};
use meld::config::ConfigLoader;
use meld::logging::{init_logging, LoggingConfig};
use std::process;
use tracing::{error, info};

fn main() {
    let cli = Cli::parse();

    // Build logging config from CLI args, env vars, and config file
    let logging_config = build_logging_config(&cli);

    // Initialize logging early
    if let Err(e) = init_logging(Some(&logging_config)) {
        eprintln!("Failed to initialize logging: {}", e);
        process::exit(1);
    }

    info!("Meld CLI starting");

    // Create CLI context
    let context = match RunContext::new(cli.workspace.clone(), cli.config.clone()) {
        Ok(ctx) => {
            info!("CLI context initialized");
            ctx
        }
        Err(e) => {
            error!("Error initializing workspace: {}", e);
            eprintln!("{}", meld::cli::map_error(&e));
            process::exit(1);
        }
    };

    // Execute command
    match context.execute(&cli.command) {
        Ok(output) => {
            info!("Command completed successfully");
            println!("{}", output);
        }
        Err(e) => {
            error!("Command failed: {}", e);
            eprintln!("{}", meld::cli::map_error(&e));
            process::exit(1);
        }
    }
}

/// Build logging configuration from CLI args, environment, and config file.
/// Precedence: CLI flags override config file override defaults.
fn build_logging_config(cli: &Cli) -> LoggingConfig {
    let mut config = if let Some(ref config_path) = cli.config {
        ConfigLoader::load_from_file(config_path)
            .ok()
            .map(|c| c.logging)
            .unwrap_or_default()
    } else {
        ConfigLoader::load(&cli.workspace)
            .ok()
            .map(|c| c.logging)
            .unwrap_or_default()
    };

    if cli.quiet {
        config.enabled = false;
    }
    if cli.verbose {
        config.level = "debug".to_string();
        // Make verbose mode observable in terminal output without losing file logs.
        // An explicit --log-output value still takes precedence below.
        if config.output == "file" {
            config.output = "file+stderr".to_string();
        }
    }
    if let Some(ref level) = cli.log_level {
        config.level = level.clone();
    }
    if let Some(ref format) = cli.log_format {
        config.format = format.clone();
    }
    if let Some(ref output) = cli.log_output {
        config.output = output.clone();
    }

    let output_uses_file = config.output == "file" || config.output == "file+stderr";
    if config.enabled && output_uses_file {
        let resolved = meld::logging::resolve_log_file_path(
            cli.log_file.clone(),
            config.file.clone(),
            Some(cli.workspace.as_path()),
        );
        if let Ok(path) = resolved {
            config.file = Some(path);
        }
    } else if let Some(ref file) = cli.log_file {
        config.file = Some(file.clone());
    }

    config
}

#[cfg(test)]
mod tests {
    use super::*;
    use meld::cli::Cli;

    #[test]
    fn test_build_logging_config_default() {
        let temp = tempfile::tempdir().unwrap();
        let ws = temp.path().to_string_lossy();
        let cli = Cli::try_parse_from(&["meld", "--workspace", ws.as_ref(), "status"]).unwrap();
        let config = build_logging_config(&cli);
        assert!(config.enabled, "default should have logging enabled");
        assert_eq!(config.output, "file", "default output should be file");
        assert_eq!(config.level, "info", "default level should be info");
    }

    #[test]
    fn test_build_logging_config_quiet() {
        let cli = Cli::try_parse_from(&["meld", "--quiet", "status"]).unwrap();
        let config = build_logging_config(&cli);
        assert!(!config.enabled, "quiet should disable logging");
    }

    #[test]
    fn test_build_logging_config_verbose() {
        let temp = tempfile::tempdir().unwrap();
        let ws = temp.path().to_string_lossy();
        let cli = Cli::try_parse_from(&["meld", "--workspace", ws.as_ref(), "--verbose", "status"])
            .unwrap();
        let config = build_logging_config(&cli);
        assert_eq!(config.level, "debug", "verbose should set level to debug");
        assert_eq!(
            config.output, "file+stderr",
            "verbose should mirror logs to stderr when default output is file"
        );
    }

    #[test]
    fn test_build_logging_config_verbose_respects_explicit_output_override() {
        let temp = tempfile::tempdir().unwrap();
        let ws = temp.path().to_string_lossy();
        let cli = Cli::try_parse_from(&[
            "meld",
            "--workspace",
            ws.as_ref(),
            "--verbose",
            "--log-output",
            "stderr",
            "status",
        ])
        .unwrap();
        let config = build_logging_config(&cli);
        assert_eq!(config.level, "debug");
        assert_eq!(
            config.output, "stderr",
            "explicit --log-output should win over verbose defaults"
        );
    }
}