hyperforge 3.3.0

Multi-forge repository management
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

//! Sub-hub modules for hyperforge's nested plugin hierarchy
//!
//! Each sub-hub is a leaf plugin under the root `hyperforge` hub.

pub mod config;
pub mod package;
pub mod repo;
pub mod workspace;

use std::collections::HashMap;
use std::path::PathBuf;
use std::sync::{Arc, RwLock};

use crate::adapters::LocalForge;
use crate::services::SymmetricSyncService;

pub use config::ConfigHub;
pub use package::PackageHub;
pub use repo::RepoHub;
pub use workspace::WorkspaceHub;

/// Shared state for all hyperforge sub-hubs
#[derive(Clone)]
pub struct HyperforgeState {
    pub sync_service: Arc<SymmetricSyncService>,
    /// Cached LocalForge instances per org
    pub local_forges: Arc<RwLock<HashMap<String, Arc<LocalForge>>>>,
    /// Base config directory (~/.config/hyperforge)
    pub config_dir: PathBuf,
}

impl HyperforgeState {
    pub fn new() -> Self {
        let config_dir = dirs::home_dir()
            .unwrap_or_else(|| PathBuf::from("."))
            .join(".config")
            .join("hyperforge");

        Self {
            sync_service: Arc::new(SymmetricSyncService::new()),
            local_forges: Arc::new(RwLock::new(HashMap::new())),
            config_dir,
        }
    }

    /// Get or create LocalForge for an org with file persistence
    pub async fn get_local_forge(&self, org: &str) -> Arc<LocalForge> {
        // Try to get existing
        {
            let forges = self.local_forges.read().unwrap();
            if let Some(forge) = forges.get(org) {
                return forge.clone();
            }
        }

        // Create new with persistence
        let yaml_path = self.config_dir.join("orgs").join(org).join("repos.yaml");
        let forge = Arc::new(LocalForge::with_config_path(org, yaml_path));

        // Try to load existing state
        let _ = forge.load_from_yaml().await;

        // Cache it
        {
            let mut forges = self.local_forges.write().unwrap();
            forges.insert(org.to_string(), forge.clone());
        }

        forge
    }
}

impl Default for HyperforgeState {
    fn default() -> Self {
        Self::new()
    }
}