hiboss 1.0.0

CLI for AI agents to communicate with their boss
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
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
141
142
143
144
145
146
147
148
149
150
151
152

// Purpose: Manage agent groups via the hiboss CLI.
// Exports: GroupArgs, GroupCommand, and run().
// Dependencies: clap, colored, crate::client, crate::config.

use crate::client::HiBossClient;
use crate::config::Config;
use crate::helpers::short_id;
use clap::{Args, Subcommand};
use colored::Colorize;
use std::error::Error;

#[derive(Debug, Args)]
pub struct GroupArgs {
    #[command(subcommand)]
    pub command: GroupCommand,
}

#[derive(Debug, Subcommand)]
pub enum GroupCommand {
    /// List all groups
    List,
    /// Create a new group
    Create(GroupCreateArgs),
    /// Show group details
    Show(GroupShowArgs),
    /// Delete a group
    Delete(GroupDeleteArgs),
    /// Add a member to a group
    AddMember(GroupMemberArgs),
    /// Remove a member from a group
    RemoveMember(GroupMemberArgs),
    /// Broadcast a message to all group members
    Broadcast(GroupBroadcastArgs),
}

#[derive(Debug, Args)]
pub struct GroupCreateArgs {
    /// Group name
    pub name: String,
    /// Optional description
    #[arg(long)]
    pub description: Option<String>,
}

#[derive(Debug, Args)]
pub struct GroupShowArgs {
    /// Group ID or name
    pub id: String,
}

#[derive(Debug, Args)]
pub struct GroupDeleteArgs {
    /// Group ID
    pub id: String,
}

#[derive(Debug, Args)]
pub struct GroupMemberArgs {
    /// Group ID
    pub group_id: String,
    /// Agent ID
    pub agent_id: String,
}

#[derive(Debug, Args)]
pub struct GroupBroadcastArgs {
    /// Group ID or name
    pub group_id: String,
    /// Message body
    pub body: String,
    /// Priority
    #[arg(long, default_value = "normal")]
    pub priority: String,
}

pub async fn run(args: &GroupArgs, _config: &Config, client: &HiBossClient) -> Result<(), Box<dyn Error>> {
    match &args.command {
        GroupCommand::List => run_list(client).await,
        GroupCommand::Create(a) => run_create(a, client).await,
        GroupCommand::Show(a) => run_show(a, client).await,
        GroupCommand::Delete(a) => run_delete(a, client).await,
        GroupCommand::AddMember(a) => run_add_member(a, client).await,
        GroupCommand::RemoveMember(a) => run_remove_member(a, client).await,
        GroupCommand::Broadcast(a) => run_broadcast(a, client).await,
    }
}

async fn run_list(client: &HiBossClient) -> Result<(), Box<dyn Error>> {
    let groups = client.list_groups().await?;
    let items = groups["groups"].as_array();
    if items.map_or(true, |a| a.is_empty()) {
        eprintln!("No groups found.");
        return Ok(());
    }
    println!("{:<10} {:<20} {:<8} {}", "ID", "Name", "Members", "Created");
    for g in items.unwrap() {
        let id = short_id(g["id"].as_str().unwrap_or(""));
        let name = g["name"].as_str().unwrap_or("-");
        let count = g["member_count"].as_u64().unwrap_or(0);
        let created = g["created_at"].as_str().unwrap_or("-");
        println!("{:<10} {:<20} {:<8} {}", id.green(), name, count, created.dimmed());
    }
    Ok(())
}

async fn run_create(args: &GroupCreateArgs, client: &HiBossClient) -> Result<(), Box<dyn Error>> {
    let group = client.create_group(&args.name, args.description.as_deref()).await?;
    let id = group["id"].as_str().unwrap_or("unknown");
    eprintln!("Group created: {} ({})", args.name, short_id(id));
    Ok(())
}

async fn run_show(args: &GroupShowArgs, client: &HiBossClient) -> Result<(), Box<dyn Error>> {
    let group = client.get_group(&args.id).await?;
    println!("Name: {}", group["name"].as_str().unwrap_or("-"));
    println!("Description: {}", group["description"].as_str().unwrap_or("-"));
    let members = group["members"].as_array();
    println!("Members:");
    if let Some(members) = members {
        for m in members {
            let id = short_id(m["id"].as_str().unwrap_or(""));
            let name = m["name"].as_str().unwrap_or("-");
            println!("  {} {}", id.green(), name);
        }
    }
    Ok(())
}

async fn run_delete(args: &GroupDeleteArgs, client: &HiBossClient) -> Result<(), Box<dyn Error>> {
    client.delete_group(&args.id).await?;
    eprintln!("Group deleted");
    Ok(())
}

async fn run_add_member(args: &GroupMemberArgs, client: &HiBossClient) -> Result<(), Box<dyn Error>> {
    client.add_group_member(&args.group_id, &args.agent_id).await?;
    eprintln!("Member added");
    Ok(())
}

async fn run_remove_member(args: &GroupMemberArgs, client: &HiBossClient) -> Result<(), Box<dyn Error>> {
    client.remove_group_member(&args.group_id, &args.agent_id).await?;
    eprintln!("Member removed");
    Ok(())
}

async fn run_broadcast(args: &GroupBroadcastArgs, client: &HiBossClient) -> Result<(), Box<dyn Error>> {
    let result = client.broadcast_to_group(&args.group_id, &args.body, &args.priority).await?;
    let count = result["count"].as_u64().unwrap_or(0);
    eprintln!("Broadcast sent to {} agents", count);
    Ok(())
}