Function duplicates

crates/ccql/src/cli/commands.rs:485–622

(
    config: &Config,
    threshold: f64,
    min_count: usize,
    limit: usize,
    show_variants: bool,
    sort: &str,
    min_length: usize,
    format: OutputFormat,
)

#[allow(clippy::too_many_arguments)]
pub async fn duplicates(
    config: &Config,
    threshold: f64,
    min_count: usize,
    limit: usize,
    show_variants: bool,
    sort: &str,
    min_length: usize,
    format: OutputFormat,
) -> Result<()> {
    use crate::dedup::FuzzyDeduper;

    let history = HistoryDataSource::new(config.clone());
    let entries = history.filter_prompts().await?;

    // Include timestamps for sorting
    let prompts: Vec<(String, i64)> = entries
        .iter()
        .map(|e| (e.display.clone(), e.timestamp))
        .collect();

    let deduper = FuzzyDeduper::new(threshold, min_length);
    let mut clusters = deduper.cluster(prompts);

    // Sort based on user preference
    match sort {
        "latest" => FuzzyDeduper::sort_by_latest(&mut clusters),
        _ => FuzzyDeduper::sort_by_count(&mut clusters),
    }

    let filtered: Vec<_> = clusters
        .into_iter()
        .filter(|c| c.count >= min_count)
        .take(limit)
        .collect();

    let mut writer = OutputWriter::new(std::io::stdout(), format);

    match format {
        OutputFormat::Json => {
            let data: Vec<_> = filtered
                .iter()
                .map(|c| {
                    serde_json::json!({
                        "prompt": c.canonical,
                        "count": c.count,
                        "latest": c.latest_timestamp,
                        "variants": c.variants
                    })
                })
                .collect();
            writer.write_json(&data)?;
        }
        OutputFormat::Raw | OutputFormat::Jsonl => {
            for cluster in &filtered {
                writer.write_json(&serde_json::json!({
                    "prompt": cluster.canonical,
                    "count": cluster.count,