feature: bt datasets

src/datasets/api.rs

@@ -0,0 +1,68 @@
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+use urlencoding::encode;
+
+use crate::http::ApiClient;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Dataset {
+    pub id: String,
+    pub name: String,
+    pub project_id: String,
+    #[serde(default)]
+    pub description: Option<String>,
+    #[serde(default)]
+    pub created: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct ListResponse {
+    objects: Vec<Dataset>,
+}
+
+pub async fn list_datasets(client: &ApiClient, project: &str) -> Result<Vec<Dataset>> {
+    let path = format!(
+        "/v1/dataset?org_name={}&project_name={}",
+        encode(client.org_name()),
+        encode(project)
+    );
+    let list: ListResponse = client.get(&path).await?;
+    Ok(list.objects)
+}
+
+pub async fn get_dataset_by_name(
+    client: &ApiClient,
+    project: &str,
+    name: &str,
+) -> Result<Option<Dataset>> {
+    let path = format!(
+        "/v1/dataset?org_name={}&project_name={}&dataset_name={}",
+        encode(client.org_name()),
+        encode(project),
+        encode(name)
+    );
+    let list: ListResponse = client.get(&path).await?;
+    Ok(list.objects.into_iter().next())
+}
+
+pub async fn create_dataset(
+    client: &ApiClient,
+    project_id: &str,
+    name: &str,
+    description: Option<&str>,
+) -> Result<Dataset> {
+    let mut body = serde_json::json!({
+        "name": name,
+        "project_id": project_id,
+        "org_name": client.org_name(),
+    });
+    if let Some(desc) = description {
+        body["description"] = serde_json::Value::String(desc.to_string());
+    }
+    client.post("/v1/dataset", &body).await
+}
+
+pub async fn delete_dataset(client: &ApiClient, dataset_id: &str) -> Result<()> {
+    let path = format!("/v1/dataset/{}", encode(dataset_id));
+    client.delete(&path).await
+}

src/datasets/create.rs

@@ -0,0 +1,58 @@
+use std::time::Duration;
+
+use anyhow::bail;
+use anyhow::Result;
+use dialoguer::Input;
+
+use crate::ui::{
+    is_interactive, print_command_status, with_spinner, with_spinner_visible, CommandStatus,
+};
+
+use super::{api, ResolvedContext};
+
+pub async fn run(
+    ctx: &ResolvedContext,
+    name: Option<&str>,
+    description: Option<&str>,
+) -> Result<()> {
+    let project_name = &ctx.project.name;
+    let name = match name {
+        Some(n) if !n.is_empty() => n.to_string(),
+        _ => {
+            if !is_interactive() {
+                bail!("dataset name required. Use: bt datasets create <name>");
+            }
+            Input::new().with_prompt("Dataset name").interact_text()?
+        }
+    };
+
+    // Check if dataset already exists
+    let exists = with_spinner(
+        "Checking dataset...",
+        api::get_dataset_by_name(&ctx.client, project_name, &name),
+    )
+    .await?;
+    if exists.is_some() {
+        bail!("dataset '{name}' already exists in project '{project_name}'");
+    }
+
+    match with_spinner_visible(
+        "Creating dataset...",
+        api::create_dataset(&ctx.client, &ctx.project.id, &name, description),
+        Duration::from_millis(300),
+    )
+    .await
+    {
+        Ok(_) => {
+            print_command_status(
+                CommandStatus::Success,
+                &format!("Created dataset '{name}' in {project_name}"),
+            );
+            Ok(())
+        }
+        Err(e) => {
+            print_command_status(CommandStatus::Error, &format!("Failed to create '{name}'"));
+            Err(e)
+        }
+    }
+}

src/datasets/delete.rs

@@ -0,0 +1,82 @@
+use anyhow::{anyhow, bail, Result};
+use dialoguer::Confirm;
+
+use crate::{
+    datasets::api::{self, Dataset},
+    http::ApiClient,
+    ui::{self, is_interactive, print_command_status, with_spinner, CommandStatus},
+};
+
+use super::ResolvedContext;
+
+pub async fn run(ctx: &ResolvedContext, name: Option<&str>, force: bool) -> Result<()> {
+    let project_name = &ctx.project.name;
+    if force && name.is_none() {
+        bail!("name required when using --force. Use: bt datasets delete <name> --force");
+    }
+
+    let dataset = match name {
+        Some(n) => api::get_dataset_by_name(&ctx.client, project_name, n)
+            .await?
+            .ok_or_else(|| anyhow!("dataset '{n}' not found"))?,
+        None => {
+            if !is_interactive() {
+                bail!("dataset name required. Use: bt datasets delete <name>");
+            }
+            select_dataset_interactive(&ctx.client, project_name).await?
+        }
+    };
+
+    if !force && is_interactive() {
+        let confirm = Confirm::new()
+            .with_prompt(format!(
+                "Delete dataset '{}' from {}?",
+                &dataset.name, project_name
+            ))
+            .default(false)
+            .interact()?;
+
+        if !confirm {
+            return Ok(());
+        }
+    }
+
+    match with_spinner(
+        "Deleting dataset...",
+        api::delete_dataset(&ctx.client, &dataset.id),
+    )
+    .await
+    {
+        Ok(_) => {
+            print_command_status(
+                CommandStatus::Success,
+                &format!("Deleted '{}'", dataset.name),
+            );
+            if !crate::ui::is_quiet() {
+                eprintln!("Run `bt datasets list` to see remaining datasets.");
+            }
+            Ok(())
+        }
+        Err(e) => {
+            print_command_status(
+                CommandStatus::Error,
+                &format!("Failed to delete '{}'", dataset.name),
+            );
+            Err(e)
+        }
+    }
+}
+
+pub async fn select_dataset_interactive(client: &ApiClient, project: &str) -> Result<Dataset> {
+    let mut datasets =
+        with_spinner("Loading datasets...", api::list_datasets(client, project)).await?;
+    if datasets.is_empty() {
+        bail!("no datasets found");
+    }
+
+    datasets.sort_by(|a, b| a.name.cmp(&b.name));
+    let names: Vec<&str> = datasets.iter().map(|d| d.name.as_str()).collect();
+
+    let selection = ui::fuzzy_select("Select dataset", &names, 0)?;
+    Ok(datasets[selection].clone())
+}

src/datasets/list.rs

@@ -0,0 +1,64 @@
+use std::fmt::Write as _;
+
+use anyhow::Result;
+use dialoguer::console;
+
+use crate::{
+    ui::{apply_column_padding, header, print_with_pager, styled_table, truncate, with_spinner},
+    utils::pluralize,
+};
+
+use super::{api, ResolvedContext};
+
+pub async fn run(ctx: &ResolvedContext, json: bool) -> Result<()> {
+    let project_name = &ctx.project.name;
+    let datasets = with_spinner(
+        "Loading datasets...",
+        api::list_datasets(&ctx.client, project_name),
+    )
+    .await?;
+
+    if json {
+        println!("{}", serde_json::to_string(&datasets)?);
+        return Ok(());
+    }
+
+    let mut output = String::new();
+
+    let count = format!(
+        "{} {}",
+        datasets.len(),
+        pluralize(datasets.len(), "dataset", None)
+    );
+    writeln!(
+        output,
+        "{} found in {} {} {}\n",
+        console::style(count),
+        console::style(ctx.client.org_name()).bold(),
+        console::style("/").dim().bold(),
+        console::style(project_name).bold()
+    )?;
+
+    let mut table = styled_table();
+    table.set_header(vec![
+        header("Name"),
+        header("Description"),
+        header("Created"),
+    ]);
+    apply_column_padding(&mut table, (0, 6));
+
+    for dataset in &datasets {
+        let desc = dataset
+            .description
+            .as_deref()
+            .filter(|s| !s.is_empty())
+            .map(|s| truncate(s, 60))
+            .unwrap_or_else(|| "-".to_string());
+        let created = dataset.created.as_deref().unwrap_or("-").to_string();
+        table.add_row(vec![&dataset.name, &desc, &created]);
+    }
+
+    write!(output, "{table}")?;
+    print_with_pager(&output)?;
+    Ok(())
+}