aa-cli 0.0.1-alpha.9

aasm — command-line tool for Agent Assembly
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
131
132
133
134
135
136
137
138
139
140

//! `aasm context` — manage named API contexts.

use std::process::ExitCode;

use clap::{Args, Subcommand};

use crate::config;

/// Arguments for the `aasm context` subcommand group.
#[derive(Args)]
pub struct ContextArgs {
    #[command(subcommand)]
    pub command: ContextCommands,
}

/// Available context subcommands.
#[derive(Subcommand)]
pub enum ContextCommands {
    /// List all configured contexts.
    List,
    /// Set or create a named context.
    Set(SetArgs),
    /// Switch the default context.
    Use(UseArgs),
}

/// Arguments for `aasm context set`.
#[derive(Args)]
pub struct SetArgs {
    /// Name of the context to create or update.
    pub name: String,
    /// API URL for this context.
    #[arg(long)]
    pub api_url: String,
    /// API key for this context (optional).
    #[arg(long)]
    pub api_key: Option<String>,
}

/// Arguments for `aasm context use`.
#[derive(Args)]
pub struct UseArgs {
    /// Name of the context to set as default.
    pub name: String,
}

/// Dispatch a context subcommand.
pub fn dispatch(args: ContextArgs) -> ExitCode {
    match args.command {
        ContextCommands::List => run_list(),
        ContextCommands::Set(set_args) => run_set(set_args),
        ContextCommands::Use(use_args) => run_use(use_args),
    }
}

/// List all configured contexts with their API URLs.
fn run_list() -> ExitCode {
    let cfg = match config::load() {
        Ok(c) => c,
        Err(e) => {
            eprintln!("error: {e}");
            return ExitCode::FAILURE;
        }
    };

    if cfg.contexts.is_empty() {
        println!("No contexts configured. Use `aasm context set` to add one.");
        return ExitCode::SUCCESS;
    }

    let default_name = cfg.default_context.as_deref().unwrap_or("");
    for (name, ctx) in &cfg.contexts {
        let marker = if name == default_name { " *" } else { "" };
        let key_status = if ctx.api_key.is_some() { " (key set)" } else { "" };
        println!("{name}{marker}  {}{key_status}", ctx.api_url);
    }
    ExitCode::SUCCESS
}

/// Create or update a named context in the config file.
fn run_set(args: SetArgs) -> ExitCode {
    let mut cfg = match config::load() {
        Ok(c) => c,
        Err(e) => {
            eprintln!("error: {e}");
            return ExitCode::FAILURE;
        }
    };

    cfg.contexts.insert(
        args.name.clone(),
        config::ContextConfig {
            api_url: args.api_url,
            api_key: args.api_key,
        },
    );

    // If this is the first context, make it the default.
    if cfg.contexts.len() == 1 {
        cfg.default_context = Some(args.name.clone());
    }

    if let Err(e) = config::save(&cfg) {
        eprintln!("error: {e}");
        return ExitCode::FAILURE;
    }

    println!("Context '{}' saved.", args.name);
    ExitCode::SUCCESS
}

/// Switch the default context.
fn run_use(args: UseArgs) -> ExitCode {
    let mut cfg = match config::load() {
        Ok(c) => c,
        Err(e) => {
            eprintln!("error: {e}");
            return ExitCode::FAILURE;
        }
    };

    if !cfg.contexts.contains_key(&args.name) {
        eprintln!("error: context '{}' not found", args.name);
        eprintln!("Available contexts:");
        for name in cfg.contexts.keys() {
            eprintln!("  {name}");
        }
        return ExitCode::FAILURE;
    }

    cfg.default_context = Some(args.name.clone());

    if let Err(e) = config::save(&cfg) {
        eprintln!("error: {e}");
        return ExitCode::FAILURE;
    }

    println!("Switched to context '{}'.", args.name);
    ExitCode::SUCCESS
}