add conflict resolver

Author: zhangfengcdt

src/agent/persistence.rs

@@ -692,8 +692,6 @@ mod tests {
                 backend_path
             };
 
-            let start_time = std::time::Instant::now();
-
             let mut store = match backend_name {
                 "Git" => BaseMemoryStore::init_with_thread_safe_git(
                     &actual_path,
@@ -732,8 +730,6 @@ mod tests {
                 .await
                 .unwrap();
 
-            let duration = start_time.elapsed();
-
             // Verify all memories were stored
             for i in 0..10 {
                 let retrieved = store.get(&format!("perf_test_{}", i)).await.unwrap();

src/diff.rs

@@ -19,18 +19,66 @@ pub enum DiffResult {
     Modified(Vec<u8>, Vec<u8>, Vec<u8>),
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Clone)]
 pub enum MergeResult {
     Added(Vec<u8>, Vec<u8>),
     Removed(Vec<u8>),
     Modified(Vec<u8>, Vec<u8>),
     Conflict(MergeConflict),
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Clone)]
 pub struct MergeConflict {
     pub key: Vec<u8>,
     pub base_value: Option<Vec<u8>>,
     pub source_value: Option<Vec<u8>>,
     pub destination_value: Option<Vec<u8>>,
 }
+
+/// Trait for resolving merge conflicts
+pub trait ConflictResolver {
+    /// Resolve a conflict by returning the desired MergeResult
+    /// Returns None if the conflict cannot be resolved and should remain as a conflict
+    fn resolve_conflict(&self, conflict: &MergeConflict) -> Option<MergeResult>;
+}
+
+/// Default conflict resolver that ignores all conflicts (treats them as no-ops)
+#[derive(Debug, Clone, Default)]
+pub struct IgnoreConflictsResolver;
+
+impl ConflictResolver for IgnoreConflictsResolver {
+    fn resolve_conflict(&self, conflict: &MergeConflict) -> Option<MergeResult> {
+        // Ignore conflicts by keeping the destination value (no change applied)
+        // This effectively means "do nothing" for this key
+        match &conflict.destination_value {
+            Some(value) => Some(MergeResult::Modified(conflict.key.clone(), value.clone())),
+            None => Some(MergeResult::Removed(conflict.key.clone())),
+        }
+    }
+}
+
+/// Conflict resolver that always takes the source value
+#[derive(Debug, Clone, Default)]
+pub struct TakeSourceResolver;
+
+impl ConflictResolver for TakeSourceResolver {
+    fn resolve_conflict(&self, conflict: &MergeConflict) -> Option<MergeResult> {
+        match &conflict.source_value {
+            Some(value) => Some(MergeResult::Modified(conflict.key.clone(), value.clone())),
+            None => Some(MergeResult::Removed(conflict.key.clone())),
+        }
+    }
+}
+
+/// Conflict resolver that always takes the destination value
+#[derive(Debug, Clone, Default)]
+pub struct TakeDestinationResolver;
+
+impl ConflictResolver for TakeDestinationResolver {
+    fn resolve_conflict(&self, conflict: &MergeConflict) -> Option<MergeResult> {
+        match &conflict.destination_value {
+            Some(value) => Some(MergeResult::Modified(conflict.key.clone(), value.clone())),
+            None => Some(MergeResult::Removed(conflict.key.clone())),
+        }
+    }
+}

src/git/storage.rs

@@ -27,6 +27,7 @@ use std::sync::{Arc, Mutex};
 /// This storage implementation uses Git blobs to store serialized ProllyNode instances.
 /// Each node is stored as a Git blob object, with the blob's SHA-1 hash serving as the
 /// node's content-addressable identifier.
+#[derive(Debug)]
 pub struct GitNodeStorage<const N: usize> {
     _repository: Arc<Mutex<gix::Repository>>,
     cache: Mutex<LruCache<ValueDigest<N>, ProllyNode<N>>>,

src/rocksdb/storage.rs

@@ -30,6 +30,7 @@ const NODE_PREFIX: &[u8] = b"node:";
 ///
 /// This storage implementation uses RocksDB as the persistent storage backend,
 /// with an LRU cache for frequently accessed nodes to improve performance.
+#[derive(Debug)]
 pub struct RocksDBNodeStorage<const N: usize> {
     db: Arc<DB>,
     cache: Arc<Mutex<LruCache<ValueDigest<N>, ProllyNode<N>>>>,

src/storage.rs

@@ -31,7 +31,7 @@ use std::sync::RwLock;
 /// # Type Parameters
 ///
 /// - `N`: The size of the value digest.
-pub trait NodeStorage<const N: usize>: Send + Sync {
+pub trait NodeStorage<const N: usize>: Send + Sync + Clone {
     /// Retrieves a node from storage by its hash.
     ///
     /// # Arguments
@@ -67,6 +67,7 @@ pub trait NodeStorage<const N: usize>: Send + Sync {
 /// # Type Parameters
 ///
 /// - `N`: The size of the value digest.
+#[derive(Debug)]
 pub struct InMemoryNodeStorage<const N: usize> {
     map: HashMap<ValueDigest<N>, ProllyNode<N>>,
     configs: RwLock<HashMap<String, Vec<u8>>>,
@@ -127,6 +128,7 @@ impl<const N: usize> NodeStorage<N> for InMemoryNodeStorage<N> {
     }
 }
 
+#[derive(Clone, Debug)]
 pub struct FileNodeStorage<const N: usize> {
     storage_dir: PathBuf,
 }