clickup-cli 0.9.1

CLI for the ClickUp API, optimized for AI agents
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

use crate::client::ClickUpClient;
use crate::commands::auth::resolve_token;
use crate::commands::workspace::resolve_workspace;
use crate::error::CliError;
use crate::output::OutputConfig;
use crate::Cli;
use clap::Subcommand;

#[derive(Subcommand)]
pub enum SpaceCommands {
    /// List spaces in workspace
    List {
        /// Include archived spaces
        #[arg(long)]
        archived: bool,
    },
    /// Get space details
    Get {
        /// Space ID
        id: String,
    },
    /// Create a new space
    Create {
        /// Space name
        #[arg(long)]
        name: String,
        /// Make space private
        #[arg(long)]
        private: bool,
        /// Allow multiple assignees
        #[arg(long)]
        multiple_assignees: bool,
    },
    /// Update a space
    Update {
        /// Space ID
        id: String,
        /// New name
        #[arg(long)]
        name: Option<String>,
        /// Color hex
        #[arg(long)]
        color: Option<String>,
    },
    /// Delete a space
    Delete {
        /// Space ID
        id: String,
    },
}

pub async fn execute(command: SpaceCommands, cli: &Cli) -> Result<(), CliError> {
    let token = resolve_token(cli)?;
    let client = ClickUpClient::new(&token, cli.timeout)?;
    let output = OutputConfig::from_cli(&cli.output, &cli.fields, cli.no_header, cli.quiet);

    match command {
        SpaceCommands::List { archived } => {
            let ws_id = resolve_workspace(cli)?;
            let resp = client
                .get(&format!("/v2/team/{}/space?archived={}", ws_id, archived))
                .await?;
            let spaces = resp
                .get("spaces")
                .and_then(|s| s.as_array())
                .cloned()
                .unwrap_or_default();
            output.print_items(&spaces, &["id", "name", "private", "archived"], "id");
            Ok(())
        }
        SpaceCommands::Get { id } => {
            let resp = client.get(&format!("/v2/space/{}", id)).await?;
            output.print_single(&resp, &["id", "name", "private", "archived"], "id");
            Ok(())
        }
        SpaceCommands::Create {
            name,
            private,
            multiple_assignees,
        } => {
            let ws_id = resolve_workspace(cli)?;
            let body = serde_json::json!({
                "name": name,
                "multiple_assignees": multiple_assignees,
                "features": {
                    "due_dates": { "enabled": true },
                    "priorities": { "enabled": true },
                    "tags": { "enabled": true },
                    "time_estimates": { "enabled": true },
                },
                "private": private,
            });
            let resp = client
                .post(&format!("/v2/team/{}/space", ws_id), &body)
                .await?;
            output.print_single(&resp, &["id", "name", "private"], "id");
            Ok(())
        }
        SpaceCommands::Update { id, name, color } => {
            let mut body = serde_json::Map::new();
            if let Some(n) = name {
                body.insert("name".into(), serde_json::Value::String(n));
            }
            if let Some(c) = color {
                body.insert("color".into(), serde_json::Value::String(c));
            }
            let resp = client
                .put(
                    &format!("/v2/space/{}", id),
                    &serde_json::Value::Object(body),
                )
                .await?;
            output.print_single(&resp, &["id", "name", "private"], "id");
            Ok(())
        }
        SpaceCommands::Delete { id } => {
            client.delete(&format!("/v2/space/{}", id)).await?;
            output.print_message(&format!("Space {} deleted", id));
            Ok(())
        }
    }
}