xbp_cli/commands/linear_cmd/

issues.rs

//! Linear issue list/create/update operations and CLI handlers.

use super::meta::{
    list_workflow_states, resolve_assignee_id, resolve_label_ids, resolve_state_id, resolve_team_id,
};
use super::{parse_priority_arg, priority_label, require_interactive};
use crate::cli::commands::{
    LinearAssignCmd, LinearCreateCmd, LinearEditCmd, LinearLabelsCmd, LinearListCmd,
    LinearPriorityCmd, LinearShowCmd, LinearStatusCmd,
};
use crate::cli::ui::Loader;
use crate::commands::linear::{linear_graphql_errors, linear_graphql_request};
use crate::commands::text_util::truncate_chars;
use crate::commands::terminal_table::{render_table, TableStyle};
use crate::config::{LinearConfig, SshConfig};
use crate::strategies::deployment_config::XbpConfig;
use crate::utils::find_xbp_config_upwards;
use colored::Colorize;
use dialoguer::{theme::ColorfulTheme, FuzzySelect, Input, MultiSelect};
use serde::Deserialize;
use serde_json::{json, Map as JsonMap, Value as JsonValue};
use std::env;
use std::fs;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct LinearIssue {
    pub id: String,
    pub identifier: String,
    pub title: String,
    pub description: Option<String>,
    pub priority: i32,
    pub url: Option<String>,
    pub state_id: Option<String>,
    pub state_name: Option<String>,
    pub state_type: Option<String>,
    pub assignee_id: Option<String>,
    pub assignee_name: Option<String>,
    pub team_id: Option<String>,
    pub team_key: Option<String>,
    pub team_name: Option<String>,
    pub labels: Vec<(String, String)>, // id, name
}

#[derive(Debug, Clone, Default)]
pub struct ListIssuesFilter {
    pub team_id: Option<String>,
    pub state: Option<String>,
    pub assignee_id: Option<String>,
    pub query: Option<String>,
    pub limit: usize,
}

#[derive(Debug, Clone, Default)]
pub struct CreateIssueInput {
    pub team_id: String,
    pub title: String,
    pub description: Option<String>,
    pub priority: Option<i32>,
    pub state_id: Option<String>,
    pub assignee_id: Option<String>,
    pub label_ids: Vec<String>,
}

#[derive(Debug, Clone, Default)]
pub struct UpdateIssueInput {
    pub title: Option<String>,
    pub description: Option<String>,
    pub priority: Option<i32>,
    pub state_id: Option<String>,
    pub assignee_id: Option<Option<String>>,
    pub label_ids: Option<Vec<String>>,
}

#[derive(Debug, Deserialize)]
struct IssueNode {
    id: String,
    identifier: String,
    title: String,
    #[serde(default)]
    description: Option<String>,
    #[serde(default)]
    priority: i32,
    #[serde(default)]
    url: Option<String>,
    #[serde(default)]
    state: Option<NamedRef>,
    #[serde(default)]
    assignee: Option<NamedRef>,
    #[serde(default)]
    team: Option<TeamRef>,
    #[serde(default)]
    labels: Option<LabelsNodes>,
}

#[derive(Debug, Deserialize)]
struct NamedRef {
    id: String,
    name: String,
    #[serde(default, rename = "type")]
    type_name: Option<String>,
}

#[derive(Debug, Deserialize)]
struct TeamRef {
    id: String,
    key: String,
    name: String,
}

#[derive(Debug, Deserialize)]
struct LabelsNodes {
    nodes: Vec<LabelRef>,
}

#[derive(Debug, Deserialize)]
struct LabelRef {
    id: String,
    name: String,
}

impl From<IssueNode> for LinearIssue {
    fn from(n: IssueNode) -> Self {
        let labels = n
            .labels
            .map(|l| l.nodes.into_iter().map(|x| (x.id, x.name)).collect())
            .unwrap_or_default();
        Self {
            id: n.id,
            identifier: n.identifier,
            title: n.title,
            description: n.description,
            priority: n.priority,
            url: n.url,
            state_id: n.state.as_ref().map(|s| s.id.clone()),
            state_name: n.state.as_ref().map(|s| s.name.clone()),
            state_type: n.state.and_then(|s| s.type_name),
            assignee_id: n.assignee.as_ref().map(|a| a.id.clone()),
            assignee_name: n.assignee.map(|a| a.name),
            team_id: n.team.as_ref().map(|t| t.id.clone()),
            team_key: n.team.as_ref().map(|t| t.key.clone()),
            team_name: n.team.map(|t| t.name),
            labels,
        }
    }
}

const ISSUE_FIELDS: &str = r#"
  id
  identifier
  title
  description
  priority
  url
  state { id name type }
  assignee { id name }
  team { id key name }
  labels { nodes { id name } }
"#;

pub async fn list_issues(
    api_key: &str,
    filter: ListIssuesFilter,
) -> Result<Vec<LinearIssue>, String> {
    let limit = filter.limit.clamp(1, 250);
    let mut filter_obj = JsonMap::new();
    if let Some(team_id) = filter.team_id {
        filter_obj.insert("team".into(), json!({ "id": { "eq": team_id } }));
    }
    if let Some(state) = filter.state {
        let state = state.trim();
        if !state.is_empty() {
            // Accept type (started/completed) or name via OR-ish: try name first via contains
            if matches!(
                state.to_ascii_lowercase().as_str(),
                "backlog" | "unstarted" | "started" | "completed" | "canceled" | "cancelled"
            ) {
                let st = if state.eq_ignore_ascii_case("cancelled") {
                    "canceled"
                } else {
                    state
                };
                filter_obj.insert("state".into(), json!({ "type": { "eq": st } }));
            } else {
                filter_obj.insert("state".into(), json!({ "name": { "eq": state } }));
            }
        }
    }
    if let Some(assignee_id) = filter.assignee_id {
        filter_obj.insert(
            "assignee".into(),
            json!({ "id": { "eq": assignee_id } }),
        );
    }

    let query = if filter_obj.is_empty() {
        format!(
            r#"
            query XbpLinearIssues($first: Int!) {{
              issues(first: $first, orderBy: updatedAt) {{
                nodes {{ {fields} }}
              }}
            }}
            "#,
            fields = ISSUE_FIELDS
        )
    } else {
        format!(
            r#"
            query XbpLinearIssues($first: Int!, $filter: IssueFilter) {{
              issues(first: $first, filter: $filter, orderBy: updatedAt) {{
                nodes {{ {fields} }}
              }}
            }}
            "#,
            fields = ISSUE_FIELDS
        )
    };

    let mut variables = json!({ "first": limit as i64 });
    if !filter_obj.is_empty() {
        variables["filter"] = JsonValue::Object(filter_obj);
    }

    let body = linear_graphql_request(api_key, &json!({ "query": query, "variables": variables }))
        .await?;
    linear_graphql_errors(&body)?;

    let mut issues: Vec<LinearIssue> = body
        .get("data")
        .and_then(|d| d.get("issues"))
        .and_then(|i| i.get("nodes"))
        .and_then(JsonValue::as_array)
        .ok_or_else(|| "Linear issues query returned no data.".to_string())?
        .iter()
        .cloned()
        .map(|v| {
            serde_json::from_value::<IssueNode>(v)
                .map(LinearIssue::from)
                .map_err(|e| format!("Failed to decode Linear issue: {e}"))
        })
        .collect::<Result<Vec<_>, _>>()?;

    if let Some(q) = filter.query {
        let q = q.trim().to_ascii_lowercase();
        if !q.is_empty() {
            issues.retain(|issue| {
                issue.title.to_ascii_lowercase().contains(&q)
                    || issue.identifier.to_ascii_lowercase().contains(&q)
                    || issue
                        .description
                        .as_deref()
                        .is_some_and(|d| d.to_ascii_lowercase().contains(&q))
            });
        }
    }

    Ok(issues)
}

pub async fn get_issue(api_key: &str, id_or_identifier: &str) -> Result<LinearIssue, String> {
    let id = id_or_identifier.trim();
    if id.is_empty() {
        return Err("Issue id or identifier is required.".into());
    }
    let query = format!(
        r#"
        query XbpLinearIssue($id: String!) {{
          issue(id: $id) {{ {fields} }}
        }}
        "#,
        fields = ISSUE_FIELDS
    );
    let body = linear_graphql_request(
        api_key,
        &json!({ "query": query, "variables": { "id": id } }),
    )
    .await?;
    linear_graphql_errors(&body)?;
    let value = body
        .get("data")
        .and_then(|d| d.get("issue"))
        .cloned()
        .filter(|v| !v.is_null())
        .ok_or_else(|| format!("Linear issue `{id}` not found."))?;
    let node: IssueNode =
        serde_json::from_value(value).map_err(|e| format!("Failed to decode Linear issue: {e}"))?;
    Ok(node.into())
}

pub async fn create_issue(api_key: &str, input: CreateIssueInput) -> Result<LinearIssue, String> {
    let mut create_input = JsonMap::new();
    create_input.insert("teamId".into(), json!(input.team_id));
    create_input.insert("title".into(), json!(input.title));
    if let Some(description) = input.description {
        create_input.insert("description".into(), json!(description));
    }
    if let Some(priority) = input.priority {
        create_input.insert("priority".into(), json!(priority));
    }
    if let Some(state_id) = input.state_id {
        create_input.insert("stateId".into(), json!(state_id));
    }
    if let Some(assignee_id) = input.assignee_id {
        create_input.insert("assigneeId".into(), json!(assignee_id));
    }
    if !input.label_ids.is_empty() {
        create_input.insert("labelIds".into(), json!(input.label_ids));
    }

    let query = format!(
        r#"
        mutation XbpLinearIssueCreate($input: IssueCreateInput!) {{
          issueCreate(input: $input) {{
            success
            issue {{ {fields} }}
          }}
        }}
        "#,
        fields = ISSUE_FIELDS
    );
    let body = linear_graphql_request(
        api_key,
        &json!({
            "query": query,
            "variables": { "input": JsonValue::Object(create_input) }
        }),
    )
    .await?;
    linear_graphql_errors(&body)?;
    let payload = body
        .get("data")
        .and_then(|d| d.get("issueCreate"))
        .cloned()
        .ok_or_else(|| "Linear issueCreate returned no data.".to_string())?;
    if payload.get("success").and_then(JsonValue::as_bool) == Some(false) {
        return Err("Linear issueCreate reported success=false.".into());
    }
    let issue = payload
        .get("issue")
        .cloned()
        .ok_or_else(|| "Linear issueCreate returned no issue.".to_string())?;
    let node: IssueNode =
        serde_json::from_value(issue).map_err(|e| format!("Failed to decode created issue: {e}"))?;
    Ok(node.into())
}

pub async fn update_issue(
    api_key: &str,
    id_or_identifier: &str,
    input: UpdateIssueInput,
) -> Result<LinearIssue, String> {
    let existing = get_issue(api_key, id_or_identifier).await?;
    let mut update = JsonMap::new();
    if let Some(title) = input.title {
        update.insert("title".into(), json!(title));
    }
    if let Some(description) = input.description {
        update.insert("description".into(), json!(description));
    }
    if let Some(priority) = input.priority {
        update.insert("priority".into(), json!(priority));
    }
    if let Some(state_id) = input.state_id {
        update.insert("stateId".into(), json!(state_id));
    }
    if let Some(assignee) = input.assignee_id {
        match assignee {
            Some(id) => {
                update.insert("assigneeId".into(), json!(id));
            }
            None => {
                update.insert("assigneeId".into(), JsonValue::Null);
            }
        }
    }
    if let Some(label_ids) = input.label_ids {
        update.insert("labelIds".into(), json!(label_ids));
    }
    if update.is_empty() {
        return Ok(existing);
    }

    let query = format!(
        r#"
        mutation XbpLinearIssueUpdate($id: String!, $input: IssueUpdateInput!) {{
          issueUpdate(id: $id, input: $input) {{
            success
            issue {{ {fields} }}
          }}
        }}
        "#,
        fields = ISSUE_FIELDS
    );
    let body = linear_graphql_request(
        api_key,
        &json!({
            "query": query,
            "variables": {
                "id": existing.id,
                "input": JsonValue::Object(update)
            }
        }),
    )
    .await?;
    linear_graphql_errors(&body)?;
    let payload = body
        .get("data")
        .and_then(|d| d.get("issueUpdate"))
        .cloned()
        .ok_or_else(|| "Linear issueUpdate returned no data.".to_string())?;
    if payload.get("success").and_then(JsonValue::as_bool) == Some(false) {
        return Err("Linear issueUpdate reported success=false.".into());
    }
    let issue = payload
        .get("issue")
        .cloned()
        .ok_or_else(|| "Linear issueUpdate returned no issue.".to_string())?;
    let node: IssueNode =
        serde_json::from_value(issue).map_err(|e| format!("Failed to decode updated issue: {e}"))?;
    Ok(node.into())
}

pub async fn run_list(api_key: &str, args: LinearListCmd) -> Result<(), String> {
    let loader = Loader::start("Fetching Linear issues");
    let filter = build_list_filter(api_key, &args).await;
    let filter = match filter {
        Ok(f) => f,
        Err(e) => {
            loader.fail(&e);
            return Err(e);
        }
    };
    let issues = match list_issues(api_key, filter).await {
        Ok(v) => {
            loader.success();
            v
        }
        Err(e) => {
            loader.fail(&e);
            return Err(e);
        }
    };
    print_issue_table(&issues);
    Ok(())
}

async fn build_list_filter(
    api_key: &str,
    args: &LinearListCmd,
) -> Result<ListIssuesFilter, String> {
    let team_id = if let Some(team) = args.team.as_deref() {
        Some(resolve_team_id(api_key, team).await?)
    } else {
        None
    };
    let assignee_id = if let Some(assignee) = args.assignee.as_deref() {
        resolve_assignee_id(api_key, assignee).await?
    } else {
        None
    };
    Ok(ListIssuesFilter {
        team_id,
        state: args.state.clone(),
        assignee_id,
        query: args.query.clone(),
        limit: args.limit,
    })
}

pub async fn run_show(api_key: &str, args: LinearShowCmd) -> Result<(), String> {
    let loader = Loader::start("Fetching Linear issue");
    let issue = match get_issue(api_key, &args.id).await {
        Ok(v) => {
            loader.success();
            v
        }
        Err(e) => {
            loader.fail(&e);
            return Err(e);
        }
    };
    print_issue_detail(&issue);
    Ok(())
}

pub async fn run_create(api_key: &str, args: LinearCreateCmd) -> Result<(), String> {
    let team_id = match args.team.as_deref() {
        Some(t) if !t.trim().is_empty() => resolve_team_id(api_key, t).await?,
        _ => match default_team_hint() {
            Some(t) => resolve_team_id(api_key, &t).await?,
            None => match super::meta::resolve_team_id_auto(api_key, None).await {
                Ok(id) => id,
                Err(_) if is_tty() => pick_team_interactive(api_key).await?,
                Err(e) => return Err(e),
            },
        },
    };

    let title = match args.title.as_deref() {
        Some(t) if !t.trim().is_empty() => t.trim().to_string(),
        _ if is_tty() => {
            require_interactive("Creating a Linear issue")?;
            Input::<String>::with_theme(&ColorfulTheme::default())
                .with_prompt("Title")
                .interact_text()
                .map_err(|e| e.to_string())?
        }
        _ => return Err("Title is required (`--title`).".into()),
    };

    let description = match args.description.clone() {
        Some(d) => Some(d),
        None if args.interactive_body && is_tty() => {
            let body: String = Input::with_theme(&ColorfulTheme::default())
                .with_prompt("Description (optional)")
                .allow_empty(true)
                .interact_text()
                .map_err(|e| e.to_string())?;
            if body.trim().is_empty() {
                None
            } else {
                Some(body)
            }
        }
        None => None,
    };

    let priority = match args.priority.as_deref() {
        Some(p) => Some(parse_priority_arg(p)?),
        None => None,
    };

    let state_id = match args.state.as_deref() {
        Some(s) => Some(resolve_state_id(api_key, &team_id, s).await?),
        None => None,
    };

    let assignee_id = match args.assignee.as_deref() {
        Some(a) => resolve_assignee_id(api_key, a).await?,
        None => None,
    };

    let label_ids = resolve_label_ids(api_key, Some(&team_id), &args.labels).await?;

    let loader = Loader::start("Creating Linear issue");
    let issue = match create_issue(
        api_key,
        CreateIssueInput {
            team_id,
            title,
            description,
            priority,
            state_id,
            assignee_id,
            label_ids,
        },
    )
    .await
    {
        Ok(v) => {
            loader.success_with(&format!("created {}", v.identifier));
            v
        }
        Err(e) => {
            loader.fail(&e);
            return Err(e);
        }
    };
    print_issue_detail(&issue);
    Ok(())
}

pub async fn run_edit(api_key: &str, args: LinearEditCmd) -> Result<(), String> {
    let mut input = UpdateIssueInput {
        title: args.title.clone(),
        description: args.description.clone(),
        priority: args
            .priority
            .as_deref()
            .map(parse_priority_arg)
            .transpose()?,
        state_id: None,
        assignee_id: None,
        label_ids: None,
    };

    if input.title.is_none()
        && input.description.is_none()
        && input.priority.is_none()
        && args.state.is_none()
        && args.assignee.is_none()
        && args.labels.is_empty()
    {
        require_interactive("Editing a Linear issue")?;
        let issue = get_issue(api_key, &args.id).await?;
        let title: String = Input::with_theme(&ColorfulTheme::default())
            .with_prompt("Title")
            .with_initial_text(&issue.title)
            .interact_text()
            .map_err(|e| e.to_string())?;
        input.title = Some(title);
        let description: String = Input::with_theme(&ColorfulTheme::default())
            .with_prompt("Description")
            .with_initial_text(issue.description.as_deref().unwrap_or(""))
            .allow_empty(true)
            .interact_text()
            .map_err(|e| e.to_string())?;
        input.description = Some(description);
    }

    if let Some(state) = args.state.as_deref() {
        let issue = get_issue(api_key, &args.id).await?;
        let team_id = issue
            .team_id
            .ok_or_else(|| "Issue has no team; cannot resolve state.".to_string())?;
        input.state_id = Some(resolve_state_id(api_key, &team_id, state).await?);
    }
    if let Some(assignee) = args.assignee.as_deref() {
        input.assignee_id = Some(resolve_assignee_id(api_key, assignee).await?);
    }
    if !args.labels.is_empty() {
        let issue = get_issue(api_key, &args.id).await?;
        input.label_ids = Some(
            resolve_label_ids(api_key, issue.team_id.as_deref(), &args.labels).await?,
        );
    }

    let loader = Loader::start("Updating Linear issue");
    let issue = match update_issue(api_key, &args.id, input).await {
        Ok(v) => {
            loader.success_with(&format!("updated {}", v.identifier));
            v
        }
        Err(e) => {
            loader.fail(&e);
            return Err(e);
        }
    };
    print_issue_detail(&issue);
    Ok(())
}

pub async fn run_status(api_key: &str, args: LinearStatusCmd) -> Result<(), String> {
    let issue = get_issue(api_key, &args.id).await?;
    let team_id = issue
        .team_id
        .clone()
        .ok_or_else(|| "Issue has no team; cannot change status.".to_string())?;
    let state = match args.state.as_deref() {
        Some(s) if !s.trim().is_empty() => s.to_string(),
        _ => {
            require_interactive("Changing Linear issue status")?;
            let states = list_workflow_states(api_key, &team_id).await?;
            if states.is_empty() {
                return Err("No workflow states found for this team.".into());
            }
            let labels: Vec<String> = states
                .iter()
                .map(|s| format!("{} ({})", s.name, s.state_type))
                .collect();
            let idx = FuzzySelect::with_theme(&ColorfulTheme::default())
                .with_prompt(format!("Status for {}", issue.identifier))
                .items(&labels)
                .default(0)
                .interact()
                .map_err(|e| e.to_string())?;
            states[idx].name.clone()
        }
    };
    let state_id = resolve_state_id(api_key, &team_id, &state).await?;
    let loader = Loader::start("Updating status");
    let updated = match update_issue(
        api_key,
        &issue.id,
        UpdateIssueInput {
            state_id: Some(state_id),
            ..Default::default()
        },
    )
    .await
    {
        Ok(v) => {
            loader.success();
            v
        }
        Err(e) => {
            loader.fail(&e);
            return Err(e);
        }
    };
    println!(
        "{} {} → {}",
        "OK".bright_green().bold(),
        updated.identifier.bright_white().bold(),
        updated
            .state_name
            .as_deref()
            .unwrap_or("?")
            .bright_cyan()
    );
    Ok(())
}

pub async fn run_priority(api_key: &str, args: LinearPriorityCmd) -> Result<(), String> {
    let priority = match args.priority.as_deref() {
        Some(p) => parse_priority_arg(p)?,
        None => {
            require_interactive("Changing Linear issue priority")?;
            let options = ["None", "Urgent", "High", "Medium", "Low"];
            let idx = FuzzySelect::with_theme(&ColorfulTheme::default())
                .with_prompt(format!("Priority for {}", args.id))
                .items(&options)
                .default(0)
                .interact()
                .map_err(|e| e.to_string())?;
            idx as i32
        }
    };
    let loader = Loader::start("Updating priority");
    let updated = match update_issue(
        api_key,
        &args.id,
        UpdateIssueInput {
            priority: Some(priority),
            ..Default::default()
        },
    )
    .await
    {
        Ok(v) => {
            loader.success();
            v
        }
        Err(e) => {
            loader.fail(&e);
            return Err(e);
        }
    };
    println!(
        "{} {} priority → {}",
        "OK".bright_green().bold(),
        updated.identifier.bright_white().bold(),
        priority_label(updated.priority).bright_yellow()
    );
    Ok(())
}

pub async fn run_labels(api_key: &str, args: LinearLabelsCmd) -> Result<(), String> {
    let issue = get_issue(api_key, &args.id).await?;
    let team_id = issue.team_id.clone();
    let label_ids = if !args.add.is_empty() || !args.set.is_empty() || args.clear {
        if args.clear {
            Vec::new()
        } else if !args.set.is_empty() {
            resolve_label_ids(api_key, team_id.as_deref(), &args.set).await?
        } else {
            let mut current: Vec<String> = issue.labels.iter().map(|(id, _)| id.clone()).collect();
            let add_ids = resolve_label_ids(api_key, team_id.as_deref(), &args.add).await?;
            for id in add_ids {
                if !current.contains(&id) {
                    current.push(id);
                }
            }
            if !args.remove.is_empty() {
                let remove_ids =
                    resolve_label_ids(api_key, team_id.as_deref(), &args.remove).await?;
                current.retain(|id| !remove_ids.contains(id));
            }
            current
        }
    } else {
        require_interactive("Assigning Linear labels")?;
        let known = super::meta::list_labels(api_key, team_id.as_deref()).await?;
        if known.is_empty() {
            return Err("No labels found for this workspace/team.".into());
        }
        let names: Vec<String> = known.iter().map(|l| l.name.clone()).collect();
        let defaults: Vec<bool> = known
            .iter()
            .map(|l| issue.labels.iter().any(|(id, _)| id == &l.id))
            .collect();
        let selected = MultiSelect::with_theme(&ColorfulTheme::default())
            .with_prompt(format!("Labels for {}", issue.identifier))
            .items(&names)
            .defaults(&defaults)
            .interact()
            .map_err(|e| e.to_string())?;
        selected.into_iter().map(|i| known[i].id.clone()).collect()
    };

    let loader = Loader::start("Updating labels");
    let updated = match update_issue(
        api_key,
        &issue.id,
        UpdateIssueInput {
            label_ids: Some(label_ids),
            ..Default::default()
        },
    )
    .await
    {
        Ok(v) => {
            loader.success();
            v
        }
        Err(e) => {
            loader.fail(&e);
            return Err(e);
        }
    };
    let label_str = if updated.labels.is_empty() {
        "(none)".dimmed().to_string()
    } else {
        updated
            .labels
            .iter()
            .map(|(_, n)| n.as_str())
            .collect::<Vec<_>>()
            .join(", ")
    };
    println!(
        "{} {} labels → {}",
        "OK".bright_green().bold(),
        updated.identifier.bright_white().bold(),
        label_str
    );
    Ok(())
}

pub async fn run_assign(api_key: &str, args: LinearAssignCmd) -> Result<(), String> {
    let assignee = match args.assignee.as_deref() {
        Some(a) => a.to_string(),
        None => {
            require_interactive("Assigning a Linear issue")?;
            let users = super::meta::list_users(api_key).await?;
            let mut labels = vec!["(unassign)".to_string(), "me".to_string()];
            labels.extend(users.iter().map(|u| {
                format!(
                    "{}{}",
                    u.display_name.as_deref().unwrap_or(&u.name),
                    u.email
                        .as_ref()
                        .map(|e| format!(" <{e}>"))
                        .unwrap_or_default()
                )
            }));
            let idx = FuzzySelect::with_theme(&ColorfulTheme::default())
                .with_prompt(format!("Assignee for {}", args.id))
                .items(&labels)
                .default(1)
                .interact()
                .map_err(|e| e.to_string())?;
            if idx == 0 {
                "none".to_string()
            } else if idx == 1 {
                "me".to_string()
            } else {
                users[idx - 2].id.clone()
            }
        }
    };
    let assignee_id = resolve_assignee_id(api_key, &assignee).await?;
    let loader = Loader::start("Updating assignee");
    let updated = match update_issue(
        api_key,
        &args.id,
        UpdateIssueInput {
            assignee_id: Some(assignee_id),
            ..Default::default()
        },
    )
    .await
    {
        Ok(v) => {
            loader.success();
            v
        }
        Err(e) => {
            loader.fail(&e);
            return Err(e);
        }
    };
    println!(
        "{} {} assignee → {}",
        "OK".bright_green().bold(),
        updated.identifier.bright_white().bold(),
        updated
            .assignee_name
            .as_deref()
            .unwrap_or("(none)")
            .bright_cyan()
    );
    Ok(())
}

pub fn print_issue_table(issues: &[LinearIssue]) {
    if issues.is_empty() {
        println!("{}", "No issues found.".dimmed());
        return;
    }
    let rows: Vec<Vec<String>> = issues
        .iter()
        .map(|issue| {
            vec![
                issue.identifier.clone().bright_white().bold().to_string(),
                issue
                    .state_name
                    .clone()
                    .unwrap_or_else(|| "-".into())
                    .bright_cyan()
                    .to_string(),
                priority_label(issue.priority).bright_yellow().to_string(),
                issue
                    .assignee_name
                    .clone()
                    .unwrap_or_else(|| "-".into()),
                truncate_chars(&issue.title, 60),
            ]
        })
        .collect();
    print!(
        "{}",
        render_table(
            &["ID", "State", "Pri", "Assignee", "Title"],
            &rows,
            TableStyle::Pipe,
            "",
        )
    );
    println!("Total: {} issue(s)", issues.len());
}

pub fn print_issue_detail(issue: &LinearIssue) {
    println!();
    println!(
        "{} {}",
        issue.identifier.bright_white().bold(),
        issue.title.bright_cyan()
    );
    if let Some(url) = &issue.url {
        println!("{} {}", "url".dimmed(), url.underline());
    }
    println!(
        "{} {}",
        "state".dimmed(),
        issue.state_name.as_deref().unwrap_or("-")
    );
    println!(
        "{} {}",
        "priority".dimmed(),
        priority_label(issue.priority)
    );
    println!(
        "{} {}",
        "assignee".dimmed(),
        issue.assignee_name.as_deref().unwrap_or("-")
    );
    println!(
        "{} {}",
        "team".dimmed(),
        issue
            .team_key
            .as_deref()
            .or(issue.team_name.as_deref())
            .unwrap_or("-")
    );
    let labels = if issue.labels.is_empty() {
        "-".to_string()
    } else {
        issue
            .labels
            .iter()
            .map(|(_, n)| n.as_str())
            .collect::<Vec<_>>()
            .join(", ")
    };
    println!("{} {}", "labels".dimmed(), labels);
    if let Some(desc) = &issue.description {
        if !desc.trim().is_empty() {
            println!();
            println!("{}", desc.trim());
        }
    }
    println!();
}

async fn pick_team_interactive(api_key: &str) -> Result<String, String> {
    require_interactive("Selecting a Linear team")?;
    let teams = super::meta::list_teams(api_key).await?;
    if teams.is_empty() {
        return Err("No Linear teams available for this API key.".into());
    }
    let labels: Vec<String> = teams
        .iter()
        .map(|t| format!("{} — {}", t.key, t.name))
        .collect();
    let idx = FuzzySelect::with_theme(&ColorfulTheme::default())
        .with_prompt("Select Linear team")
        .items(&labels)
        .default(0)
        .interact()
        .map_err(|e| e.to_string())?;
    Ok(teams[idx].id.clone())
}

/// Interactive team picker that persists `linear.default_team_key` (and id) on the project.
pub async fn prompt_and_save_default_team(api_key: &str) -> Result<(), String> {
    require_interactive("Saving default Linear team")?;
    let teams = super::meta::list_teams(api_key).await?;
    if teams.is_empty() {
        return Err("No Linear teams available for this API key.".into());
    }
    let labels: Vec<String> = teams
        .iter()
        .map(|t| format!("{} — {}", t.key, t.name))
        .collect();
    let idx = FuzzySelect::with_theme(&ColorfulTheme::default())
        .with_prompt("Default Linear team for this repo")
        .items(&labels)
        .default(0)
        .interact()
        .map_err(|e| e.to_string())?;
    let selected = &teams[idx];
    save_default_team_to_project(&selected.id, &selected.key)?;
    println!(
        "{} default team `{}` ({}) → .xbp/xbp.yaml",
        "OK".bright_green().bold(),
        selected.key.bright_white().bold(),
        selected.name
    );
    Ok(())
}

fn save_default_team_to_project(team_id: &str, team_key: &str) -> Result<(), String> {
    let cwd = env::current_dir().map_err(|e| format!("cwd: {e}"))?;
    let found = find_xbp_config_upwards(&cwd).ok_or_else(|| {
        "No XBP project config found. Run this inside a repo with `.xbp/xbp.yaml`.".to_string()
    })?;
    let content = fs::read_to_string(&found.config_path)
        .map_err(|e| format!("Failed to read {}: {e}", found.config_path.display()))?;

    let mut root: serde_json::Value = if found.kind == "yaml" {
        let yaml: serde_yaml::Value =
            serde_yaml::from_str(&content).map_err(|e| format!("parse yaml: {e}"))?;
        serde_json::to_value(yaml).map_err(|e| e.to_string())?
    } else {
        serde_json::from_str(&content).map_err(|e| format!("parse json: {e}"))?
    };

    let obj = root
        .as_object_mut()
        .ok_or_else(|| "Project config root must be a mapping.".to_string())?;
    let linear = obj
        .entry("linear".to_string())
        .or_insert_with(|| serde_json::json!({}));
    if linear.is_null() {
        *linear = serde_json::json!({});
    }
    let linear_obj = linear
        .as_object_mut()
        .ok_or_else(|| "Project `linear` must be an object.".to_string())?;
    linear_obj.insert(
        "default_team_id".into(),
        serde_json::Value::String(team_id.to_string()),
    );
    linear_obj.insert(
        "default_team_key".into(),
        serde_json::Value::String(team_key.to_string()),
    );

    if found.kind == "yaml" {
        let yaml_val: serde_yaml::Value =
            serde_json::from_value(root).map_err(|e| e.to_string())?;
        let yaml = serde_yaml::to_string(&yaml_val).map_err(|e| e.to_string())?;
        fs::write(&found.config_path, yaml)
            .map_err(|e| format!("Failed to write {}: {e}", found.config_path.display()))?;
    } else {
        let json = serde_json::to_string_pretty(&root).map_err(|e| e.to_string())?;
        fs::write(&found.config_path, json + "\n")
            .map_err(|e| format!("Failed to write {}: {e}", found.config_path.display()))?;
    }
    Ok(())
}

pub fn default_team_hint() -> Option<String> {
    if let Ok(cwd) = env::current_dir() {
        if let Some(found) = find_xbp_config_upwards(&cwd) {
            if let Ok(content) = fs::read_to_string(&found.config_path) {
                let linear = if found.kind == "yaml" {
                    serde_yaml::from_str::<XbpConfig>(&content)
                        .ok()
                        .and_then(|cfg| cfg.linear)
                } else {
                    serde_json::from_str::<XbpConfig>(&content)
                        .ok()
                        .and_then(|cfg| cfg.linear)
                };
                if let Some(linear) = linear {
                    if let Some(id) = linear.default_team_id.filter(|s| !s.trim().is_empty()) {
                        return Some(id);
                    }
                    if let Some(key) = linear.default_team_key.filter(|s| !s.trim().is_empty()) {
                        return Some(key);
                    }
                }
            }
        }
    }
    if let Ok(cfg) = SshConfig::load() {
        if let Some(LinearConfig {
            default_team_id,
            default_team_key,
            ..
        }) = cfg.linear
        {
            if let Some(id) = default_team_id.filter(|s| !s.trim().is_empty()) {
                return Some(id);
            }
            if let Some(key) = default_team_key.filter(|s| !s.trim().is_empty()) {
                return Some(key);
            }
        }
    }
    None
}

fn is_tty() -> bool {
    crate::commands::cloudflare_config::is_interactive_terminal()
}