mcp-code-indexer 4.0.1__py3-none-any.whl → 4.1.0__py3-none-any.whl

mcp_code_indexer/transport/base.py

@@ -7,7 +7,7 @@ Provides common interface and functionality for different transport methods.
 import asyncio
 import logging
 from abc import ABC, abstractmethod
-from typing import Any, Optional
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
@@ -15,66 +15,68 @@ logger = logging.getLogger(__name__)
 class Transport(ABC):
     """
     Abstract base class for MCP transport implementations.
-    
+
     Defines the common interface that all transports must implement
     to work with the MCPCodeIndexServer.
     """
-    
+
     def __init__(self, server_instance: Any):
         """
         Initialize transport with server instance.
-        
+
         Args:
             server_instance: The MCPCodeIndexServer instance
         """
         self.server = server_instance
         self.logger = logger.getChild(self.__class__.__name__)
-        
+
     @abstractmethod
     async def run(self) -> None:
         """
         Run the transport server.
-        
+
         This method should handle the main server loop and connection
         management for the specific transport type.
         """
         pass
-    
+
     async def initialize(self) -> None:
         """
         Initialize transport-specific resources.
-        
+
         Called before run() to set up any transport-specific state.
         Default implementation does nothing.
         """
         pass
-    
+
     async def cleanup(self) -> None:
         """
         Clean up transport-specific resources.
-        
+
         Called when shutting down to clean up connections and resources.
         Default implementation does nothing.
         """
         pass
-    
-    async def _run_with_retry(self, max_retries: int = 3, base_delay: float = 1.0) -> None:
+
+    async def _run_with_retry(
+        self, max_retries: int = 3, base_delay: float = 1.0
+    ) -> None:
         """
         Run transport with exponential backoff retry logic.
-        
+
         Args:
             max_retries: Maximum number of retry attempts
             base_delay: Base delay between retries in seconds
         """
         retry_count = 0
-        
+
         while retry_count <= max_retries:
             try:
                 await self.run()
                 break
             except Exception as e:
                 retry_count += 1
-                
+
                 if retry_count > max_retries:
                     self.logger.error(
                         "Transport failed after %d attempts",
@@ -88,7 +90,7 @@ class Transport(ABC):
                         },
                     )
                     raise
-                
+
                 delay = base_delay * (2 ** (retry_count - 1))
                 self.logger.warning(
                     "Transport failed, retrying in %.1f seconds (attempt %d/%d)",
@@ -104,5 +106,5 @@ class Transport(ABC):
                         }
                     },
                 )
-                
+
                 await asyncio.sleep(delay)

mcp_code_indexer/transport/http_transport.py

@@ -8,17 +8,16 @@ Server-Sent Events for streaming responses.
 import asyncio
 import json
 import logging
-import uuid
 from contextlib import asynccontextmanager
-from typing import Any, Dict, List, Optional
+from typing import Any, AsyncGenerator, Dict, List, Optional
 
 try:
-    from fastapi import FastAPI, HTTPException, Request, Depends
-    from fastapi.responses import StreamingResponse
+    import uvicorn
+    from fastapi import Depends, FastAPI, HTTPException
     from fastapi.middleware.cors import CORSMiddleware
-    from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+    from fastapi.responses import StreamingResponse
+    from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
     from pydantic import BaseModel, ValidationError
-    import uvicorn
 except ImportError as e:
     raise ImportError(
         "HTTP transport dependencies not installed. "
@@ -26,18 +25,19 @@ except ImportError as e:
         "Please reinstall mcp-code-indexer."
     ) from e
 
-from .base import Transport
+from ..middleware.auth import HTTPAuthMiddleware
 
 # Import middleware
 from ..middleware.logging import HTTPLoggingMiddleware, HTTPMetricsCollector
-from ..middleware.auth import HTTPAuthMiddleware
 from ..middleware.security import HTTPSecurityMiddleware
+from .base import Transport
 
 logger = logging.getLogger(__name__)
 
 
 class MCPRequest(BaseModel):
     """MCP JSON-RPC request model."""
+
     jsonrpc: str = "2.0"
     method: str
     params: Dict[str, Any]
@@ -46,6 +46,7 @@ class MCPRequest(BaseModel):
 
 class MCPResponse(BaseModel):
     """MCP JSON-RPC response model."""
+
     jsonrpc: str = "2.0"
     result: Optional[Any] = None
     error: Optional[Dict[str, Any]] = None
@@ -55,11 +56,11 @@ class MCPResponse(BaseModel):
 class HTTPTransport(Transport):
     """
     HTTP transport implementation using FastAPI.
-    
+
     Provides REST API endpoints for MCP tools with optional authentication
     and Server-Sent Events for streaming responses.
     """
-    
+
     def __init__(
         self,
         server_instance: Any,
@@ -70,7 +71,7 @@ class HTTPTransport(Transport):
     ):
         """
         Initialize HTTP transport.
-        
+
         Args:
             server_instance: The MCPCodeIndexServer instance
             host: Host to bind the server to
@@ -83,26 +84,26 @@ class HTTPTransport(Transport):
         self.port = port
         self.auth_token = auth_token
         self.cors_origins = cors_origins or ["*"]
-        
+
         # Connection management
         self.active_connections: Dict[str, asyncio.Queue] = {}
         self.app: Optional[FastAPI] = None
-        
+
         # Metrics collection
         self.metrics = HTTPMetricsCollector()
-        
+
     async def initialize(self) -> None:
         """Initialize FastAPI application and routes."""
         self.app = await self._create_app()
-        
+
     @asynccontextmanager
-    async def _lifespan(self, app: FastAPI):
+    async def _lifespan(self, app: FastAPI) -> AsyncGenerator[None, None]:
         """FastAPI lifespan context manager."""
         self.logger.info("HTTP transport starting up")
         yield
         self.logger.info("HTTP transport shutting down")
         await self.cleanup()
-        
+
     async def _create_app(self) -> FastAPI:
         """Create and configure FastAPI application."""
         app = FastAPI(
@@ -111,23 +112,23 @@ class HTTPTransport(Transport):
             version="1.0.0",
             lifespan=self._lifespan,
         )
-        
+
         # Add middleware stack (in reverse order of execution)
-        
+
         # Security middleware (outermost)
         app.add_middleware(HTTPSecurityMiddleware)
-        
+
         # Logging middleware
         app.add_middleware(HTTPLoggingMiddleware)
-        
+
         # Authentication middleware
         if self.auth_token:
             app.add_middleware(
                 HTTPAuthMiddleware,
                 auth_token=self.auth_token,
-                public_paths=["/health", "/docs", "/openapi.json", "/metrics"]
+                public_paths=["/health", "/docs", "/openapi.json", "/metrics"],
             )
-        
+
         # CORS middleware (innermost, applied first)
         app.add_middleware(
             CORSMiddleware,
@@ -136,62 +137,64 @@ class HTTPTransport(Transport):
             allow_methods=["GET", "POST", "OPTIONS"],
             allow_headers=["*"],
         )
-        
+
         # Authentication dependency
         security = HTTPBearer(auto_error=False) if self.auth_token else None
-        
+
         async def verify_token(
-            credentials: Optional[HTTPAuthorizationCredentials] = Depends(security)
+            credentials: Optional[HTTPAuthorizationCredentials] = Depends(security),
         ) -> bool:
             """Verify Bearer token if authentication is enabled."""
             if not self.auth_token:
                 return True
-                
+
             if not credentials or credentials.credentials != self.auth_token:
                 raise HTTPException(
-                    status_code=401,
-                    detail="Invalid authentication token"
+                    status_code=401, detail="Invalid authentication token"
                 )
             return True
-        
+
         @app.get("/health")
-        async def health_check():
+        async def health_check() -> Dict[str, str]:
             """Health check endpoint."""
             return {"status": "healthy", "transport": "http"}
-            
+
         @app.get("/metrics")
-        async def get_metrics(authenticated: bool = Depends(verify_token)):
+        async def get_metrics(
+            authenticated: bool = Depends(verify_token),
+        ) -> Dict[str, Any]:
             """Get HTTP transport metrics."""
             metrics = {}
-            
+
             metrics["http"] = self.metrics.get_metrics()
-            
+
             # Add connection stats
             metrics["connections"] = {
                 "active_sse_connections": len(self.active_connections),
                 "connection_ids": list(self.active_connections.keys()),
             }
-            
+
             return metrics
-            
+
         @app.get("/tools")
-        async def list_tools(authenticated: bool = Depends(verify_token)):
+        async def list_tools(
+            authenticated: bool = Depends(verify_token),
+        ) -> Dict[str, Any]:
             """List available MCP tools."""
             tools = await self.server._handle_list_tools()
             return {"tools": tools}
-            
+
         @app.post("/mcp", response_model=MCPResponse)
         async def handle_mcp_request(
-            request: MCPRequest,
-            authenticated: bool = Depends(verify_token)
-        ):
+            request: MCPRequest, authenticated: bool = Depends(verify_token)
+        ) -> MCPResponse:
             """Handle MCP JSON-RPC requests."""
             try:
                 # Route to appropriate tool handler
                 if request.method == "tools/call":
                     tool_name = request.params.get("name")
                     tool_arguments = request.params.get("arguments", {})
-                    
+
                     # Map tool names to handler methods
                     tool_handlers = {
                         "get_file_description": self.server._handle_get_file_description,
@@ -206,28 +209,34 @@ class HTTPTransport(Transport):
                         "search_codebase_overview": self.server._handle_search_codebase_overview,
                         "check_database_health": self.server._handle_check_database_health,
                     }
-                    
+
                     if tool_name not in tool_handlers:
                         return MCPResponse(
                             id=request.id,
-                            error={"code": -32601, "message": f"Unknown tool: {tool_name}"}
+                            error={
+                                "code": -32601,
+                                "message": f"Unknown tool: {tool_name}",
+                            },
                         )
-                    
+
                     # Execute tool handler
                     result = await tool_handlers[tool_name](tool_arguments)
-                    
+
                     return MCPResponse(id=request.id, result=result)
-                    
+
                 else:
                     return MCPResponse(
                         id=request.id,
-                        error={"code": -32601, "message": f"Unknown method: {request.method}"}
+                        error={
+                            "code": -32601,
+                            "message": f"Unknown method: {request.method}",
+                        },
                     )
-                    
+
             except ValidationError as e:
                 return MCPResponse(
                     id=request.id,
-                    error={"code": -32602, "message": f"Invalid params: {str(e)}"}
+                    error={"code": -32602, "message": f"Invalid params: {str(e)}"},
                 )
             except Exception as e:
                 self.logger.error(
@@ -242,56 +251,58 @@ class HTTPTransport(Transport):
                 )
                 return MCPResponse(
                     id=request.id,
-                    error={"code": -32603, "message": f"Internal error: {str(e)}"}
+                    error={"code": -32603, "message": f"Internal error: {str(e)}"},
                 )
-        
+
         @app.get("/events/{connection_id}")
         async def server_sent_events(
-            connection_id: str,
-            authenticated: bool = Depends(verify_token)
-        ):
+            connection_id: str, authenticated: bool = Depends(verify_token)
+        ) -> Any:
             """Server-Sent Events endpoint for streaming responses."""
-            async def event_stream():
+
+            async def event_stream() -> AsyncGenerator[str, None]:
                 # Create connection queue
-                queue = asyncio.Queue()
+                queue: asyncio.Queue[Dict[str, Any]] = asyncio.Queue()
                 self.active_connections[connection_id] = queue
-                
+
                 try:
                     while True:
                         # Wait for events from the queue
                         try:
-                            event_data = await asyncio.wait_for(queue.get(), timeout=30.0)
+                            event_data = await asyncio.wait_for(
+                                queue.get(), timeout=30.0
+                            )
                             yield f"data: {json.dumps(event_data)}\\n\\n"
                         except asyncio.TimeoutError:
                             # Send keepalive
                             yield f"data: {json.dumps({'type': 'keepalive'})}\\n\\n"
-                            
+
                 except asyncio.CancelledError:
                     pass
                 finally:
                     # Clean up connection
                     self.active_connections.pop(connection_id, None)
-            
+
             return StreamingResponse(
                 event_stream(),
                 media_type="text/event-stream",
                 headers={
                     "Cache-Control": "no-cache",
                     "Connection": "keep-alive",
-                }
+                },
             )
-        
+
         return app
-    
+
     async def run(self) -> None:
         """
         Run the HTTP transport server.
-        
+
         Starts the uvicorn ASGI server with the configured FastAPI application.
         """
         if not self.app:
             await self.initialize()
-            
+
         self.logger.info(
             "Starting HTTP transport",
             extra={
@@ -304,8 +315,10 @@ class HTTPTransport(Transport):
                 }
             },
         )
-        
+
         # Configure uvicorn
+        if not self.app:
+            raise RuntimeError("FastAPI app not initialized")
         config = uvicorn.Config(
             app=self.app,
             host=self.host,
@@ -314,9 +327,9 @@ class HTTPTransport(Transport):
             access_log=True,
             loop="asyncio",
         )
-        
+
         server = uvicorn.Server(config)
-        
+
         try:
             await server.serve()
         except Exception as e:
@@ -330,7 +343,7 @@ class HTTPTransport(Transport):
                 },
             )
             raise
-    
+
     async def cleanup(self) -> None:
         """Clean up HTTP transport resources."""
         # Close all active SSE connections
@@ -339,24 +352,24 @@ class HTTPTransport(Transport):
                 await queue.put({"type": "disconnect"})
             except Exception as e:
                 self.logger.warning(f"Error closing connection {connection_id}: {e}")
-        
+
         self.active_connections.clear()
         self.logger.info("HTTP transport cleanup completed")
-    
+
     async def send_event(self, connection_id: str, event_data: Dict[str, Any]) -> bool:
         """
         Send an event to a specific SSE connection.
-        
+
         Args:
             connection_id: Connection identifier
             event_data: Event data to send
-            
+
         Returns:
             True if event was sent successfully, False otherwise
         """
         if connection_id not in self.active_connections:
             return False
-            
+
         try:
             await self.active_connections[connection_id].put(event_data)
             return True

mcp_code_indexer/transport/stdio_transport.py

@@ -19,24 +19,24 @@ logger = logging.getLogger(__name__)
 class StdioTransport(Transport):
     """
     Stdio transport implementation using MCP's built-in stdio server.
-    
+
     This transport maintains compatibility with the existing stdio-based
     MCP protocol while fitting into the transport abstraction.
     """
-    
+
     def __init__(self, server_instance: Any):
         """
         Initialize stdio transport.
-        
+
         Args:
             server_instance: The MCPCodeIndexServer instance
         """
         super().__init__(server_instance)
-        
+
     async def run(self) -> None:
         """
         Run the stdio transport server.
-        
+
         Uses the mcp library's stdio_server context manager to handle
         JSON-RPC communication over stdin/stdout with retry logic.
         """
@@ -49,7 +49,7 @@ class StdioTransport(Transport):
                 }
             },
         )
-        
+
         max_retries = 5
         base_delay = 2.0  # seconds
 
@@ -59,8 +59,12 @@ class StdioTransport(Transport):
                     self.logger.info(
                         f"stdio_server context established (attempt {attempt + 1})"
                     )
-                    initialization_options = self.server.server.create_initialization_options()
-                    self.logger.debug(f"Initialization options: {initialization_options}")
+                    initialization_options = (
+                        self.server.server.create_initialization_options()
+                    )
+                    self.logger.debug(
+                        f"Initialization options: {initialization_options}"
+                    )
 
                     await self.server._run_session_with_retry(
                         read_stream, write_stream, initialization_options

mcp_code_indexer/vector_mode/__init__.py

@@ -0,0 +1,36 @@
+"""
+Vector Mode for MCP Code Indexer.
+
+This package provides semantic search capabilities using embeddings and vector databases.
+Includes automated file monitoring, AST-based code chunking, and secure embedding generation.
+"""
+
+from typing import Optional
+from pathlib import Path
+import os
+
+__version__ = "1.0.0"
+
+def is_vector_mode_available() -> bool:
+    """Check if vector mode dependencies are available."""
+    try:
+        import voyage
+        import turbopuffer
+        import tree_sitter
+        import watchdog
+        return True
+    except ImportError:
+        return False
+
+def get_vector_config_path() -> Path:
+    """Get path to vector mode configuration."""
+    config_dir = Path.home() / ".mcp-code-index" / "vector"
+    config_dir.mkdir(parents=True, exist_ok=True)
+    return config_dir / "config.yaml"
+
+def check_api_keys() -> dict[str, bool]:
+    """Check availability of required API keys."""
+    return {
+        "voyage": os.getenv("VOYAGE_API_KEY") is not None,
+        "turbopuffer": os.getenv("TURBOPUFFER_API_KEY") is not None,
+    }

mcp_code_indexer/vector_mode/chunking/__init__.py

@@ -0,0 +1,19 @@
+"""
+AST-based code chunking for vector mode.
+
+Provides semantic code chunking using Tree-sitter parsers to extract
+meaningful code units for embedding generation.
+"""
+
+from .ast_chunker import ASTChunker, CodeChunk
+from .language_handlers import LanguageHandler, get_language_handler
+from .chunk_optimizer import ChunkOptimizer, OptimizedChunk
+
+__all__ = [
+    "ASTChunker",
+    "CodeChunk", 
+    "LanguageHandler",
+    "get_language_handler",
+    "ChunkOptimizer",
+    "OptimizedChunk",
+]