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

portacode/connection/handlers/file_handlers.py

@@ -2,13 +2,17 @@
 
 import os
 import logging
-from typing import Any, Dict
+from typing import Any, Dict, List
 from pathlib import Path
 
 from .base import AsyncHandler, SyncHandler
+from .chunked_content import create_chunked_response
 
 logger = logging.getLogger(__name__)
 
+# Global content cache: hash -> content
+_content_cache = {}
+
 
 class FileReadHandler(SyncHandler):
     """Handler for reading file contents."""
@@ -365,4 +369,66 @@ class FileRenameHandler(SyncHandler):
         except PermissionError:
             raise RuntimeError(f"Permission denied: {old_path}")
         except OSError as e:
-            raise RuntimeError(f"Failed to rename: {e}")
+            raise RuntimeError(f"Failed to rename: {e}")
+
+
+class ContentRequestHandler(AsyncHandler):
+    """Handler for requesting content by hash for caching optimization."""
+    
+    @property
+    def command_name(self) -> str:
+        return "content_request"
+    
+    async def execute(self, message: Dict[str, Any]) -> None:
+        """Return content by hash if available, chunked for large content."""
+        content_hash = message.get("content_hash")
+        request_id = message.get("request_id")
+        source_client_session = message.get("source_client_session")
+        
+        if not content_hash:
+            raise ValueError("content_hash parameter is required")
+        if not request_id:
+            raise ValueError("request_id parameter is required")
+        
+        # Check if content is in cache
+        content = _content_cache.get(content_hash)
+        
+        if content is not None:
+            # Create base response
+            base_response = {
+                "event": "content_response",
+                "request_id": request_id,
+                "content_hash": content_hash,
+                "success": True,
+            }
+            
+            # Create chunked responses
+            responses = create_chunked_response(base_response, "content", content)
+            
+            # Send all responses
+            for response in responses:
+                await self.send_response(response, project_id=None)
+            
+            logger.info(f"Sent content response in {len(responses)} chunk(s) for hash: {content_hash[:16]}...")
+        else:
+            # Content not found in cache
+            response = {
+                "event": "content_response",
+                "request_id": request_id,
+                "content_hash": content_hash,
+                "content": None,
+                "success": False,
+                "error": "Content not found in cache",
+                "chunked": False,
+            }
+            await self.send_response(response, project_id=None)
+
+
+def cache_content(content_hash: str, content: str) -> None:
+    """Cache content by hash for future retrieval."""
+    _content_cache[content_hash] = content
+
+
+def get_cached_content(content_hash: str) -> str:
+    """Get cached content by hash."""
+    return _content_cache.get(content_hash)

portacode/connection/handlers/project_aware_file_handlers.py

@@ -70,4 +70,146 @@ class ProjectAwareFileWriteHandler(SyncHandler):
         except PermissionError:
             raise RuntimeError(f"Permission denied: {file_path}")
         except OSError as e:
-            raise RuntimeError(f"Failed to write file: {e}")
+            raise RuntimeError(f"Failed to write file: {e}")
+
+
+class ProjectAwareFileCreateHandler(SyncHandler):
+    """Handler for creating new files that updates project state."""
+    
+    @property
+    def command_name(self) -> str:
+        return "file_create"
+    
+    def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        """Create a new file and refresh project state."""
+        parent_path = message.get("parent_path")
+        file_name = message.get("file_name")
+        content = message.get("content", "")
+        
+        if not parent_path:
+            raise ValueError("parent_path parameter is required")
+        if not file_name:
+            raise ValueError("file_name parameter is required")
+        
+        # Validate file name (no path separators or special chars)
+        if "/" in file_name or "\\" in file_name or file_name in [".", ".."]:
+            raise ValueError("Invalid file name")
+        
+        try:
+            # Ensure parent directory exists
+            parent_dir = Path(parent_path)
+            if not parent_dir.exists():
+                raise ValueError(f"Parent directory does not exist: {parent_path}")
+            if not parent_dir.is_dir():
+                raise ValueError(f"Parent path is not a directory: {parent_path}")
+            
+            # Create the full file path
+            file_path = parent_dir / file_name
+            
+            # Check if file already exists
+            if file_path.exists():
+                raise ValueError(f"File already exists: {file_name}")
+            
+            # Create the file
+            with open(file_path, 'w', encoding='utf-8') as f:
+                f.write(content)
+            
+            # Trigger project state refresh
+            try:
+                manager = get_or_create_project_state_manager(self.context, self.control_channel)
+                
+                # Schedule the refresh (don't await since this is sync handler)
+                import asyncio
+                try:
+                    loop = asyncio.get_event_loop()
+                    if loop.is_running():
+                        loop.create_task(manager.refresh_project_state_for_file_change(str(file_path)))
+                        logger.info(f"Scheduled project state refresh after file creation: {file_path}")
+                except Exception as e:
+                    logger.warning(f"Could not schedule project state refresh: {e}")
+                        
+            except Exception as e:
+                logger.warning(f"Failed to refresh project state after file creation: {e}")
+                # Don't fail the file creation just because project state refresh failed
+            
+            return {
+                "event": "file_create_response",
+                "parent_path": parent_path,
+                "file_name": file_name,
+                "file_path": str(file_path),
+                "success": True,
+            }
+        except PermissionError:
+            raise RuntimeError(f"Permission denied: {parent_path}")
+        except OSError as e:
+            raise RuntimeError(f"Failed to create file: {e}")
+
+
+class ProjectAwareFolderCreateHandler(SyncHandler):
+    """Handler for creating new folders that updates project state."""
+    
+    @property
+    def command_name(self) -> str:
+        return "folder_create"
+    
+    def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        """Create a new folder and refresh project state."""
+        parent_path = message.get("parent_path")
+        folder_name = message.get("folder_name")
+        
+        if not parent_path:
+            raise ValueError("parent_path parameter is required")
+        if not folder_name:
+            raise ValueError("folder_name parameter is required")
+        
+        # Validate folder name (no path separators or special chars)
+        if "/" in folder_name or "\\" in folder_name or folder_name in [".", ".."]:
+            raise ValueError("Invalid folder name")
+        
+        try:
+            # Ensure parent directory exists
+            parent_dir = Path(parent_path)
+            if not parent_dir.exists():
+                raise ValueError(f"Parent directory does not exist: {parent_path}")
+            if not parent_dir.is_dir():
+                raise ValueError(f"Parent path is not a directory: {parent_path}")
+            
+            # Create the full folder path
+            folder_path = parent_dir / folder_name
+            
+            # Check if folder already exists
+            if folder_path.exists():
+                raise ValueError(f"Folder already exists: {folder_name}")
+            
+            # Create the folder
+            folder_path.mkdir(parents=False, exist_ok=False)
+            
+            # Trigger project state refresh
+            try:
+                manager = get_or_create_project_state_manager(self.context, self.control_channel)
+                
+                # Schedule the refresh (don't await since this is sync handler)
+                import asyncio
+                try:
+                    loop = asyncio.get_event_loop()
+                    if loop.is_running():
+                        loop.create_task(manager.refresh_project_state_for_file_change(str(folder_path)))
+                        logger.info(f"Scheduled project state refresh after folder creation: {folder_path}")
+                except Exception as e:
+                    logger.warning(f"Could not schedule project state refresh: {e}")
+                        
+            except Exception as e:
+                logger.warning(f"Failed to refresh project state after folder creation: {e}")
+                # Don't fail the folder creation just because project state refresh failed
+            
+            return {
+                "event": "folder_create_response",
+                "parent_path": parent_path,
+                "folder_name": folder_name,
+                "folder_path": str(folder_path),
+                "success": True,
+            }
+        except PermissionError:
+            raise RuntimeError(f"Permission denied: {parent_path}")
+        except OSError as e:
+            raise RuntimeError(f"Failed to create folder: {e}")