portacode 0.3.20.dev4__tar.gz → 0.3.20.dev6__tar.gz

{portacode-0.3.20.dev4 → portacode-0.3.20.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: portacode
-Version: 0.3.20.dev4
+Version: 0.3.20.dev6
 Summary: Portacode CLI client and SDK
 Home-page: https://github.com/portacode/portacode
 Author: Meena Erian

{portacode-0.3.20.dev4 → portacode-0.3.20.dev6}/portacode/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.3.20.dev4'
-__version_tuple__ = version_tuple = (0, 3, 20, 'dev4')
+__version__ = version = '0.3.20.dev6'
+__version_tuple__ = version_tuple = (0, 3, 20, 'dev6')

{portacode-0.3.20.dev4 → portacode-0.3.20.dev6}/portacode/connection/handlers/project_state/centralized_handlers.py

@@ -268,6 +268,102 @@ class CentralizedProjectStateGitRevertHandler(AsyncHandler):
         }
 
 
+class CentralizedProjectStateSetActiveTabHandler(AsyncHandler):
+    """Handler for setting active tab using centralized state."""
+    
+    @property
+    def command_name(self) -> str:
+        return "project_state_set_active_tab"
+    
+    async def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        """Set active tab in project state."""
+        server_project_id = message.get("project_id")
+        tab_id = message.get("tab_id")  # Can be None to clear active tab
+        source_client_session = message.get("source_client_session")
+        
+        if not server_project_id:
+            raise ValueError("project_id is required")
+        if not source_client_session:
+            raise ValueError("source_client_session is required")
+        
+        logger.info("Setting active tab %s for session %s", tab_id, source_client_session)
+        
+        # Note: Active tab is deprecated in the new centralized system
+        # This handler maintains compatibility but does nothing
+        logger.info("Active tab functionality is deprecated in centralized system")
+        
+        return {
+            "event": "project_state_set_active_tab_response",
+            "project_id": server_project_id,
+            "tab_id": tab_id,
+            "success": True
+        }
+
+
+class CentralizedProjectStateDiffOpenHandler(AsyncHandler):
+    """Handler for opening diff tabs using centralized state."""
+    
+    @property
+    def command_name(self) -> str:
+        return "project_state_diff_open"
+    
+    async def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        """Open a diff tab comparing file versions at different git timeline points."""
+        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")
+        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 from_ref:
+            raise ValueError("from_ref is required")
+        if not to_ref:
+            raise ValueError("to_ref is required")
+        if not source_client_session:
+            raise ValueError("source_client_session is required")
+        
+        # Validate reference types
+        valid_refs = {'head', 'staged', 'working', 'commit'}
+        if from_ref not in valid_refs:
+            raise ValueError(f"Invalid from_ref: {from_ref}. Must be one of {valid_refs}")
+        if to_ref not in valid_refs:
+            raise ValueError(f"Invalid to_ref: {to_ref}. Must be one of {valid_refs}")
+        
+        # Validate commit hashes are provided when needed
+        if from_ref == 'commit' and not from_hash:
+            raise ValueError("from_hash is required when from_ref='commit'")
+        if to_ref == 'commit' and not to_hash:
+            raise ValueError("to_hash is required when to_ref='commit'")
+        
+        logger.info("Opening diff tab %s (%s->%s) for session %s", 
+                   file_path, from_ref, to_ref, source_client_session)
+        
+        # Get centralized manager
+        manager = get_or_create_centralized_manager(self.context, self.control_channel)
+        
+        # For now, return success but don't actually implement diff tabs
+        # This would need to be implemented in the centralized manager
+        logger.info("Diff tab functionality not yet implemented in centralized system")
+        
+        return {
+            "event": "project_state_diff_open_response",
+            "project_id": server_project_id,
+            "file_path": file_path,
+            "from_ref": from_ref,
+            "to_ref": to_ref,
+            "from_hash": from_hash,
+            "to_hash": to_hash,
+            "success": False,  # Not implemented yet
+            "error": "Diff tab functionality not yet implemented in centralized system"
+        }
+
+
 # Handler for explicit client session cleanup
 async def handle_centralized_client_session_cleanup(handler, payload: Dict[str, Any], 
                                                    source_client_session: str) -> Dict[str, Any]:

{portacode-0.3.20.dev4 → portacode-0.3.20.dev6}/portacode/connection/handlers/project_state/centralized_state.py

@@ -78,6 +78,7 @@ class CentralizedProjectState:
         
         # Single source of truth for git state
         self._git_snapshot: Optional[GitStateSnapshot] = None
+        self._last_git_status_hash: Optional[str] = None
         
         # File system state
         self._monitored_folders: List[MonitoredFolder] = []
@@ -228,14 +229,15 @@ class StateUpdateManager:
         self.git_manager = git_manager
         
     async def refresh_git_state(self, state: CentralizedProjectState) -> bool:
-        """Refresh git state from repository. Returns True if state changed."""
+        """Refresh git state from repository using hash-based change detection. Returns True if state changed."""
         try:
             # Check if .git directory exists
             git_dir = os.path.join(state.project_folder_path, '.git')
             is_git_repo = os.path.exists(git_dir)
             
             if not is_git_repo:
-                # No git repository
+                # No git repository - reset hash and set empty state
+                state._last_git_status_hash = None
                 empty_snapshot = GitStateSnapshot(
                     is_git_repo=False,
                     branch_name=None,
@@ -250,7 +252,19 @@ class StateUpdateManager:
             if not self.git_manager.is_git_repo:
                 self.git_manager.reinitialize()
             
-            # Get complete git state atomically
+            # Use hash-based change detection for performance
+            current_git_hash = self.git_manager.compute_git_status_hash()
+            
+            # Only compute detailed status if hash changed
+            if current_git_hash == state._last_git_status_hash:
+                logger.debug("Git status hash unchanged for %s, skipping detailed computation", 
+                           state.client_session_id)
+                return False
+            
+            logger.debug("Git status hash changed for %s: %s -> %s", 
+                        state.client_session_id, state._last_git_status_hash, current_git_hash)
+            
+            # Hash changed, compute detailed status
             branch_name = self.git_manager.get_branch_name()
             detailed_status = self.git_manager.get_detailed_status()
             
@@ -263,6 +277,8 @@ class StateUpdateManager:
                 untracked_files=detailed_status.untracked_files
             )
             
+            # Update hash and state
+            state._last_git_status_hash = current_git_hash
             return state.update_git_state(new_snapshot)
             
         except Exception as e:

{portacode-0.3.20.dev4 → portacode-0.3.20.dev6}/portacode/connection/handlers/project_state/git_manager.py

@@ -851,6 +851,46 @@ class GitManager:
             logger.debug("Error getting HEAD commit hash: %s", e)
             return None
     
+    def compute_git_status_hash(self) -> str:
+        """Compute a hash representing the current git status.
+        
+        This method uses GitPython to quickly get git status information
+        and computes a hash that changes when the status changes.
+        """
+        if not self.is_git_repo or not self.repo:
+            return "no-repo"
+        
+        import hashlib
+        
+        try:
+            status_components = []
+            
+            # Include HEAD commit hash
+            head_hash = self.get_head_commit_hash() or "no-head"
+            status_components.append(f"head:{head_hash}")
+            
+            # Include branch name
+            branch = self.get_branch_name() or "no-branch"
+            status_components.append(f"branch:{branch}")
+            
+            # Use git status --porcelain for consistent status representation
+            porcelain_status = self.repo.git.status("--porcelain")
+            status_components.append(f"porcelain:{porcelain_status}")
+            
+            # Include index file modification time as a fallback for edge cases
+            index_path = os.path.join(self.repo.git_dir, 'index')
+            if os.path.exists(index_path):
+                index_mtime = str(os.path.getmtime(index_path))
+                status_components.append(f"index_mtime:{index_mtime}")
+            
+            # Combine all components and hash
+            combined_status = "|".join(status_components)
+            return hashlib.sha256(combined_status.encode('utf-8')).hexdigest()
+            
+        except Exception as e:
+            logger.error("Error computing git status hash: %s", e)
+            return f"error-{str(hash(str(e)))}"
+
     def get_detailed_status(self) -> GitDetailedStatus:
         """Get detailed Git status with file hashes using GitPython APIs."""
         if not self.is_git_repo or not self.repo:
@@ -1092,13 +1132,25 @@ class GitManager:
             
             if has_commits:
                 # Repository has commits - use git restore --staged
-                self.repo.git.restore('--staged', rel_path)
-                logger.info("Successfully unstaged file using restore: %s", rel_path)
+                try:
+                    self.repo.git.restore('--staged', rel_path)
+                    logger.info("Successfully unstaged file using restore: %s", rel_path)
+                except Exception as restore_error:
+                    # If restore fails, try reset HEAD approach
+                    logger.debug("git restore failed, trying reset HEAD: %s", restore_error)
+                    self.repo.git.reset('HEAD', rel_path)
+                    logger.info("Successfully unstaged file using reset HEAD: %s", rel_path)
             else:
                 # Repository has no commits - use git rm --cached
                 # This handles the case where files are staged but no initial commit exists
-                self.repo.git.rm('--cached', rel_path)
-                logger.info("Successfully unstaged file using rm --cached (no HEAD): %s", rel_path)
+                try:
+                    self.repo.git.rm('--cached', rel_path)
+                    logger.info("Successfully unstaged file using rm --cached (no HEAD): %s", rel_path)
+                except Exception as rm_error:
+                    # If rm --cached fails, try with --force flag
+                    logger.debug("git rm --cached failed, trying with --force: %s", rm_error)
+                    self.repo.git.rm('--cached', '--force', rel_path)
+                    logger.info("Successfully unstaged file using rm --cached --force (no HEAD): %s", rel_path)
             
             return True
             

{portacode-0.3.20.dev4 → portacode-0.3.20.dev6}/portacode/connection/handlers/project_state/simplified_file_watcher.py

@@ -110,7 +110,7 @@ class SimplifiedEventHandler(FileSystemEventHandler):
         
         # Skip git directories entirely - they're handled by periodic polling
         path_parts = Path(event.src_path).parts
-        if '.git' in path_parts:
+        if '.git' in path_parts or event.src_path.endswith(('.git', '/.git')):
             logger.debug("Skipping git directory event: %s", event.src_path)
             return
         

{portacode-0.3.20.dev4 → portacode-0.3.20.dev6}/portacode/connection/handlers/project_state_handlers.py

@@ -15,18 +15,18 @@ project_state/README.md
 # Import everything from the modular structure for backward compatibility
 from .project_state import *
 
-# Ensure all handlers are available at module level for existing imports
-from .project_state.handlers import (
-    ProjectStateFolderExpandHandler,
-    ProjectStateFolderCollapseHandler,
-    ProjectStateFileOpenHandler,
-    ProjectStateTabCloseHandler,
-    ProjectStateSetActiveTabHandler,
-    ProjectStateDiffOpenHandler,
-    ProjectStateGitStageHandler,
-    ProjectStateGitUnstageHandler,
-    ProjectStateGitRevertHandler,
-    handle_client_session_cleanup
+# Use the new centralized handlers for better performance and reliability
+from .project_state.centralized_handlers import (
+    CentralizedProjectStateFolderExpandHandler as ProjectStateFolderExpandHandler,
+    CentralizedProjectStateFolderCollapseHandler as ProjectStateFolderCollapseHandler,
+    CentralizedProjectStateFileOpenHandler as ProjectStateFileOpenHandler,
+    CentralizedProjectStateTabCloseHandler as ProjectStateTabCloseHandler,
+    CentralizedProjectStateSetActiveTabHandler as ProjectStateSetActiveTabHandler,
+    CentralizedProjectStateDiffOpenHandler as ProjectStateDiffOpenHandler,
+    CentralizedProjectStateGitStageHandler as ProjectStateGitStageHandler,
+    CentralizedProjectStateGitUnstageHandler as ProjectStateGitUnstageHandler,
+    CentralizedProjectStateGitRevertHandler as ProjectStateGitRevertHandler,
+    handle_centralized_client_session_cleanup as handle_client_session_cleanup
 )
 
 from .project_state.manager import (

{portacode-0.3.20.dev4 → portacode-0.3.20.dev6}/portacode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: portacode
-Version: 0.3.20.dev4
+Version: 0.3.20.dev6
 Summary: Portacode CLI client and SDK
 Home-page: https://github.com/portacode/portacode
 Author: Meena Erian