mcp-code-indexer 1.0.0__py3-none-any.whl

mcp_code_indexer/merge_handler.py

@@ -0,0 +1,386 @@
+"""
+Two-phase merge functionality for branch descriptions.
+
+This module implements conflict detection and resolution for merging
+file descriptions between branches with AI-assisted conflict resolution.
+"""
+
+import logging
+from datetime import datetime
+from typing import Dict, List, Optional, Tuple
+from uuid import uuid4
+
+from mcp_code_indexer.database.database import DatabaseManager
+from mcp_code_indexer.database.models import FileDescription
+from mcp_code_indexer.error_handler import ValidationError, DatabaseError
+from mcp_code_indexer.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+class MergeConflict:
+    """Represents a merge conflict between file descriptions."""
+    
+    def __init__(
+        self,
+        file_path: str,
+        source_branch: str,
+        target_branch: str,
+        source_description: str,
+        target_description: str,
+        conflict_id: Optional[str] = None
+    ):
+        """
+        Initialize merge conflict.
+        
+        Args:
+            file_path: Path to conflicted file
+            source_branch: Branch being merged from
+            target_branch: Branch being merged into
+            source_description: Description from source branch
+            target_description: Description from target branch
+            conflict_id: Optional conflict identifier
+        """
+        self.file_path = file_path
+        self.source_branch = source_branch
+        self.target_branch = target_branch
+        self.source_description = source_description
+        self.target_description = target_description
+        self.conflict_id = conflict_id or str(uuid4())
+        self.resolution: Optional[str] = None
+    
+    def to_dict(self) -> Dict:
+        """Convert conflict to dictionary representation."""
+        return {
+            "conflictId": self.conflict_id,
+            "filePath": self.file_path,
+            "sourceBranch": self.source_branch,
+            "targetBranch": self.target_branch,
+            "sourceDescription": self.source_description,
+            "targetDescription": self.target_description,
+            "resolution": self.resolution
+        }
+
+
+class MergeSession:
+    """Manages a merge session with conflicts and resolutions."""
+    
+    def __init__(self, project_id: str, source_branch: str, target_branch: str):
+        """
+        Initialize merge session.
+        
+        Args:
+            project_id: Project identifier
+            source_branch: Branch being merged from
+            target_branch: Branch being merged into
+        """
+        self.session_id = str(uuid4())
+        self.project_id = project_id
+        self.source_branch = source_branch
+        self.target_branch = target_branch
+        self.conflicts: List[MergeConflict] = []
+        self.created = datetime.utcnow()
+        self.status = "pending"  # pending, resolved, aborted
+    
+    def add_conflict(self, conflict: MergeConflict) -> None:
+        """Add a conflict to the session."""
+        self.conflicts.append(conflict)
+    
+    def get_conflict_count(self) -> int:
+        """Get total number of conflicts."""
+        return len(self.conflicts)
+    
+    def get_resolved_count(self) -> int:
+        """Get number of resolved conflicts."""
+        return len([c for c in self.conflicts if c.resolution is not None])
+    
+    def is_fully_resolved(self) -> bool:
+        """Check if all conflicts are resolved."""
+        return self.get_resolved_count() == self.get_conflict_count()
+    
+    def to_dict(self) -> Dict:
+        """Convert session to dictionary representation."""
+        return {
+            "sessionId": self.session_id,
+            "projectId": self.project_id,
+            "sourceBranch": self.source_branch,
+            "targetBranch": self.target_branch,
+            "totalConflicts": self.get_conflict_count(),
+            "resolvedConflicts": self.get_resolved_count(),
+            "isFullyResolved": self.is_fully_resolved(),
+            "created": self.created.isoformat(),
+            "status": self.status,
+            "conflicts": [conflict.to_dict() for conflict in self.conflicts]
+        }
+
+
+class MergeHandler:
+    """
+    Handles two-phase merge operations for file descriptions.
+    
+    Phase 1: Detect conflicts between source and target branches
+    Phase 2: Apply resolutions and complete merge
+    """
+    
+    def __init__(self, db_manager: DatabaseManager):
+        """
+        Initialize merge handler.
+        
+        Args:
+            db_manager: Database manager instance
+        """
+        self.db_manager = db_manager
+        self._active_sessions: Dict[str, MergeSession] = {}
+    
+    async def start_merge_phase1(
+        self,
+        project_id: str,
+        source_branch: str,
+        target_branch: str
+    ) -> MergeSession:
+        """
+        Phase 1: Detect merge conflicts.
+        
+        Args:
+            project_id: Project identifier
+            source_branch: Branch to merge from
+            target_branch: Branch to merge into
+            
+        Returns:
+            MergeSession with detected conflicts
+            
+        Raises:
+            ValidationError: If branches are invalid
+            DatabaseError: If database operation fails
+        """
+        if source_branch == target_branch:
+            raise ValidationError("Source and target branches cannot be the same")
+        
+        logger.info(f"Starting merge phase 1: {source_branch} -> {target_branch}")
+        
+        try:
+            # Get file descriptions from both branches
+            source_descriptions = await self.db_manager.get_all_file_descriptions(
+                project_id, source_branch
+            )
+            target_descriptions = await self.db_manager.get_all_file_descriptions(
+                project_id, target_branch
+            )
+            
+            # Create session
+            session = MergeSession(project_id, source_branch, target_branch)
+            
+            # Build lookup dictionaries
+            source_lookup = {desc.file_path: desc for desc in source_descriptions}
+            target_lookup = {desc.file_path: desc for desc in target_descriptions}
+            
+            # Detect conflicts
+            conflicts_found = 0
+            all_files = set(source_lookup.keys()) | set(target_lookup.keys())
+            
+            for file_path in all_files:
+                source_desc = source_lookup.get(file_path)
+                target_desc = target_lookup.get(file_path)
+                
+                # Conflict occurs when:
+                # 1. File exists in both branches with different descriptions
+                # 2. File has been modified in source but also exists in target
+                if source_desc and target_desc:
+                    if source_desc.description != target_desc.description:
+                        conflict = MergeConflict(
+                            file_path=file_path,
+                            source_branch=source_branch,
+                            target_branch=target_branch,
+                            source_description=source_desc.description,
+                            target_description=target_desc.description
+                        )
+                        session.add_conflict(conflict)
+                        conflicts_found += 1
+            
+            # Store session
+            self._active_sessions[session.session_id] = session
+            
+            logger.info(f"Merge phase 1 completed: {conflicts_found} conflicts found")
+            
+            return session
+            
+        except Exception as e:
+            logger.error(f"Error in merge phase 1: {e}")
+            raise DatabaseError(f"Failed to detect merge conflicts: {e}") from e
+    
+    async def complete_merge_phase2(
+        self,
+        session_id: str,
+        conflict_resolutions: List[Dict[str, str]]
+    ) -> Dict:
+        """
+        Phase 2: Apply resolutions and complete merge.
+        
+        Args:
+            session_id: Merge session identifier
+            conflict_resolutions: List of {conflictId, resolvedDescription}
+            
+        Returns:
+            Merge result summary
+            
+        Raises:
+            ValidationError: If session not found or resolutions invalid
+            DatabaseError: If database operation fails
+        """
+        session = self._active_sessions.get(session_id)
+        if not session:
+            raise ValidationError(f"Merge session not found: {session_id}")
+        
+        logger.info(f"Starting merge phase 2 for session {session_id}")
+        
+        try:
+            # Validate and apply resolutions
+            resolution_lookup = {res["conflictId"]: res["resolvedDescription"] 
+                               for res in conflict_resolutions}
+            
+            resolved_count = 0
+            for conflict in session.conflicts:
+                if conflict.conflict_id in resolution_lookup:
+                    conflict.resolution = resolution_lookup[conflict.conflict_id]
+                    resolved_count += 1
+            
+            # Check if all conflicts are resolved
+            if not session.is_fully_resolved():
+                unresolved = session.get_conflict_count() - session.get_resolved_count()
+                raise ValidationError(
+                    f"Not all conflicts resolved: {unresolved} remaining",
+                    details={
+                        "total_conflicts": session.get_conflict_count(),
+                        "resolved_conflicts": session.get_resolved_count(),
+                        "unresolved_conflicts": unresolved
+                    }
+                )
+            
+            # Apply merge
+            merged_descriptions = []
+            
+            # Get all descriptions from source branch
+            source_descriptions = await self.db_manager.get_all_file_descriptions(
+                session.project_id, session.source_branch
+            )
+            
+            # Get existing target descriptions
+            target_descriptions = await self.db_manager.get_all_file_descriptions(
+                session.project_id, session.target_branch
+            )
+            
+            target_lookup = {desc.file_path: desc for desc in target_descriptions}
+            
+            # Apply resolved descriptions
+            for source_desc in source_descriptions:
+                resolved_conflict = next(
+                    (c for c in session.conflicts if c.file_path == source_desc.file_path),
+                    None
+                )
+                
+                if resolved_conflict:
+                    # Use resolved description
+                    new_desc = FileDescription(
+                        project_id=session.project_id,
+                        branch=session.target_branch,
+                        file_path=source_desc.file_path,
+                        description=resolved_conflict.resolution,
+                        file_hash=source_desc.file_hash,
+                        last_modified=datetime.utcnow(),
+                        version=1,
+                        source_project_id=source_desc.source_project_id
+                    )
+                else:
+                    # No conflict, copy from source
+                    new_desc = FileDescription(
+                        project_id=session.project_id,
+                        branch=session.target_branch,
+                        file_path=source_desc.file_path,
+                        description=source_desc.description,
+                        file_hash=source_desc.file_hash,
+                        last_modified=datetime.utcnow(),
+                        version=1,
+                        source_project_id=source_desc.source_project_id
+                    )
+                
+                merged_descriptions.append(new_desc)
+            
+            # Batch update target branch
+            await self.db_manager.batch_create_file_descriptions(merged_descriptions)
+            
+            # Mark session as completed
+            session.status = "resolved"
+            
+            result = {
+                "success": True,
+                "sessionId": session_id,
+                "sourceBranch": session.source_branch,
+                "targetBranch": session.target_branch,
+                "totalConflicts": session.get_conflict_count(),
+                "resolvedConflicts": session.get_resolved_count(),
+                "mergedFiles": len(merged_descriptions),
+                "message": f"Successfully merged {len(merged_descriptions)} files from {session.source_branch} to {session.target_branch}"
+            }
+            
+            logger.info(f"Merge phase 2 completed successfully: {len(merged_descriptions)} files merged")
+            
+            # Clean up session
+            del self._active_sessions[session_id]
+            
+            return result
+            
+        except Exception as e:
+            if session:
+                session.status = "aborted"
+            logger.error(f"Error in merge phase 2: {e}")
+            raise DatabaseError(f"Failed to complete merge: {e}") from e
+    
+    def get_session(self, session_id: str) -> Optional[MergeSession]:
+        """Get merge session by ID."""
+        return self._active_sessions.get(session_id)
+    
+    def get_active_sessions(self) -> List[MergeSession]:
+        """Get all active merge sessions."""
+        return list(self._active_sessions.values())
+    
+    def abort_session(self, session_id: str) -> bool:
+        """
+        Abort a merge session.
+        
+        Args:
+            session_id: Session to abort
+            
+        Returns:
+            True if session was aborted
+        """
+        session = self._active_sessions.get(session_id)
+        if session:
+            session.status = "aborted"
+            del self._active_sessions[session_id]
+            logger.info(f"Merge session {session_id} aborted")
+            return True
+        return False
+    
+    def cleanup_old_sessions(self, max_age_hours: int = 24) -> int:
+        """
+        Clean up old merge sessions.
+        
+        Args:
+            max_age_hours: Maximum age of sessions to keep
+            
+        Returns:
+            Number of sessions cleaned up
+        """
+        cutoff_time = datetime.utcnow() - datetime.timedelta(hours=max_age_hours)
+        old_sessions = [
+            session_id for session_id, session in self._active_sessions.items()
+            if session.created < cutoff_time
+        ]
+        
+        for session_id in old_sessions:
+            del self._active_sessions[session_id]
+        
+        if old_sessions:
+            logger.info(f"Cleaned up {len(old_sessions)} old merge sessions")
+        
+        return len(old_sessions)

mcp_code_indexer/middleware/__init__.py

@@ -0,0 +1,7 @@
+"""
+Middleware components for the MCP Code Indexer.
+"""
+
+from .error_middleware import ToolMiddleware, AsyncTaskManager, create_tool_middleware
+
+__all__ = ["ToolMiddleware", "AsyncTaskManager", "create_tool_middleware"]

mcp_code_indexer/middleware/error_middleware.py

@@ -0,0 +1,286 @@
+"""
+Error handling middleware for MCP tools.
+
+This module provides decorators and middleware functions to standardize
+error handling across all MCP tool implementations.
+"""
+
+import asyncio
+import functools
+import time
+from typing import Any, Callable, Dict, List
+
+from mcp import types
+
+from mcp_code_indexer.error_handler import ErrorHandler, MCPError
+from mcp_code_indexer.logging_config import get_logger, log_tool_usage, log_performance_metrics
+
+logger = get_logger(__name__)
+
+
+class ToolMiddleware:
+    """Middleware for MCP tool error handling and logging."""
+    
+    def __init__(self, error_handler: ErrorHandler):
+        """Initialize middleware with error handler."""
+        self.error_handler = error_handler
+    
+    def wrap_tool_handler(self, tool_name: str):
+        """
+        Decorator to wrap tool handlers with error handling and logging.
+        
+        Args:
+            tool_name: Name of the MCP tool
+            
+        Returns:
+            Decorator function
+        """
+        def decorator(func: Callable) -> Callable:
+            @functools.wraps(func)
+            async def wrapper(arguments: Dict[str, Any]) -> List[types.TextContent]:
+                start_time = time.time()
+                success = False
+                result_size = 0
+                
+                try:
+                    # Log tool invocation
+                    logger.info(f"Tool {tool_name} called", extra={
+                        "structured_data": {
+                            "tool_invocation": {
+                                "tool_name": tool_name,
+                                "arguments_count": len(arguments)
+                            }
+                        }
+                    })
+                    
+                    # Call the actual tool handler
+                    result = await func(arguments)
+                    
+                    # Calculate result size
+                    if isinstance(result, list):
+                        result_size = sum(len(item.text) if hasattr(item, 'text') else 0 for item in result)
+                    
+                    success = True
+                    duration = time.time() - start_time
+                    
+                    # Log performance metrics
+                    log_performance_metrics(
+                        logger,
+                        f"tool_{tool_name}",
+                        duration,
+                        result_size=result_size,
+                        arguments_count=len(arguments)
+                    )
+                    
+                    return result
+                    
+                except Exception as e:
+                    duration = time.time() - start_time
+                    
+                    # Log the error
+                    self.error_handler.log_error(
+                        e,
+                        context={"arguments_count": len(arguments)},
+                        tool_name=tool_name
+                    )
+                    
+                    # Create error response
+                    error_response = self.error_handler.create_mcp_error_response(
+                        e, tool_name, arguments
+                    )
+                    
+                    return [error_response]
+                
+                finally:
+                    # Always log tool usage
+                    log_tool_usage(
+                        logger,
+                        tool_name,
+                        arguments,
+                        success,
+                        time.time() - start_time,
+                        result_size if success else None
+                    )
+            
+            return wrapper
+        return decorator
+    
+    def validate_tool_arguments(self, required_fields: List[str], optional_fields: List[str] = None):
+        """
+        Decorator to validate tool arguments.
+        
+        Args:
+            required_fields: List of required argument names
+            optional_fields: List of optional argument names
+            
+        Returns:
+            Decorator function
+        """
+        def decorator(func: Callable) -> Callable:
+            @functools.wraps(func)
+            async def wrapper(arguments: Dict[str, Any]) -> Any:
+                from ..error_handler import ValidationError
+                
+                # Check required fields
+                missing_fields = [field for field in required_fields if field not in arguments]
+                if missing_fields:
+                    raise ValidationError(
+                        f"Missing required fields: {', '.join(missing_fields)}",
+                        details={"missing_fields": missing_fields, "provided_fields": list(arguments.keys())}
+                    )
+                
+                # Check for unexpected fields if optional_fields is provided
+                if optional_fields is not None:
+                    all_fields = set(required_fields + optional_fields)
+                    unexpected_fields = [field for field in arguments.keys() if field not in all_fields]
+                    if unexpected_fields:
+                        raise ValidationError(
+                            f"Unexpected fields: {', '.join(unexpected_fields)}",
+                            details={"unexpected_fields": unexpected_fields, "allowed_fields": list(all_fields)}
+                        )
+                
+                return await func(arguments)
+            
+            return wrapper
+        return decorator
+
+
+class AsyncTaskManager:
+    """Manages async tasks with proper error handling."""
+    
+    def __init__(self, error_handler: ErrorHandler):
+        """Initialize task manager."""
+        self.error_handler = error_handler
+        self._tasks: List[asyncio.Task] = []
+    
+    def create_task(self, coro, name: str = None) -> asyncio.Task:
+        """
+        Create a managed async task.
+        
+        Args:
+            coro: Coroutine to run
+            name: Optional task name for logging
+            
+        Returns:
+            Created task
+        """
+        task = asyncio.create_task(coro, name=name)
+        self._tasks.append(task)
+        
+        # Add done callback for error handling
+        task.add_done_callback(
+            lambda t: asyncio.create_task(
+                self._handle_task_completion(t, name or "unnamed_task")
+            )
+        )
+        
+        return task
+    
+    async def _handle_task_completion(self, task: asyncio.Task, task_name: str) -> None:
+        """Handle task completion and errors."""
+        try:
+            if task.done() and not task.cancelled():
+                exception = task.exception()
+                if exception:
+                    await self.error_handler.handle_async_task_error(
+                        task, task_name
+                    )
+        except Exception as e:
+            logger.error(f"Error handling task completion for {task_name}: {e}")
+        finally:
+            # Remove completed task from tracking
+            if task in self._tasks:
+                self._tasks.remove(task)
+    
+    async def wait_for_all(self, timeout: float = None) -> None:
+        """
+        Wait for all managed tasks to complete.
+        
+        Args:
+            timeout: Maximum time to wait in seconds
+        """
+        if not self._tasks:
+            return
+        
+        try:
+            await asyncio.wait_for(
+                asyncio.gather(*self._tasks, return_exceptions=True),
+                timeout=timeout
+            )
+        except asyncio.TimeoutError:
+            logger.warning(f"Timeout waiting for {len(self._tasks)} tasks")
+            # Cancel remaining tasks
+            for task in self._tasks:
+                if not task.done():
+                    task.cancel()
+        except Exception as e:
+            logger.error(f"Error waiting for tasks: {e}")
+    
+    def cancel_all(self) -> None:
+        """Cancel all managed tasks."""
+        for task in self._tasks:
+            if not task.done():
+                task.cancel()
+        self._tasks.clear()
+    
+    @property
+    def active_task_count(self) -> int:
+        """Get count of active tasks."""
+        return len([task for task in self._tasks if not task.done()])
+
+
+def create_tool_middleware(error_handler: ErrorHandler) -> ToolMiddleware:
+    """
+    Create tool middleware instance.
+    
+    Args:
+        error_handler: Error handler instance
+        
+    Returns:
+        Configured ToolMiddleware
+    """
+    return ToolMiddleware(error_handler)
+
+
+# Convenience decorators for common patterns
+
+def require_fields(*required_fields):
+    """Decorator that requires specific fields in arguments."""
+    def decorator(func):
+        @functools.wraps(func)
+        async def wrapper(self, arguments: Dict[str, Any]):
+            from ..error_handler import ValidationError
+            
+            missing = [field for field in required_fields if field not in arguments]
+            if missing:
+                raise ValidationError(f"Missing required fields: {', '.join(missing)}")
+            
+            return await func(self, arguments)
+        return wrapper
+    return decorator
+
+
+def handle_file_operations(func):
+    """Decorator for file operation error handling."""
+    @functools.wraps(func)
+    async def wrapper(*args, **kwargs):
+        try:
+            return await func(*args, **kwargs)
+        except (FileNotFoundError, PermissionError, OSError) as e:
+            from ..error_handler import FileSystemError
+            raise FileSystemError(f"File operation failed: {e}") from e
+    return wrapper
+
+
+def handle_database_operations(func):
+    """Decorator for database operation error handling."""
+    @functools.wraps(func)
+    async def wrapper(*args, **kwargs):
+        try:
+            return await func(*args, **kwargs)
+        except Exception as e:
+            if any(keyword in str(e).lower() for keyword in ["database", "sqlite", "sql"]):
+                from ..error_handler import DatabaseError
+                raise DatabaseError(f"Database operation failed: {e}") from e
+            raise
+    return wrapper

mcp_code_indexer/server/__init__.py

@@ -0,0 +1 @@
+"""MCP server implementation modules."""