agmem 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

memvcs/core/diff.py

@@ -14,6 +14,7 @@ from .objects import ObjectStore, Commit, Tree, Blob
 
 class DiffType(Enum):
     """Types of differences."""
+
     ADDED = "added"
     DELETED = "deleted"
     MODIFIED = "modified"
@@ -23,6 +24,7 @@ class DiffType(Enum):
 @dataclass
 class FileDiff:
     """Difference for a single file."""
+
     path: str
     diff_type: DiffType
     old_hash: Optional[str]
@@ -35,6 +37,7 @@ class FileDiff:
 @dataclass
 class TreeDiff:
     """Difference between two trees."""
+
     files: List[FileDiff]
     added_count: int
     deleted_count: int
@@ -43,67 +46,67 @@ class TreeDiff:
 
 class DiffEngine:
     """Engine for computing differences."""
-    
+
     def __init__(self, object_store: ObjectStore):
         self.object_store = object_store
-    
+
     def get_tree_files(self, tree_hash: str) -> Dict[str, str]:
         """Get all files in a tree with their blob hashes."""
         files = {}
         tree = Tree.load(self.object_store, tree_hash)
-        
+
         if tree:
             for entry in tree.entries:
-                path = entry.path + '/' + entry.name if entry.path else entry.name
+                path = entry.path + "/" + entry.name if entry.path else entry.name
                 files[path] = entry.hash
-        
+
         return files
-    
+
     def get_blob_content(self, hash_id: Optional[str]) -> Optional[str]:
         """Get blob content as string."""
         if not hash_id:
             return None
-        
+
         blob = Blob.load(self.object_store, hash_id)
         if blob:
-            return blob.content.decode('utf-8', errors='replace')
+            return blob.content.decode("utf-8", errors="replace")
         return None
-    
-    def compute_line_diff(self, old_content: Optional[str], new_content: Optional[str]) -> List[str]:
+
+    def compute_line_diff(
+        self, old_content: Optional[str], new_content: Optional[str]
+    ) -> List[str]:
         """
         Compute line-by-line diff between two contents.
-        
+
         Returns:
             List of diff lines with +/- prefixes
         """
-        old_lines = (old_content or '').splitlines(keepends=True)
-        new_lines = (new_content or '').splitlines(keepends=True)
-        
+        old_lines = (old_content or "").splitlines(keepends=True)
+        new_lines = (new_content or "").splitlines(keepends=True)
+
         # Simple diff algorithm (LCS-based would be better)
         diff_lines = []
-        
+
         # Handle empty cases
-        if not old_lines or old_lines == ['']:
+        if not old_lines or old_lines == [""]:
             for line in new_lines:
-                diff_lines.append(f'+ {line.rstrip()}')
+                diff_lines.append(f"+ {line.rstrip()}")
             return diff_lines
-        
-        if not new_lines or new_lines == ['']:
+
+        if not new_lines or new_lines == [""]:
             for line in old_lines:
-                diff_lines.append(f'- {line.rstrip()}')
+                diff_lines.append(f"- {line.rstrip()}")
             return diff_lines
-        
+
         # Use unified diff style
-        max_lines = max(len(old_lines), len(new_lines))
-        
         i, j = 0, 0
         while i < len(old_lines) or j < len(new_lines):
             if i < len(old_lines) and j < len(new_lines):
                 old_line = old_lines[i].rstrip()
                 new_line = new_lines[j].rstrip()
-                
+
                 if old_line == new_line:
-                    diff_lines.append(f'  {old_line}')
+                    diff_lines.append(f"  {old_line}")
                     i += 1
                     j += 1
                 else:
@@ -112,153 +115,158 @@ class DiffEngine:
                     for k in range(j + 1, min(j + 5, len(new_lines))):
                         if new_lines[k].rstrip() == old_line:
                             # Lines were added
-                            for l in range(j, k):
-                                diff_lines.append(f'+ {new_lines[l].rstrip()}')
+                            for idx in range(j, k):
+                                diff_lines.append(f"+ {new_lines[idx].rstrip()}")
                             j = k
                             found = True
                             break
-                    
+
                     if not found:
                         # Line was removed
-                        diff_lines.append(f'- {old_line}')
+                        diff_lines.append(f"- {old_line}")
                         i += 1
             elif i < len(old_lines):
-                diff_lines.append(f'- {old_lines[i].rstrip()}')
+                diff_lines.append(f"- {old_lines[i].rstrip()}")
                 i += 1
             else:
-                diff_lines.append(f'+ {new_lines[j].rstrip()}')
+                diff_lines.append(f"+ {new_lines[j].rstrip()}")
                 j += 1
-        
+
         return diff_lines
-    
+
     def diff_trees(self, old_tree_hash: Optional[str], new_tree_hash: Optional[str]) -> TreeDiff:
         """
         Compute diff between two trees.
-        
+
         Args:
             old_tree_hash: Hash of old tree (None for empty)
             new_tree_hash: Hash of new tree (None for empty)
-            
+
         Returns:
             TreeDiff with file differences
         """
         old_files = self.get_tree_files(old_tree_hash) if old_tree_hash else {}
         new_files = self.get_tree_files(new_tree_hash) if new_tree_hash else {}
-        
+
         all_paths = set(old_files.keys()) | set(new_files.keys())
-        
+
         file_diffs = []
         added = 0
         deleted = 0
         modified = 0
-        
+
         for path in sorted(all_paths):
             old_hash = old_files.get(path)
             new_hash = new_files.get(path)
-            
+
             if not old_hash and new_hash:
                 # Added
                 new_content = self.get_blob_content(new_hash)
                 diff_lines = self.compute_line_diff(None, new_content)
-                
-                file_diffs.append(FileDiff(
-                    path=path,
-                    diff_type=DiffType.ADDED,
-                    old_hash=None,
-                    new_hash=new_hash,
-                    old_content=None,
-                    new_content=new_content,
-                    diff_lines=diff_lines
-                ))
+
+                file_diffs.append(
+                    FileDiff(
+                        path=path,
+                        diff_type=DiffType.ADDED,
+                        old_hash=None,
+                        new_hash=new_hash,
+                        old_content=None,
+                        new_content=new_content,
+                        diff_lines=diff_lines,
+                    )
+                )
                 added += 1
-            
+
             elif old_hash and not new_hash:
                 # Deleted
                 old_content = self.get_blob_content(old_hash)
                 diff_lines = self.compute_line_diff(old_content, None)
-                
-                file_diffs.append(FileDiff(
-                    path=path,
-                    diff_type=DiffType.DELETED,
-                    old_hash=old_hash,
-                    new_hash=None,
-                    old_content=old_content,
-                    new_content=None,
-                    diff_lines=diff_lines
-                ))
+
+                file_diffs.append(
+                    FileDiff(
+                        path=path,
+                        diff_type=DiffType.DELETED,
+                        old_hash=old_hash,
+                        new_hash=None,
+                        old_content=old_content,
+                        new_content=None,
+                        diff_lines=diff_lines,
+                    )
+                )
                 deleted += 1
-            
+
             elif old_hash != new_hash:
                 # Modified
                 old_content = self.get_blob_content(old_hash)
                 new_content = self.get_blob_content(new_hash)
                 diff_lines = self.compute_line_diff(old_content, new_content)
-                
-                file_diffs.append(FileDiff(
-                    path=path,
-                    diff_type=DiffType.MODIFIED,
-                    old_hash=old_hash,
-                    new_hash=new_hash,
-                    old_content=old_content,
-                    new_content=new_content,
-                    diff_lines=diff_lines
-                ))
+
+                file_diffs.append(
+                    FileDiff(
+                        path=path,
+                        diff_type=DiffType.MODIFIED,
+                        old_hash=old_hash,
+                        new_hash=new_hash,
+                        old_content=old_content,
+                        new_content=new_content,
+                        diff_lines=diff_lines,
+                    )
+                )
                 modified += 1
-        
+
         return TreeDiff(
-            files=file_diffs,
-            added_count=added,
-            deleted_count=deleted,
-            modified_count=modified
+            files=file_diffs, added_count=added, deleted_count=deleted, modified_count=modified
         )
-    
-    def diff_commits(self, old_commit_hash: Optional[str], new_commit_hash: Optional[str]) -> TreeDiff:
+
+    def diff_commits(
+        self, old_commit_hash: Optional[str], new_commit_hash: Optional[str]
+    ) -> TreeDiff:
         """
         Compute diff between two commits.
-        
+
         Args:
             old_commit_hash: Hash of old commit (None for empty)
             new_commit_hash: Hash of new commit (None for empty)
-            
+
         Returns:
             TreeDiff with file differences
         """
         old_tree_hash = None
         new_tree_hash = None
-        
+
         if old_commit_hash:
             old_commit = Commit.load(self.object_store, old_commit_hash)
             if old_commit:
                 old_tree_hash = old_commit.tree
-        
+
         if new_commit_hash:
             new_commit = Commit.load(self.object_store, new_commit_hash)
             if new_commit:
                 new_tree_hash = new_commit.tree
-        
+
         return self.diff_trees(old_tree_hash, new_tree_hash)
-    
-    def format_diff(self, tree_diff: TreeDiff, old_ref: str = 'a', new_ref: str = 'b') -> str:
+
+    def format_diff(self, tree_diff: TreeDiff, old_ref: str = "a", new_ref: str = "b") -> str:
         """
         Format tree diff as unified diff string.
-        
+
         Args:
             tree_diff: TreeDiff to format
             old_ref: Label for old version
             new_ref: Label for new version
-            
+
         Returns:
             Formatted diff string
         """
         lines = []
-        
+
         for file_diff in tree_diff.files:
             if file_diff.diff_type == DiffType.UNCHANGED:
                 continue
-            
+
             # File header
             lines.append(f"diff --agmem {old_ref}/{file_diff.path} {new_ref}/{file_diff.path}")
-            
+
             if file_diff.diff_type == DiffType.ADDED:
                 lines.append(f"new file mode 100644")
                 lines.append(f"index 0000000..{file_diff.new_hash[:7]}")
@@ -273,29 +281,29 @@ class DiffEngine:
                 lines.append(f"index {file_diff.old_hash[:7]}..{file_diff.new_hash[:7]}")
                 lines.append(f"--- {old_ref}/{file_diff.path}")
                 lines.append(f"+++ {new_ref}/{file_diff.path}")
-            
+
             # Diff content
             lines.append("@@ -1 +1 @@")
             for diff_line in file_diff.diff_lines:
                 lines.append(diff_line)
-            
+
             lines.append("")  # Empty line between files
-        
+
         # Summary
         lines.append(f"# {tree_diff.added_count} file(s) added")
         lines.append(f"# {tree_diff.deleted_count} file(s) deleted")
         lines.append(f"# {tree_diff.modified_count} file(s) modified")
-        
-        return '\n'.join(lines)
-    
+
+        return "\n".join(lines)
+
     def diff_working_dir(self, commit_hash: str, working_files: Dict[str, bytes]) -> TreeDiff:
         """
         Compute diff between a commit and working directory.
-        
+
         Args:
             commit_hash: Commit to compare against
             working_files: Dict mapping paths to file contents
-            
+
         Returns:
             TreeDiff with differences
         """
@@ -303,78 +311,85 @@ class DiffEngine:
         commit = Commit.load(self.object_store, commit_hash)
         if not commit:
             return TreeDiff(files=[], added_count=0, deleted_count=0, modified_count=0)
-        
+
         commit_files = self.get_tree_files(commit.tree)
-        
+
         file_diffs = []
         added = 0
         deleted = 0
         modified = 0
-        
+
         all_paths = set(commit_files.keys()) | set(working_files.keys())
-        
+
         for path in sorted(all_paths):
             commit_hash_id = commit_files.get(path)
             working_content = working_files.get(path)
-            
+
             # Compute working file hash
             working_hash = None
             if working_content is not None:
                 blob = Blob(content=working_content)
                 working_hash = blob.store(self.object_store)
-            
+
             if not commit_hash_id and working_hash:
                 # Added
-                new_content = working_content.decode('utf-8', errors='replace') if working_content else None
+                new_content = (
+                    working_content.decode("utf-8", errors="replace") if working_content else None
+                )
                 diff_lines = self.compute_line_diff(None, new_content)
-                
-                file_diffs.append(FileDiff(
-                    path=path,
-                    diff_type=DiffType.ADDED,
-                    old_hash=None,
-                    new_hash=working_hash,
-                    old_content=None,
-                    new_content=new_content,
-                    diff_lines=diff_lines
-                ))
+
+                file_diffs.append(
+                    FileDiff(
+                        path=path,
+                        diff_type=DiffType.ADDED,
+                        old_hash=None,
+                        new_hash=working_hash,
+                        old_content=None,
+                        new_content=new_content,
+                        diff_lines=diff_lines,
+                    )
+                )
                 added += 1
-            
+
             elif commit_hash_id and not working_hash:
                 # Deleted
                 old_content = self.get_blob_content(commit_hash_id)
                 diff_lines = self.compute_line_diff(old_content, None)
-                
-                file_diffs.append(FileDiff(
-                    path=path,
-                    diff_type=DiffType.DELETED,
-                    old_hash=commit_hash_id,
-                    new_hash=None,
-                    old_content=old_content,
-                    new_content=None,
-                    diff_lines=diff_lines
-                ))
+
+                file_diffs.append(
+                    FileDiff(
+                        path=path,
+                        diff_type=DiffType.DELETED,
+                        old_hash=commit_hash_id,
+                        new_hash=None,
+                        old_content=old_content,
+                        new_content=None,
+                        diff_lines=diff_lines,
+                    )
+                )
                 deleted += 1
-            
+
             elif commit_hash_id != working_hash:
                 # Modified
                 old_content = self.get_blob_content(commit_hash_id)
-                new_content = working_content.decode('utf-8', errors='replace') if working_content else None
+                new_content = (
+                    working_content.decode("utf-8", errors="replace") if working_content else None
+                )
                 diff_lines = self.compute_line_diff(old_content, new_content)
-                
-                file_diffs.append(FileDiff(
-                    path=path,
-                    diff_type=DiffType.MODIFIED,
-                    old_hash=commit_hash_id,
-                    new_hash=working_hash,
-                    old_content=old_content,
-                    new_content=new_content,
-                    diff_lines=diff_lines
-                ))
+
+                file_diffs.append(
+                    FileDiff(
+                        path=path,
+                        diff_type=DiffType.MODIFIED,
+                        old_hash=commit_hash_id,
+                        new_hash=working_hash,
+                        old_content=old_content,
+                        new_content=new_content,
+                        diff_lines=diff_lines,
+                    )
+                )
                 modified += 1
-        
+
         return TreeDiff(
-            files=file_diffs,
-            added_count=added,
-            deleted_count=deleted,
-            modified_count=modified
+            files=file_diffs, added_count=added, deleted_count=deleted, modified_count=modified
         )