portacode 1.3.32__py3-none-any.whl → 1.4.11.dev0__py3-none-any.whl

portacode/connection/handlers/project_aware_file_handlers.py

@@ -22,6 +22,17 @@ class ProjectAwareFileWriteHandler(SyncHandler):
         """Write file contents and update project state tabs."""
         file_path = message.get("path")
         content = message.get("content", "")
+        # Optimistic lock: ensure the client saw the correct file state
+        expected_mtime = message.get("expected_mtime")
+        if expected_mtime is not None:
+            try:
+                current_mtime = os.path.getmtime(file_path)
+            except FileNotFoundError:
+                raise ValueError(f"File not found: {file_path}")
+            if current_mtime != expected_mtime:
+                raise ValueError(
+                    f"File was modified on disk (current {current_mtime} != expected {expected_mtime})"
+                )
         
         if not file_path:
             raise ValueError("path parameter is required")

portacode/connection/handlers/project_state/file_system_watcher.py

@@ -71,50 +71,29 @@ class FileSystemWatcher:
                     return
                 
                 # Only process events that represent actual content changes
-                # Skip opened/closed events that don't indicate file modifications
-                if event.event_type in ('opened', 'closed'):
-                    logger.debug("🔍 [TRACE] Skipping opened/closed event: %s", event.event_type)
+                # Skip events that indicate read-only access or metadata churn
+                significant_event_types = {'modified', 'created', 'deleted', 'moved', 'closed_write'}
+                if event.event_type not in significant_event_types:
+                    logger.debug("🔍 [TRACE] Skipping non-content event: %s", event.event_type)
+                    return
+                
+                # Reading directory contents during refresh generates metadata-only "modified" events.
+                if event.is_directory and event.event_type == 'modified':
+                    logger.debug("🔍 [TRACE] Skipping directory metadata change: %s", event.src_path)
                     return
                 
                 # Handle .git folder events separately for git status monitoring
                 path_parts = Path(event.src_path).parts
                 if '.git' in path_parts:
-                    logger.debug("🔍 [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.debug("🔍 [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 == 'index.lock' or  # Staging operations in progress
-                            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_relative_path.startswith('objects/') and event.event_type in ('created', 'modified')  # New objects (commits, blobs)
-                        )
-                        
-                        if should_monitor_git_file:
-                            logger.debug("🔍 [TRACE] ✅ Git file matches monitoring criteria: %s", event.src_path)
-                        else:
-                            logger.debug("🔍 [TRACE] ❌ Git file does NOT match monitoring criteria - SKIPPING: %s", event.src_path)
-                            return  # Skip other .git files
-                    except (ValueError, IndexError):
-                        logger.debug("🔍 [TRACE] ❌ Could not parse .git path - SKIPPING: %s", event.src_path)
-                        return  # Skip if can't parse .git path
+                    logger.debug("🔍 [TRACE] Skipping .git folder event entirely: %s", event.src_path)
+                    return
+                
+                logger.debug("🔍 [TRACE] Processing non-git file event: %s", event.src_path)
+                # Only log significant file changes, not every single event
+                if event.event_type in ['created', 'deleted'] or event.src_path.endswith(('.py', '.js', '.html', '.css', '.json', '.md')):
+                    logger.debug("File system event: %s - %s", event.event_type, os.path.basename(event.src_path))
                 else:
-                    logger.debug("🔍 [TRACE] Processing non-git file event: %s", event.src_path)
-                    # Only log significant file changes, not every single event
-                    if event.event_type in ['created', 'deleted'] or event.src_path.endswith(('.py', '.js', '.html', '.css', '.json', '.md')):
-                        logger.debug("File system event: %s - %s", event.event_type, os.path.basename(event.src_path))
-                    else:
-                        logger.debug("File event: %s", os.path.basename(event.src_path))
+                    logger.debug("File event: %s", os.path.basename(event.src_path))
                 
                 # Schedule async task in the main event loop from this watchdog thread
                 logger.debug("🔍 [TRACE] About to schedule async handler - event_loop exists: %s, closed: %s", 
@@ -142,6 +121,11 @@ class FileSystemWatcher:
             logger.warning("Watchdog not available, cannot start watching: %s", path)
             return
 
+        normalized_name = Path(path).name
+        if normalized_name == '.git':
+            logger.debug("Skipping watch for .git path: %s", path)
+            return
+
         if path not in self.watched_paths:
             try:
                 # Use recursive=False to watch only direct contents of each folder
@@ -158,28 +142,6 @@ class FileSystemWatcher:
         else:
             logger.debug("Path already being watched: %s", path)
     
-    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.
-                watch_handle = self.observer.schedule(self.event_handler, git_path, recursive=True)
-                self.watched_paths.add(git_path)
-                self.watch_handles[git_path] = watch_handle  # Store handle for cleanup
-                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)
-    
     def stop_watching(self, path: str):
         """Stop watching a specific path."""
         if not WATCHDOG_AVAILABLE or not self.observer:
@@ -206,4 +168,12 @@ class FileSystemWatcher:
             self.observer.stop()
             self.observer.join()
             self.watched_paths.clear()
-            self.watch_handles.clear()
+            self.watch_handles.clear()
+
+    def get_diagnostics(self) -> dict:
+        """Return lightweight stats for health monitoring."""
+        return {
+            "watched_paths": len(self.watched_paths),
+            "git_watched_paths": len([path for path in self.watched_paths if path.endswith(".git")]),
+            "observer_alive": bool(self.observer and self.observer.is_alive()),
+        }