soulsync 1.0.0 → 1.0.5

package/src/sync.py

@@ -1,140 +1,203 @@
 import os
 import time
-from src.profiles import ProfilesClient, ConflictError
+import shutil
+import threading
+from profiles import ProfilesClient, ConflictError
 
 
 class ProfileSync:
     """多文件同步逻辑"""
-    
+  
     def __init__(self, client: ProfilesClient, version_manager, workspace: str):
         self.client = client
         self.version_manager = version_manager
-        self.workspace = os.path.abspath(workspace)
-        self.is_syncing = False
-    
-    def pull_all(self) -> int:
-        """从云端拉取所有文件
-        
-        Returns:
-            拉取的文件数量
-        """
-        print("[Sync] Pulling all profiles from cloud...")
-        self.is_syncing = True
-        
+        self.workspace = workspace
+        self._syncing_files = set()
+        self._sync_lock = threading.Lock()
+  
+    def _get_absolute_path(self, relative_path: str) -> str:
+        """获取文件的绝对路径"""
+        return os.path.normpath(os.path.join(self.workspace, relative_path))
+  
+    def _is_syncing(self, file_path: str) -> bool:
+        """检查文件是否正在同步"""
+        return file_path in self._syncing_files
+  
+    def _mark_syncing(self, file_path: str):
+        """标记文件正在同步"""
+        self._syncing_files.add(file_path)
+  
+    def _unmark_syncing(self, file_path: str):
+        """延迟取消同步标记"""
+        def remove():
+            time.sleep(2)
+            self._syncing_files.discard(file_path)
+        threading.Thread(target=remove, daemon=True).start()
+  
+    def _read_local_file(self, file_path: str) -> str | None:
+        """读取本地文件内容"""
+        absolute_path = self._get_absolute_path(file_path)
+        if os.path.exists(absolute_path):
+            try:
+                with open(absolute_path, 'r', encoding='utf-8') as f:
+                    return f.read()
+            except Exception as e:
+                print(f"[Sync] Error reading local file {file_path}: {e}")
+                return None
+        return None
+  
+    def _write_local_file(self, file_path: str, content: str):
+        """写入本地文件"""
+        absolute_path = self._get_absolute_path(file_path)
         try:
-            result = self.client.sync_profiles(since='0')
-            files = result.get('files', [])
-            
-            if not files:
-                print("[Sync] No files in cloud")
-                return 0
+            directory = os.path.dirname(absolute_path)
+            if directory and not os.path.exists(directory):
+                os.makedirs(directory, exist_ok=True)
             
-            count = 0
-            for file_info in files:
-                file_path = file_info.get('file_path')
-                content = file_info.get('content')
-                version = file_info.get('version')
-                
-                if file_path and content is not None:
-                    self._write_local_file(file_path, content)
-                    self.version_manager.set_version(file_path, version)
-                    count += 1
-                    print(f"[Sync] Downloaded: {file_path} (v{version})")
-            
-            print(f"[Sync] Pulled {count} files")
-            return count
-        finally:
-            self.is_syncing = False
-    
-    def push_file(self, file_path: str):
-        """推送单个文件到云端
+            with open(absolute_path, 'w', encoding='utf-8') as f:
+                f.write(content)
+        except Exception as e:
+            print(f"[Sync] Error writing local file {file_path}: {e}")
+  
+    def _create_conflict_backup(self, file_path: str, local_content: str, server_content: str):
+        """创建冲突备份文件"""
+        absolute_path = self._get_absolute_path(file_path)
+        conflict_path = absolute_path + '.conflict'
+        try:
+            with open(conflict_path, 'w', encoding='utf-8') as f:
+                f.write(f"# Conflict: {file_path}\n")
+                f.write(f"# Created at: {time.strftime('%Y-%m-%d %H:%M:%S')}\n\n")
+                f.write("========== LOCAL VERSION ==========\n")
+                f.write(local_content or "(empty)")
+                f.write("\n\n========== SERVER VERSION ==========\n")
+                f.write(server_content or "(empty)")
+            print(f"[Sync] Conflict backup created: {conflict_path}")
+        except Exception as e:
+            print(f"[Sync] Error creating conflict backup: {e}")
+  
+    def pull_all(self):
+        """Pull all profiles from cloud"""
+        print("[Sync] Pulling all profiles from cloud...")
         
-        Args:
-            file_path: 文件相对路径
-        """
-        if self.is_syncing:
-            print(f"[Sync] Skipping push, currently syncing: {file_path}")
+        try:
+            result = self.client.get_profiles()
+            cloud_files = result.get('files', [])
+        except Exception as e:
+            print(f"[Sync] Error fetching cloud profiles: {e}")
             return
         
-        print(f"[Sync] Pushing file: {file_path}")
-        
-        content = self._read_local_file(file_path)
-        if content is None:
-            print(f"[Sync] File not found or read error: {file_path}")
+        if not cloud_files:
+            print("[Sync] No files on cloud")
             return
         
-        local_version = self.version_manager.get_version(file_path)
+        pulled_count = 0
+        pushed_count = 0
+        skipped_count = 0
         
-        try:
-            result = self.client.upload_profile(file_path, content, local_version)
+        for cloud_file in cloud_files:
+            file_path = cloud_file.get('file_path')
+            cloud_version = cloud_file.get('version', 0)
+            cloud_content = cloud_file.get('content', '')
             
-            new_version = result.get('version')
-            self.version_manager.set_version(file_path, new_version)
+            if not file_path:
+                continue
             
-            print(f"[Sync] Uploaded: {file_path} (v{new_version})")
+            local_content = self._read_local_file(file_path)
+            local_version = self.version_manager.get_version(file_path)
             
-        except ConflictError as e:
-            print(f"[Sync] Version conflict for {file_path}, pulling latest...")
-            
-            self._write_local_file(file_path, e.latest_content)
-            self.version_manager.set_version(file_path, e.latest_version)
-            
-            print(f"[Sync] Resolved conflict: {file_path} (now v{e.latest_version})")
-        
-        except Exception as e:
-            print(f"[Sync] Upload error: {e}")
-    
-    def on_remote_change(self, file_path: str, version: int):
-        """远程文件变化回调
+            if cloud_version > local_version:
+                self._mark_syncing(file_path)
+                try:
+                    self._write_local_file(file_path, cloud_content)
+                    self.version_manager.set_version(file_path, cloud_version)
+                    pulled_count += 1
+                    print(f"[Sync] Pulled: {file_path} (v{cloud_version})")
+                finally:
+                    self._unmark_syncing(file_path)
+            elif local_version > cloud_version and local_content is not None:
+                try:
+                    result = self.client.upload_profile(file_path, local_content, local_version)
+                    self.version_manager.set_version(file_path, result.get('version', local_version))
+                    pushed_count += 1
+                    print(f"[Sync] Pushed: {file_path} (v{local_version})")
+                except ConflictError as e:
+                    self._handle_conflict(file_path, local_content, e.server_content, e.server_version)
+                    pushed_count += 1
+                except Exception as e:
+                    print(f"[Sync] Error pushing {file_path}: {e}")
+            else:
+                skipped_count += 1
         
-        Args:
-            file_path: 文件相对路径
-            version: 新版本号
-        """
-        print(f"[Sync] Remote change detected: {file_path} (v{version})")
+        print(f"[Sync] Sync complete: {pulled_count} pulled, {pushed_count} pushed, {skipped_count} skipped")
+  
+    def push_file(self, file_path: str):
+        """Push a file to cloud"""
+        if self._is_syncing(file_path):
+            return
         
-        local_version = self.version_manager.get_version(file_path)
+        self._mark_syncing(file_path)
         
-        if version > local_version:
+        try:
+            local_content = self._read_local_file(file_path)
+            if local_content is None:
+                print(f"[Sync] File not found locally: {file_path}")
+                return
+            
+            local_version = self.version_manager.get_version(file_path)
+            
             try:
-                result = self.client.get_profiles(path=file_path)
-                files = result.get('files', [])
-                
-                if files:
-                    file_info = files[0]
-                    content = file_info.get('content')
-                    
-                    self._write_local_file(file_path, content)
-                    self.version_manager.set_version(file_path, version)
-                    
-                    print(f"[Sync] Pulled remote change: {file_path} (v{version})")
+                result = self.client.upload_profile(file_path, local_content, local_version)
+                new_version = result.get('version', local_version + 1)
+                self.version_manager.set_version(file_path, new_version)
+                print(f"[Sync] Pushed: {file_path} (v{new_version})")
+            except ConflictError as e:
+                self._handle_conflict(file_path, local_content, e.server_content, e.server_version)
             except Exception as e:
-                print(f"[Sync] Pull remote change error: {e}")
-    
-    def _read_local_file(self, file_path: str) -> str:
-        """读取本地文件"""
-        full_path = os.path.join(self.workspace, file_path)
+                print(f"[Sync] Error pushing {file_path}: {e}")
+        finally:
+            self._unmark_syncing(file_path)
+  
+    def on_remote_change(self, file_path: str, version: int):
+        """Handle remote file change"""
+        local_version = self.version_manager.get_version(file_path)
+        
+        if version <= local_version:
+            print(f"[Sync] Remote version not newer, skipping: {file_path} (local: v{local_version}, remote: v{version})")
+            return
         
-        if not os.path.exists(full_path):
-            return None
+        self._mark_syncing(file_path)
         
         try:
-            with open(full_path, 'r', encoding='utf-8') as f:
-                return f.read()
+            result = self.client.get_profiles(file_path)
+            files = result.get('files', [])
+            if not files:
+                print(f"[Sync] File not found on cloud: {file_path}")
+                return
+            
+            cloud_file = files[0]
+            cloud_content = cloud_file.get('content', '')
+            
+            local_content = self._read_local_file(file_path)
+            
+            if local_content is not None and local_content != cloud_content:
+                self._create_conflict_backup(file_path, local_content, cloud_content)
+            
+            self._write_local_file(file_path, cloud_content)
+            self.version_manager.set_version(file_path, version)
+            print(f"[Sync] Pulled remote change: {file_path} (v{version})")
         except Exception as e:
-            print(f"[Sync] Read error {file_path}: {e}")
-            return None
-    
-    def _write_local_file(self, file_path: str, content: str):
-        """写入本地文件"""
-        full_path = os.path.join(self.workspace, file_path)
+            print(f"[Sync] Error handling remote change for {file_path}: {e}")
+        finally:
+            self._unmark_syncing(file_path)
+  
+    def _handle_conflict(self, file_path: str, local_content: str, server_content: str, server_version: int):
+        """Handle conflict when pushing file"""
+        print(f"[Sync] CONFLICT detected for {file_path}")
         
-        directory = os.path.dirname(full_path)
-        if directory and not os.path.exists(directory):
-            os.makedirs(directory, exist_ok=True)
+        self._create_conflict_backup(file_path, local_content, server_content)
         
-        try:
-            with open(full_path, 'w', encoding='utf-8') as f:
-                f.write(content)
-        except Exception as e:
-            print(f"[Sync] Write error {file_path}: {e}")
+        self._write_local_file(file_path, server_content)
+        self.version_manager.set_version(file_path, server_version)
+        
+        print(f"[Sync] Conflict resolved: server version used for {file_path}")
+        print(f"[Sync] Please manually merge the conflict backup file")

package/workspace/MEMORY.md

@@ -1,5 +0,0 @@
-# Memory
-
-This is your SoulSync memory file.
-
-Start writing your memories here, and they will be automatically synced to the cloud!