shimpz-cli 0.5.38

Fast local tooling for Shimpz Assistants
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

//! Command-line tooling for Shimpz Assistants.

mod args;
mod auth;
mod credentials;
mod develop;
mod human_request;
mod install;
mod invoke;
mod manifest;
mod new_assistant;
mod output;
mod publish;
mod python;
mod source_package;
mod space;
mod toolchain;
mod upgrade;
mod ustar;

#[cfg(test)]
mod source_package_tests;

use std::env;
use std::process::ExitCode;

use args::{AssistantCommand, AuthAction, Command, Invocation};

fn main() -> ExitCode {
    match args::parse(env::args_os().skip(1)) {
        Ok(Invocation::Help) => {
            output::plain(args::HELP.trim_end());
            ExitCode::SUCCESS
        }
        Ok(Invocation::Version) => {
            output::plain(&format!("shimpz {}", env!("CARGO_PKG_VERSION")));
            ExitCode::SUCCESS
        }
        Ok(Invocation::Execute(command)) => run(&command),
        Err(message) => {
            output::error(&message);
            output::warning(args::USAGE);
            ExitCode::from(2)
        }
    }
}

fn run(command: &Command) -> ExitCode {
    let (result, presentation) = match command {
        Command::Auth(AuthAction::Login) => (auth::login(), Presentation::Success),
        Command::Auth(AuthAction::Status) => (auth::status(), Presentation::Info),
        Command::Auth(AuthAction::Logout) => (auth::logout(), Presentation::Success),
        Command::Assistant(AssistantCommand::New { name }) => {
            (new_assistant::run(name), Presentation::Success)
        }
        Command::Assistant(AssistantCommand::Develop {
            agent,
            project,
            yolo,
        }) => (develop::run(*agent, project, *yolo), Presentation::Success),
        Command::Assistant(AssistantCommand::Check { project }) => {
            (check(project), Presentation::Success)
        }
        Command::Assistant(AssistantCommand::Run {
            project,
            action,
            input,
        }) => (invoke::run(project, action, input), Presentation::Data),
        Command::Assistant(AssistantCommand::Publish {
            project,
            visibility,
        }) => (publish::run(project, *visibility), Presentation::Success),
        Command::Assistant(AssistantCommand::Install {
            source_digest,
            team,
        }) => (
            install::run(source_digest, team.as_deref()),
            Presentation::Success,
        ),
        Command::Install(options) => (
            space::lifecycle::install(options),
            if options.print_graph.is_some() {
                Presentation::Data
            } else {
                Presentation::Success
            },
        ),
        Command::Reset => (space::lifecycle::reset(), Presentation::Success),
        Command::Start(options) => (space::lifecycle::start(options), Presentation::Success),
        Command::Status => (space::lifecycle::status(), Presentation::Info),
        Command::Stop => (space::lifecycle::stop(), Presentation::Success),
        Command::Upgrade => (upgrade::run(), Presentation::Success),
    };
    match result {
        Ok(message) => {
            presentation.write(&message);
            ExitCode::SUCCESS
        }
        Err(message) => {
            output::error(&message);
            ExitCode::FAILURE
        }
    }
}

fn check(project: &std::path::Path) -> Result<String, String> {
    let package = source_package::build(project)?;
    python::Assistant::open(project)?.contract()?;
    if let Some(message) = source_package::exclusion_warning(&package) {
        output::warning(&message);
    }
    Ok(source_package::check_summary(&package))
}

#[derive(Clone, Copy)]
enum Presentation {
    Data,
    Info,
    Success,
}

impl Presentation {
    fn write(self, message: &str) {
        match self {
            Self::Data => output::data(message),
            Self::Info => output::info(message),
            Self::Success => output::success(message),
        }
    }
}