agileplus-domain 0.3.0

Typed intent graphs for engineering work — convert prompts into validated DAGs of intents, features, tasks, tests, and edges, then store, query, and serve them from Rust, HTTP, or MCP.
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

//! `GraphMetadataBuilder` — constructs `GraphMetadata` records with sensible
//! default values for AgilePlus v1.0.0.

use crate::intent_graph::GraphMetadata;

const DEFAULT_SCHEMA_URI: &str =
    "https://phenotype.dev/schemas/agileplus-intent-ontology/v1.json";

/// Builder for graph-level metadata.
#[derive(Debug, Default)]
pub struct GraphMetadataBuilder {
    version: Option<String>,
    schema_uri: Option<String>,
    created_at: Option<String>,
    updated_at: Option<String>,
    node_count: Option<usize>,
    edge_count: Option<usize>,
    dag_valid: Option<bool>,
    source_system: Option<String>,
}

impl GraphMetadataBuilder {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn version(mut self, v: impl Into<String>) -> Self {
        self.version = Some(v.into());
        self
    }

    pub fn schema_uri(mut self, uri: impl Into<String>) -> Self {
        self.schema_uri = Some(uri.into());
        self
    }

    pub fn created_at(mut self, at: impl Into<String>) -> Self {
        self.created_at = Some(at.into());
        self
    }

    pub fn updated_at(mut self, at: impl Into<String>) -> Self {
        self.updated_at = Some(at.into());
        self
    }

    pub fn node_count(mut self, n: usize) -> Self {
        self.node_count = Some(n);
        self
    }

    pub fn edge_count(mut self, n: usize) -> Self {
        self.edge_count = Some(n);
        self
    }

    pub fn dag_valid(mut self, v: bool) -> Self {
        self.dag_valid = Some(v);
        self
    }

    pub fn source_system(mut self, s: impl Into<String>) -> Self {
        self.source_system = Some(s.into());
        self
    }

    pub fn build(self) -> Result<GraphMetadata, String> {
        let now = chrono::Utc::now().to_rfc3339();
        Ok(GraphMetadata {
            version: self.version.unwrap_or_else(|| "1.0.0".to_string()),
            schema_uri: self
                .schema_uri
                .unwrap_or_else(|| DEFAULT_SCHEMA_URI.to_string()),
            created_at: self.created_at.unwrap_or_else(|| now.clone()),
            updated_at: self.updated_at.or(Some(now)),
            node_count: self.node_count,
            edge_count: self.edge_count,
            dag_valid: self.dag_valid,
            source_system: self.source_system,
        })
    }
}