perspt_agent/

ledger.rs

//! DuckDB Merkle Ledger
//!
//! Persistent storage for session history, commits, and Merkle proofs.

use anyhow::Result;
use std::path::Path;

/// Merkle commit record
#[derive(Debug, Clone)]
pub struct MerkleCommit {
    pub commit_id: String,
    pub session_id: String,
    pub node_id: String,
    pub merkle_root: [u8; 32],
    pub parent_hash: Option<[u8; 32]>,
    pub timestamp: i64,
    pub energy: f32,
    pub stable: bool,
}

/// Session record
#[derive(Debug, Clone)]
pub struct SessionRecord {
    pub session_id: String,
    pub task: String,
    pub started_at: i64,
    pub ended_at: Option<i64>,
    pub status: String,
    pub total_nodes: usize,
    pub completed_nodes: usize,
}

/// Merkle Ledger using DuckDB for persistence
pub struct MerkleLedger {
    /// Database connection string
    db_path: String,
    /// In-memory cache of current session
    current_session: Option<SessionRecord>,
}

impl MerkleLedger {
    /// Create a new ledger (opens or creates database)
    pub fn new(db_path: &str) -> Result<Self> {
        let ledger = Self {
            db_path: db_path.to_string(),
            current_session: None,
        };

        // Initialize schema
        ledger.init_schema()?;

        Ok(ledger)
    }

    /// Create an in-memory ledger (for testing)
    pub fn in_memory() -> Result<Self> {
        Self::new(":memory:")
    }

    /// Initialize database schema
    fn init_schema(&self) -> Result<()> {
        // Note: In a real implementation, this would use duckdb crate
        // For now, we'll use a file-based approach with JSON
        log::info!("Initializing Merkle Ledger at: {}", self.db_path);

        // Create the ledger directory if needed
        if self.db_path != ":memory:" {
            if let Some(parent) = Path::new(&self.db_path).parent() {
                std::fs::create_dir_all(parent)?;
            }
        }

        Ok(())
    }

    /// Start a new session
    pub fn start_session(&mut self, session_id: &str, task: &str) -> Result<()> {
        let record = SessionRecord {
            session_id: session_id.to_string(),
            task: task.to_string(),
            started_at: chrono_timestamp(),
            ended_at: None,
            status: "RUNNING".to_string(),
            total_nodes: 0,
            completed_nodes: 0,
        };

        self.current_session = Some(record);
        log::info!("Started session: {}", session_id);

        Ok(())
    }

    /// Commit a stable node state
    pub fn commit_node(
        &mut self,
        node_id: &str,
        merkle_root: [u8; 32],
        parent_hash: Option<[u8; 32]>,
        energy: f32,
    ) -> Result<String> {
        let session_id = self
            .current_session
            .as_ref()
            .map(|s| s.session_id.clone())
            .unwrap_or_else(|| "unknown".to_string());

        let commit = MerkleCommit {
            commit_id: generate_commit_id(),
            session_id,
            node_id: node_id.to_string(),
            merkle_root,
            parent_hash,
            timestamp: chrono_timestamp(),
            energy,
            stable: energy < 0.1,
        };

        log::info!("Committed node {} with energy {:.4}", node_id, energy);

        // Update session progress
        if let Some(ref mut session) = self.current_session {
            session.completed_nodes += 1;
        }

        Ok(commit.commit_id)
    }

    /// End the current session
    pub fn end_session(&mut self, status: &str) -> Result<()> {
        if let Some(ref mut session) = self.current_session {
            session.ended_at = Some(chrono_timestamp());
            session.status = status.to_string();
            log::info!(
                "Ended session {} with status: {}",
                session.session_id,
                status
            );
        }
        Ok(())
    }

    /// Get recent commits for a session
    pub fn get_recent_commits(&self, session_id: &str, limit: usize) -> Vec<MerkleCommit> {
        // Placeholder - would query DuckDB
        log::debug!(
            "Getting recent {} commits for session {}",
            limit,
            session_id
        );
        Vec::new()
    }

    /// Rollback to a specific commit
    pub fn rollback_to(&mut self, commit_id: &str) -> Result<()> {
        log::info!("Rolling back to commit: {}", commit_id);
        // Would restore state from the commit
        Ok(())
    }

    /// Get session statistics
    pub fn get_stats(&self) -> LedgerStats {
        LedgerStats {
            total_sessions: 0,
            total_commits: 0,
            db_size_bytes: 0,
        }
    }

    /// Get the current merkle root
    pub fn current_merkle_root(&self) -> [u8; 32] {
        [0u8; 32] // Placeholder
    }
}

/// Ledger statistics
#[derive(Debug, Clone)]
pub struct LedgerStats {
    pub total_sessions: usize,
    pub total_commits: usize,
    pub db_size_bytes: u64,
}

/// Generate a unique commit ID
fn generate_commit_id() -> String {
    use std::time::{SystemTime, UNIX_EPOCH};
    let now = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_nanos();
    format!("{:x}", now)
}

/// Get current timestamp
fn chrono_timestamp() -> i64 {
    use std::time::{SystemTime, UNIX_EPOCH};
    SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_secs() as i64
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_ledger_creation() {
        let ledger = MerkleLedger::in_memory().unwrap();
        assert!(ledger.current_session.is_none());
    }

    #[test]
    fn test_session_lifecycle() {
        let mut ledger = MerkleLedger::in_memory().unwrap();

        ledger.start_session("test-123", "Test task").unwrap();
        assert!(ledger.current_session.is_some());

        ledger.commit_node("node-1", [0u8; 32], None, 0.05).unwrap();
        assert_eq!(ledger.current_session.as_ref().unwrap().completed_nodes, 1);

        ledger.end_session("COMPLETED").unwrap();
        assert_eq!(ledger.current_session.as_ref().unwrap().status, "COMPLETED");
    }
}