subcog/services/

sync.rs

//! Memory synchronization service.
//!
//! **Note**: With the migration to `SQLite` as authoritative storage, remote sync
//! is no longer supported. This service now returns no-op results for all
//! operations. Git context detection (branch, remote info) remains available
//! via `RemoteManager` for faceting purposes.

use crate::Result;
use crate::config::Config;
use crate::git::RemoteManager;
use std::time::Instant;
use tracing::instrument;

/// Service for synchronizing memories with remote storage.
///
/// **Deprecated**: With `SQLite` as authoritative storage, remote sync is no longer
/// supported. All sync operations return empty stats. Use this service only for
/// remote context detection.
pub struct SyncService {
    /// Configuration.
    config: Config,
}

impl SyncService {
    /// Creates a new sync service.
    #[must_use]
    pub const fn new(config: Config) -> Self {
        Self { config }
    }

    /// Creates a no-op sync service for user-scoped storage.
    ///
    /// This service does nothing when sync operations are called,
    /// returning empty stats.
    #[must_use]
    pub fn no_op() -> Self {
        Self {
            config: Config::default(),
        }
    }

    /// Returns whether this service can perform sync operations.
    ///
    /// **Note**: Always returns `false` since remote sync is no longer supported.
    #[must_use]
    pub const fn is_enabled(&self) -> bool {
        false // Remote sync no longer supported
    }

    /// Fetches memories from remote.
    ///
    /// **Note**: Returns empty stats since remote sync is no longer supported.
    ///
    /// # Errors
    ///
    /// This function does not return errors (always succeeds with empty stats).
    #[instrument(skip(self), fields(operation = "sync.fetch"))]
    pub fn fetch(&self) -> Result<SyncStats> {
        let start = Instant::now();

        // Remote sync no longer supported - return empty stats
        let stats = SyncStats::default();

        metrics::counter!(
            "memory_sync_total",
            "direction" => "fetch",
            "domain" => "project",
            "status" => "noop"
        )
        .increment(1);
        metrics::histogram!("memory_sync_duration_ms", "direction" => "fetch")
            .record(start.elapsed().as_secs_f64() * 1000.0);

        Ok(stats)
    }

    /// Pushes memories to remote.
    ///
    /// **Note**: Returns empty stats since remote sync is no longer supported.
    ///
    /// # Errors
    ///
    /// This function does not return errors (always succeeds with empty stats).
    #[instrument(skip(self), fields(operation = "sync.push"))]
    pub fn push(&self) -> Result<SyncStats> {
        let start = Instant::now();

        // Remote sync no longer supported - return empty stats
        let stats = SyncStats::default();

        metrics::counter!(
            "memory_sync_total",
            "direction" => "push",
            "domain" => "project",
            "status" => "noop"
        )
        .increment(1);
        metrics::histogram!("memory_sync_duration_ms", "direction" => "push")
            .record(start.elapsed().as_secs_f64() * 1000.0);

        Ok(stats)
    }

    /// Performs a full sync (fetch + push).
    ///
    /// **Note**: Returns empty stats since remote sync is no longer supported.
    ///
    /// # Errors
    ///
    /// This function does not return errors (always succeeds with empty stats).
    #[instrument(skip(self), fields(operation = "sync.full"))]
    pub fn sync(&self) -> Result<SyncStats> {
        let start = Instant::now();

        // Remote sync no longer supported - return empty stats
        let stats = SyncStats::default();

        metrics::counter!(
            "memory_sync_total",
            "direction" => "full",
            "domain" => "project",
            "status" => "noop"
        )
        .increment(1);
        metrics::histogram!("memory_sync_duration_ms", "direction" => "full")
            .record(start.elapsed().as_secs_f64() * 1000.0);

        Ok(stats)
    }

    /// Checks if sync is available (remote exists and is reachable).
    ///
    /// **Note**: Always returns `false` since remote sync is no longer supported.
    ///
    /// # Errors
    ///
    /// This function does not return errors (always succeeds with `false`).
    #[allow(clippy::unused_self)]
    pub const fn is_available(&self) -> Result<bool> {
        Ok(false) // Remote sync no longer supported
    }

    /// Returns the configured remote name.
    ///
    /// Can still be used for git context detection.
    ///
    /// # Errors
    ///
    /// Returns an error if no repo is configured.
    pub fn remote_name(&self) -> Result<Option<String>> {
        let repo_path = match &self.config.repo_path {
            Some(p) => p,
            None => return Ok(None),
        };

        let remote = RemoteManager::new(repo_path);
        remote.default_remote()
    }

    /// Returns the remote URL.
    ///
    /// Can still be used for git context detection.
    ///
    /// # Errors
    ///
    /// Returns an error if no repo is configured.
    pub fn remote_url(&self) -> Result<Option<String>> {
        let repo_path = match &self.config.repo_path {
            Some(p) => p,
            None => return Ok(None),
        };

        let remote = RemoteManager::new(repo_path);
        let remote_name = match remote.default_remote()? {
            Some(name) => name,
            None => return Ok(None),
        };

        remote.get_remote_url(&remote_name)
    }
}

impl Default for SyncService {
    fn default() -> Self {
        Self::new(Config::default())
    }
}

/// Statistics from a sync operation.
#[derive(Debug, Clone, Default)]
pub struct SyncStats {
    /// Number of memories pushed.
    pub pushed: usize,
    /// Number of memories pulled.
    pub pulled: usize,
    /// Number of conflicts encountered.
    pub conflicts: usize,
}

impl SyncStats {
    /// Returns true if the sync was a no-op.
    #[must_use]
    pub const fn is_empty(&self) -> bool {
        self.pushed == 0 && self.pulled == 0 && self.conflicts == 0
    }

    /// Returns a human-readable summary.
    #[must_use]
    pub fn summary(&self) -> String {
        if self.is_empty() {
            "Already up to date".to_string()
        } else {
            format!(
                "Pushed: {}, Pulled: {}, Conflicts: {}",
                self.pushed, self.pulled, self.conflicts
            )
        }
    }
}

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

    #[test]
    fn test_sync_stats_empty() {
        let stats = SyncStats::default();
        assert!(stats.is_empty());
        assert_eq!(stats.summary(), "Already up to date");
    }

    #[test]
    fn test_sync_stats_summary() {
        let stats = SyncStats {
            pushed: 5,
            pulled: 3,
            conflicts: 1,
        };
        assert!(!stats.is_empty());
        assert!(stats.summary().contains("Pushed: 5"));
        assert!(stats.summary().contains("Pulled: 3"));
        assert!(stats.summary().contains("Conflicts: 1"));
    }

    #[test]
    fn test_sync_service_no_repo() {
        let service = SyncService::default();

        // All sync operations return Ok with empty stats (no-op)
        let result = service.fetch();
        assert!(result.is_ok());
        assert!(result.unwrap().is_empty());

        let result = service.push();
        assert!(result.is_ok());
        assert!(result.unwrap().is_empty());

        let result = service.sync();
        assert!(result.is_ok());
        assert!(result.unwrap().is_empty());
    }

    #[test]
    fn test_sync_service_availability() {
        let service = SyncService::default();
        assert!(!service.is_available().unwrap());
    }
}