kindly-tools 0.11.14

Development tools and utilities for KindlyGuard ecosystem
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

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

// Platform-specific code will be added here if needed

use kindly_tools::{
    dev::DevCommand, install::InstallCommand, mcp::McpCommand, monitor::MonitorCommand,
    shield::ShieldCommand, wrap::WrapCommand, Execute,
};

#[derive(Parser)]
#[command(
    name = "kindly-tools",
    about = "Development tools and utilities for KindlyGuard ecosystem",
    version,
    author
)]
struct Cli {
    #[command(subcommand)]
    command: Commands,

    /// Enable verbose output
    #[arg(short, long, global = true)]
    verbose: bool,
}

#[derive(Subcommand)]
enum Commands {
    /// Scan files or directories for security threats
    Scan {
        /// Path to scan (file or directory)
        path: String,

        /// Output format (json, table, brief)
        #[arg(short, long, default_value = "table")]
        format: String,

        /// Recursively scan directories
        #[arg(short, long)]
        recursive: bool,

        /// File extensions to include (e.g., json,txt,md)
        #[arg(short, long)]
        extensions: Option<String>,

        /// Maximum file size in MB
        #[arg(long, default_value = "10")]
        max_size_mb: u64,

        /// Configuration file to use
        #[arg(short, long)]
        config: Option<String>,
    },

    /// Install tools and dependencies
    Install(InstallCommand),

    /// Manage MCP (Model Context Protocol) servers
    Mcp(McpCommand),

    /// Development utilities
    Dev(DevCommand),

    /// Wrap any AI CLI command with KindlyGuard protection
    Wrap(WrapCommand),

    /// Monitor KindlyGuard server status in real-time
    Monitor(MonitorCommand),

    /// Security shield commands for protecting AI interactions
    Shield(ShieldCommand),
}

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

    // Initialize logging
    let filter = if cli.verbose {
        EnvFilter::new("kindly_tools=debug,info")
    } else {
        EnvFilter::new("kindly_tools=info,warn")
    };

    tracing_subscriber::fmt()
        .with_env_filter(filter)
        .with_target(false)
        .init();

    match cli.command {
        Commands::Scan {
            path,
            format,
            recursive,
            extensions,
            max_size_mb,
            config,
        } => {
            use kindly_tools::commands::scan;
            scan::execute(path, format, recursive, extensions, max_size_mb, config).await
        },
        Commands::Install(cmd) => cmd.execute().await,
        Commands::Mcp(cmd) => cmd.execute().await,
        Commands::Dev(cmd) => cmd.execute().await,
        Commands::Wrap(cmd) => cmd.execute().await,
        Commands::Monitor(cmd) => cmd.execute().await,
        Commands::Shield(cmd) => cmd.execute().await,
    }
}