bibox 0.2.30

Terminal-based bibliography manager with three-panel TUI and AI-agent-friendly Markdown notes
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

use anyhow::{Context, Result};
use serde::Deserialize;

#[derive(Debug, Deserialize)]
struct UnpaywallResponse {
    best_oa_location: Option<OaLocation>,
    is_oa: bool,
}

#[derive(Debug, Deserialize)]
struct OaLocation {
    url_for_pdf: Option<String>,
    url: Option<String>,
    host_type: Option<String>,
    #[serde(rename = "repository_institution")]
    repository: Option<String>,
}

#[derive(Debug)]
pub struct OaResult {
    pub pdf_url: String,
    pub source: String,
}

/// Find an open-access PDF for a given DOI using the Unpaywall API.
pub async fn find_open_access(doi: &str) -> Result<Option<OaResult>> {
    let client = reqwest::Client::new();
    let url = format!(
        "https://api.unpaywall.org/v2/{}?email=bibox@example.com",
        doi
    );

    let resp = client
        .get(&url)
        .send()
        .await
        .context("Unpaywall API request failed")?;

    if !resp.status().is_success() {
        return Ok(None);
    }

    let data: UnpaywallResponse = match resp.json().await {
        Ok(d) => d,
        Err(_) => return Ok(None),
    };

    if !data.is_oa {
        return Ok(None);
    }

    if let Some(loc) = data.best_oa_location {
        let pdf_url = loc.url_for_pdf.or(loc.url);
        if let Some(url) = pdf_url {
            let source = loc
                .host_type
                .unwrap_or_else(|| loc.repository.unwrap_or_else(|| "Open Access".to_string()));
            return Ok(Some(OaResult {
                pdf_url: url,
                source,
            }));
        }
    }

    Ok(None)
}

/// Download a PDF from a URL and save it to the given path.
pub async fn download_pdf(url: &str, dest: &std::path::Path) -> Result<()> {
    let client = reqwest::Client::builder()
        .user_agent("bibox/0.1 (https://github.com/namil-k/bibox; mailto:bibox@example.com)")
        .build()?;
    let resp = client
        .get(url)
        .send()
        .await
        .context("PDF download request failed")?;

    if !resp.status().is_success() {
        anyhow::bail!("PDF download failed: HTTP {}", resp.status());
    }

    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("")
        .to_lowercase();
    if !content_type.contains("pdf") {
        anyhow::bail!("URL did not return a PDF (content-type: {})", content_type);
    }

    let bytes = resp.bytes().await.context("PDF download failed")?;
    std::fs::write(dest, bytes)?;
    Ok(())
}