rsclaw 0.0.1-alpha.1

use super::database::Store;
use crate::provider::ChatMessage;
use anyhow::{Context, Result};
use serde::{Deserialize, Serialize};
use std::sync::Arc;

/// Persisted agent state.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AgentStateData {
    pub name: Arc<str>,
    pub model: Arc<str>,
    pub system_prompt: Arc<str>,
    pub message_count: usize,
    pub created_at: u64,
    pub last_active: u64,
}

/// Agent persistence manager.
pub struct AgentStore {
    store: Arc<Store>,
}

impl AgentStore {
    /// Create a new agent store.
    pub fn new(store: Arc<Store>) -> Self {
        Self { store }
    }

    /// Save agent state to disk.
    pub fn save(
        &self,
        name: &str,
        model: &str,
        system_prompt: &str,
        message_count: usize,
    ) -> Result<()> {
        let now = std::time::SystemTime::now()
            .duration_since(std::time::SystemTime::UNIX_EPOCH)?
            .as_secs();

        let state = AgentStateData {
            name: Arc::from(name),
            model: Arc::from(model),
            system_prompt: Arc::from(system_prompt),
            message_count,
            created_at: now,
            last_active: now,
        };

        let serialized = serde_json::to_vec(&state)?;
        self.store.save_agent(name, &serialized)?;

        tracing::info!("Agent '{}' state saved", name);
        Ok(())
    }

    /// Load agent state from disk.
    pub fn load(&self, name: &str) -> Result<Option<AgentStateData>> {
        match self.store.get_agent(name)? {
            Some(data) => {
                let state: AgentStateData = serde_json::from_slice(&data)?;
                Ok(Some(state))
            }
            None => Ok(None),
        }
    }

    /// Delete agent state.
    pub fn delete(&self, name: &str) -> Result<bool> {
        self.store.delete_agent(name)
    }

    /// List all agent names.
    pub fn list(&self) -> Result<Vec<String>> {
        self.store.list_agents()
    }
}