portacode 0.3.20.dev7__tar.gz → 0.3.20.dev9__tar.gz

{portacode-0.3.20.dev7 → portacode-0.3.20.dev9}/PKG-INFO

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

{portacode-0.3.20.dev7 → portacode-0.3.20.dev9}/portacode/_version.py

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

{portacode-0.3.20.dev7 → portacode-0.3.20.dev9}/portacode/connection/handlers/project_state/centralized_manager.py

@@ -11,7 +11,7 @@ This replaces the old ProjectStateManager with a cleaner design:
 import asyncio
 import logging
 import os
-from typing import Dict, List, Optional, Set
+from typing import Dict, List, Optional, Set, Any
 from pathlib import Path
 
 from .centralized_state import (
@@ -46,9 +46,19 @@ class CentralizedProjectStateManager:
         # File system change tracking
         self._pending_file_changes: Set[str] = set()
         self._debounce_timer: Optional[asyncio.Task] = None
-        
+    
         logger.info("Initialized CentralizedProjectStateManager")
     
+    # Backward compatibility properties
+    @property
+    def projects(self) -> Dict[str, CentralizedProjectState]:
+        """Backward compatibility: alias for _project_states."""
+        return self._project_states
+        
+    def cleanup_project(self, client_session_id: str):
+        """Backward compatibility: alias for cleanup_project_state (sync version)."""
+        asyncio.create_task(self.cleanup_project_state(client_session_id))
+    
     def get_active_sessions(self) -> List[str]:
         """Get list of active client session IDs."""
         return list(self._project_states.keys())
@@ -399,6 +409,20 @@ class CentralizedProjectStateManager:
         state = self._project_states.get(client_session_id)
         if state:
             await self._notification_manager.force_notification(state, server_project_id)
+            
+    # Backward compatibility serialization methods
+    def _serialize_tab_info(self, tab: TabInfo) -> Dict[str, Any]:
+        """Serialize TabInfo for JSON output."""
+        from dataclasses import asdict
+        return asdict(tab) if hasattr(tab, '__dataclass_fields__') else {}
+    
+    def _serialize_file_item(self, item: FileItem) -> Dict[str, Any]:
+        """Serialize FileItem for JSON output."""  
+        from dataclasses import asdict
+        result = asdict(item) if hasattr(item, '__dataclass_fields__') else {}
+        if item.children:
+            result["children"] = [self._serialize_file_item(child) for child in item.children]
+        return result
 
 
 # Global instance management
@@ -413,4 +437,150 @@ def get_or_create_centralized_manager(context: Dict,
         _global_manager = CentralizedProjectStateManager(context, control_channel)
         logger.info("Created new centralized project state manager")
     
-    return _global_manager
+    return _global_manager
+
+
+def reset_global_centralized_manager():
+    """Reset the global centralized project state manager."""
+    global _global_manager
+    
+    if _global_manager:
+        # Stop all monitoring
+        _global_manager._git_monitor.stop_monitoring()
+        if _global_manager._file_watcher:
+            _global_manager._file_watcher.stop_all()
+        
+        logger.info("Reset centralized project state manager")
+    
+    _global_manager = None
+
+
+def debug_global_centralized_manager_state() -> dict:
+    """Get debug information about the global centralized manager state."""
+    global _global_manager
+    
+    if _global_manager is None:
+        return {"error": "No global centralized manager instance"}
+    
+    import os
+    debug_info = {
+        "_instance_info": {
+            "pid": os.getpid(),
+            "timestamp": __import__('time').time(),
+            "project_count": len(_global_manager._project_states)
+        }
+    }
+    
+    # Add state for each project
+    for client_session_id, state in _global_manager._project_states.items():
+        debug_info[f"specific..inmemory!{client_session_id}"] = {
+            "project_folder_path": state.project_folder_path,
+            "is_git_repo": state.is_git_repo,
+            "git_branch": state.git_branch,
+            "git_status_summary": state.git_status_summary,
+            "git_detailed_status": {
+                "head_commit_hash": state.git_detailed_status.head_commit_hash,
+                "staged_changes": [
+                    {
+                        "file_repo_path": f.file_repo_path,
+                        "file_name": f.file_name,
+                        "file_abs_path": f.file_abs_path,
+                        "change_type": f.change_type,
+                        "content_hash": f.content_hash,
+                        "is_staged": f.is_staged,
+                        "diff_details": {
+                            "diffs": f.diff_details.diffs if f.diff_details else [],
+                            "stats": {
+                                "char_additions": f.diff_details.stats.char_additions if f.diff_details else 0,
+                                "char_deletions": f.diff_details.stats.char_deletions if f.diff_details else 0,
+                                "char_unchanged": f.diff_details.stats.char_unchanged if f.diff_details else 0,
+                                "total_changes": f.diff_details.stats.total_changes if f.diff_details else 0
+                            },
+                            "algorithm": f.diff_details.algorithm if f.diff_details else "diff-match-patch"
+                        }
+                    } for f in state.git_detailed_status.staged_changes
+                ],
+                "unstaged_changes": [
+                    {
+                        "file_repo_path": f.file_repo_path,
+                        "file_name": f.file_name,
+                        "file_abs_path": f.file_abs_path,
+                        "change_type": f.change_type,
+                        "content_hash": f.content_hash,
+                        "is_staged": f.is_staged,
+                        "diff_details": {
+                            "diffs": f.diff_details.diffs if f.diff_details else [],
+                            "stats": {
+                                "char_additions": f.diff_details.stats.char_additions if f.diff_details else 0,
+                                "char_deletions": f.diff_details.stats.char_deletions if f.diff_details else 0,
+                                "char_unchanged": f.diff_details.stats.char_unchanged if f.diff_details else 0,
+                                "total_changes": f.diff_details.stats.total_changes if f.diff_details else 0
+                            },
+                            "algorithm": f.diff_details.algorithm if f.diff_details else "diff-match-patch"
+                        }
+                    } for f in state.git_detailed_status.unstaged_changes
+                ],
+                "untracked_files": [
+                    {
+                        "file_repo_path": f.file_repo_path,
+                        "file_name": f.file_name,
+                        "file_abs_path": f.file_abs_path,
+                        "change_type": f.change_type,
+                        "content_hash": f.content_hash,
+                        "is_staged": f.is_staged,
+                        "diff_details": {
+                            "diffs": f.diff_details.diffs if f.diff_details else [],
+                            "stats": {
+                                "char_additions": f.diff_details.stats.char_additions if f.diff_details else 0,
+                                "char_deletions": f.diff_details.stats.char_deletions if f.diff_details else 0,
+                                "char_unchanged": f.diff_details.stats.char_unchanged if f.diff_details else 0,
+                                "total_changes": f.diff_details.stats.total_changes if f.diff_details else 0
+                            },
+                            "algorithm": f.diff_details.algorithm if f.diff_details else "diff-match-patch"
+                        }
+                    } for f in state.git_detailed_status.untracked_files
+                ]
+            },
+            "open_tabs": [
+                {
+                    "tab_id": tab.tab_id,
+                    "tab_type": tab.tab_type,
+                    "title": tab.title,
+                    "file_path": tab.file_path,
+                    "content": tab.content,
+                    "original_content": tab.original_content,
+                    "modified_content": tab.modified_content,
+                    "is_dirty": tab.is_dirty,
+                    "mime_type": tab.mime_type,
+                    "encoding": tab.encoding,
+                    "metadata": tab.metadata
+                } for tab in state.open_tabs
+            ],
+            "active_tab": None,  # Deprecated in centralized system
+            "monitored_folders": [
+                {
+                    "folder_path": folder.folder_path,
+                    "is_expanded": folder.is_expanded
+                } for folder in state.monitored_folders
+            ],
+            "items": [
+                {
+                    "name": item.name,
+                    "path": item.path,
+                    "is_directory": item.is_directory,
+                    "parent_path": item.parent_path,
+                    "size": item.size,
+                    "modified_time": item.modified_time,
+                    "is_git_tracked": item.is_git_tracked,
+                    "git_status": item.git_status,
+                    "is_staged": item.is_staged,
+                    "is_hidden": item.is_hidden,
+                    "is_ignored": item.is_ignored,
+                    "children": item.children,
+                    "is_expanded": item.is_expanded,
+                    "is_loaded": item.is_loaded
+                } for item in state.items
+            ]
+        }
+    
+    return debug_info

{portacode-0.3.20.dev7 → portacode-0.3.20.dev9}/portacode/connection/handlers/project_state/centralized_state.py

@@ -122,8 +122,19 @@ class CentralizedProjectState:
         
     # Open tabs properties
     @property
-    def open_tabs(self) -> Dict[str, TabInfo]:
+    def open_tabs(self) -> List[TabInfo]:
+        """Return open tabs as a list for backward compatibility."""
+        return list(self._open_tabs.values())
+        
+    @property
+    def open_tabs_dict(self) -> Dict[str, TabInfo]:
+        """Return open tabs as a dict (internal use)."""
         return self._open_tabs.copy()
+        
+    @property  
+    def active_tab(self) -> Optional[TabInfo]:
+        """Backward compatibility: active_tab is deprecated in centralized system."""
+        return None
     
     @property
     def state_version(self) -> int:
@@ -379,7 +390,7 @@ class StateNotificationManager:
                     "to_ref": tab.to_ref,
                     "from_hash": tab.from_hash,
                     "to_hash": tab.to_hash
-                } for tab in state.open_tabs.values()
+                } for tab in state.open_tabs_dict.values()
             ],
             "items": [
                 {

{portacode-0.3.20.dev7 → portacode-0.3.20.dev9}/portacode/connection/handlers/project_state/file_system_watcher.py

@@ -75,37 +75,11 @@ class FileSystemWatcher:
                     logger.info("🔍 [TRACE] Skipping opened/closed event: %s", event.event_type)
                     return
                 
-                # Handle .git folder events separately for git status monitoring
+                # Skip all .git folder events - git monitoring is handled by centralized periodic polling
                 path_parts = Path(event.src_path).parts
                 if '.git' in path_parts:
-                    logger.info("🔍 [TRACE] Processing .git folder event: %s", event.src_path)
-                    # Get the relative path within .git directory
-                    try:
-                        git_index = path_parts.index('.git')
-                        git_relative_path = '/'.join(path_parts[git_index + 1:])
-                        git_file = Path(event.src_path).name
-                        
-                        logger.info("🔍 [TRACE] Git file details - relative_path: %s, file: %s", git_relative_path, git_file)
-                        
-                        # Monitor git files that indicate repository state changes
-                        should_monitor_git_file = (
-                            git_file == 'index' or  # Staging area changes
-                            git_file == 'HEAD' or   # Branch switches
-                            git_relative_path.startswith('refs/heads/') or  # Branch updates
-                            git_relative_path.startswith('refs/remotes/') or  # Remote tracking branches
-                            git_relative_path.startswith('logs/refs/heads/') or  # Branch history
-                            git_relative_path.startswith('logs/HEAD') or  # HEAD history
-                            (git_file == 'index.lock' and event.event_type in ['moved', 'deleted'])  # Index updates via lock file
-                        )
-                        
-                        if should_monitor_git_file:
-                            logger.info("🔍 [TRACE] ✅ Git file matches monitoring criteria: %s", event.src_path)
-                        else:
-                            logger.info("🔍 [TRACE] ❌ Git file does NOT match monitoring criteria - SKIPPING: %s", event.src_path)
-                            return  # Skip other .git files
-                    except (ValueError, IndexError):
-                        logger.info("🔍 [TRACE] ❌ Could not parse .git path - SKIPPING: %s", event.src_path)
-                        return  # Skip if can't parse .git path
+                    logger.debug("Skipping .git folder event (centralized monitoring active): %s", event.src_path)
+                    return
                 else:
                     logger.info("🔍 [TRACE] Processing non-git file event: %s", event.src_path)
                     # Only log significant file changes, not every single event
@@ -157,24 +131,9 @@ class FileSystemWatcher:
     
     def start_watching_git_directory(self, git_path: str):
         """Start watching a .git directory for git status changes."""
-        if not WATCHDOG_AVAILABLE or not self.observer:
-            logger.warning("Watchdog not available, cannot start watching git directory: %s", git_path)
-            return
-        
-        if git_path not in self.watched_paths:
-            try:
-                # Watch .git directory recursively to catch changes in refs/, logs/, etc.
-                self.observer.schedule(self.event_handler, git_path, recursive=True)
-                self.watched_paths.add(git_path)
-                logger.info("Started watching git directory (recursive): %s", git_path)
-                
-                if not self.observer.is_alive():
-                    self.observer.start()
-                    logger.info("Started file system observer")
-            except Exception as e:
-                logger.error("Error starting git directory watcher for %s: %s", git_path, e)
-        else:
-            logger.debug("Git directory already being watched: %s", git_path)
+        # DISABLED: Git monitoring is now handled by centralized hash-based periodic polling
+        logger.debug("Git directory monitoring disabled - using centralized periodic polling: %s", git_path)
+        return
     
     def stop_watching(self, path: str):
         """Stop watching a specific path."""

{portacode-0.3.20.dev7 → portacode-0.3.20.dev9}/portacode/connection/handlers/project_state_handlers.py

@@ -29,10 +29,10 @@ from .project_state.centralized_handlers import (
     handle_centralized_client_session_cleanup as handle_client_session_cleanup
 )
 
-from .project_state.manager import (
-    get_or_create_project_state_manager,
-    reset_global_project_state_manager,
-    debug_global_manager_state
+from .project_state.centralized_manager import (
+    get_or_create_centralized_manager as get_or_create_project_state_manager,
+    reset_global_centralized_manager as reset_global_project_state_manager,
+    debug_global_centralized_manager_state as debug_global_manager_state
 )
 
 from .project_state.utils import generate_tab_key

{portacode-0.3.20.dev7 → portacode-0.3.20.dev9}/portacode.egg-info/PKG-INFO

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