mockforge-intelligence 0.3.236

AI-powered behavior, response generation, and behavioral cloning for MockForge
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

//! Typed drift engine boundaries and stable public HTTP entrypoints.
//! Budget, incident, GitOps and metric operations live in focused submodules.

use super::structural_incidents::StructuralIncidents;
use async_trait::async_trait;
use mockforge_contracts::contract_drift::types::{DriftBudget, DriftBudgetConfig};
use mockforge_foundation::incidents_types::DriftIncident;

mod budgets;
mod gitops;
mod incidents;
mod metrics;
mod scoped_budgets;

pub use budgets::*;
pub use gitops::*;
pub use incidents::*;
pub use metrics::*;
pub use scoped_budgets::*;

/// Read access to the existing drift budget engine and its precedence rules.
pub trait DriftBudgetSource: Send + Sync {
    /// Current engine configuration.
    fn config(&self) -> &DriftBudgetConfig;
    /// Resolve the effective endpoint/workspace/service/tag budget.
    fn get_budget_for_endpoint(
        &self,
        endpoint: &str,
        method: &str,
        workspace_id: Option<&str>,
        service_name: Option<&str>,
        tags: Option<&[String]>,
    ) -> DriftBudget;
}

/// GitOps implementation supplied by the consuming application.
#[async_trait]
pub trait DriftGitOps: Send + Sync {
    /// Generate a pull request with the existing configured GitOps behavior.
    async fn generate_pr_from_incidents(
        &self,
        incidents: &[DriftIncident],
    ) -> mockforge_foundation::Result<Option<crate::pr_generation::PRResult>>;
}

/// Existing engine/manager instances supplied by downstream HTTP integrations.
pub trait DriftBudgetStateProvider: Clone + Send + Sync + 'static {
    /// Budget lookup implementation.
    type Engine: DriftBudgetSource;
    /// Structural incident manager implementation.
    type Incidents: StructuralIncidents;
    /// Optional configured GitOps implementation.
    type GitOps: DriftGitOps;
    /// Access the existing engine.
    fn engine(&self) -> &Self::Engine;
    /// Access the existing incident manager.
    fn incident_manager(&self) -> &Self::Incidents;
    /// Access the configured GitOps handler, if any.
    fn gitops_handler(&self) -> Option<&Self::GitOps>;
    /// Publish through the application's pipeline bus when enabled. The default
    /// keeps applications without pipeline support free of that dependency.
    fn publish_drift_threshold(
        &self,
        _workspace: uuid::Uuid,
        _endpoint: String,
        _exceeded: i32,
        _total: i32,
    ) {
    }
}

/// Create drift budget router
pub fn drift_budget_router<S: DriftBudgetStateProvider>(state: S) -> axum::Router {
    use axum::{
        routing::{get, patch, post},
        Router,
    };

    Router::new()
        .route("/api/v1/drift/budgets", post(create_budget::<S>))
        .route("/api/v1/drift/budgets", get(list_budgets::<S>))
        .route("/api/v1/drift/budgets/lookup", get(get_budget_for_endpoint::<S>))
        .route("/api/v1/drift/budgets/workspace", post(create_workspace_budget::<S>))
        .route("/api/v1/drift/budgets/service", post(create_service_budget::<S>))
        .route("/api/v1/drift/budgets/{id}", get(get_budget::<S>))
        .route("/api/v1/drift/incidents", get(list_incidents::<S>))
        .route("/api/v1/drift/incidents/stats", get(get_incident_stats::<S>))
        .route("/api/v1/drift/incidents/{id}", get(get_incident::<S>))
        .route("/api/v1/drift/incidents/{id}", patch(update_incident::<S>))
        .route("/api/v1/drift/incidents/{id}/resolve", post(resolve_incident::<S>))
        .route("/api/v1/drift/gitops/generate-pr", post(generate_gitops_pr::<S>))
        .route("/api/v1/drift/metrics", get(get_drift_metrics::<S>))
        .with_state(state)
}

impl DriftBudgetSource for mockforge_contracts::contract_drift::DriftBudgetEngine {
    fn config(&self) -> &DriftBudgetConfig {
        mockforge_contracts::contract_drift::DriftBudgetEngine::config(self)
    }
    fn get_budget_for_endpoint(
        &self,
        endpoint: &str,
        method: &str,
        workspace_id: Option<&str>,
        service_name: Option<&str>,
        tags: Option<&[String]>,
    ) -> DriftBudget {
        mockforge_contracts::contract_drift::DriftBudgetEngine::get_budget_for_endpoint(
            self,
            endpoint,
            method,
            workspace_id,
            service_name,
            tags,
        )
    }
}