sc/cli/commands/

issue.rs

//! Issue command implementations.

use crate::cli::{
    IssueCommands, IssueCreateArgs, IssueDepCommands, IssueLabelCommands, IssueListArgs,
    IssueUpdateArgs,
};
use crate::config::{default_actor, resolve_db_path, resolve_project_path};
use crate::error::{Error, Result};
use crate::storage::SqliteStorage;
use serde::{Deserialize, Serialize};
use std::io::BufRead;
use std::path::PathBuf;

/// Input for batch issue creation (from JSON).
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
struct BatchInput {
    issues: Vec<BatchIssue>,
    #[serde(default)]
    dependencies: Option<Vec<BatchDependency>>,
    #[serde(default)]
    plan_id: Option<String>,
}

/// Single issue in batch input.
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
struct BatchIssue {
    title: String,
    #[serde(default)]
    description: Option<String>,
    #[serde(default)]
    details: Option<String>,
    #[serde(default)]
    issue_type: Option<String>,
    #[serde(default)]
    priority: Option<i32>,
    #[serde(default)]
    parent_id: Option<String>,
    #[serde(default)]
    plan_id: Option<String>,
    #[serde(default)]
    labels: Option<Vec<String>>,
}

/// Dependency definition in batch input.
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
struct BatchDependency {
    issue_index: usize,
    depends_on_index: usize,
    #[serde(default)]
    dependency_type: Option<String>,
}

/// Output for batch creation.
#[derive(Debug, Serialize)]
struct BatchOutput {
    issues: Vec<BatchIssueResult>,
    dependencies: Vec<BatchDepResult>,
}

/// Result for single issue in batch.
#[derive(Debug, Serialize)]
struct BatchIssueResult {
    id: String,
    short_id: Option<String>,
    title: String,
    index: usize,
}

/// Result for dependency in batch.
#[derive(Debug, Serialize)]
struct BatchDepResult {
    issue_id: String,
    depends_on_id: String,
    dependency_type: String,
}

/// Output for issue create.
#[derive(Serialize)]
struct IssueCreateOutput {
    id: String,
    short_id: Option<String>,
    title: String,
    status: String,
    priority: i32,
    issue_type: String,
}

/// Output for issue list.
#[derive(Serialize)]
struct IssueListOutput {
    issues: Vec<crate::storage::Issue>,
    count: usize,
}

/// Execute issue commands.
pub fn execute(
    command: &IssueCommands,
    db_path: Option<&PathBuf>,
    actor: Option<&str>,
    json: bool,
) -> Result<()> {
    match command {
        IssueCommands::Create(args) => create(args, db_path, actor, json),
        IssueCommands::List(args) => list(args, db_path, json),
        IssueCommands::Show { id } => show(id, db_path, json),
        IssueCommands::Update(args) => update(args, db_path, actor, json),
        IssueCommands::Claim { ids } => claim(ids, db_path, actor, json),
        IssueCommands::Release { ids } => release(ids, db_path, actor, json),
        IssueCommands::Delete { ids } => delete(ids, db_path, actor, json),
        IssueCommands::Label { command } => label(command, db_path, actor, json),
        IssueCommands::Dep { command } => dep(command, db_path, actor, json),
        IssueCommands::Clone { id, title } => clone_issue(id, title.as_deref(), db_path, actor, json),
        IssueCommands::Duplicate { id, of } => duplicate(id, of, db_path, actor, json),
        IssueCommands::Ready { limit } => ready(*limit, db_path, json),
        IssueCommands::NextBlock { count } => next_block(*count, db_path, actor, json),
        IssueCommands::Batch { json_input } => batch(json_input, db_path, actor, json),
        IssueCommands::Count { group_by } => count(group_by, db_path, json),
        IssueCommands::Stale { days, limit } => stale(*days, *limit, db_path, json),
        IssueCommands::Blocked { limit } => blocked(*limit, db_path, json),
        IssueCommands::Complete { ids, reason } => complete(ids, reason.as_deref(), db_path, actor, json),
    }
}

fn create(
    args: &IssueCreateArgs,
    db_path: Option<&PathBuf>,
    actor: Option<&str>,
    json: bool,
) -> Result<()> {
    // Handle file-based bulk import
    if let Some(ref file_path) = args.file {
        return create_from_file(file_path, db_path, actor, json);
    }

    let db_path = resolve_db_path(db_path.map(|p| p.as_path()))
        .ok_or(Error::NotInitialized)?;

    if !db_path.exists() {
        return Err(Error::NotInitialized);
    }

    let actor = actor.map(ToString::to_string).unwrap_or_else(default_actor);

    // Normalize type via synonym lookup
    let issue_type = crate::validate::normalize_type(&args.issue_type)
        .map_err(|(val, suggestion)| {
            let msg = if let Some(s) = suggestion {
                format!("Invalid issue type '{val}'. Did you mean '{s}'?")
            } else {
                format!("Invalid issue type '{val}'. Valid: task, bug, feature, epic, chore")
            };
            Error::InvalidArgument(msg)
        })?;

    // Normalize priority via synonym lookup
    let priority = crate::validate::normalize_priority(&args.priority.to_string())
        .map_err(|(val, suggestion)| {
            let msg = suggestion.unwrap_or_else(|| format!("Invalid priority '{val}'"));
            Error::InvalidArgument(msg)
        })?;

    // Dry-run: preview without writing
    if crate::is_dry_run() {
        let labels_str = args.labels.as_ref().map(|l| l.join(",")).unwrap_or_default();
        if json {
            let output = serde_json::json!({
                "dry_run": true,
                "action": "create_issue",
                "title": args.title,
                "issue_type": issue_type,
                "priority": priority,
                "labels": labels_str,
            });
            println!("{output}");
        } else {
            println!("Would create issue: {} [{}, priority={}]", args.title, issue_type, priority);
            if !labels_str.is_empty() {
                println!("  Labels: {labels_str}");
            }
        }
        return Ok(());
    }

    let mut storage = SqliteStorage::open(&db_path)?;
    let project_path = resolve_project_path(&storage, None)?;

    // Generate IDs
    let id = format!("issue_{}", &uuid::Uuid::new_v4().to_string()[..12]);
    let short_id = generate_short_id();

    storage.create_issue(
        &id,
        Some(&short_id),
        &project_path,
        &args.title,
        args.description.as_deref(),
        args.details.as_deref(),
        Some(&issue_type),
        Some(priority),
        args.plan_id.as_deref(),
        &actor,
    )?;

    // Set parent via parent-child dependency if provided
    if let Some(ref parent) = args.parent {
        storage.add_issue_dependency(&id, parent, "parent-child", &actor)?;
    }

    // Add labels if provided (already Vec from clap value_delimiter)
    if let Some(ref labels) = args.labels {
        if !labels.is_empty() {
            storage.add_issue_labels(&id, labels, &actor)?;
        }
    }

    if crate::is_silent() {
        println!("{short_id}");
        return Ok(());
    }

    if json {
        let output = IssueCreateOutput {
            id,
            short_id: Some(short_id),
            title: args.title.clone(),
            status: "open".to_string(),
            priority,
            issue_type: issue_type.clone(),
        };
        println!("{}", serde_json::to_string(&output)?);
    } else {
        println!("Created issue: {} [{}]", args.title, short_id);
        println!("  Type: {issue_type}");
        println!("  Priority: {priority}");
    }

    Ok(())
}

/// Create issues from a JSONL file (one JSON object per line).
fn create_from_file(
    file_path: &PathBuf,
    db_path: Option<&PathBuf>,
    actor: Option<&str>,
    json: bool,
) -> Result<()> {
    let db_path = resolve_db_path(db_path.map(|p| p.as_path()))
        .ok_or(Error::NotInitialized)?;

    if !db_path.exists() {
        return Err(Error::NotInitialized);
    }

    let file = std::fs::File::open(file_path)
        .map_err(|e| Error::Other(format!("Could not open file {}: {e}", file_path.display())))?;

    let reader = std::io::BufReader::new(file);
    let mut issues: Vec<BatchIssue> = Vec::new();

    for (line_num, line) in reader.lines().enumerate() {
        let line = line.map_err(|e| Error::Other(format!("Read error at line {}: {e}", line_num + 1)))?;
        let trimmed = line.trim();
        if trimmed.is_empty() || trimmed.starts_with('#') {
            continue; // Skip blank lines and comments
        }
        let issue: BatchIssue = serde_json::from_str(trimmed)
            .map_err(|e| Error::Other(format!("Invalid JSON at line {}: {e}", line_num + 1)))?;
        issues.push(issue);
    }

    if issues.is_empty() {
        return Err(Error::Other("No issues found in file".to_string()));
    }

    // Dry-run: just preview
    if crate::is_dry_run() {
        if json {
            let output = serde_json::json!({
                "dry_run": true,
                "action": "create_issues_from_file",
                "file": file_path.display().to_string(),
                "count": issues.len(),
            });
            println!("{output}");
        } else {
            println!("Would create {} issues from {}:", issues.len(), file_path.display());
            for issue in &issues {
                println!("  - {} [{}]", issue.title, issue.issue_type.as_deref().unwrap_or("task"));
            }
        }
        return Ok(());
    }

    let mut storage = SqliteStorage::open(&db_path)?;
    let actor = actor.map(ToString::to_string).unwrap_or_else(default_actor);
    let project_path = resolve_project_path(&storage, None)?;

    let mut results: Vec<BatchIssueResult> = Vec::with_capacity(issues.len());

    for (index, issue) in issues.iter().enumerate() {
        let id = format!("issue_{}", &uuid::Uuid::new_v4().to_string()[..12]);
        let short_id = generate_short_id();

        storage.create_issue(
            &id,
            Some(&short_id),
            &project_path,
            &issue.title,
            issue.description.as_deref(),
            issue.details.as_deref(),
            issue.issue_type.as_deref(),
            issue.priority,
            issue.plan_id.as_deref(),
            &actor,
        )?;

        if let Some(ref labels) = issue.labels {
            if !labels.is_empty() {
                storage.add_issue_labels(&id, labels, &actor)?;
            }
        }

        results.push(BatchIssueResult {
            id,
            short_id: Some(short_id),
            title: issue.title.clone(),
            index,
        });
    }

    if crate::is_silent() {
        for r in &results {
            println!("{}", r.short_id.as_deref().unwrap_or(&r.id));
        }
        return Ok(());
    }

    if json {
        let output = serde_json::json!({
            "issues": results,
            "count": results.len(),
        });
        println!("{}", serde_json::to_string(&output)?);
    } else {
        println!("Created {} issues from {}:", results.len(), file_path.display());
        for r in &results {
            let sid = r.short_id.as_deref().unwrap_or(&r.id[..8]);
            println!("  [{}] {}", sid, r.title);
        }
    }

    Ok(())
}

fn list(args: &IssueListArgs, db_path: Option<&PathBuf>, json: bool) -> Result<()> {
    let db_path = resolve_db_path(db_path.map(|p| p.as_path()))
        .ok_or(Error::NotInitialized)?;

    if !db_path.exists() {
        return Err(Error::NotInitialized);
    }

    let storage = SqliteStorage::open(&db_path)?;

    // Handle single issue lookup by ID
    if let Some(ref id) = args.id {
        let project_path = resolve_project_path(&storage, None).ok();
        let issue = storage
            .get_issue(id, project_path.as_deref())?
            .ok_or_else(|| {
                let all_ids = storage.get_all_issue_short_ids().unwrap_or_default();
                let similar = crate::validate::find_similar_ids(id, &all_ids, 3);
                if similar.is_empty() {
                    Error::IssueNotFound { id: id.to_string() }
                } else {
                    Error::IssueNotFoundSimilar {
                        id: id.to_string(),
                        similar,
                    }
                }
            })?;
        if json {
            let output = IssueListOutput {
                count: 1,
                issues: vec![issue],
            };
            println!("{}", serde_json::to_string(&output)?);
        } else {
            print_issue_list(&[issue], Some(&storage));
        }
        return Ok(());
    }

    // Determine project filter
    let project_path = if args.all_projects {
        None
    } else {
        Some(resolve_project_path(&storage, None)?)
    };

    // Normalize status filter via synonym lookup (e.g., "done" → "closed")
    let normalized_status = if args.status == "all" {
        "all".to_string()
    } else {
        crate::validate::normalize_status(&args.status).unwrap_or_else(|_| args.status.clone())
    };
    let status = Some(normalized_status.as_str());

    // Get base results from storage (fetch extra for post-filtering)
    #[allow(clippy::cast_possible_truncation)]
    let fetch_limit = (args.limit * 10).min(1000) as u32;

    let issues = if let Some(ref path) = project_path {
        storage.list_issues(path, status, args.issue_type.as_deref(), Some(fetch_limit))?
    } else {
        // For all_projects, we need to query without project filter
        // Storage doesn't support this directly, so we need a workaround
        // For now, get from storage with a higher limit
        storage.list_all_issues(status, args.issue_type.as_deref(), Some(fetch_limit))?
    };

    // Apply post-filters
    let now = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .map(|d| d.as_secs() as i64)
        .unwrap_or(0);

    // Pre-fetch child IDs if filtering by parent
    let child_ids = if let Some(ref parent) = args.parent {
        Some(storage.get_child_issue_ids(parent)?)
    } else {
        None
    };

    let issues: Vec<_> = issues
        .into_iter()
        // Filter by search
        .filter(|i| {
            if let Some(ref search) = args.search {
                let s = search.to_lowercase();
                i.title.to_lowercase().contains(&s)
                    || i.description
                        .as_ref()
                        .map(|d| d.to_lowercase().contains(&s))
                        .unwrap_or(false)
            } else {
                true
            }
        })
        // Filter by exact priority
        .filter(|i| args.priority.map_or(true, |p| i.priority == p))
        // Filter by priority range
        .filter(|i| args.priority_min.map_or(true, |p| i.priority >= p))
        .filter(|i| args.priority_max.map_or(true, |p| i.priority <= p))
        // Filter by parent
        .filter(|i| {
            if let Some(ref child_set) = child_ids {
                // Only include issues that are children of the specified parent
                child_set.contains(&i.id)
            } else {
                true
            }
        })
        // Filter by plan
        .filter(|i| {
            if let Some(ref plan) = args.plan {
                i.plan_id.as_ref().map_or(false, |p| p == plan)
            } else {
                true
            }
        })
        // Filter by assignee
        .filter(|i| {
            if let Some(ref assignee) = args.assignee {
                i.assigned_to_agent
                    .as_ref()
                    .map_or(false, |a| a == assignee)
            } else {
                true
            }
        })
        // Filter by created time
        .filter(|i| {
            if let Some(days) = args.created_days {
                let cutoff = now - (days * 24 * 60 * 60);
                i.created_at >= cutoff
            } else {
                true
            }
        })
        .filter(|i| {
            if let Some(hours) = args.created_hours {
                let cutoff = now - (hours * 60 * 60);
                i.created_at >= cutoff
            } else {
                true
            }
        })
        // Filter by updated time
        .filter(|i| {
            if let Some(days) = args.updated_days {
                let cutoff = now - (days * 24 * 60 * 60);
                i.updated_at >= cutoff
            } else {
                true
            }
        })
        .filter(|i| {
            if let Some(hours) = args.updated_hours {
                let cutoff = now - (hours * 60 * 60);
                i.updated_at >= cutoff
            } else {
                true
            }
        })
        .collect();

    // Apply label filtering
    let issues: Vec<_> = if args.labels.is_some() || args.labels_any.is_some() {
        issues
            .into_iter()
            .filter(|i| {
                let issue_labels = storage.get_issue_labels(&i.id).unwrap_or_default();

                // Check --labels (all must match)
                let all_match = args.labels.as_ref().map_or(true, |required| {
                    required.iter().all(|l| issue_labels.contains(l))
                });

                // Check --labels-any (any must match)
                let any_match = args.labels_any.as_ref().map_or(true, |required| {
                    required.iter().any(|l| issue_labels.contains(l))
                });

                all_match && any_match
            })
            .collect()
    } else {
        issues
    };

    // Apply has_deps/no_deps filtering
    let issues: Vec<_> = if args.has_deps || args.no_deps {
        issues
            .into_iter()
            .filter(|i| {
                let has_dependencies = storage.issue_has_dependencies(&i.id).unwrap_or(false);
                if args.has_deps {
                    has_dependencies
                } else {
                    !has_dependencies
                }
            })
            .collect()
    } else {
        issues
    };

    // Apply has_subtasks/no_subtasks filtering
    let issues: Vec<_> = if args.has_subtasks || args.no_subtasks {
        issues
            .into_iter()
            .filter(|i| {
                let has_subtasks = storage.issue_has_subtasks(&i.id).unwrap_or(false);
                if args.has_subtasks {
                    has_subtasks
                } else {
                    !has_subtasks
                }
            })
            .collect()
    } else {
        issues
    };

    // Apply sorting
    let mut issues = issues;
    match args.sort.as_str() {
        "priority" => issues.sort_by(|a, b| {
            if args.order == "asc" {
                a.priority.cmp(&b.priority)
            } else {
                b.priority.cmp(&a.priority)
            }
        }),
        "updatedAt" => issues.sort_by(|a, b| {
            if args.order == "asc" {
                a.updated_at.cmp(&b.updated_at)
            } else {
                b.updated_at.cmp(&a.updated_at)
            }
        }),
        _ => {
            // Default: createdAt
            issues.sort_by(|a, b| {
                if args.order == "asc" {
                    a.created_at.cmp(&b.created_at)
                } else {
                    b.created_at.cmp(&a.created_at)
                }
            });
        }
    }

    // Apply limit
    issues.truncate(args.limit);

    if crate::is_csv() {
        println!("id,title,status,priority,type,assigned_to");
        for issue in &issues {
            let short_id = issue.short_id.as_deref().unwrap_or(&issue.id[..8]);
            let title = crate::csv_escape(&issue.title);
            let assignee = issue.assigned_to_agent.as_deref().unwrap_or("");
            println!("{},{},{},{},{},{}", short_id, title, issue.status, issue.priority, issue.issue_type, assignee);
        }
    } else if json {
        let output = IssueListOutput {
            count: issues.len(),
            issues,
        };
        println!("{}", serde_json::to_string(&output)?);
    } else if issues.is_empty() {
        println!("No issues found.");
    } else {
        print_issue_list(&issues, Some(&storage));
    }

    Ok(())
}

/// Print formatted issue list to stdout.
fn print_issue_list(issues: &[crate::storage::Issue], storage: Option<&SqliteStorage>) {
    println!("Issues ({} found):", issues.len());
    println!();
    for issue in issues {
        let status_icon = match issue.status.as_str() {
            "open" => "○",
            "in_progress" => "●",
            "blocked" => "⊘",
            "closed" => "✓",
            "deferred" => "◌",
            _ => "?",
        };
        let priority_str = match issue.priority {
            4 => "!!",
            3 => "! ",
            2 => "  ",
            1 => "- ",
            0 => "--",
            _ => "  ",
        };
        let short_id = issue.short_id.as_deref().unwrap_or(&issue.id[..8]);

        // Show epic progress inline if available
        let progress_str = if issue.issue_type == "epic" {
            storage.and_then(|s| s.get_epic_progress(&issue.id).ok())
                .filter(|p| p.total > 0)
                .map(|p| {
                    let pct = (p.closed as f64 / p.total as f64 * 100.0) as u32;
                    format!(" {}/{} ({pct}%)", p.closed, p.total)
                })
                .unwrap_or_default()
        } else {
            String::new()
        };

        println!(
            "{} [{}] {} {} ({}){progress_str}",
            status_icon, short_id, priority_str, issue.title, issue.issue_type
        );
        if let Some(ref desc) = issue.description {
            let truncated = if desc.len() > 60 {
                format!("{}...", &desc[..60])
            } else {
                desc.clone()
            };
            println!("        {truncated}");
        }
    }
}

fn show(id: &str, db_path: Option<&PathBuf>, json: bool) -> Result<()> {
    let db_path = resolve_db_path(db_path.map(|p| p.as_path()))
        .ok_or(Error::NotInitialized)?;

    if !db_path.exists() {
        return Err(Error::NotInitialized);
    }

    let storage = SqliteStorage::open(&db_path)?;
    let project_path = resolve_project_path(&storage, None).ok();

    let issue = storage
        .get_issue(id, project_path.as_deref())?
        .ok_or_else(|| {
            let all_ids = storage.get_all_issue_short_ids().unwrap_or_default();
            let similar = crate::validate::find_similar_ids(id, &all_ids, 3);
            if similar.is_empty() {
                Error::IssueNotFound { id: id.to_string() }
            } else {
                Error::IssueNotFoundSimilar {
                    id: id.to_string(),
                    similar,
                }
            }
        })?;

    // Check for epic progress
    let progress = if issue.issue_type == "epic" {
        storage.get_epic_progress(&issue.id).ok()
            .filter(|p| p.total > 0)
    } else {
        None
    };

    // Check for close_reason
    let close_reason = if issue.status == "closed" {
        storage.get_close_reason(&issue.id).ok().flatten()
    } else {
        None
    };

    if json {
        let mut value = serde_json::to_value(&issue)?;
        if let Some(ref p) = progress {
            value["progress"] = serde_json::to_value(p)?;
        }
        if let Some(ref reason) = close_reason {
            value["close_reason"] = serde_json::Value::String(reason.clone());
        }
        println!("{}", serde_json::to_string(&value)?);
    } else {
        let short_id = issue.short_id.as_deref().unwrap_or(&issue.id[..8]);
        println!("[{}] {}", short_id, issue.title);
        println!();
        println!("Status:   {}", issue.status);
        println!("Type:     {}", issue.issue_type);
        println!("Priority: {}", issue.priority);
        if let Some(ref desc) = issue.description {
            println!();
            println!("Description:");
            println!("{desc}");
        }
        if let Some(ref details) = issue.details {
            println!();
            println!("Details:");
            println!("{details}");
        }
        if let Some(ref agent) = issue.assigned_to_agent {
            println!();
            println!("Assigned to: {agent}");
        }
        if let Some(ref reason) = close_reason {
            println!();
            println!("Close reason: {reason}");
        }
        if let Some(ref p) = progress {
            let pct = if p.total > 0 {
                (p.closed as f64 / p.total as f64 * 100.0) as u32
            } else {
                0
            };
            println!();
            println!("Progress: {}/{} tasks ({pct}%)", p.closed, p.total);
            if p.closed > 0 { println!("  Closed:      {}", p.closed); }
            if p.in_progress > 0 { println!("  In progress: {}", p.in_progress); }
            if p.open > 0 { println!("  Open:        {}", p.open); }
            if p.blocked > 0 { println!("  Blocked:     {}", p.blocked); }
            if p.deferred > 0 { println!("  Deferred:    {}", p.deferred); }
        }
    }

    Ok(())
}

fn update(
    args: &IssueUpdateArgs,
    db_path: Option<&PathBuf>,
    actor: Option<&str>,
    json: bool,
) -> Result<()> {
    if crate::is_dry_run() {
        if json {
            let output = serde_json::json!({
                "dry_run": true,
                "action": "update_issue",
                "id": args.id,
            });
            println!("{output}");
        } else {
            println!("Would update issue: {}", args.id);
        }
        return Ok(());
    }

    let db_path = resolve_db_path(db_path.map(|p| p.as_path()))
        .ok_or(Error::NotInitialized)?;

    if !db_path.exists() {
        return Err(Error::NotInitialized);
    }

    let mut storage = SqliteStorage::open(&db_path)?;
    let actor = actor.map(ToString::to_string).unwrap_or_else(default_actor);

    // Normalize type if provided
    let normalized_type = args.issue_type.as_ref().map(|t| {
        crate::validate::normalize_type(t).unwrap_or_else(|_| t.clone())
    });

    // Normalize priority if provided
    let normalized_priority = args.priority.map(|p| {
        crate::validate::normalize_priority(&p.to_string()).unwrap_or(p)
    });

    // Check if any non-status fields are being updated
    let has_field_updates = args.title.is_some()
        || args.description.is_some()
        || args.details.is_some()
        || normalized_priority.is_some()
        || normalized_type.is_some()
        || args.plan.is_some()
        || args.parent.is_some();

    // Update fields if any are provided
    if has_field_updates {
        storage.update_issue(
            &args.id,
            args.title.as_deref(),
            args.description.as_deref(),
            args.details.as_deref(),
            normalized_priority,
            normalized_type.as_deref(),
            args.plan.as_deref(),
            args.parent.as_deref(),
            &actor,
        )?;
    }

    // Normalize and update status if provided
    if let Some(ref status) = args.status {
        let normalized = crate::validate::normalize_status(status)
            .unwrap_or_else(|_| status.clone());
        storage.update_issue_status(&args.id, &normalized, &actor)?;
    }

    if json {
        let output = serde_json::json!({
            "id": args.id,
            "updated": true
        });
        println!("{output}");
    } else {
        println!("Updated issue: {}", args.id);
    }

    Ok(())
}

fn complete(ids: &[String], reason: Option<&str>, db_path: Option<&PathBuf>, actor: Option<&str>, json: bool) -> Result<()> {
    let db_path = resolve_db_path(db_path.map(|p| p.as_path()))
        .ok_or(Error::NotInitialized)?;

    if !db_path.exists() {
        return Err(Error::NotInitialized);
    }

    if crate::is_dry_run() {
        for id in ids {
            println!("Would complete issue: {id}");
        }
        return Ok(());
    }

    let mut storage = SqliteStorage::open(&db_path)?;
    let actor = actor.map(ToString::to_string).unwrap_or_else(default_actor);

    let mut results = Vec::new();
    for id in ids {
        storage.update_issue_status(id, "closed", &actor)?;
        if let Some(reason) = reason {
            storage.set_close_reason(id, reason, &actor)?;
        }
        results.push(id.as_str());
    }

    if crate::is_silent() {
        for id in &results {
            println!("{id}");
        }
    } else if json {
        let mut output = serde_json::json!({
            "ids": results,
            "status": "closed",
            "count": results.len()
        });
        if let Some(reason) = reason {
            output["close_reason"] = serde_json::Value::String(reason.to_string());
        }
        println!("{output}");
    } else {
        for id in &results {
            println!("Completed issue: {id}");
        }
        if let Some(reason) = reason {
            println!("  Reason: {reason}");
        }
    }

    Ok(())
}

fn claim(ids: &[String], db_path: Option<&PathBuf>, actor: Option<&str>, json: bool) -> Result<()> {
    let db_path = resolve_db_path(db_path.map(|p| p.as_path()))
        .ok_or(Error::NotInitialized)?;

    if !db_path.exists() {
        return Err(Error::NotInitialized);
    }

    if crate::is_dry_run() {
        for id in ids {
            println!("Would claim issue: {id}");
        }
        return Ok(());
    }

    let mut storage = SqliteStorage::open(&db_path)?;
    let actor = actor.map(ToString::to_string).unwrap_or_else(default_actor);

    let mut results = Vec::new();
    for id in ids {
        storage.claim_issue(id, &actor)?;
        results.push(id.as_str());
    }

    if crate::is_silent() {
        for id in &results {
            println!("{id}");
        }
    } else if json {
        let output = serde_json::json!({
            "ids": results,
            "status": "in_progress",
            "assigned_to": actor,
            "count": results.len()
        });
        println!("{output}");
    } else {
        for id in &results {
            println!("Claimed issue: {id}");
        }
    }

    Ok(())
}

fn release(ids: &[String], db_path: Option<&PathBuf>, actor: Option<&str>, json: bool) -> Result<()> {
    let db_path = resolve_db_path(db_path.map(|p| p.as_path()))
        .ok_or(Error::NotInitialized)?;

    if !db_path.exists() {
        return Err(Error::NotInitialized);
    }

    if crate::is_dry_run() {
        for id in ids {
            println!("Would release issue: {id}");
        }
        return Ok(());
    }

    let mut storage = SqliteStorage::open(&db_path)?;
    let actor = actor.map(ToString::to_string).unwrap_or_else(default_actor);

    let mut results = Vec::new();
    for id in ids {
        storage.release_issue(id, &actor)?;
        results.push(id.as_str());
    }

    if crate::is_silent() {
        for id in &results {
            println!("{id}");
        }
    } else if json {
        let output = serde_json::json!({
            "ids": results,
            "status": "open",
            "count": results.len()
        });
        println!("{output}");
    } else {
        for id in &results {
            println!("Released issue: {id}");
        }
    }

    Ok(())
}

fn delete(ids: &[String], db_path: Option<&PathBuf>, actor: Option<&str>, json: bool) -> Result<()> {
    let db_path = resolve_db_path(db_path.map(|p| p.as_path()))
        .ok_or(Error::NotInitialized)?;

    if !db_path.exists() {
        return Err(Error::NotInitialized);
    }

    if crate::is_dry_run() {
        for id in ids {
            println!("Would delete issue: {id}");
        }
        return Ok(());
    }

    let mut storage = SqliteStorage::open(&db_path)?;
    let actor = actor.map(ToString::to_string).unwrap_or_else(default_actor);

    let mut results = Vec::new();
    for id in ids {
        storage.delete_issue(id, &actor)?;
        results.push(id.as_str());
    }

    if crate::is_silent() {
        for id in &results {
            println!("{id}");
        }
    } else if json {
        let output = serde_json::json!({
            "ids": results,
            "deleted": true,
            "count": results.len()
        });
        println!("{output}");
    } else {
        for id in &results {
            println!("Deleted issue: {id}");
        }
    }

    Ok(())
}

/// Generate a short ID (4 hex chars).
fn generate_short_id() -> String {
    use std::time::{SystemTime, UNIX_EPOCH};
    let now = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_millis();
    format!("{:04x}", (now & 0xFFFF) as u16)
}

fn label(
    command: &IssueLabelCommands,
    db_path: Option<&PathBuf>,
    actor: Option<&str>,
    json: bool,
) -> Result<()> {
    let db_path = resolve_db_path(db_path.map(|p| p.as_path()))
        .ok_or(Error::NotInitialized)?;

    if !db_path.exists() {
        return Err(Error::NotInitialized);
    }

    let mut storage = SqliteStorage::open(&db_path)?;
    let actor = actor.map(ToString::to_string).unwrap_or_else(default_actor);

    match command {
        IssueLabelCommands::Add { id, labels } => {
            storage.add_issue_labels(id, labels, &actor)?;

            if json {
                let output = serde_json::json!({
                    "id": id,
                    "action": "add",
                    "labels": labels
                });
                println!("{output}");
            } else {
                println!("Added labels to {}: {}", id, labels.join(", "));
            }
        }
        IssueLabelCommands::Remove { id, labels } => {
            storage.remove_issue_labels(id, labels, &actor)?;

            if json {
                let output = serde_json::json!({
                    "id": id,
                    "action": "remove",
                    "labels": labels
                });
                println!("{output}");
            } else {
                println!("Removed labels from {}: {}", id, labels.join(", "));
            }
        }
    }

    Ok(())
}

fn dep(
    command: &IssueDepCommands,
    db_path: Option<&PathBuf>,
    actor: Option<&str>,
    json: bool,
) -> Result<()> {
    let db_path = resolve_db_path(db_path.map(|p| p.as_path()))
        .ok_or(Error::NotInitialized)?;

    if !db_path.exists() {
        return Err(Error::NotInitialized);
    }

    let mut storage = SqliteStorage::open(&db_path)?;
    let actor = actor.map(ToString::to_string).unwrap_or_else(default_actor);

    match command {
        IssueDepCommands::Add { id, depends_on, dep_type } => {
            storage.add_issue_dependency(id, depends_on, dep_type, &actor)?;

            if json {
                let output = serde_json::json!({
                    "issue_id": id,
                    "depends_on_id": depends_on,
                    "dependency_type": dep_type
                });
                println!("{output}");
            } else {
                println!("Added dependency: {} depends on {} ({})", id, depends_on, dep_type);
            }
        }
        IssueDepCommands::Remove { id, depends_on } => {
            storage.remove_issue_dependency(id, depends_on, &actor)?;

            if json {
                let output = serde_json::json!({
                    "issue_id": id,
                    "depends_on_id": depends_on,
                    "removed": true
                });
                println!("{output}");
            } else {
                println!("Removed dependency: {} no longer depends on {}", id, depends_on);
            }
        }
        IssueDepCommands::Tree { id } => {
            return dep_tree(id.as_deref(), Some(&db_path), json);
        }
    }

    Ok(())
}

fn clone_issue(
    id: &str,
    new_title: Option<&str>,
    db_path: Option<&PathBuf>,
    actor: Option<&str>,
    json: bool,
) -> Result<()> {
    let db_path = resolve_db_path(db_path.map(|p| p.as_path()))
        .ok_or(Error::NotInitialized)?;

    if !db_path.exists() {
        return Err(Error::NotInitialized);
    }

    let mut storage = SqliteStorage::open(&db_path)?;
    let actor = actor.map(ToString::to_string).unwrap_or_else(default_actor);

    let cloned = storage.clone_issue(id, new_title, &actor)?;

    if json {
        println!("{}", serde_json::to_string(&cloned)?);
    } else {
        let short_id = cloned.short_id.as_deref().unwrap_or(&cloned.id[..8]);
        println!("Cloned issue {} to: {} [{}]", id, cloned.title, short_id);
    }

    Ok(())
}

fn duplicate(
    id: &str,
    duplicate_of: &str,
    db_path: Option<&PathBuf>,
    actor: Option<&str>,
    json: bool,
) -> Result<()> {
    let db_path = resolve_db_path(db_path.map(|p| p.as_path()))
        .ok_or(Error::NotInitialized)?;

    if !db_path.exists() {
        return Err(Error::NotInitialized);
    }

    let mut storage = SqliteStorage::open(&db_path)?;
    let actor = actor.map(ToString::to_string).unwrap_or_else(default_actor);

    storage.mark_issue_duplicate(id, duplicate_of, &actor)?;

    if json {
        let output = serde_json::json!({
            "id": id,
            "duplicate_of": duplicate_of,
            "status": "closed"
        });
        println!("{output}");
    } else {
        println!("Marked {} as duplicate of {} (closed)", id, duplicate_of);
    }

    Ok(())
}

fn ready(limit: usize, db_path: Option<&PathBuf>, json: bool) -> Result<()> {
    let db_path = resolve_db_path(db_path.map(|p| p.as_path()))
        .ok_or(Error::NotInitialized)?;

    if !db_path.exists() {
        return Err(Error::NotInitialized);
    }

    let storage = SqliteStorage::open(&db_path)?;
    let project_path = resolve_project_path(&storage, None)?;

    #[allow(clippy::cast_possible_truncation)]
    let issues = storage.get_ready_issues(&project_path, limit as u32)?;

    if json {
        let output = IssueListOutput {
            count: issues.len(),
            issues,
        };
        println!("{}", serde_json::to_string(&output)?);
    } else if issues.is_empty() {
        println!("No issues ready to work on.");
    } else {
        println!("Ready issues ({} found):", issues.len());
        println!();
        for issue in &issues {
            let priority_str = match issue.priority {
                4 => "!!",
                3 => "! ",
                2 => "  ",
                1 => "- ",
                0 => "--",
                _ => "  ",
            };
            let short_id = issue.short_id.as_deref().unwrap_or(&issue.id[..8]);
            println!(
                "○ [{}] {} {} ({})",
                short_id, priority_str, issue.title, issue.issue_type
            );
        }
    }

    Ok(())
}

fn next_block(
    count: usize,
    db_path: Option<&PathBuf>,
    actor: Option<&str>,
    json: bool,
) -> Result<()> {
    let db_path = resolve_db_path(db_path.map(|p| p.as_path()))
        .ok_or(Error::NotInitialized)?;

    if !db_path.exists() {
        return Err(Error::NotInitialized);
    }

    let mut storage = SqliteStorage::open(&db_path)?;
    let actor = actor.map(ToString::to_string).unwrap_or_else(default_actor);
    let project_path = resolve_project_path(&storage, None)?;

    #[allow(clippy::cast_possible_truncation)]
    let issues = storage.get_next_issue_block(&project_path, count as u32, &actor)?;

    if json {
        let output = IssueListOutput {
            count: issues.len(),
            issues,
        };
        println!("{}", serde_json::to_string(&output)?);
    } else if issues.is_empty() {
        println!("No issues available to claim.");
    } else {
        println!("Claimed {} issues:", issues.len());
        println!();
        for issue in &issues {
            let priority_str = match issue.priority {
                4 => "!!",
                3 => "! ",
                2 => "  ",
                1 => "- ",
                0 => "--",
                _ => "  ",
            };
            let short_id = issue.short_id.as_deref().unwrap_or(&issue.id[..8]);
            println!(
                "● [{}] {} {} ({})",
                short_id, priority_str, issue.title, issue.issue_type
            );
        }
    }

    Ok(())
}

/// Create multiple issues at once with dependencies.
fn batch(
    json_input: &str,
    db_path: Option<&PathBuf>,
    actor: Option<&str>,
    json: bool,
) -> Result<()> {
    let db_path = resolve_db_path(db_path.map(|p| p.as_path()))
        .ok_or(Error::NotInitialized)?;

    if !db_path.exists() {
        return Err(Error::NotInitialized);
    }

    let mut storage = SqliteStorage::open(&db_path)?;
    let actor = actor.map(ToString::to_string).unwrap_or_else(default_actor);
    let project_path = resolve_project_path(&storage, None)?;

    // Parse the JSON input
    let input: BatchInput = serde_json::from_str(json_input)
        .map_err(|e| Error::Other(format!("Invalid JSON input: {e}")))?;

    // Track created issue IDs by index for resolving $N references
    let mut created_ids: Vec<String> = Vec::with_capacity(input.issues.len());
    let mut results: Vec<BatchIssueResult> = Vec::with_capacity(input.issues.len());

    // Create issues in order
    for (index, issue) in input.issues.iter().enumerate() {
        let id = format!("issue_{}", &uuid::Uuid::new_v4().to_string()[..12]);
        let short_id = generate_short_id();

        // Resolve parent_id: if it starts with "$", look up created ID by index
        let resolved_parent_id = issue.parent_id.as_ref().and_then(|pid| {
            if let Some(idx_str) = pid.strip_prefix('$') {
                if let Ok(idx) = idx_str.parse::<usize>() {
                    created_ids.get(idx).cloned()
                } else {
                    Some(pid.clone())
                }
            } else {
                Some(pid.clone())
            }
        });

        // Use issue-level plan_id, or fall back to batch-level plan_id
        let plan_id = issue.plan_id.as_ref().or(input.plan_id.as_ref());

        storage.create_issue(
            &id,
            Some(&short_id),
            &project_path,
            &issue.title,
            issue.description.as_deref(),
            issue.details.as_deref(),
            issue.issue_type.as_deref(),
            issue.priority,
            plan_id.map(String::as_str),
            &actor,
        )?;

        // Set parent via parent-child dependency if resolved
        if let Some(ref parent) = resolved_parent_id {
            storage.add_issue_dependency(&id, parent, "parent-child", &actor)?;
        }

        // Add labels if provided
        if let Some(ref labels) = issue.labels {
            if !labels.is_empty() {
                storage.add_issue_labels(&id, labels, &actor)?;
            }
        }

        created_ids.push(id.clone());
        results.push(BatchIssueResult {
            id,
            short_id: Some(short_id),
            title: issue.title.clone(),
            index,
        });
    }

    // Create dependencies
    let mut dep_results: Vec<BatchDepResult> = Vec::new();
    if let Some(deps) = input.dependencies {
        for dep in deps {
            if dep.issue_index >= created_ids.len() || dep.depends_on_index >= created_ids.len() {
                return Err(Error::Other(format!(
                    "Dependency index out of range: {} -> {}",
                    dep.issue_index, dep.depends_on_index
                )));
            }

            let issue_id = &created_ids[dep.issue_index];
            let depends_on_id = &created_ids[dep.depends_on_index];
            let dep_type = dep.dependency_type.as_deref().unwrap_or("blocks");

            storage.add_issue_dependency(issue_id, depends_on_id, dep_type, &actor)?;

            dep_results.push(BatchDepResult {
                issue_id: issue_id.clone(),
                depends_on_id: depends_on_id.clone(),
                dependency_type: dep_type.to_string(),
            });
        }
    }

    let output = BatchOutput {
        issues: results,
        dependencies: dep_results,
    };

    if json {
        println!("{}", serde_json::to_string(&output)?);
    } else {
        println!("Created {} issues:", output.issues.len());
        for result in &output.issues {
            let short_id = result.short_id.as_deref().unwrap_or(&result.id[..8]);
            println!("  [{}] {}", short_id, result.title);
        }
        if !output.dependencies.is_empty() {
            println!("\nCreated {} dependencies:", output.dependencies.len());
            for dep in &output.dependencies {
                println!("  {} -> {} ({})", dep.issue_id, dep.depends_on_id, dep.dependency_type);
            }
        }
    }

    Ok(())
}

fn count(group_by: &str, db_path: Option<&PathBuf>, json: bool) -> Result<()> {
    let db_path = resolve_db_path(db_path.map(|p| p.as_path()))
        .ok_or(Error::NotInitialized)?;

    if !db_path.exists() {
        return Err(Error::NotInitialized);
    }

    let storage = SqliteStorage::open(&db_path)?;
    let project_path = resolve_project_path(&storage, None)?;

    let groups = storage.count_issues_grouped(&project_path, group_by)?;
    let total: i64 = groups.iter().map(|(_, c)| c).sum();

    if crate::is_csv() {
        println!("group,count");
        for (key, count) in &groups {
            println!("{},{count}", crate::csv_escape(key));
        }
    } else if json {
        let output = serde_json::json!({
            "groups": groups.iter().map(|(k, c)| {
                serde_json::json!({"key": k, "count": c})
            }).collect::<Vec<_>>(),
            "total": total,
            "group_by": group_by
        });
        println!("{output}");
    } else if groups.is_empty() {
        println!("No issues found.");
    } else {
        println!("Issues by {group_by}:");
        let max_key_len = groups.iter().map(|(k, _)| k.len()).max().unwrap_or(10);
        for (key, count) in &groups {
            println!("  {:<width$}  {count}", key, width = max_key_len);
        }
        println!("  {}", "─".repeat(max_key_len + 6));
        println!("  {:<width$}  {total}", "Total", width = max_key_len);
    }

    Ok(())
}

fn stale(days: u64, limit: usize, db_path: Option<&PathBuf>, json: bool) -> Result<()> {
    let db_path = resolve_db_path(db_path.map(|p| p.as_path()))
        .ok_or(Error::NotInitialized)?;

    if !db_path.exists() {
        return Err(Error::NotInitialized);
    }

    let storage = SqliteStorage::open(&db_path)?;
    let project_path = resolve_project_path(&storage, None)?;

    #[allow(clippy::cast_possible_truncation)]
    let issues = storage.get_stale_issues(&project_path, days, limit as u32)?;
    let now_ms = chrono::Utc::now().timestamp_millis();

    if crate::is_csv() {
        println!("id,title,status,priority,type,stale_days");
        for issue in &issues {
            let short_id = issue.short_id.as_deref().unwrap_or(&issue.id[..8]);
            let title = crate::csv_escape(&issue.title);
            let stale_d = (now_ms - issue.updated_at) / (24 * 60 * 60 * 1000);
            println!("{short_id},{title},{},{},{},{stale_d}", issue.status, issue.priority, issue.issue_type);
        }
    } else if json {
        let enriched: Vec<_> = issues.iter().map(|i| {
            let stale_d = (now_ms - i.updated_at) / (24 * 60 * 60 * 1000);
            serde_json::json!({
                "issue": i,
                "stale_days": stale_d
            })
        }).collect();
        let output = serde_json::json!({
            "issues": enriched,
            "count": issues.len(),
            "threshold_days": days
        });
        println!("{}", serde_json::to_string(&output)?);
    } else if issues.is_empty() {
        println!("No stale issues (threshold: {days} days).");
    } else {
        println!("Stale issues ({} found, threshold: {days} days):", issues.len());
        println!();
        for issue in &issues {
            let short_id = issue.short_id.as_deref().unwrap_or(&issue.id[..8]);
            let stale_d = (now_ms - issue.updated_at) / (24 * 60 * 60 * 1000);
            let status_icon = match issue.status.as_str() {
                "open" => "○",
                "in_progress" => "●",
                "blocked" => "⊘",
                _ => "?",
            };
            println!(
                "{status_icon} [{}] {} ({}) — last updated {stale_d} days ago",
                short_id, issue.title, issue.issue_type
            );
        }
    }

    Ok(())
}

fn blocked(limit: usize, db_path: Option<&PathBuf>, json: bool) -> Result<()> {
    let db_path = resolve_db_path(db_path.map(|p| p.as_path()))
        .ok_or(Error::NotInitialized)?;

    if !db_path.exists() {
        return Err(Error::NotInitialized);
    }

    let storage = SqliteStorage::open(&db_path)?;
    let project_path = resolve_project_path(&storage, None)?;

    #[allow(clippy::cast_possible_truncation)]
    let blocked_issues = storage.get_blocked_issues(&project_path, limit as u32)?;

    if crate::is_csv() {
        println!("id,title,status,blocked_by_ids");
        for (issue, blockers) in &blocked_issues {
            let short_id = issue.short_id.as_deref().unwrap_or(&issue.id[..8]);
            let title = crate::csv_escape(&issue.title);
            let blocker_ids: Vec<&str> = blockers.iter()
                .map(|b| b.short_id.as_deref().unwrap_or(&b.id[..8]))
                .collect();
            println!("{short_id},{title},{},{}", issue.status, blocker_ids.join(";"));
        }
    } else if json {
        let entries: Vec<_> = blocked_issues.iter().map(|(issue, blockers)| {
            serde_json::json!({
                "issue": issue,
                "blocked_by": blockers
            })
        }).collect();
        let output = serde_json::json!({
            "blocked_issues": entries,
            "count": blocked_issues.len()
        });
        println!("{}", serde_json::to_string(&output)?);
    } else if blocked_issues.is_empty() {
        println!("No blocked issues.");
    } else {
        println!("Blocked issues ({} found):", blocked_issues.len());
        println!();
        for (issue, blockers) in &blocked_issues {
            let short_id = issue.short_id.as_deref().unwrap_or(&issue.id[..8]);
            println!("⊘ [{}] {} ({})", short_id, issue.title, issue.issue_type);
            for blocker in blockers {
                let b_short_id = blocker.short_id.as_deref().unwrap_or(&blocker.id[..8]);
                println!(
                    "    blocked by: [{}] {} [{}]",
                    b_short_id, blocker.title, blocker.status
                );
            }
        }
    }

    Ok(())
}

fn dep_tree(id: Option<&str>, db_path: Option<&PathBuf>, json: bool) -> Result<()> {
    let db_path = resolve_db_path(db_path.map(|p| p.as_path()))
        .ok_or(Error::NotInitialized)?;

    if !db_path.exists() {
        return Err(Error::NotInitialized);
    }

    let storage = SqliteStorage::open(&db_path)?;
    let project_path = resolve_project_path(&storage, None)?;

    if let Some(root_id) = id {
        // Show tree for a specific issue
        let tree = storage.get_dependency_tree(root_id)?;
        print_dep_tree(&tree, json)?;
    } else {
        // Show trees for all epics
        let epics = storage.get_epics(&project_path)?;
        if epics.is_empty() {
            if json {
                println!("{{\"trees\":[],\"count\":0}}");
            } else {
                println!("No epics found.");
            }
            return Ok(());
        }

        if json {
            let mut trees = Vec::new();
            for epic in &epics {
                let tree = storage.get_dependency_tree(&epic.id)?;
                trees.push(tree_to_json(&tree));
            }
            let output = serde_json::json!({
                "trees": trees,
                "count": epics.len()
            });
            println!("{}", serde_json::to_string(&output)?);
        } else {
            for (i, epic) in epics.iter().enumerate() {
                if i > 0 {
                    println!();
                }
                let tree = storage.get_dependency_tree(&epic.id)?;
                print_ascii_tree(&tree);
            }
        }
    }

    Ok(())
}

fn print_dep_tree(tree: &[(crate::storage::Issue, i32)], json: bool) -> Result<()> {
    if json {
        let output = tree_to_json(tree);
        println!("{}", serde_json::to_string(&output)?);
    } else {
        print_ascii_tree(tree);
    }
    Ok(())
}

fn tree_to_json(tree: &[(crate::storage::Issue, i32)]) -> serde_json::Value {
    if tree.is_empty() {
        return serde_json::json!(null);
    }

    // Build nested structure from flat (issue, depth) list
    #[derive(serde::Serialize)]
    struct TreeNode {
        issue: serde_json::Value,
        children: Vec<TreeNode>,
    }

    fn build_children(
        tree: &[(crate::storage::Issue, i32)],
        parent_idx: usize,
        parent_depth: i32,
    ) -> Vec<TreeNode> {
        let mut children = Vec::new();
        let mut i = parent_idx + 1;
        while i < tree.len() {
            let (ref issue, depth) = tree[i];
            if depth <= parent_depth {
                break;
            }
            if depth == parent_depth + 1 {
                let node = TreeNode {
                    issue: serde_json::to_value(issue).unwrap_or_default(),
                    children: build_children(tree, i, depth),
                };
                children.push(node);
            }
            i += 1;
        }
        children
    }

    let (ref root, root_depth) = tree[0];
    let root_node = TreeNode {
        issue: serde_json::to_value(root).unwrap_or_default(),
        children: build_children(tree, 0, root_depth),
    };

    serde_json::to_value(root_node).unwrap_or_default()
}

fn print_ascii_tree(tree: &[(crate::storage::Issue, i32)]) {
    if tree.is_empty() {
        return;
    }

    for (idx, (issue, depth)) in tree.iter().enumerate() {
        let short_id = issue.short_id.as_deref().unwrap_or(&issue.id[..8]);
        let status_icon = match issue.status.as_str() {
            "open" => "○",
            "in_progress" => "●",
            "blocked" => "⊘",
            "closed" => "✓",
            "deferred" => "◌",
            _ => "?",
        };

        if *depth == 0 {
            println!("{status_icon} {} [{}] {short_id}", issue.title, issue.issue_type);
        } else {
            // Find if this is the last child at this depth
            let is_last = !tree[idx + 1..].iter().any(|(_, d)| *d == *depth);
            let connector = if is_last { "└── " } else { "├── " };
            let indent: String = (1..*depth).map(|_| "│   ").collect();
            println!(
                "{indent}{connector}{status_icon} {} [{}] {short_id}",
                issue.title, issue.issue_type
            );
        }
    }
}