portacode 0.3.23__tar.gz → 0.3.25__tar.gz

{portacode-0.3.23 → portacode-0.3.25}/PKG-INFO

@@ -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
@@ -27,6 +27,17 @@ 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 → portacode-0.3.25}/docker-compose.yaml

@@ -32,6 +32,35 @@ services:
     volumes:
       - ./server/portacode_django:/app
 
+  unibot-worker:
+    build:
+      context: ./server/portacode_django
+      dockerfile: Dockerfile
+    container_name: portacode-unibot-worker
+    restart: unless-stopped
+    command: ["python", "manage.py", "run_worker"]
+    env_file:
+      - main.env
+    depends_on:
+      db:
+        condition: service_healthy
+    volumes:
+      - ./server/portacode_django:/app
+
+  imap-worker:
+    build:
+      context: ./server/portacode_django
+      dockerfile: Dockerfile
+    container_name: portacode-imap-worker
+    restart: unless-stopped
+    command: ["python", "manage.py", "start_imap_listeners"]
+    env_file:
+      - main.env
+    depends_on:
+      db:
+        condition: service_healthy
+    volumes:
+      - ./server/portacode_django:/app
 
 volumes:
   pgdata: 

{portacode-0.3.23 → portacode-0.3.25}/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-0.3.23 → portacode-0.3.25}/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-0.3.23 → portacode-0.3.25}/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: