pmat 3.15.0

PMAT - Zero-config AI context generation and code quality toolkit (CLI, MCP, HTTP)
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

/// State persistence manager
pub struct StatePersistence {
    /// Path to state file
    state_file: PathBuf,

    /// Current state
    state: Arc<RwLock<AgentState>>,

    /// Auto-save interval in seconds
    auto_save_interval: u64,
}

impl StatePersistence {
    /// Create new state persistence manager
    #[provable_contracts_macros::contract("pmat-core.yaml", equation = "path_exists")]
    pub fn new(state_dir: impl AsRef<Path>) -> Result<Self> {
        let state_file = state_dir.as_ref().join("agent_state.json");

        let state = if state_file.exists() {
            Self::load_from_file(&state_file)?
        } else {
            AgentState::default()
        };

        Ok(Self {
            state_file,
            state: Arc::new(RwLock::new(state)),
            auto_save_interval: 60, // Save every minute
        })
    }

    /// Load state from file
    fn load_from_file(path: &Path) -> Result<AgentState> {
        let contents = std::fs::read_to_string(path).context("Failed to read state file")?;

        serde_json::from_str(&contents).context("Failed to deserialize state")
    }

    /// Save current state to file
    #[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
    pub async fn save(&self) -> Result<()> {
        let state = self.state.read().await;
        let json = serde_json::to_string_pretty(&*state)?;

        // Create parent directory if needed
        if let Some(parent) = self.state_file.parent() {
            fs::create_dir_all(parent).await?;
        }

        // Use safe two-phase write pattern with .tmp extension
        let temp_file = self.state_file.with_extension("tmp");
        fs::write(&temp_file, json).await?;
        fs::rename(&temp_file, &self.state_file).await?;

        Ok(())
    }

    /// Start auto-save task
    #[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
    pub async fn start_auto_save(&self) {
        let state_file = self.state_file.clone();
        let state = self.state.clone();
        let interval = self.auto_save_interval;

        tokio::spawn(async move {
            let mut interval = tokio::time::interval(std::time::Duration::from_secs(interval));

            loop {
                interval.tick().await;

                // Save state
                if let Ok(state) = state.read().await.to_json() {
                    if let Err(e) = fs::write(&state_file, state).await {
                        tracing::error!("Failed to auto-save state: {}", e);
                    } else {
                        tracing::debug!("State auto-saved");
                    }
                }
            }
        });
    }

    /// Add or update monitored project
    #[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
    pub async fn add_project(&self, project: ProjectState) -> Result<()> {
        let mut state = self.state.write().await;
        state.monitored_projects.insert(project.id.clone(), project);
        state.last_updated = Utc::now();
        Ok(())
    }

    /// Remove monitored project
    #[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
    pub async fn remove_project(&self, project_id: &str) -> Result<()> {
        let mut state = self.state.write().await;
        state.monitored_projects.remove(project_id);
        state.last_updated = Utc::now();
        Ok(())
    }

    /// Update project metrics
    #[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
    pub async fn update_metrics(&self, project_id: &str, metrics: QualityMetrics) -> Result<()> {
        let mut state = self.state.write().await;

        if let Some(project) = state.monitored_projects.get_mut(project_id) {
            project.current_metrics = metrics.clone();
            project.last_analyzed = Some(Utc::now());

            // Add to history
            state.quality_history.push(QualitySnapshot {
                timestamp: Utc::now(),
                project_id: project_id.to_string(),
                metrics,
                violations: Vec::new(),
            });

            // Trim history to last 1000 entries
            if state.quality_history.len() > 1000 {
                let drain_count = state.quality_history.len() - 1000;
                state.quality_history.drain(0..drain_count);
            }

            state.last_updated = Utc::now();
        }

        Ok(())
    }

    /// Get current state
    #[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
    pub async fn get_state(&self) -> AgentState {
        self.state.read().await.clone()
    }

    /// Update statistics
    #[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
    pub async fn update_statistics<F>(&self, updater: F) -> Result<()>
    where
        F: FnOnce(&mut AgentStatistics),
    {
        let mut state = self.state.write().await;
        updater(&mut state.statistics);
        state.last_updated = Utc::now();
        Ok(())
    }
}