inklog 0.2.0

Enterprise-grade Rust logging infrastructure
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

// Copyright (c) 2026 Kirky.X
// SPDX-License-Identifier: MIT
use anyhow::Result;
use clap::Parser;
use std::path::PathBuf;

use super::{Cli, Commands};
use super::{decrypt, generate, validate};

pub fn run_cli() -> Result<()> {
    let args = Cli::parse();

    match args.command {
        Commands::Decrypt {
            input,
            output,
            key_env,
            recursive,
            batch,
        } => {
            let output = output.unwrap_or_else(|| {
                if input.is_file() {
                    input.with_extension("decrypted.log")
                } else {
                    input.join("decrypted")
                }
            });

            if batch {
                let input_str = input.to_str().ok_or_else(|| {
                    let mut args = fluent_bundle::FluentArgs::new();
                    args.set("path", format!("{:?}", input));
                    anyhow::anyhow!(
                        "{}",
                        inklog::i18n::tr_args("cli-decrypt-err-input-utf8", args)
                    )
                })?;
                decrypt::batch_decrypt(input_str, &output, &key_env)?;
            } else if input.is_file() {
                decrypt::decrypt_file_compatible(&input, &output, &key_env)?;
                let mut args = fluent_bundle::FluentArgs::new();
                args.set("input", input.display().to_string());
                args.set("output", output.display().to_string());
                println!("{}", inklog::i18n::tr_args("cli-decrypt-done", args));
            } else {
                decrypt::decrypt_directory_compatible(&input, &output, &key_env, recursive)?;
                let mut args = fluent_bundle::FluentArgs::new();
                args.set("input", input.display().to_string());
                args.set("output", output.display().to_string());
                println!("{}", inklog::i18n::tr_args("cli-decrypt-dir-done", args));
            }
        }

        Commands::Generate {
            output,
            config_type,
            env_example,
        } => {
            let output_path = output.unwrap_or_else(|| PathBuf::from("."));
            let output_path = if output_path.is_dir() {
                output_path
            } else {
                output_path
                    .parent()
                    .unwrap_or(&PathBuf::from("."))
                    .to_path_buf()
            };

            generate::generate_config(&output_path, &config_type.to_string())?;

            if env_example {
                generate::generate_env_example(&output_path)?;
            }
        }

        Commands::Validate {
            config,
            prerequisites,
        } => {
            if prerequisites {
                validate::check_prerequisites()?;
                return Ok(());
            }

            let config_path = config.unwrap_or_else(|| PathBuf::from("inklog_config.toml"));
            validate::validate_config(&config_path)?;
        }
    }

    Ok(())
}