feat: add bl team add / update / delete / icon commands

.cspell/dicts/project.txt

@@ -34,3 +34,4 @@ NEWKEY
 burndown
 splitn
 hexdigit
+PRRT

docs/TESTING.md

@@ -149,6 +149,40 @@ fn add_with_text_output_succeeds() { /* json: false */ }
 fn add_with_json_output_succeeds() { /* json: true */ }
 ```
 
+## ANSI color codes in format row tests
+
+`owo_colors` wraps values in ANSI escape sequences. Asserting on bracket-wrapped strings like
+`"[1]"` fails because the brackets are not adjacent to the digits in the raw string:
+
+```rust
+// ❌ fails — ANSI codes are inserted between "[" and "1" and "]"
+assert!(row.contains("[1]"));
+
+// ✅ check the text content only
+assert!(row.contains("1"));
+assert!(row.contains("Fix bug"));
+```
+
+This applies to any `format_*_row` function that uses `.cyan()`, `.bold()`, or similar.
+
+## `#[cfg_attr(test, derive(Debug))]` for `try_new` Args structs
+
+`Result::unwrap_err()` requires `T: Debug` so it can format the *Ok value* when the result is
+unexpectedly `Ok`. When an Args struct using `try_new` is the `T` in `Result<T, _>`, tests that
+call `.unwrap_err()` will fail to compile without `Debug`. Add the conditional derive to avoid
+a compile error without bloating release builds:
+
+```rust
+#[cfg_attr(test, derive(Debug))]
+pub struct MyUpdateArgs { ... }
+
+#[test]
+fn try_new_fails_when_no_fields_provided() {
+    let err = MyUpdateArgs::try_new(...).unwrap_err();  // T=MyUpdateArgs needs Debug
+    assert!(err.to_string().contains("at least one"));
+}
+```
+
 ## Rules
 
 - **Never** call `BacklogClient::from_config()` in tests — it requires real credentials on disk.

src/api/mod.rs

@@ -524,6 +524,18 @@ pub trait BacklogApi {
     fn delete_project_team(&self, _key: &str, _team_id: u64) -> Result<Team> {
         unimplemented!()
     }
+    fn create_team(&self, _params: &[(String, String)]) -> Result<Team> {
+        unimplemented!()
+    }
+    fn update_team(&self, _team_id: u64, _params: &[(String, String)]) -> Result<Team> {
+        unimplemented!()
+    }
+    fn delete_team(&self, _team_id: u64) -> Result<Team> {
+        unimplemented!()
+    }
+    fn download_team_icon(&self, _team_id: u64) -> Result<(Vec<u8>, String)> {
+        unimplemented!()
+    }
     fn get_user_activities(
         &self,
         _user_id: u64,
@@ -1286,6 +1298,22 @@ impl BacklogApi for BacklogClient {
         self.delete_project_team(key, team_id)
     }
 
+    fn create_team(&self, params: &[(String, String)]) -> Result<Team> {
+        self.create_team(params)
+    }
+
+    fn update_team(&self, team_id: u64, params: &[(String, String)]) -> Result<Team> {
+        self.update_team(team_id, params)
+    }
+
+    fn delete_team(&self, team_id: u64) -> Result<Team> {
+        self.delete_team(team_id)
+    }
+
+    fn download_team_icon(&self, team_id: u64) -> Result<(Vec<u8>, String)> {
+        self.download_team_icon(team_id)
+    }
+
     fn get_user_activities(
         &self,
         user_id: u64,

src/api/team.rs

@@ -91,6 +91,43 @@ impl BacklogClient {
             )
         })
     }
+
+    pub fn create_team(&self, params: &[(String, String)]) -> Result<Team> {
+        let value = self.post_form("/teams", params)?;
+        serde_json::from_value(value.clone()).map_err(|e| {
+            anyhow::anyhow!(
+                "Failed to deserialize create team response: {}\nRaw JSON:\n{}",
+                e,
+                serde_json::to_string_pretty(&value).unwrap_or_else(|_| value.to_string())
+            )
+        })
+    }
+
+    pub fn update_team(&self, team_id: u64, params: &[(String, String)]) -> Result<Team> {
+        let value = self.patch_form(&format!("/teams/{team_id}"), params)?;
+        serde_json::from_value(value.clone()).map_err(|e| {
+            anyhow::anyhow!(
+                "Failed to deserialize update team response: {}\nRaw JSON:\n{}",
+                e,
+                serde_json::to_string_pretty(&value).unwrap_or_else(|_| value.to_string())
+            )
+        })
+    }
+
+    pub fn delete_team(&self, team_id: u64) -> Result<Team> {
+        let value = self.delete_req(&format!("/teams/{team_id}"))?;
+        serde_json::from_value(value.clone()).map_err(|e| {
+            anyhow::anyhow!(
+                "Failed to deserialize delete team response: {}\nRaw JSON:\n{}",
+                e,
+                serde_json::to_string_pretty(&value).unwrap_or_else(|_| value.to_string())
+            )
+        })
+    }
+
+    pub fn download_team_icon(&self, team_id: u64) -> Result<(Vec<u8>, String)> {
+        self.download(&format!("/teams/{team_id}/icon"))
+    }
 }
 
 #[cfg(test)]
@@ -271,4 +308,64 @@ mod tests {
         let err = client.delete_project_team("TEST", 1).unwrap_err();
         assert!(err.to_string().contains("No team"));
     }
+
+    #[test]
+    fn create_team_returns_parsed_struct() {
+        let server = MockServer::start();
+        server.mock(|when, then| {
+            when.method(POST).path("/teams");
+            then.status(201).json_body(team_json());
+        });
+
+        let client = BacklogClient::new_with(&server.base_url(), "test-key").unwrap();
+        let params = vec![("name".to_string(), "dev-team".to_string())];
+        let team = client.create_team(&params).unwrap();
+        assert_eq!(team.id, 1);
+        assert_eq!(team.name, "dev-team");
+    }
+
+    #[test]
+    fn update_team_returns_parsed_struct() {
+        let server = MockServer::start();
+        server.mock(|when, then| {
+            when.method(httpmock::Method::PATCH).path("/teams/1");
+            then.status(200).json_body(team_json());
+        });
+
+        let client = BacklogClient::new_with(&server.base_url(), "test-key").unwrap();
+        let params = vec![("name".to_string(), "dev-team".to_string())];
+        let team = client.update_team(1, &params).unwrap();
+        assert_eq!(team.id, 1);
+        assert_eq!(team.name, "dev-team");
+    }
+
+    #[test]
+    fn delete_team_returns_parsed_struct() {
+        let server = MockServer::start();
+        server.mock(|when, then| {
+            when.method(DELETE).path("/teams/1");
+            then.status(200).json_body(team_json());
+        });
+
+        let client = BacklogClient::new_with(&server.base_url(), "test-key").unwrap();
+        let team = client.delete_team(1).unwrap();
+        assert_eq!(team.id, 1);
+        assert_eq!(team.name, "dev-team");
+    }
+
+    #[test]
+    fn download_team_icon_returns_bytes() {
+        let server = MockServer::start();
+        server.mock(|when, then| {
+            when.method(GET).path("/teams/1/icon");
+            then.status(200)
+                .header("Content-Disposition", "attachment; filename=\"icon.png\"")
+                .body(b"png-data");
+        });
+
+        let client = BacklogClient::new_with(&server.base_url(), "test-key").unwrap();
+        let (bytes, filename) = client.download_team_icon(1).unwrap();
+        assert_eq!(bytes, b"png-data");
+        assert_eq!(filename, "icon.png");
+    }
 }

src/cmd/team/add.rs

@@ -0,0 +1,114 @@
+use anstream::println;
+use anyhow::{Context, Result};
+
+use super::format_team_row;
+use crate::api::{BacklogApi, BacklogClient};
+
+pub struct TeamAddArgs {
+    name: String,
+    members: Vec<u64>,
+    json: bool,
+}
+
+impl TeamAddArgs {
+    pub fn new(name: String, members: Vec<u64>, json: bool) -> Self {
+        Self {
+            name,
+            members,
+            json,
+        }
+    }
+}
+
+pub fn add(args: &TeamAddArgs) -> Result<()> {
+    let client = BacklogClient::from_config()?;
+    add_with(args, &client)
+}
+
+pub fn add_with(args: &TeamAddArgs, api: &dyn BacklogApi) -> Result<()> {
+    let mut params = vec![("name".to_string(), args.name.clone())];
+    for id in &args.members {
+        params.push(("members[]".to_string(), id.to_string()));
+    }
+    let team = api.create_team(&params)?;
+    if args.json {
+        println!(
+            "{}",
+            serde_json::to_string_pretty(&team).context("Failed to serialize JSON")?
+        );
+    } else {
+        println!("Created: {}", format_team_row(&team));
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use anyhow::anyhow;
+    use std::collections::BTreeMap;
+
+    use crate::api::team::{Team, TeamMember};
+
+    struct MockApi {
+        team: Option<Team>,
+    }
+
+    impl crate::api::BacklogApi for MockApi {
+        fn create_team(&self, _params: &[(String, String)]) -> anyhow::Result<Team> {
+            self.team.clone().ok_or_else(|| anyhow!("create failed"))
+        }
+    }
+
+    fn sample_member() -> TeamMember {
+        TeamMember {
+            id: 2,
+            user_id: Some("dev".to_string()),
+            name: "Developer".to_string(),
+            role_type: 2,
+            lang: None,
+            mail_address: None,
+            last_login_time: None,
+            extra: BTreeMap::new(),
+        }
+    }
+
+    fn sample_team() -> Team {
+        Team {
+            id: 1,
+            name: "dev-team".to_string(),
+            members: vec![sample_member()],
+            display_order: None,
+            created: "2024-01-01T00:00:00Z".to_string(),
+            updated: "2024-01-01T00:00:00Z".to_string(),
+            extra: BTreeMap::new(),
+        }
+    }
+
+    fn args(json: bool) -> TeamAddArgs {
+        TeamAddArgs::new("dev-team".to_string(), vec![2], json)
+    }
+
+    #[test]
+    fn add_with_text_output_succeeds() {
+        let api = MockApi {
+            team: Some(sample_team()),
+        };
+        assert!(add_with(&args(false), &api).is_ok());
+    }
+
+    #[test]
+    fn add_with_json_output_succeeds() {
+        let api = MockApi {
+            team: Some(sample_team()),
+        };
+        assert!(add_with(&args(true), &api).is_ok());
+    }
+
+    #[test]
+    fn add_with_propagates_api_error() {
+        let api = MockApi { team: None };
+        let err = add_with(&args(false), &api).unwrap_err();
+        assert!(err.to_string().contains("create failed"));
+    }
+}