talahon 2.3.0

Talon — automated AI SOC analyst (host orchestrator)
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

//! `talon` host binary. See the library docs (`talon` crate) for the
//! architecture; this file only parses the command line, sets up logging
//! and dispatches.

use std::path::{Path, PathBuf};
use std::process::ExitCode;
use std::sync::Arc;

use clap::Parser;
use talon::cli::{AuditCommand, Cli, Command, EvalCommand};
use talon::logging::{self, LogFormat, LogTarget};
use talon_core::config::TalonConfig;
use talon_core::env::EnvFile;

fn exit_code(code: i32) -> ExitCode {
    ExitCode::from(u8::try_from(code).unwrap_or(1))
}

/// Load `.env`, install logging (redacting, format from
/// `TALON_LOG_FORMAT`) and resolve the configuration.
fn bootstrap(
    root: &Path,
    target: LogTarget,
    default_filter: &str,
) -> (Arc<TalonConfig>, Arc<talon_security::redact::Redactor>) {
    let env = EnvFile::load(root);
    let format = LogFormat::parse(env.get("TALON_LOG_FORMAT").as_deref());
    let redactor = talon::secrets::redactor_for(&env);
    logging::init(format, target, default_filter, redactor.clone());
    (Arc::new(TalonConfig::from_env(root, env)), redactor)
}

async fn dispatch(cli: Cli, root: PathBuf) -> i32 {
    match cli.command() {
        Command::Version => {
            println!("talon {}", talon::VERSION);
            0
        }
        Command::Run => {
            let (config, redactor) = bootstrap(&root, LogTarget::Stdout, "info");
            match talon::app::run(config, redactor).await {
                Ok(()) => 0,
                Err(e) => {
                    tracing::error!(error = %format!("{e:#}"), "Failed to start Talon");
                    1
                }
            }
        }
        Command::Setup(args) => {
            let _ = bootstrap(&root, LogTarget::Stderr, "info");
            let ctx = talon_setup::SetupContext::detect(&root);
            match talon_setup::run_step_by_name(&args.step, &args.args, &ctx).await {
                Ok(outcome) => {
                    println!("{}", outcome.render());
                    outcome.exit_code
                }
                Err(unknown) => {
                    eprintln!("{unknown}");
                    1
                }
            }
        }
        Command::Doctor => {
            let (config, _) = bootstrap(&root, LogTarget::Stderr, "warn");
            talon::doctor::run(&root, &config).await
        }
        Command::Eval { command } => {
            let (config, _) = bootstrap(&root, LogTarget::Stderr, "warn");
            match command {
                EvalCommand::Score(args) => talon::eval_cmd::score(&root, args),
                EvalCommand::Run(args) => talon::eval_cmd::run(&root, &config, args).await,
            }
        }
        Command::Audit { command } => {
            let (config, _) = bootstrap(&root, LogTarget::Stderr, "warn");
            let result = match command {
                AuditCommand::Verify => talon::audit_cmd::verify(&config),
                AuditCommand::Head => talon::audit_cmd::head(&config),
                AuditCommand::Tail { lines, kind } => {
                    talon::audit_cmd::tail(&config, *lines, kind.as_deref())
                }
            };
            result.unwrap_or_else(|e| {
                eprintln!("talon audit: {e:#}");
                1
            })
        }
    }
}

fn main() -> ExitCode {
    let cli = Cli::parse();
    let root = match cli.resolve_project_root() {
        Ok(root) => root,
        Err(e) => {
            eprintln!("talon: cannot determine the project directory: {e}");
            return ExitCode::from(1);
        }
    };
    let runtime = match tokio::runtime::Builder::new_multi_thread()
        .enable_all()
        .thread_name("talon")
        .build()
    {
        Ok(rt) => rt,
        Err(e) => {
            eprintln!("talon: cannot start the async runtime: {e}");
            return ExitCode::from(1);
        }
    };
    exit_code(runtime.block_on(dispatch(cli, root)))
}