Skip to main content

hyprstream_core/archetypes/
mod.rs

1//! Repository archetype detection and capability system
2//!
3//! Archetypes provide internal capability detection for repositories.
4//! They detect what kind of content a repo contains and what features
5//! can be enabled for it.
6//!
7//! # Design Philosophy
8//!
9//! - Archetypes are **internal** - not user-facing CLI concepts
10//! - Detection uses **convention over configuration** - no manifest files
11//! - Archetypes are **composable** - a repo can match multiple
12//! - Capabilities **gate features** - inference, query, training, etc.
13//!
14//! # Capability Display Format
15//!
16//! Capabilities are displayed as comma-separated IDs (e.g., `infer,train,serve`).
17//! Available capabilities:
18//! - `infer` = run model inference
19//! - `train` = modify model weights
20//! - `query` = SELECT from data
21//! - `write` = INSERT/UPDATE data
22//! - `serve` = expose via API
23//! - `manage` = admin operations
24//! - `context` = context-augmented generation
25//!
26//! # Built-in Archetypes
27//!
28//! | Archetype | Detects | Capabilities |
29//! |-----------|---------|--------------|
30//! | HfModel | config.json + *.safetensors | INFER, TRAIN, SERVE |
31//! | HfDataset | dataset_infos.json, *.parquet | QUERY, WRITE, SERVE |
32//! | DuckDb | *.duckdb | QUERY, WRITE, SERVE |
33//! | CagContext | context.json | CONTEXT |
34
35mod cag;
36pub mod capabilities;
37pub mod domain;
38mod duckdb;
39mod hf_dataset;
40mod hf_model;
41mod registry;
42
43pub use cag::CagContextArchetype;
44pub use duckdb::DuckDbArchetype;
45pub use hf_dataset::HfDatasetArchetype;
46pub use hf_model::HfModelArchetype;
47pub use registry::{global_registry, ArchetypeRegistry, DetectedArchetypes, DetectedDomains};
48
49// Re-export type-safe capability system
50pub use capabilities::{
51    Capability, CapabilitySet, Context, Infer, Manage, Query, Serve, Train, Write,
52};
53
54// Re-export domain types
55pub use domain::{DetectionError, DetectionResult, Domain, SimpleDomain};
56
57use std::path::Path;
58
59/// Trait for repository archetype detection
60///
61/// Implementations detect whether a repository matches a particular
62/// archetype based on file patterns (convention over configuration).
63pub trait RepoArchetype: Send + Sync {
64    /// Unique identifier for this archetype
65    fn name(&self) -> &'static str;
66
67    /// Human-readable description
68    fn description(&self) -> &'static str;
69
70    /// Detect if a repository path matches this archetype
71    ///
72    /// Should check for marker files/patterns without loading heavy data.
73    fn detect(&self, repo_path: &Path) -> bool;
74
75    /// Capabilities this archetype enables
76    fn capabilities(&self) -> CapabilitySet;
77}
78
79/// Get all built-in archetypes
80pub fn builtin_archetypes() -> Vec<Box<dyn RepoArchetype>> {
81    vec![
82        Box::new(HfModelArchetype),
83        Box::new(HfDatasetArchetype),
84        Box::new(DuckDbArchetype),
85        Box::new(CagContextArchetype),
86    ]
87}
88
89#[cfg(test)]
90mod tests {
91    use super::*;
92
93    #[test]
94    fn test_capabilities_display() {
95        // Model capabilities: infer + train
96        let mut model = CapabilitySet::new();
97        model.insert::<Infer>();
98        model.insert::<Train>();
99        assert_eq!(format!("{}", model), "infer,train");
100
101        // Data capabilities: query + write
102        let mut data = CapabilitySet::new();
103        data.insert::<Query>();
104        data.insert::<Write>();
105        assert_eq!(format!("{}", data), "query,write");
106
107        // Full capabilities (sorted alphabetically)
108        let mut full = CapabilitySet::new();
109        full.insert::<Infer>();
110        full.insert::<Train>();
111        full.insert::<Query>();
112        full.insert::<Write>();
113        full.insert::<Serve>();
114        full.insert::<Manage>();
115        full.insert::<Context>();
116        assert_eq!(
117            format!("{}", full),
118            "context,infer,manage,query,serve,train,write"
119        );
120
121        // Empty
122        let empty = CapabilitySet::new();
123        assert_eq!(format!("{}", empty), "");
124
125        // Context capability alone
126        let mut context = CapabilitySet::new();
127        context.insert::<Context>();
128        assert_eq!(format!("{}", context), "context");
129    }
130
131    #[test]
132    fn test_capabilities_composable() {
133        let mut model = CapabilitySet::new();
134        model.insert::<Infer>();
135        model.insert::<Train>();
136        model.insert::<Serve>();
137
138        let mut data = CapabilitySet::new();
139        data.insert::<Query>();
140        data.insert::<Write>();
141        data.insert::<Serve>();
142
143        // Repos can have multiple capabilities (model + data)
144        let combined = model.union(&data);
145        assert!(combined.has::<Infer>());
146        assert!(combined.has::<Query>());
147        assert!(combined.has::<Serve>());
148        assert_eq!(format!("{}", combined), "infer,query,serve,train,write");
149
150        // Model with CAG context
151        let mut model_with_cag = model.clone();
152        model_with_cag.insert::<Context>();
153        assert_eq!(format!("{}", model_with_cag), "context,infer,serve,train");
154    }
155}