portacode 0.3.23__py3-none-any.whl → 0.3.25__py3-none-any.whl

portacode/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.3.23'
-__version_tuple__ = version_tuple = (0, 3, 23)
+__version__ = version = '0.3.25'
+__version_tuple__ = version_tuple = (0, 3, 25)
 
 __commit_id__ = commit_id = None

portacode/connection/handlers/WEBSOCKET_PROTOCOL.md

@@ -458,12 +458,19 @@ Requests the content for a specific diff tab identified by its diff parameters.
 
 ### `project_state_git_stage`
 
-Stages a file for commit in the project's git repository. Handled by [`project_state_git_stage`](./project_state_handlers.py).
+Stages file(s) for commit in the project's git repository. Supports both single file and bulk operations. Handled by [`project_state_git_stage`](./project_state_handlers.py).
 
 **Payload Fields:**
 
 *   `project_id` (string, mandatory): The project ID from the initialized project state.
-*   `file_path` (string, mandatory): The absolute path to the file to stage.
+*   `file_path` (string, optional): The absolute path to a single file to stage. Used for backward compatibility.
+*   `file_paths` (array of strings, optional): Array of absolute paths to files to stage. Used for bulk operations.
+*   `stage_all` (boolean, optional): If true, stages all unstaged changes in the repository. Takes precedence over file_path/file_paths.
+
+**Operation Modes:**
+- Single file: Provide `file_path`
+- Bulk operation: Provide `file_paths` array  
+- Stage all: Set `stage_all` to true
 
 **Responses:**
 
@@ -472,12 +479,19 @@ Stages a file for commit in the project's git repository. Handled by [`project_s
 
 ### `project_state_git_unstage`
 
-Unstages a file (removes from staging area) in the project's git repository. Handled by [`project_state_git_unstage`](./project_state_handlers.py).
+Unstages file(s) (removes from staging area) in the project's git repository. Supports both single file and bulk operations. Handled by [`project_state_git_unstage`](./project_state_handlers.py).
 
 **Payload Fields:**
 
 *   `project_id` (string, mandatory): The project ID from the initialized project state.
-*   `file_path` (string, mandatory): The absolute path to the file to unstage.
+*   `file_path` (string, optional): The absolute path to a single file to unstage. Used for backward compatibility.
+*   `file_paths` (array of strings, optional): Array of absolute paths to files to unstage. Used for bulk operations.
+*   `unstage_all` (boolean, optional): If true, unstages all staged changes in the repository. Takes precedence over file_path/file_paths.
+
+**Operation Modes:**
+- Single file: Provide `file_path`
+- Bulk operation: Provide `file_paths` array  
+- Unstage all: Set `unstage_all` to true
 
 **Responses:**
 
@@ -486,12 +500,19 @@ Unstages a file (removes from staging area) in the project's git repository. Han
 
 ### `project_state_git_revert`
 
-Reverts a file to its HEAD version, discarding local changes in the project's git repository. Handled by [`project_state_git_revert`](./project_state_handlers.py).
+Reverts file(s) to their HEAD version, discarding local changes in the project's git repository. Supports both single file and bulk operations. Handled by [`project_state_git_revert`](./project_state_handlers.py).
 
 **Payload Fields:**
 
 *   `project_id` (string, mandatory): The project ID from the initialized project state.
-*   `file_path` (string, mandatory): The absolute path to the file to revert.
+*   `file_path` (string, optional): The absolute path to a single file to revert. Used for backward compatibility.
+*   `file_paths` (array of strings, optional): Array of absolute paths to files to revert. Used for bulk operations.
+*   `revert_all` (boolean, optional): If true, reverts all unstaged changes in the repository. Takes precedence over file_path/file_paths.
+
+**Operation Modes:**
+- Single file: Provide `file_path`
+- Bulk operation: Provide `file_paths` array  
+- Revert all: Set `revert_all` to true
 
 **Responses:**
 
@@ -1019,34 +1040,40 @@ Returns the requested content for a specific diff tab, sent in response to a [`p
 
 ### <a name="project_state_git_stage_response"></a>`project_state_git_stage_response`
 
-Confirms the result of a git stage operation.
+Confirms the result of a git stage operation. Supports responses for both single file and bulk operations.
 
 **Event Fields:**
 
 *   `project_id` (string, mandatory): The project ID the operation was performed on.
-*   `file_path` (string, mandatory): The path to the file that was staged.
+*   `file_path` (string, optional): The path to the file that was staged (for single file operations).
+*   `file_paths` (array of strings, optional): Array of paths to files that were staged (for bulk operations).
+*   `stage_all` (boolean, optional): Present if the operation was a "stage all" operation.
 *   `success` (boolean, mandatory): Whether the stage operation was successful.
 *   `error` (string, optional): Error message if the operation failed.
 
 ### <a name="project_state_git_unstage_response"></a>`project_state_git_unstage_response`
 
-Confirms the result of a git unstage operation.
+Confirms the result of a git unstage operation. Supports responses for both single file and bulk operations.
 
 **Event Fields:**
 
 *   `project_id` (string, mandatory): The project ID the operation was performed on.
-*   `file_path` (string, mandatory): The path to the file that was unstaged.
+*   `file_path` (string, optional): The path to the file that was unstaged (for single file operations).
+*   `file_paths` (array of strings, optional): Array of paths to files that were unstaged (for bulk operations).
+*   `unstage_all` (boolean, optional): Present if the operation was an "unstage all" operation.
 *   `success` (boolean, mandatory): Whether the unstage operation was successful.
 *   `error` (string, optional): Error message if the operation failed.
 
 ### <a name="project_state_git_revert_response"></a>`project_state_git_revert_response`
 
-Confirms the result of a git revert operation.
+Confirms the result of a git revert operation. Supports responses for both single file and bulk operations.
 
 **Event Fields:**
 
 *   `project_id` (string, mandatory): The project ID the operation was performed on.
-*   `file_path` (string, mandatory): The path to the file that was reverted.
+*   `file_path` (string, optional): The path to the file that was reverted (for single file operations).
+*   `file_paths` (array of strings, optional): Array of paths to files that were reverted (for bulk operations).
+*   `revert_all` (boolean, optional): Present if the operation was a "revert all" operation.
 *   `success` (boolean, mandatory): Whether the revert operation was successful.
 *   `error` (string, optional): Error message if the operation failed.
 

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())
@@ -1134,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:
@@ -1143,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
             
@@ -1161,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
@@ -1217,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:

portacode/connection/handlers/project_state/handlers.py

@@ -365,20 +365,33 @@ class ProjectStateGitStageHandler(AsyncHandler):
         return "project_state_git_stage"
     
     async def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
-        """Stage a file in git for a project."""
+        """Stage file(s) in git for a project. Supports both single file and bulk operations."""
         server_project_id = message.get("project_id")
-        file_path = message.get("file_path")
+        file_path = message.get("file_path")  # Single file (backward compatibility)
+        file_paths = message.get("file_paths")  # Multiple files (bulk operation)
+        stage_all = message.get("stage_all", False)  # Stage all changes
         source_client_session = message.get("source_client_session")
         
         if not server_project_id:
             raise ValueError("project_id is required")
-        if not file_path:
-            raise ValueError("file_path is required")
         if not source_client_session:
             raise ValueError("source_client_session is required")
         
-        logger.info("Staging file %s for project %s (client session: %s)", 
-                   file_path, server_project_id, source_client_session)
+        # Determine operation mode
+        if stage_all:
+            operation_desc = "staging all changes"
+            file_paths_to_stage = []
+        elif file_paths:
+            operation_desc = f"staging {len(file_paths)} files"
+            file_paths_to_stage = file_paths
+        elif file_path:
+            operation_desc = f"staging file {file_path}"
+            file_paths_to_stage = [file_path]
+        else:
+            raise ValueError("Either file_path, file_paths, or stage_all must be provided")
+        
+        logger.info("%s for project %s (client session: %s)", 
+                   operation_desc.capitalize(), server_project_id, source_client_session)
         
         # Get the project state manager
         manager = get_or_create_project_state_manager(self.context, self.control_channel)
@@ -388,19 +401,34 @@ class ProjectStateGitStageHandler(AsyncHandler):
         if not git_manager:
             raise ValueError("No git repository found for this project")
         
-        # Stage the file
-        success = git_manager.stage_file(file_path)
+        # Perform the staging operation
+        if stage_all:
+            success = git_manager.stage_all_changes()
+        elif len(file_paths_to_stage) == 1:
+            success = git_manager.stage_file(file_paths_to_stage[0])
+        else:
+            success = git_manager.stage_files(file_paths_to_stage)
         
         if success:
             # Refresh entire project state to ensure consistency
             await manager._refresh_project_state(source_client_session)
         
-        return {
+        # Build response
+        response = {
             "event": "project_state_git_stage_response",
             "project_id": server_project_id,
-            "file_path": file_path,
             "success": success
         }
+        
+        # Include appropriate file information in response for backward compatibility
+        if file_path:
+            response["file_path"] = file_path
+        if file_paths:
+            response["file_paths"] = file_paths
+        if stage_all:
+            response["stage_all"] = True
+            
+        return response
 
 
 class ProjectStateGitUnstageHandler(AsyncHandler):
@@ -411,20 +439,33 @@ class ProjectStateGitUnstageHandler(AsyncHandler):
         return "project_state_git_unstage"
     
     async def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
-        """Unstage a file in git for a project."""
+        """Unstage file(s) in git for a project. Supports both single file and bulk operations."""
         server_project_id = message.get("project_id")
-        file_path = message.get("file_path")
+        file_path = message.get("file_path")  # Single file (backward compatibility)
+        file_paths = message.get("file_paths")  # Multiple files (bulk operation)
+        unstage_all = message.get("unstage_all", False)  # Unstage all changes
         source_client_session = message.get("source_client_session")
         
         if not server_project_id:
             raise ValueError("project_id is required")
-        if not file_path:
-            raise ValueError("file_path is required")
         if not source_client_session:
             raise ValueError("source_client_session is required")
         
-        logger.info("Unstaging file %s for project %s (client session: %s)", 
-                   file_path, server_project_id, source_client_session)
+        # Determine operation mode
+        if unstage_all:
+            operation_desc = "unstaging all changes"
+            file_paths_to_unstage = []
+        elif file_paths:
+            operation_desc = f"unstaging {len(file_paths)} files"
+            file_paths_to_unstage = file_paths
+        elif file_path:
+            operation_desc = f"unstaging file {file_path}"
+            file_paths_to_unstage = [file_path]
+        else:
+            raise ValueError("Either file_path, file_paths, or unstage_all must be provided")
+        
+        logger.info("%s for project %s (client session: %s)", 
+                   operation_desc.capitalize(), server_project_id, source_client_session)
         
         # Get the project state manager
         manager = get_or_create_project_state_manager(self.context, self.control_channel)
@@ -434,19 +475,34 @@ class ProjectStateGitUnstageHandler(AsyncHandler):
         if not git_manager:
             raise ValueError("No git repository found for this project")
         
-        # Unstage the file
-        success = git_manager.unstage_file(file_path)
+        # Perform the unstaging operation
+        if unstage_all:
+            success = git_manager.unstage_all_changes()
+        elif len(file_paths_to_unstage) == 1:
+            success = git_manager.unstage_file(file_paths_to_unstage[0])
+        else:
+            success = git_manager.unstage_files(file_paths_to_unstage)
         
         if success:
             # Refresh entire project state to ensure consistency
             await manager._refresh_project_state(source_client_session)
         
-        return {
+        # Build response
+        response = {
             "event": "project_state_git_unstage_response",
             "project_id": server_project_id,
-            "file_path": file_path,
             "success": success
         }
+        
+        # Include appropriate file information in response for backward compatibility
+        if file_path:
+            response["file_path"] = file_path
+        if file_paths:
+            response["file_paths"] = file_paths
+        if unstage_all:
+            response["unstage_all"] = True
+            
+        return response
 
 
 class ProjectStateGitRevertHandler(AsyncHandler):
@@ -457,20 +513,33 @@ class ProjectStateGitRevertHandler(AsyncHandler):
         return "project_state_git_revert"
     
     async def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
-        """Revert a file in git for a project."""
+        """Revert file(s) in git for a project. Supports both single file and bulk operations."""
         server_project_id = message.get("project_id")
-        file_path = message.get("file_path")
+        file_path = message.get("file_path")  # Single file (backward compatibility)
+        file_paths = message.get("file_paths")  # Multiple files (bulk operation)
+        revert_all = message.get("revert_all", False)  # Revert all changes
         source_client_session = message.get("source_client_session")
         
         if not server_project_id:
             raise ValueError("project_id is required")
-        if not file_path:
-            raise ValueError("file_path is required")
         if not source_client_session:
             raise ValueError("source_client_session is required")
         
-        logger.info("Reverting file %s for project %s (client session: %s)", 
-                   file_path, server_project_id, source_client_session)
+        # Determine operation mode
+        if revert_all:
+            operation_desc = "reverting all changes"
+            file_paths_to_revert = []
+        elif file_paths:
+            operation_desc = f"reverting {len(file_paths)} files"
+            file_paths_to_revert = file_paths
+        elif file_path:
+            operation_desc = f"reverting file {file_path}"
+            file_paths_to_revert = [file_path]
+        else:
+            raise ValueError("Either file_path, file_paths, or revert_all must be provided")
+        
+        logger.info("%s for project %s (client session: %s)", 
+                   operation_desc.capitalize(), server_project_id, source_client_session)
         
         # Get the project state manager
         manager = get_or_create_project_state_manager(self.context, self.control_channel)
@@ -480,19 +549,34 @@ class ProjectStateGitRevertHandler(AsyncHandler):
         if not git_manager:
             raise ValueError("No git repository found for this project")
         
-        # Revert the file
-        success = git_manager.revert_file(file_path)
+        # Perform the revert operation
+        if revert_all:
+            success = git_manager.revert_all_changes()
+        elif len(file_paths_to_revert) == 1:
+            success = git_manager.revert_file(file_paths_to_revert[0])
+        else:
+            success = git_manager.revert_files(file_paths_to_revert)
         
         if success:
             # Refresh entire project state to ensure consistency
             await manager._refresh_project_state(source_client_session)
         
-        return {
+        # Build response
+        response = {
             "event": "project_state_git_revert_response",
             "project_id": server_project_id,
-            "file_path": file_path,
             "success": success
         }
+        
+        # Include appropriate file information in response for backward compatibility
+        if file_path:
+            response["file_path"] = file_path
+        if file_paths:
+            response["file_paths"] = file_paths
+        if revert_all:
+            response["revert_all"] = True
+            
+        return response
 
 
 class ProjectStateGitCommitHandler(AsyncHandler):

portacode/connection/handlers/session.py

@@ -161,6 +161,10 @@ class TerminalSession:
     async def _send_terminal_data_now(self, data: str) -> None:
         """Send terminal data immediately and update last send time."""
         self._last_send_time = time.time()
+        data_size = len(data.encode('utf-8'))
+        
+        logger.info("session: Attempting to send terminal_data for terminal %s (data_size=%d bytes)", 
+                   self.id, data_size)
         
         # Add to buffer for snapshots with size limiting
         self._add_to_buffer(data)
@@ -174,18 +178,25 @@ class TerminalSession:
                     "data": data,
                     "project_id": self.project_id
                 }, project_id=self.project_id)
+                logger.info("session: Successfully queued terminal_data for terminal %s via terminal_manager", self.id)
             else:
                 # Fallback to raw channel for backward compatibility
                 await self.channel.send(data)
+                logger.info("session: Successfully sent terminal_data for terminal %s via raw channel", self.id)
         except Exception as exc:
-            logger.warning("Failed to forward terminal output: %s", exc)
+            logger.warning("session: Failed to forward terminal output for terminal %s: %s", self.id, exc)
 
     async def _flush_pending_data(self) -> None:
         """Send accumulated pending data and reset pending buffer."""
         if self._pending_data:
+            pending_size = len(self._pending_data.encode('utf-8'))
+            logger.info("session: Flushing pending terminal_data for terminal %s (pending_size=%d bytes)", 
+                       self.id, pending_size)
             data_to_send = self._pending_data
             self._pending_data = ""
             await self._send_terminal_data_now(data_to_send)
+        else:
+            logger.debug("session: No pending data to flush for terminal %s", self.id)
         
         # Clear the debounce task
         self._debounce_task = None
@@ -194,6 +205,10 @@ class TerminalSession:
         """Handle new terminal data with rate limiting and debouncing."""
         current_time = time.time()
         time_since_last_send = (current_time - self._last_send_time) * 1000  # Convert to milliseconds
+        data_size = len(data.encode('utf-8'))
+        
+        logger.info("session: Received terminal_data for terminal %s (data_size=%d bytes, time_since_last_send=%.1fms)", 
+                   self.id, data_size, time_since_last_send)
         
         # Add new data to pending buffer with simple size limiting
         # Always add the new data first
@@ -202,15 +217,19 @@ class TerminalSession:
         # Simple size limiting - only trim if we exceed the 30KB limit significantly
         pending_size = len(self._pending_data.encode('utf-8'))
         if pending_size > TERMINAL_BUFFER_SIZE_LIMIT_BYTES:
+            logger.info("session: Buffer size limit exceeded for terminal %s (pending_size=%d bytes, limit=%d bytes), trimming", 
+                       self.id, pending_size, TERMINAL_BUFFER_SIZE_LIMIT_BYTES)
             # Only do minimal ANSI-safe trimming from the beginning
             excess_bytes = pending_size - TERMINAL_BUFFER_SIZE_LIMIT_BYTES
             trim_pos = self._find_minimal_safe_trim_position(excess_bytes)
             
             if trim_pos > 0:
                 self._pending_data = self._pending_data[trim_pos:]
+                logger.info("session: Trimmed %d bytes from pending buffer for terminal %s", trim_pos, self.id)
         
         # Cancel existing debounce task if any
         if self._debounce_task and not self._debounce_task.done():
+            logger.debug("session: Cancelling existing debounce task for terminal %s", self.id)
             self._debounce_task.cancel()
         
         # Always set up a debounce timer to catch rapid consecutive outputs
@@ -219,19 +238,27 @@ class TerminalSession:
                 if time_since_last_send >= TERMINAL_DATA_RATE_LIMIT_MS:
                     # Enough time has passed since last send, wait initial delay for more data
                     wait_time = TERMINAL_DATA_INITIAL_WAIT_MS / 1000
+                    logger.info("session: Rate limit satisfied for terminal %s, waiting %.1fms for more data", 
+                               self.id, wait_time * 1000)
                 else:
                     # Too soon since last send, wait for either the rate limit period or max wait time
                     wait_time = min(
                         (TERMINAL_DATA_RATE_LIMIT_MS - time_since_last_send) / 1000,
                         TERMINAL_DATA_MAX_WAIT_MS / 1000
                     )
+                    logger.info("session: Rate limit active for terminal %s, waiting %.1fms before send (time_since_last=%.1fms, rate_limit=%dms)", 
+                               self.id, wait_time * 1000, time_since_last_send, TERMINAL_DATA_RATE_LIMIT_MS)
+                
                 await asyncio.sleep(wait_time)
+                logger.info("session: Debounce timer expired for terminal %s, flushing pending data", self.id)
                 await self._flush_pending_data()
             except asyncio.CancelledError:
+                logger.debug("session: Debounce timer cancelled for terminal %s (new data arrived)", self.id)
                 # Timer was cancelled, another data event came in
                 pass
         
         self._debounce_task = asyncio.create_task(_debounce_timer())
+        logger.info("session: Started debounce timer for terminal %s", self.id)
 
     def _find_minimal_safe_trim_position(self, excess_bytes: int) -> int:
         """Find a minimal safe position to trim that only avoids breaking ANSI sequences."""

portacode/connection/handlers/tab_factory.py

@@ -59,7 +59,7 @@ MEDIA_EXTENSIONS = {
     '.ico', '.icns', '.cur', '.psd', '.ai', '.eps', '.raw', '.cr2', '.nef',
     
     # Audio
-    '.mp3', '.wav', '.flac', '.aac', '.ogg', '.wma', '.m4a', '.opus', '.webm',
+    '.mp3', '.wav', '.flac', '.aac', '.ogg', '.oga', '.wma', '.m4a', '.opus', '.webm',
     
     # Video
     '.mp4', '.avi', '.mkv', '.mov', '.wmv', '.flv', '.webm', '.m4v', '.3gp',

portacode/connection/terminal.py

@@ -738,15 +738,17 @@ class TerminalManager:
             payload: The message payload to send
             project_id: Optional project filter for targeting specific sessions
         """
+        event_type = payload.get("event", "unknown")
+        
         # Check if there are any interested clients
         if not self._client_session_manager.has_interested_clients():
-            logger.debug("terminal_manager: No interested clients, skipping message send")
+            logger.info("terminal_manager: No interested clients for %s event, skipping send", event_type)
             return
         
         # Get target sessions
         target_sessions = self._client_session_manager.get_target_sessions(project_id)
         if not target_sessions:
-            logger.debug("terminal_manager: No target sessions found, skipping message send")
+            logger.info("terminal_manager: No target sessions found for %s event (project_id=%s), skipping send", event_type, project_id)
             return
         
         # Add session targeting information
@@ -758,8 +760,15 @@ class TerminalManager:
         if reply_channel and "reply_channel" not in enhanced_payload:
             enhanced_payload["reply_channel"] = reply_channel
         
-        logger.debug("terminal_manager: Sending to %d client sessions: %s", 
-                    len(target_sessions), target_sessions)
+        # Log all event dispatches at INFO level, with data size for terminal_data
+        if event_type == "terminal_data":
+            data_size = len(payload.get("data", ""))
+            terminal_id = payload.get("channel", "unknown")
+            logger.info("terminal_manager: Dispatching %s event (terminal_id=%s, data_size=%d bytes) to %d client sessions", 
+                       event_type, terminal_id, data_size, len(target_sessions))
+        else:
+            logger.info("terminal_manager: Dispatching %s event to %d client sessions", 
+                       event_type, len(target_sessions))
         
         await self._control_channel.send(enhanced_payload)
 

{portacode-0.3.23.dist-info → portacode-0.3.25.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: portacode
-Version: 0.3.23
+Version: 0.3.25
 Summary: Portacode CLI client and SDK
 Home-page: https://github.com/portacode/portacode
 Author: Meena Erian
@@ -18,15 +18,26 @@ Requires-Dist: websockets>=12.0
 Requires-Dist: pyperclip>=1.8
 Requires-Dist: psutil>=5.9
 Requires-Dist: pyte>=0.8
+Requires-Dist: pywinpty>=2.0; platform_system == "Windows"
 Requires-Dist: GitPython>=3.1.45
 Requires-Dist: watchdog>=3.0
 Requires-Dist: diff-match-patch>=20230430
 Requires-Dist: Pygments>=2.14.0
-Requires-Dist: pywinpty>=2.0; platform_system == "Windows"
 Provides-Extra: dev
 Requires-Dist: black; extra == "dev"
 Requires-Dist: flake8; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # Portacode
 

{portacode-0.3.23.dist-info → portacode-0.3.25.dist-info}/RECORD

@@ -1,7 +1,7 @@
 portacode/README.md,sha256=4dKtpvR8LNgZPVz37GmkQCMWIr_u25Ao63iW56s7Ke4,775
 portacode/__init__.py,sha256=oB3sV1wXr-um-RXio73UG8E5Xx6cF2ZVJveqjNmC-vQ,1086
 portacode/__main__.py,sha256=jmHTGC1hzmo9iKJLv-SSYe9BSIbPPZ2IOpecI03PlTs,296
-portacode/_version.py,sha256=isxlLzkGNxdPT011JL31oZc6SSnC8W3VtEFGWzPRCHQ,706
+portacode/_version.py,sha256=hLpn_M2C5NIFPhfMSw9x0kkUzdCUeI3MFt6ODjxDxdA,706
 portacode/cli.py,sha256=Fcz8aXhgKhoWR9UbtmkN843DVuoJZtCTqBF3K-neVSc,16347
 portacode/data.py,sha256=5-s291bv8J354myaHm1Y7CQZTZyRzMU3TGe5U4hb-FA,1591
 portacode/keypair.py,sha256=PAcOYqlVLOoZTPYi6LvLjfsY6BkrWbLOhSZLb8r5sHs,3635
@@ -11,9 +11,9 @@ portacode/connection/README.md,sha256=f9rbuIEKa7cTm9C98rCiBbEtbiIXQU11esGSNhSMiJ
 portacode/connection/__init__.py,sha256=atqcVGkViIEd7pRa6cP2do07RJOM0UWpbnz5zXjGktU,250
 portacode/connection/client.py,sha256=tEM4rqzCRxIG5WXqYAT7s65NlEX2Z1sW42GosctBHIA,8013
 portacode/connection/multiplex.py,sha256=L-TxqJ_ZEbfNEfu1cwxgJ5vUdyRzZjsMy2Kx1diiZys,5237
-portacode/connection/terminal.py,sha256=OfjOjybC2RRrj_a3Eq17qVFF9mD1GlMn7l_O-mIcvIs,41716
+portacode/connection/terminal.py,sha256=euST6O_3hm9qsBk52xTXORTKfKqsMYnTHuZjvlitYSE,42307
 portacode/connection/handlers/README.md,sha256=HsLZG1QK1JNm67HsgL6WoDg9nxzKXxwkc5fJPFJdX5g,12169
-portacode/connection/handlers/WEBSOCKET_PROTOCOL.md,sha256=zPj-OrsVNCB7reM9IfTQvj0lfm20kPjWlMEthileZMk,60173
+portacode/connection/handlers/WEBSOCKET_PROTOCOL.md,sha256=0KBoJzqemXbvpu8Ps7LitLwRYhJNtzcTJ5WAHMGgAuc,62509
 portacode/connection/handlers/__init__.py,sha256=4nv3Z4TGYjWcauKPWsbL_FbrTXApI94V7j6oiU1Vv-o,2144
 portacode/connection/handlers/base.py,sha256=C-H61CUHM2k431CG0usd7eEqklDj9pnuXHujBwhTugk,6666
 portacode/connection/handlers/chunked_content.py,sha256=h6hXRmxSeOgnIxoU8CkmvEf2Odv-ajPrpHIe_W3GKcA,9251
@@ -21,18 +21,19 @@ portacode/connection/handlers/file_handlers.py,sha256=CGMooOrfGbKx-bHA8vr8lmPG-v
 portacode/connection/handlers/project_aware_file_handlers.py,sha256=n0M2WmBNWPwzigdIkyZiAsePUQGXVqYSsDyOxm-Nsok,9253
 portacode/connection/handlers/project_state_handlers.py,sha256=v6ZefGW9i7n1aZLq2jOGumJIjYb6aHlPI4m1jkYewm8,1686
 portacode/connection/handlers/registry.py,sha256=ebi0vhR1XXSYU7mJXlQJ4MjBYaMygGYqX7ReK7vsZ7o,5558
-portacode/connection/handlers/session.py,sha256=7fHC46YXe5Q3uGxYPGpwcBaU_0eBhH4Hg8fmNVZsVmQ,24528
+portacode/connection/handlers/session.py,sha256=O7TMI5cRziOiXEBWCfBshkMpEthhjvKqGL0hhNOG1wU,26716
 portacode/connection/handlers/system_handlers.py,sha256=65V5ctT0dIBc-oWG91e62MbdvU0z6x6JCTQuIqCWmZ0,5242
-portacode/connection/handlers/tab_factory.py,sha256=2DPCU_un8XakkDn9NYHGWdQiDSgHfBxPNaa4boYh1O4,17992
+portacode/connection/handlers/tab_factory.py,sha256=VBZnwtxgeNJCsfBzUjkFWAAGBdijvai4MS2dXnhFY8U,18000
 portacode/connection/handlers/terminal_handlers.py,sha256=Yuo84zwKB5OiLuVtDLCQgMVrOS3T8ZOONxXpGnnougo,11019
 portacode/connection/handlers/project_state/README.md,sha256=trdd4ig6ungmwH5SpbSLfyxbL-QgPlGNU-_XrMEiXtw,10114
 portacode/connection/handlers/project_state/__init__.py,sha256=5ucIqk6Iclqg6bKkL8r_wVs5Tlt6B9J7yQH6yQUt7gc,2541
 portacode/connection/handlers/project_state/file_system_watcher.py,sha256=w-93ioUZZKZxzPFr8djJnGhWjMVFVdDsmo0fVAukoKk,10150
-portacode/connection/handlers/project_state/git_manager.py,sha256=F0Ots9-gDC5Ictb_-ocX1S4xvgSV-4lZqAB4YXogjDo,62363
-portacode/connection/handlers/project_state/handlers.py,sha256=zSqFK8GQWnf1uFBGRoO8gAVo6aNeuJf1UOJNA83bEUg,34022
+portacode/connection/handlers/project_state/git_manager.py,sha256=fA0RbWCblpJep13L4MdqnEP4sE1qWc7Y66vrIo_SWps,76575
+portacode/connection/handlers/project_state/handlers.py,sha256=nkednSbCC-0n3ZtzesaWd9_NFfxNjS4lyVNnbsYs0Zk,37823
 portacode/connection/handlers/project_state/manager.py,sha256=03mN0H9TqVa_ohD5U5-5ZywDGj0s8-y1IxGdb07dZn8,57636
 portacode/connection/handlers/project_state/models.py,sha256=EZTKvxHKs8QlQUbzI0u2IqfzfRRXZixUIDBwTGCJATI,4313
 portacode/connection/handlers/project_state/utils.py,sha256=LsbQr9TH9Bz30FqikmtTxco4PlB_n0kUIuPKQ6Fb_mo,1665
+portacode-0.3.25.dist-info/licenses/LICENSE,sha256=2FGbCnUDgRYuQTkB1O1dUUpu5CVAjK1j4_p6ack9Z54,1066
 test_modules/README.md,sha256=Do_agkm9WhSzueXjRAkV_xEj6Emy5zB3N3VKY5Roce8,9274
 test_modules/__init__.py,sha256=1LcbHodIHsB0g-g4NGjSn6AMuCoGbymvXPYLOb6Z7F0,53
 test_modules/test_device_online.py,sha256=yiSyVaMwKAugqIX_ZIxmLXiOlmA_8IRXiUp12YmpB98,1653
@@ -57,9 +58,8 @@ testing_framework/core/playwright_manager.py,sha256=9kGXJtRpRNEhaSlV7XVXvx4UQSHS
 testing_framework/core/runner.py,sha256=j2QwNJmAxVBmJvcbVS7DgPJUKPNzqfLmt_4NNdaKmZU,19297
 testing_framework/core/shared_cli_manager.py,sha256=BESSNtyQb7BOlaOvZmm04T8Uezjms4KCBs2MzTxvzYQ,8790
 testing_framework/core/test_discovery.py,sha256=2FZ9fJ8Dp5dloA-fkgXoJ_gCMC_nYPBnA3Hs2xlagzM,4928
-portacode-0.3.23.dist-info/LICENSE,sha256=2FGbCnUDgRYuQTkB1O1dUUpu5CVAjK1j4_p6ack9Z54,1066
-portacode-0.3.23.dist-info/METADATA,sha256=g5mVNppNxBH1Xh5eRA_09n4lvJwtJHzOhorWlafs4oU,6930
-portacode-0.3.23.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-portacode-0.3.23.dist-info/entry_points.txt,sha256=lLUUL-BM6_wwe44Xv0__5NQ1BnAz6jWjSMFvZdWW3zU,48
-portacode-0.3.23.dist-info/top_level.txt,sha256=TGhTYUxfW8SyVZc_zGgzjzc24gGT7nSw8Qf73liVRKM,41
-portacode-0.3.23.dist-info/RECORD,,
+portacode-0.3.25.dist-info/METADATA,sha256=cUX77zERmm5WZHrmzV1z52TAEJi8HPP4D31wNdbEXuM,7173
+portacode-0.3.25.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+portacode-0.3.25.dist-info/entry_points.txt,sha256=lLUUL-BM6_wwe44Xv0__5NQ1BnAz6jWjSMFvZdWW3zU,48
+portacode-0.3.25.dist-info/top_level.txt,sha256=TGhTYUxfW8SyVZc_zGgzjzc24gGT7nSw8Qf73liVRKM,41
+portacode-0.3.25.dist-info/RECORD,,

{portacode-0.3.23.dist-info → portacode-0.3.25.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.3.2)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any