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

portacode/connection/handlers/project_state/handlers.py

@@ -9,6 +9,7 @@ import logging
 from typing import Any, Dict, List
 
 from ..base import AsyncHandler
+from ..chunked_content import create_chunked_response
 from .manager import get_or_create_project_state_manager
 
 logger = logging.getLogger(__name__)
@@ -364,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)
@@ -387,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):
@@ -410,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)
@@ -433,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):
@@ -456,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)
@@ -479,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):
@@ -579,4 +664,195 @@ async def handle_client_session_cleanup(handler, payload: Dict[str, Any], source
         "event": "client_session_cleanup_response",
         "client_session_id": client_session_id,
         "success": True
-    }
+    }
+
+
+class ProjectStateDiffContentHandler(AsyncHandler):
+    """Handler for requesting specific diff content for diff tabs."""
+    
+    @property
+    def command_name(self) -> str:
+        return "project_state_diff_content_request"
+    
+    async def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        """Request specific content for a diff tab (original, modified, or html_diff)."""
+        server_project_id = message.get("project_id")
+        file_path = message.get("file_path")
+        from_ref = message.get("from_ref")
+        to_ref = message.get("to_ref")
+        from_hash = message.get("from_hash")
+        to_hash = message.get("to_hash")
+        content_type = message.get("content_type")  # 'original', 'modified', 'html_diff'
+        request_id = message.get("request_id")
+        source_client_session = message.get("source_client_session")
+        
+        # Validate required fields
+        if not server_project_id:
+            raise ValueError("project_id is required")
+        if not file_path:
+            raise ValueError("file_path is required")
+        if not from_ref:
+            raise ValueError("from_ref is required")
+        if not to_ref:
+            raise ValueError("to_ref is required")
+        if not content_type:
+            raise ValueError("content_type is required")
+        if not request_id:
+            raise ValueError("request_id is required")
+        if not source_client_session:
+            raise ValueError("source_client_session is required")
+        
+        # Validate content_type
+        valid_content_types = ["original", "modified", "html_diff", "all"]
+        if content_type not in valid_content_types:
+            raise ValueError(f"content_type must be one of: {valid_content_types}")
+        
+        # Get the project state manager
+        manager = get_or_create_project_state_manager(self.context, self.control_channel)
+        
+        # Get the project state for this client session
+        if source_client_session not in manager.projects:
+            raise ValueError(f"No project state found for client session: {source_client_session}")
+        
+        project_state = manager.projects[source_client_session]
+        
+        try:
+            # Find the diff tab with matching parameters
+            matching_tab = None
+            for tab in project_state.open_tabs.values():
+                if tab.tab_type == "diff" and tab.file_path == file_path:
+                    # Get diff parameters from metadata
+                    tab_metadata = getattr(tab, 'metadata', {}) or {}
+                    tab_from_ref = tab_metadata.get('from_ref')
+                    tab_to_ref = tab_metadata.get('to_ref')
+                    tab_from_hash = tab_metadata.get('from_hash')
+                    tab_to_hash = tab_metadata.get('to_hash')
+                    
+                    if (tab_from_ref == from_ref and 
+                        tab_to_ref == to_ref and
+                        tab_from_hash == from_hash and
+                        tab_to_hash == to_hash):
+                        matching_tab = tab
+                        break
+            
+            if not matching_tab:
+                # Debug information
+                logger.error(f"No diff tab found for file_path={file_path}, from_ref={from_ref}, to_ref={to_ref}")
+                logger.error(f"Available diff tabs: {[(tab.file_path, getattr(tab, 'metadata', {})) for tab in project_state.open_tabs.values() if tab.tab_type == 'diff']}")
+                raise ValueError(f"No diff tab found matching the specified parameters: file_path={file_path}, from_ref={from_ref}, to_ref={to_ref}")
+            
+            # Get the requested content based on type
+            content = None
+            if content_type == "original":
+                content = matching_tab.original_content
+            elif content_type == "modified":
+                content = matching_tab.modified_content
+            elif content_type == "html_diff":
+                # For html_diff, we need to get the HTML diff versions from metadata
+                html_diff_versions = getattr(matching_tab, 'metadata', {}).get('html_diff_versions')
+                if html_diff_versions:
+                    import json
+                    content = json.dumps(html_diff_versions)
+            elif content_type == "all":
+                # Return all content types as a JSON object
+                html_diff_versions = getattr(matching_tab, 'metadata', {}).get('html_diff_versions')
+                import json
+                content = json.dumps({
+                    "original_content": matching_tab.original_content,
+                    "modified_content": matching_tab.modified_content,
+                    "html_diff_versions": html_diff_versions
+                })
+            
+            # If content is None or incomplete for "all", regenerate if needed
+            if content is None or (content_type == "all" and not all([matching_tab.original_content, matching_tab.modified_content])):
+                if content_type in ["original", "modified", "all"]:
+                    # Re-generate the diff content if needed
+                    await manager.create_diff_tab(
+                        source_client_session, 
+                        file_path, 
+                        from_ref, 
+                        to_ref, 
+                        from_hash, 
+                        to_hash,
+                        activate=False  # Don't activate, just ensure content is loaded
+                    )
+                    
+                    # Try to get content again after regeneration (use same matching logic)
+                    updated_tab = None
+                    for tab in project_state.open_tabs.values():
+                        if tab.tab_type == "diff" and tab.file_path == file_path:
+                            tab_metadata = getattr(tab, 'metadata', {}) or {}
+                            if (tab_metadata.get('from_ref') == from_ref and 
+                                tab_metadata.get('to_ref') == to_ref and
+                                tab_metadata.get('from_hash') == from_hash and
+                                tab_metadata.get('to_hash') == to_hash):
+                                updated_tab = tab
+                                break
+                    
+                    if updated_tab:
+                        if content_type == "original":
+                            content = updated_tab.original_content
+                        elif content_type == "modified":
+                            content = updated_tab.modified_content
+                        elif content_type == "html_diff":
+                            html_diff_versions = getattr(updated_tab, 'metadata', {}).get('html_diff_versions')
+                            if html_diff_versions:
+                                import json
+                                content = json.dumps(html_diff_versions)
+                        elif content_type == "all":
+                            html_diff_versions = getattr(updated_tab, 'metadata', {}).get('html_diff_versions')
+                            import json
+                            content = json.dumps({
+                                "original_content": updated_tab.original_content,
+                                "modified_content": updated_tab.modified_content,
+                                "html_diff_versions": html_diff_versions
+                            })
+            
+            success = content is not None
+            base_response = {
+                "event": "project_state_diff_content_response",
+                "project_id": server_project_id,
+                "file_path": file_path,
+                "from_ref": from_ref,
+                "to_ref": to_ref,
+                "content_type": content_type,
+                "request_id": request_id,
+                "success": success
+            }
+            
+            if from_hash:
+                base_response["from_hash"] = from_hash
+            if to_hash:
+                base_response["to_hash"] = to_hash
+            
+            if success:
+                # Create chunked responses for large content
+                responses = create_chunked_response(base_response, "content", content)
+                
+                # Send all responses
+                for response in responses:
+                    await self.send_response(response, project_id=server_project_id)
+                
+                logger.info(f"Sent diff content response in {len(responses)} chunk(s) for {content_type} content")
+            else:
+                base_response["error"] = f"Failed to load {content_type} content for diff"
+                base_response["chunked"] = False
+                await self.send_response(base_response, project_id=server_project_id)
+            
+            return  # AsyncHandler doesn't return responses, it sends them
+            
+        except Exception as e:
+            logger.error("Error processing diff content request: %s", e)
+            error_response = {
+                "event": "project_state_diff_content_response",
+                "project_id": server_project_id,
+                "file_path": file_path,
+                "from_ref": from_ref,
+                "to_ref": to_ref,
+                "content_type": content_type,
+                "request_id": request_id,
+                "success": False,
+                "error": str(e),
+                "chunked": False
+            }
+            await self.send_response(error_response, project_id=server_project_id)

portacode/connection/handlers/project_state/manager.py

@@ -38,6 +38,9 @@ class ProjectStateManager:
         self.debug_mode = False
         self.debug_file_path: Optional[str] = None
         
+        # Content caching optimization
+        self.use_content_caching = context.get("use_content_caching", False)
+        
         # Debouncing for file changes
         self._change_debounce_timer: Optional[asyncio.Task] = None
         self._pending_changes: Set[str] = set()
@@ -102,7 +105,28 @@ class ProjectStateManager:
     
     def _serialize_tab_info(self, tab: TabInfo) -> Dict[str, Any]:
         """Serialize TabInfo for JSON output."""
-        return asdict(tab) if hasattr(tab, '__dataclass_fields__') else {}
+        if not hasattr(tab, '__dataclass_fields__'):
+            return {}
+        
+        tab_dict = asdict(tab)
+        
+        # If content caching is enabled, exclude content fields to reduce payload size
+        if self.use_content_caching:
+            # Only include hashes, not the actual content
+            tab_dict.pop('content', None)
+            tab_dict.pop('original_content', None) 
+            tab_dict.pop('modified_content', None)
+            # Keep the hashes for client-side cache lookup
+            # content_hash, original_content_hash, modified_content_hash remain
+            
+            # Also exclude large metadata for diff tabs
+            if tab_dict.get('metadata'):
+                metadata = tab_dict['metadata']
+                # Remove massive HTML diff content that can be megabytes
+                metadata.pop('html_diff_versions', None)
+                metadata.pop('diff_details', None)
+            
+        return tab_dict
     
     async def initialize_project_state(self, client_session_id: str, project_folder_path: str) -> ProjectState:
         """Initialize project state for a client session."""
@@ -1005,6 +1029,25 @@ class ProjectStateManager:
         
         logger.info("Cleaned up %d project states", len(client_session_ids))
     
+    async def refresh_project_state_for_file_change(self, file_path: str):
+        """Public method to trigger project state refresh for a specific file change."""
+        logger.info(f"Manual refresh triggered for file change: {file_path}")
+        
+        # Find project states that include this file path
+        for client_session_id, project_state in self.projects.items():
+            project_folder = Path(project_state.project_folder_path)
+            
+            # Check if the file is within this project
+            try:
+                Path(file_path).relative_to(project_folder)
+                # File is within this project, trigger refresh
+                logger.info(f"Refreshing project state for session {client_session_id} after file change: {file_path}")
+                await self._refresh_project_state(client_session_id)
+                break
+            except ValueError:
+                # File is not within this project
+                continue
+
     def cleanup_orphaned_project_states(self, current_client_sessions: List[str]):
         """Clean up project states that don't match any current client session."""
         current_sessions_set = set(current_client_sessions)

portacode/connection/handlers/project_state/models.py

@@ -19,6 +19,13 @@ class TabInfo:
     content: Optional[str] = None  # Text content or base64 for media
     original_content: Optional[str] = None  # For diff view
     modified_content: Optional[str] = None  # For diff view
+    
+    # Content hash fields for caching optimization
+    content_hash: Optional[str] = None  # SHA-256 hash of content
+    original_content_hash: Optional[str] = None  # SHA-256 hash of original_content for diffs
+    modified_content_hash: Optional[str] = None  # SHA-256 hash of modified_content for diffs
+    html_diff_hash: Optional[str] = None  # SHA-256 hash of html_diff_versions JSON
+    
     is_dirty: bool = False  # Has unsaved changes
     mime_type: Optional[str] = None  # For media files
     encoding: Optional[str] = None  # Content encoding (base64, utf-8, etc.)

portacode/connection/handlers/project_state/utils.py

@@ -4,6 +4,7 @@ This module contains shared utility functions used across the project state
 management system, including tab key generation and other helper functions.
 """
 
+import hashlib
 import uuid
 
 
@@ -31,4 +32,19 @@ def generate_tab_key(tab_type: str, file_path: str, **kwargs) -> str:
         return kwargs.get('tab_id', str(uuid.uuid4()))
     else:
         # For other tab types, use file_path if available, otherwise tab_id
-        return file_path if file_path else kwargs.get('tab_id', str(uuid.uuid4()))
+        return file_path if file_path else kwargs.get('tab_id', str(uuid.uuid4()))
+
+
+def generate_content_hash(content: str) -> str:
+    """Generate SHA-256 hash of content for caching.
+    
+    Args:
+        content: The string content to hash
+        
+    Returns:
+        SHA-256 hash prefixed with 'sha256:'
+    """
+    if content is None:
+        return None
+    
+    return "sha256:" + hashlib.sha256(content.encode('utf-8')).hexdigest()

portacode/connection/handlers/project_state_handlers.py

@@ -23,6 +23,7 @@ from .project_state.handlers import (
     ProjectStateTabCloseHandler,
     ProjectStateSetActiveTabHandler,
     ProjectStateDiffOpenHandler,
+    ProjectStateDiffContentHandler,
     ProjectStateGitStageHandler,
     ProjectStateGitUnstageHandler,
     ProjectStateGitRevertHandler,