portacode 0.3.20.dev3__tar.gz → 0.3.20.dev4__tar.gz

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

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

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

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

portacode-0.3.20.dev4/portacode/connection/handlers/project_state/__init__.py

@@ -0,0 +1,145 @@
+"""Project State Management Package
+
+This package provides a modular architecture for managing project state in the
+Portacode application, including file system monitoring, git integration,
+tab management, and real-time state synchronization.
+
+The package is organized into the following modules:
+
+- models: Data structures and models (ProjectState, FileItem, TabInfo, etc.)
+- git_manager: Git operations and repository management
+- file_system_watcher: File system change monitoring
+- manager: Central project state coordinator (legacy)
+- centralized_manager: New centralized state manager with single source of truth
+- handlers: Request handlers for various operations (legacy)
+- centralized_handlers: New handlers using centralized state management
+- utils: Utility functions and helpers
+
+Usage (New Centralized System):
+    from project_state.centralized_manager import get_or_create_centralized_manager
+    from project_state.centralized_handlers import CentralizedProjectStateFolderExpandHandler
+    from project_state.centralized_state import CentralizedProjectState
+
+Usage (Legacy System):
+    from project_state.manager import get_or_create_project_state_manager
+    from project_state.handlers import ProjectStateFolderExpandHandler
+    from project_state.models import ProjectState, FileItem
+"""
+
+# Public API exports
+from .models import (
+    ProjectState,
+    FileItem,
+    TabInfo,
+    MonitoredFolder,
+    GitFileChange,
+    GitDetailedStatus
+)
+
+# Legacy manager (for backwards compatibility)
+from .manager import (
+    ProjectStateManager,
+    get_or_create_project_state_manager,
+    reset_global_project_state_manager,
+    debug_global_manager_state
+)
+
+# New centralized system
+from .centralized_manager import (
+    CentralizedProjectStateManager,
+    get_or_create_centralized_manager
+)
+
+from .centralized_state import (
+    CentralizedProjectState,
+    GitStateSnapshot,
+    StateUpdateManager,
+    StateNotificationManager,
+    PeriodicGitMonitor
+)
+
+from .git_manager import GitManager
+from .file_system_watcher import FileSystemWatcher
+
+# Legacy handlers (for backwards compatibility)
+from .handlers import (
+    ProjectStateFolderExpandHandler,
+    ProjectStateFolderCollapseHandler,
+    ProjectStateFileOpenHandler,
+    ProjectStateTabCloseHandler,
+    ProjectStateSetActiveTabHandler,
+    ProjectStateDiffOpenHandler,
+    ProjectStateGitStageHandler,
+    ProjectStateGitUnstageHandler,
+    ProjectStateGitRevertHandler,
+    handle_client_session_cleanup
+)
+
+# New centralized handlers
+from .centralized_handlers import (
+    CentralizedProjectStateFolderExpandHandler,
+    CentralizedProjectStateFolderCollapseHandler,
+    CentralizedProjectStateFileOpenHandler,
+    CentralizedProjectStateTabCloseHandler,
+    CentralizedProjectStateGitStageHandler,
+    CentralizedProjectStateGitUnstageHandler,
+    CentralizedProjectStateGitRevertHandler,
+    handle_centralized_client_session_cleanup
+)
+
+from .utils import generate_tab_key, generate_tab_id
+
+__all__ = [
+    # Models
+    'ProjectState',
+    'FileItem',
+    'TabInfo',
+    'MonitoredFolder',
+    'GitFileChange',
+    'GitDetailedStatus',
+    
+    # Core classes
+    'ProjectStateManager',  # Legacy
+    'CentralizedProjectStateManager',  # New
+    'CentralizedProjectState',  # New
+    'GitStateSnapshot',  # New
+    'StateUpdateManager',  # New
+    'StateNotificationManager',  # New
+    'PeriodicGitMonitor',  # New
+    'GitManager',
+    'FileSystemWatcher',
+    
+    # Manager functions (Legacy)
+    'get_or_create_project_state_manager',
+    'reset_global_project_state_manager',
+    'debug_global_manager_state',
+    
+    # Manager functions (New)
+    'get_or_create_centralized_manager',
+    
+    # Legacy Handlers
+    'ProjectStateFolderExpandHandler',
+    'ProjectStateFolderCollapseHandler',
+    'ProjectStateFileOpenHandler',
+    'ProjectStateTabCloseHandler',
+    'ProjectStateSetActiveTabHandler',
+    'ProjectStateDiffOpenHandler',
+    'ProjectStateGitStageHandler',
+    'ProjectStateGitUnstageHandler',
+    'ProjectStateGitRevertHandler',
+    'handle_client_session_cleanup',
+    
+    # New Centralized Handlers
+    'CentralizedProjectStateFolderExpandHandler',
+    'CentralizedProjectStateFolderCollapseHandler',
+    'CentralizedProjectStateFileOpenHandler',
+    'CentralizedProjectStateTabCloseHandler',
+    'CentralizedProjectStateGitStageHandler',
+    'CentralizedProjectStateGitUnstageHandler',
+    'CentralizedProjectStateGitRevertHandler',
+    'handle_centralized_client_session_cleanup',
+    
+    # Utils
+    'generate_tab_key',
+    'generate_tab_id'
+]

portacode-0.3.20.dev4/portacode/connection/handlers/project_state/centralized_handlers.py

@@ -0,0 +1,299 @@
+"""
+Updated handlers that use the centralized project state manager.
+
+These handlers replace the old handlers with clean interfaces to the
+centralized state management system.
+"""
+
+import logging
+from typing import Any, Dict
+
+from ..base import AsyncHandler
+from .centralized_manager import get_or_create_centralized_manager
+
+logger = logging.getLogger(__name__)
+
+
+class CentralizedProjectStateFolderExpandHandler(AsyncHandler):
+    """Handler for expanding project folders using centralized state."""
+    
+    @property
+    def command_name(self) -> str:
+        return "project_state_folder_expand"
+    
+    async def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        """Expand a folder in project state."""
+        server_project_id = message.get("project_id")
+        folder_path = message.get("folder_path")
+        source_client_session = message.get("source_client_session")
+        
+        if not server_project_id:
+            raise ValueError("project_id is required")
+        if not folder_path:
+            raise ValueError("folder_path is required")
+        if not source_client_session:
+            raise ValueError("source_client_session is required")
+        
+        logger.info("Expanding folder %s for session %s", folder_path, source_client_session)
+        
+        # Get centralized manager
+        manager = get_or_create_centralized_manager(self.context, self.control_channel)
+        
+        # Expand folder
+        success = await manager.expand_folder(source_client_session, folder_path)
+        
+        return {
+            "event": "project_state_folder_expand_response",
+            "project_id": server_project_id,
+            "folder_path": folder_path,
+            "success": success
+        }
+
+
+class CentralizedProjectStateFolderCollapseHandler(AsyncHandler):
+    """Handler for collapsing project folders using centralized state."""
+    
+    @property
+    def command_name(self) -> str:
+        return "project_state_folder_collapse"
+    
+    async def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        """Collapse a folder in project state."""
+        server_project_id = message.get("project_id")
+        folder_path = message.get("folder_path")
+        source_client_session = message.get("source_client_session")
+        
+        if not server_project_id:
+            raise ValueError("project_id is required")
+        if not folder_path:
+            raise ValueError("folder_path is required")
+        if not source_client_session:
+            raise ValueError("source_client_session is required")
+        
+        logger.info("Collapsing folder %s for session %s", folder_path, source_client_session)
+        
+        # Get centralized manager
+        manager = get_or_create_centralized_manager(self.context, self.control_channel)
+        
+        # Collapse folder
+        success = await manager.collapse_folder(source_client_session, folder_path)
+        
+        return {
+            "event": "project_state_folder_collapse_response",
+            "project_id": server_project_id,
+            "folder_path": folder_path,
+            "success": success
+        }
+
+
+class CentralizedProjectStateFileOpenHandler(AsyncHandler):
+    """Handler for opening files using centralized state."""
+    
+    @property
+    def command_name(self) -> str:
+        return "project_state_file_open"
+    
+    async def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        """Open a file in project state."""
+        server_project_id = message.get("project_id")
+        file_path = message.get("file_path")
+        source_client_session = message.get("source_client_session")
+        set_active = message.get("set_active", True)
+        
+        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("Opening file %s for session %s", file_path, source_client_session)
+        
+        # Get centralized manager
+        manager = get_or_create_centralized_manager(self.context, self.control_channel)
+        
+        # Open file
+        success = await manager.open_file_tab(source_client_session, file_path, set_active)
+        
+        return {
+            "event": "project_state_file_open_response",
+            "project_id": server_project_id,
+            "file_path": file_path,
+            "success": success,
+            "set_active": set_active
+        }
+
+
+class CentralizedProjectStateTabCloseHandler(AsyncHandler):
+    """Handler for closing tabs using centralized state."""
+    
+    @property
+    def command_name(self) -> str:
+        return "project_state_tab_close"
+    
+    async def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        """Close a tab in project state."""
+        server_project_id = message.get("project_id")
+        tab_id = message.get("tab_id")
+        source_client_session = message.get("source_client_session")
+        
+        if not server_project_id:
+            raise ValueError("project_id is required")
+        if not tab_id:
+            raise ValueError("tab_id is required")
+        if not source_client_session:
+            raise ValueError("source_client_session is required")
+        
+        logger.info("Closing tab %s for session %s", tab_id, source_client_session)
+        
+        # Get centralized manager
+        manager = get_or_create_centralized_manager(self.context, self.control_channel)
+        
+        # Close tab
+        success = await manager.close_tab(source_client_session, tab_id)
+        
+        return {
+            "event": "project_state_tab_close_response",
+            "project_id": server_project_id,
+            "tab_id": tab_id,
+            "success": success
+        }
+
+
+class CentralizedProjectStateGitStageHandler(AsyncHandler):
+    """Handler for staging files using centralized state."""
+    
+    @property
+    def command_name(self) -> str:
+        return "project_state_git_stage"
+    
+    async def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        """Stage a file in git."""
+        server_project_id = message.get("project_id")
+        file_path = message.get("file_path")
+        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 session %s", file_path, source_client_session)
+        
+        # Get centralized manager
+        manager = get_or_create_centralized_manager(self.context, self.control_channel)
+        
+        # Stage file
+        success = await manager.stage_file(source_client_session, file_path)
+        
+        return {
+            "event": "project_state_git_stage_response",
+            "project_id": server_project_id,
+            "file_path": file_path,
+            "success": success
+        }
+
+
+class CentralizedProjectStateGitUnstageHandler(AsyncHandler):
+    """Handler for unstaging files using centralized state."""
+    
+    @property
+    def command_name(self) -> str:
+        return "project_state_git_unstage"
+    
+    async def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        """Unstage a file in git."""
+        server_project_id = message.get("project_id")
+        file_path = message.get("file_path")
+        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 session %s", file_path, source_client_session)
+        
+        # Get centralized manager
+        manager = get_or_create_centralized_manager(self.context, self.control_channel)
+        
+        # Unstage file
+        success = await manager.unstage_file(source_client_session, file_path)
+        
+        return {
+            "event": "project_state_git_unstage_response",
+            "project_id": server_project_id,
+            "file_path": file_path,
+            "success": success
+        }
+
+
+class CentralizedProjectStateGitRevertHandler(AsyncHandler):
+    """Handler for reverting files using centralized state."""
+    
+    @property
+    def command_name(self) -> str:
+        return "project_state_git_revert"
+    
+    async def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        """Revert a file in git."""
+        server_project_id = message.get("project_id")
+        file_path = message.get("file_path")
+        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 session %s", file_path, source_client_session)
+        
+        # Get centralized manager
+        manager = get_or_create_centralized_manager(self.context, self.control_channel)
+        
+        # Revert file
+        success = await manager.revert_file(source_client_session, file_path)
+        
+        return {
+            "event": "project_state_git_revert_response",
+            "project_id": server_project_id,
+            "file_path": file_path,
+            "success": success
+        }
+
+
+# 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]:
+    """Handle cleanup of a client session using centralized manager."""
+    client_session_id = payload.get('client_session_id')
+    
+    if not client_session_id:
+        logger.error("client_session_id is required for client session cleanup")
+        return {
+            "event": "client_session_cleanup_response",
+            "success": False,
+            "error": "client_session_id is required"
+        }
+    
+    logger.info("Handling centralized cleanup for client session: %s", client_session_id)
+    
+    # Get centralized manager
+    manager = get_or_create_centralized_manager(handler.context, handler.control_channel)
+    
+    # Clean up the client session
+    await manager.cleanup_project_state(client_session_id)
+    
+    logger.info("Centralized client session cleanup completed: %s", client_session_id)
+    
+    return {
+        "event": "client_session_cleanup_response",
+        "client_session_id": client_session_id,
+        "success": True
+    }