tala-cli 1.0.1

Agent-to-agent messaging for AI coding tools
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

use clap::Parser;
use models::{Envelope, Failure};
mod api;
mod cli;
mod client;
mod daemon;
mod integration;
mod models;
mod store;
#[tokio::main]
async fn main() {
    #[cfg(unix)]
    unsafe {
        libc::signal(libc::SIGPIPE, libc::SIG_DFL);
    }
    let human = std::env::args()
        .take_while(|a| a != "--")
        .any(|a| a == "--human");
    let cli = match cli::Cli::try_parse() {
        Ok(c) => c,
        Err(e) => {
            if matches!(
                e.kind(),
                clap::error::ErrorKind::DisplayHelp | clap::error::ErrorKind::DisplayVersion
            ) {
                let _ = e.print();
                return;
            }
            if human {
                let _ = e.print();
            } else {
                eprintln!(
                    "{}",
                    serde_json::to_string(&Envelope::failure(Failure::new(
                        "USAGE_ERROR",
                        e.to_string(),
                        "Run tala <command> --help."
                    )))
                    .expect("error serializes")
                );
            }
            std::process::exit(2);
        }
    };
    let human = cli.human;
    let is_daemon = matches!(cli.command, Some(cli::Commands::Daemon));
    match cli::run(cli).await {
        Ok(result) => {
            if !is_daemon {
                let attention = client::take_attention();
                if human {
                    cli::render(&result.data, attention.as_ref());
                } else {
                    println!(
                        "{}",
                        serde_json::to_string(&Envelope {
                            attention,
                            ..Envelope::success(result.data)
                        })
                        .expect("output serializes")
                    );
                }
            }
            if result.code != 0 {
                std::process::exit(result.code);
            }
        }
        Err(error) => {
            let code = if error.code == "USAGE_ERROR" {
                2
            } else if error.stored.is_some() {
                4
            } else {
                1
            };
            if human {
                eprintln!("Error: {}\n{}", error.message, error.hint);
                if let Some(next) = &error.next {
                    eprintln!("Next: {next}");
                }
            } else {
                eprintln!(
                    "{}",
                    serde_json::to_string(&Envelope::failure(error)).expect("error serializes")
                );
            }
            std::process::exit(code);
        }
    }
}