portacode 0.3.22__py3-none-any.whl → 0.3.24__py3-none-any.whl

portacode/connection/handlers/project_state/git_manager.py

@@ -181,22 +181,71 @@ class GitManager:
             if is_ignored:
                 return {"is_tracked": False, "status": "ignored", "is_ignored": True, "is_staged": False}
             
-            # For directories, only report status if they contain tracked or untracked files
+            # For directories, aggregate status from contained files
             if os.path.isdir(file_path):
-                # Check if directory contains any untracked files using path.startswith()
-                # This handles cross-platform path separators correctly
-                has_untracked = any(
-                    os.path.commonpath([f, rel_path]) == rel_path and f != rel_path
-                    for f in self.repo.untracked_files
-                )
+                # Normalize the relative path for cross-platform compatibility
+                rel_path_normalized = rel_path.replace('\\', '/')
+                
+                # Check for untracked files in this directory
+                has_untracked = False
+                for untracked_file in self.repo.untracked_files:
+                    untracked_normalized = untracked_file.replace('\\', '/')
+                    if untracked_normalized.startswith(rel_path_normalized + '/') or untracked_normalized == rel_path_normalized:
+                        has_untracked = True
+                        break
+                
+                # Check for modified files in this directory using git status
+                has_modified = False
+                has_deleted = False
+                try:
+                    # Get status for files in this directory
+                    status_output = self.repo.git.status(rel_path, porcelain=True)
+                    if status_output.strip():
+                        for line in status_output.strip().split('\n'):
+                            if len(line) >= 2:
+                                # When filtering git status by path, GitPython strips the leading space
+                                # So format is either "XY filename" or " XY filename"  
+                                if line.startswith(' '):
+                                    # Full status format: " XY filename"
+                                    index_status = line[0]
+                                    worktree_status = line[1] 
+                                    file_path_from_status = line[3:] if len(line) > 3 else ""
+                                else:
+                                    # Path-filtered format: "XY filename" (leading space stripped)
+                                    # Two possible formats:
+                                    # 1. Regular files: "M  filename" (index + worktree + space + filename)
+                                    # 2. Submodules: "M filename" (index + space + filename)
+                                    index_status = line[0] if len(line) > 0 else ' '
+                                    worktree_status = line[1] if len(line) > 1 else ' '
+                                    
+                                    # Detect format by checking if position 2 is a space
+                                    if len(line) > 2 and line[2] == ' ':
+                                        # Regular file format: "M  filename"
+                                        file_path_from_status = line[3:] if len(line) > 3 else ""
+                                    else:
+                                        # Submodule format: "M filename" 
+                                        file_path_from_status = line[2:] if len(line) > 2 else ""
+                                
+                                # Check if this file is within our directory
+                                file_normalized = file_path_from_status.replace('\\', '/')
+                                if (file_normalized.startswith(rel_path_normalized + '/') or 
+                                    file_normalized == rel_path_normalized):
+                                    if index_status in ['M', 'A', 'R', 'C'] or worktree_status in ['M', 'A', 'R', 'C']:
+                                        has_modified = True
+                                    elif index_status == 'D' or worktree_status == 'D':
+                                        has_deleted = True
+                except Exception as e:
+                    logger.debug("Error checking directory git status for %s: %s", rel_path, e)
+                
+                # Priority order: untracked > modified/deleted > clean
                 if has_untracked:
                     return {"is_tracked": False, "status": "untracked", "is_ignored": False, "is_staged": is_staged}
-                
-                # Check if directory is dirty - GitPython handles path normalization
-                if self.repo.is_dirty(path=rel_path):
+                elif has_deleted:
+                    return {"is_tracked": True, "status": "deleted", "is_ignored": False, "is_staged": is_staged}
+                elif has_modified:
                     return {"is_tracked": True, "status": "modified", "is_ignored": False, "is_staged": is_staged}
                 
-                # Check if directory has tracked files - let GitPython handle paths
+                # Check if directory has tracked files to determine if it should show as clean
                 try:
                     tracked_files = self.repo.git.ls_files(rel_path)
                     is_tracked = bool(tracked_files.strip())
@@ -925,14 +974,6 @@ class GitManager:
                     
                     # For staged files in no-HEAD repo, they are all "added" (new files)
                     diff_details = None
-                    if content_hash and os.path.exists(file_abs_path):
-                        try:
-                            with open(file_abs_path, 'r', encoding='utf-8') as f:
-                                working_content = f.read()
-                            # Compare empty content vs staged content (new file)
-                            diff_details = self._compute_diff_details("", working_content)
-                        except (OSError, UnicodeDecodeError):
-                            diff_details = None
                     
                     change = GitFileChange(
                         file_repo_path=file_repo_path,
@@ -990,17 +1031,11 @@ class GitManager:
                 elif change_type == 'untracked':
                     content_hash = self._compute_file_hash(file_abs_path) if os.path.exists(file_abs_path) else None
                     # For new files, compare empty content vs current staged content
-                    if content_hash:
-                        staged_content = self.get_file_content_staged(file_abs_path) or ""
-                        diff_details = self._compute_diff_details("", staged_content)
-                    else:
-                        diff_details = None
+                    diff_details = None
                 else:  # modified
                     content_hash = self._compute_file_hash(file_abs_path) if os.path.exists(file_abs_path) else None
                     # Compare HEAD content vs staged content
-                    head_content = self.get_file_content_at_commit(file_abs_path) or ""
-                    staged_content = self.get_file_content_staged(file_abs_path) or ""
-                    diff_details = self._compute_diff_details(head_content, staged_content)
+                    diff_details = None
                 
                 change = GitFileChange(
                     file_repo_path=file_repo_path,
@@ -1034,29 +1069,12 @@ class GitManager:
                     change_type = 'added'
                     content_hash = self._compute_file_hash(file_abs_path) if os.path.exists(file_abs_path) else None
                     # For new files, compare empty content vs current working content
-                    if content_hash and os.path.exists(file_abs_path):
-                        try:
-                            with open(file_abs_path, 'r', encoding='utf-8') as f:
-                                working_content = f.read()
-                            diff_details = self._compute_diff_details("", working_content)
-                        except (OSError, UnicodeDecodeError):
-                            diff_details = None
-                    else:
-                        diff_details = None
+                    diff_details = None
                 else:
                     change_type = 'modified'
                     content_hash = self._compute_file_hash(file_abs_path) if os.path.exists(file_abs_path) else None
                     # Compare staged/index content vs working content
-                    staged_content = self.get_file_content_staged(file_abs_path) or ""
-                    if os.path.exists(file_abs_path):
-                        try:
-                            with open(file_abs_path, 'r', encoding='utf-8') as f:
-                                working_content = f.read()
-                            diff_details = self._compute_diff_details(staged_content, working_content)
-                        except (OSError, UnicodeDecodeError):
-                            diff_details = None
-                    else:
-                        diff_details = None
+                    diff_details = None
                 
                 change = GitFileChange(
                     file_repo_path=file_repo_path,
@@ -1084,13 +1102,6 @@ class GitManager:
                 
                 # For untracked files, compare empty content vs current file content
                 diff_details = None
-                if content_hash and os.path.exists(file_abs_path):
-                    try:
-                        with open(file_abs_path, 'r', encoding='utf-8') as f:
-                            working_content = f.read()
-                        diff_details = self._compute_diff_details("", working_content)
-                    except (OSError, UnicodeDecodeError):
-                        diff_details = None
                 
                 change = GitFileChange(
                     file_repo_path=file_repo_path,
@@ -1172,6 +1183,41 @@ class GitManager:
             logger.error("Error getting staged content for %s: %s", file_path, e)
             return None
     
+    def _is_submodule(self, file_path: str) -> bool:
+        """Check if the given path is a submodule."""
+        if not self.is_git_repo or not self.repo:
+            return False
+        
+        try:
+            # Convert to relative path from repo root
+            rel_path = os.path.relpath(file_path, self.repo.working_dir)
+            
+            # Check if this path is listed in .gitmodules
+            gitmodules_path = os.path.join(self.repo.working_dir, '.gitmodules')
+            if os.path.exists(gitmodules_path):
+                try:
+                    with open(gitmodules_path, 'r') as f:
+                        content = f.read()
+                        # Simple check - look for path = rel_path in .gitmodules
+                        for line in content.splitlines():
+                            if line.strip().startswith('path ='):
+                                submodule_path = line.split('=', 1)[1].strip()
+                                if submodule_path == rel_path:
+                                    return True
+                except Exception as e:
+                    logger.warning("Error reading .gitmodules: %s", e)
+            
+            # Alternative check: see if the path has a .git file (submodule indicator)
+            git_path = os.path.join(file_path, '.git')
+            if os.path.isfile(git_path):  # Submodules have .git as a file, not directory
+                return True
+                
+            return False
+            
+        except Exception as e:
+            logger.warning("Error checking if %s is submodule: %s", file_path, e)
+            return False
+
     def stage_file(self, file_path: str) -> bool:
         """Stage a file for commit."""
         if not self.is_git_repo or not self.repo:
@@ -1181,8 +1227,15 @@ class GitManager:
             # Convert to relative path from repo root
             rel_path = os.path.relpath(file_path, self.repo.working_dir)
             
-            # Stage the file
-            self.repo.index.add([rel_path])
+            # Check if this is a submodule
+            if self._is_submodule(file_path):
+                logger.info("Detected submodule, using git add command directly: %s", rel_path)
+                # For submodules, use git add directly to stage only the submodule reference
+                self.repo.git.add(rel_path)
+            else:
+                # For regular files, use the index method
+                self.repo.index.add([rel_path])
+            
             logger.info("Successfully staged file: %s", rel_path)
             return True
             
@@ -1199,19 +1252,25 @@ class GitManager:
             # Convert to relative path from repo root
             rel_path = os.path.relpath(file_path, self.repo.working_dir)
             
-            # Check if repository has any commits (HEAD exists)
-            try:
-                self.repo.head.commit
-                has_head = True
-            except Exception:
-                has_head = False
-            
-            if has_head:
-                # Reset the file from HEAD (unstage) - for repos with commits
+            # Check if this is a submodule
+            if self._is_submodule(file_path):
+                logger.info("Detected submodule, using git restore for unstaging: %s", rel_path)
+                # For submodules, always use git restore --staged (works with submodules)
                 self.repo.git.restore('--staged', rel_path)
             else:
-                # For repositories with no commits, use git rm --cached to unstage
-                self.repo.git.rm('--cached', rel_path)
+                # Check if repository has any commits (HEAD exists)
+                try:
+                    self.repo.head.commit
+                    has_head = True
+                except Exception:
+                    has_head = False
+                
+                if has_head:
+                    # Reset the file from HEAD (unstage) - for repos with commits
+                    self.repo.git.restore('--staged', rel_path)
+                else:
+                    # For repositories with no commits, use git rm --cached to unstage
+                    self.repo.git.rm('--cached', rel_path)
             
             logger.info("Successfully unstaged file: %s", rel_path)
             return True
@@ -1255,6 +1314,207 @@ class GitManager:
             logger.error("Error reverting file %s: %s", file_path, e)
             raise RuntimeError(f"Failed to revert file: {e}")
     
+    def stage_files(self, file_paths: List[str]) -> bool:
+        """Stage multiple files for commit in one atomic operation."""
+        if not self.is_git_repo or not self.repo:
+            raise RuntimeError("Not a git repository")
+        
+        if not file_paths:
+            logger.info("No files provided for staging")
+            return True
+        
+        try:
+            # Convert all paths to relative paths from repo root
+            rel_paths = []
+            submodule_paths = []
+            
+            for file_path in file_paths:
+                rel_path = os.path.relpath(file_path, self.repo.working_dir)
+                if self._is_submodule(file_path):
+                    submodule_paths.append(rel_path)
+                else:
+                    rel_paths.append(rel_path)
+            
+            # Stage submodules using git add directly
+            if submodule_paths:
+                logger.info("Staging submodules using git add directly: %s", submodule_paths)
+                for submodule_path in submodule_paths:
+                    self.repo.git.add(submodule_path)
+            
+            # Stage regular files using index.add for efficiency
+            if rel_paths:
+                logger.info("Staging regular files: %s", rel_paths)
+                self.repo.index.add(rel_paths)
+            
+            logger.info("Successfully staged %d files (%d submodules, %d regular)", 
+                       len(file_paths), len(submodule_paths), len(rel_paths))
+            return True
+            
+        except Exception as e:
+            logger.error("Error staging files %s: %s", file_paths, e)
+            raise RuntimeError(f"Failed to stage files: {e}")
+
+    def unstage_files(self, file_paths: List[str]) -> bool:
+        """Unstage multiple files in one atomic operation."""
+        if not self.is_git_repo or not self.repo:
+            raise RuntimeError("Not a git repository")
+        
+        if not file_paths:
+            logger.info("No files provided for unstaging")
+            return True
+        
+        try:
+            # Convert all paths to relative paths from repo root
+            rel_paths = []
+            submodule_paths = []
+            
+            for file_path in file_paths:
+                rel_path = os.path.relpath(file_path, self.repo.working_dir)
+                if self._is_submodule(file_path):
+                    submodule_paths.append(rel_path)
+                else:
+                    rel_paths.append(rel_path)
+            
+            # Check if repository has any commits (HEAD exists)
+            try:
+                self.repo.head.commit
+                has_head = True
+            except Exception:
+                has_head = False
+            
+            # Unstage all files using appropriate method
+            all_rel_paths = rel_paths + submodule_paths
+            
+            if has_head:
+                # Use git restore --staged for all files (works for both regular files and submodules)
+                if all_rel_paths:
+                    self.repo.git.restore('--staged', *all_rel_paths)
+            else:
+                # For repositories with no commits, use git rm --cached
+                if all_rel_paths:
+                    self.repo.git.rm('--cached', *all_rel_paths)
+            
+            logger.info("Successfully unstaged %d files (%d submodules, %d regular)", 
+                       len(file_paths), len(submodule_paths), len(rel_paths))
+            return True
+            
+        except Exception as e:
+            logger.error("Error unstaging files %s: %s", file_paths, e)
+            raise RuntimeError(f"Failed to unstage files: {e}")
+
+    def revert_files(self, file_paths: List[str]) -> bool:
+        """Revert multiple files to their HEAD version in one atomic operation."""
+        if not self.is_git_repo or not self.repo:
+            raise RuntimeError("Not a git repository")
+        
+        if not file_paths:
+            logger.info("No files provided for reverting")
+            return True
+        
+        try:
+            # Check if repository has any commits (HEAD exists)
+            try:
+                self.repo.head.commit
+                has_head = True
+            except Exception:
+                has_head = False
+            
+            if has_head:
+                # Convert to relative paths and restore all files at once
+                rel_paths = [os.path.relpath(file_path, self.repo.working_dir) for file_path in file_paths]
+                # Filter out submodules - we don't revert submodules as they don't have working directory changes
+                regular_files = []
+                for i, file_path in enumerate(file_paths):
+                    if not self._is_submodule(file_path):
+                        regular_files.append(rel_paths[i])
+                
+                if regular_files:
+                    self.repo.git.restore(*regular_files)
+                    logger.info("Successfully reverted %d files", len(regular_files))
+            else:
+                # For repositories with no commits, remove files to "revert" them
+                removed_count = 0
+                for file_path in file_paths:
+                    if not self._is_submodule(file_path) and os.path.exists(file_path):
+                        os.remove(file_path)
+                        removed_count += 1
+                logger.info("Successfully removed %d files (no HEAD to revert to)", removed_count)
+            
+            return True
+            
+        except Exception as e:
+            logger.error("Error reverting files %s: %s", file_paths, e)
+            raise RuntimeError(f"Failed to revert files: {e}")
+
+    def stage_all_changes(self) -> bool:
+        """Stage all changes (modified, deleted, untracked) in one atomic operation."""
+        if not self.is_git_repo or not self.repo:
+            raise RuntimeError("Not a git repository")
+        
+        try:
+            # Use git add . to stage everything - this is the most efficient way
+            self.repo.git.add('.')
+            logger.info("Successfully staged all changes using 'git add .'")
+            return True
+            
+        except Exception as e:
+            logger.error("Error staging all changes: %s", e)
+            raise RuntimeError(f"Failed to stage all changes: {e}")
+
+    def unstage_all_changes(self) -> bool:
+        """Unstage all staged changes in one atomic operation."""
+        if not self.is_git_repo or not self.repo:
+            raise RuntimeError("Not a git repository")
+        
+        try:
+            # Check if repository has any commits (HEAD exists)
+            try:
+                self.repo.head.commit
+                has_head = True
+            except Exception:
+                has_head = False
+            
+            if has_head:
+                # Use git restore --staged . to unstage everything
+                self.repo.git.restore('--staged', '.')
+            else:
+                # For repositories with no commits, remove everything from index
+                self.repo.git.rm('--cached', '-r', '.')
+            
+            logger.info("Successfully unstaged all changes")
+            return True
+            
+        except Exception as e:
+            logger.error("Error unstaging all changes: %s", e)
+            raise RuntimeError(f"Failed to unstage all changes: {e}")
+
+    def revert_all_changes(self) -> bool:
+        """Revert all working directory changes in one atomic operation."""
+        if not self.is_git_repo or not self.repo:
+            raise RuntimeError("Not a git repository")
+        
+        try:
+            # Check if repository has any commits (HEAD exists)
+            try:
+                self.repo.head.commit
+                has_head = True
+            except Exception:
+                has_head = False
+            
+            if has_head:
+                # Use git restore . to revert all working directory changes
+                self.repo.git.restore('.')
+                logger.info("Successfully reverted all working directory changes")
+            else:
+                logger.warning("Cannot revert changes in repository with no commits")
+                return False
+            
+            return True
+            
+        except Exception as e:
+            logger.error("Error reverting all changes: %s", e)
+            raise RuntimeError(f"Failed to revert all changes: {e}")
+
     def commit_changes(self, message: str) -> bool:
         """Commit staged changes with the given message."""
         if not self.is_git_repo or not self.repo: