facto-core 0.1.0-alpha.1

Core models, registry/forge/runtime clients for facto: real-time package ecosystem data for AI agents
Documentation 
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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use std::collections::HashMap;
use std::sync::Arc;
use std::time::Duration;

use dashmap::DashMap;
use tokio::time::Instant;

use crate::config::Config;
use crate::http;
use crate::models::{RuntimeInfo, RuntimeVersion};
use crate::runtimes::catalog::all_runtimes;
use crate::runtimes::endoflife::EndOfLifeClient;
use crate::runtimes::{Runtime, RuntimeResult};

struct CachedVersions {
    versions: Vec<RuntimeVersion>,
    fetched_at: Instant,
}

pub struct RuntimeManager {
    runtimes: HashMap<String, Box<dyn Runtime>>,
    cache: Arc<DashMap<String, CachedVersions>>,
    client: EndOfLifeClient,
    ttl: Duration,
}

impl RuntimeManager {
    pub fn new(config: &Config) -> Result<Self, http::HttpClientError> {
        let mut runtimes = HashMap::new();

        for rt in all_runtimes() {
            if config.runtimes.enabled.contains(&rt.id().to_string()) {
                runtimes.insert(rt.id().to_string(), rt);
            }
        }

        Ok(Self {
            runtimes,
            cache: Arc::new(DashMap::new()),
            client: EndOfLifeClient::new(http::default_client()?),
            ttl: Duration::from_secs(config.cache.runtimes_secs),
        })
    }

    pub fn list_runtimes(&self) -> Vec<(String, String)> {
        self.runtimes
            .iter()
            .map(|(id, rt)| (id.clone(), rt.display_name().to_string()))
            .collect()
    }

    pub async fn get_runtime_info(&self, id: &str) -> RuntimeResult<RuntimeInfo> {
        let rt = self
            .runtimes
            .get(id)
            .ok_or_else(|| crate::runtimes::RuntimeError::Unknown(id.to_string()))?;

        let versions = self.get_versions_cached(rt.endoflife_id()).await?;

        let (latest_stable, latest_cycle) = versions
            .first()
            .map(|v| (v.latest.clone(), v.cycle.clone()))
            .unwrap_or_default();

        let changelog_url = rt.changelog_url(&latest_cycle);

        Ok(RuntimeInfo {
            id: rt.id().to_string(),
            name: rt.display_name().to_string(),
            latest_stable,
            latest_cycle,
            changelog_url,
            versions,
        })
    }

    pub async fn get_versions(
        &self,
        id: &str,
        active_only: bool,
    ) -> RuntimeResult<Vec<RuntimeVersion>> {
        let rt = self
            .runtimes
            .get(id)
            .ok_or_else(|| crate::runtimes::RuntimeError::Unknown(id.to_string()))?;

        let versions = self.get_versions_cached(rt.endoflife_id()).await?;

        if active_only {
            let today = chrono::Utc::now().date_naive();
            Ok(versions
                .into_iter()
                .filter(|v| match &v.eol {
                    crate::models::EolStatus::Date(d) => *d > today,
                    crate::models::EolStatus::Bool(b) => !b,
                })
                .collect())
        } else {
            Ok(versions)
        }
    }

    async fn get_versions_cached(&self, endoflife_id: &str) -> RuntimeResult<Vec<RuntimeVersion>> {
        // Check cache
        if let Some(cached) = self.cache.get(endoflife_id)
            && cached.fetched_at.elapsed() < self.ttl
        {
            return Ok(cached.versions.clone());
        }

        // Fetch and cache
        let versions = self.client.fetch_cycles(endoflife_id).await?;
        self.cache.insert(
            endoflife_id.to_string(),
            CachedVersions {
                versions: versions.clone(),
                fetched_at: Instant::now(),
            },
        );

        Ok(versions)
    }
}