Add service layer for better code organization

Co-authored-by: Mte90 <403283+Mte90@users.noreply.github.com>

Author: Copilot

main.py

@@ -10,7 +10,7 @@
 from datetime import datetime
 
 from db import init_db, get_project_stats
-from analyzer import analyze_local_path_background, search_semantic, call_coding_model
+from analyzer import analyze_local_path_background, call_coding_model
 from config import CFG
 from projects import (
     get_project_by_id, list_projects,
@@ -22,6 +22,7 @@
 )
 from logger import get_logger
 from rate_limiter import query_limiter, indexing_limiter, general_limiter
+from services import ProjectService, SearchService
 
 logger = get_logger(__name__)
 
@@ -259,25 +260,18 @@ def api_query(http_request: Request, request: QueryRequest):
         )
 
     try:
-        project = get_project_by_id(request.project_id)
-        if not project:
-            return JSONResponse({"error": "Project not found"}, status_code=404)
-        
-        db_path = project["database_path"]
-        
-        # Check if project has been indexed
-        stats = get_project_stats(db_path)
-        if stats["file_count"] == 0:
-            return JSONResponse({"error": "Project not indexed yet"}, status_code=400)
-        
-        # Perform semantic search
-        results = search_semantic(request.query, db_path, top_k=request.top_k)
-        
-        return JSONResponse({
-            "results": results,
-            "project_id": request.project_id,
-            "query": request.query
-        })
+        # Use SearchService for better separation of concerns
+        result = SearchService.semantic_search(
+            project_id=request.project_id,
+            query=request.query,
+            top_k=request.top_k,
+            use_cache=True
+        )
+        return JSONResponse(result)
+    except ValueError as e:
+        # ValueError for not found or not indexed
+        logger.warning(f"Query validation failed: {e}")
+        return JSONResponse({"error": str(e)}, status_code=400)
     except Exception as e:
         logger.exception(f"Error querying project: {e}")
         return JSONResponse({"error": "Query failed"}, status_code=500)

services/__init__.py

@@ -0,0 +1,11 @@
+"""
+Service layer initialization.
+Provides high-level business logic separated from database operations.
+"""
+from .project_service import ProjectService
+from .search_service import SearchService
+
+__all__ = [
+    'ProjectService',
+    'SearchService',
+]

services/project_service.py

@@ -0,0 +1,181 @@
+"""
+Service layer for project operations.
+Separates business logic from database operations.
+"""
+import os
+from typing import Dict, Any, Optional
+from datetime import datetime
+
+from db import (
+    create_project as db_create_project,
+    get_project as db_get_project,
+    get_project_by_id as db_get_project_by_id,
+    list_projects as db_list_projects,
+    update_project_status as db_update_project_status,
+    delete_project as db_delete_project,
+    get_or_create_project as db_get_or_create_project,
+    get_project_stats,
+)
+from logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class ProjectService:
+    """
+    Service layer for project management operations.
+    Provides high-level business logic for projects.
+    """
+    
+    @staticmethod
+    def create_project(project_path: str, name: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Create a new project with validation.
+        
+        Args:
+            project_path: Path to project directory
+            name: Optional project name
+        
+        Returns:
+            Project metadata dictionary
+        
+        Raises:
+            ValueError: If path is invalid
+            RuntimeError: If creation fails
+        """
+        # Validate path
+        if not project_path:
+            raise ValueError("Project path cannot be empty")
+        
+        abs_path = os.path.abspath(project_path)
+        
+        if not os.path.exists(abs_path):
+            raise ValueError(f"Project path does not exist: {abs_path}")
+        
+        if not os.path.isdir(abs_path):
+            raise ValueError(f"Project path is not a directory: {abs_path}")
+        
+        # Create project
+        try:
+            project = db_create_project(abs_path, name)
+            logger.info(f"Created project {project['id']} at {abs_path}")
+            return project
+        except Exception as e:
+            logger.error(f"Failed to create project: {e}")
+            raise RuntimeError(f"Failed to create project: {e}") from e
+    
+    @staticmethod
+    def get_project(project_path: str) -> Optional[Dict[str, Any]]:
+        """Get project by path."""
+        return db_get_project(project_path)
+    
+    @staticmethod
+    def get_project_by_id(project_id: str) -> Optional[Dict[str, Any]]:
+        """Get project by ID."""
+        return db_get_project_by_id(project_id)
+    
+    @staticmethod
+    def list_all_projects() -> list:
+        """List all projects."""
+        return db_list_projects()
+    
+    @staticmethod
+    def delete_project(project_id: str) -> None:
+        """
+        Delete a project with validation.
+        
+        Args:
+            project_id: Project identifier
+        
+        Raises:
+            ValueError: If project not found
+        """
+        project = db_get_project_by_id(project_id)
+        if not project:
+            raise ValueError(f"Project not found: {project_id}")
+        
+        try:
+            db_delete_project(project_id)
+            logger.info(f"Deleted project {project_id}")
+        except Exception as e:
+            logger.error(f"Failed to delete project: {e}")
+            raise RuntimeError(f"Failed to delete project: {e}") from e
+    
+    @staticmethod
+    def update_status(project_id: str, status: str, timestamp: Optional[str] = None) -> None:
+        """
+        Update project status.
+        
+        Args:
+            project_id: Project identifier
+            status: New status (created, indexing, ready, error)
+            timestamp: Optional timestamp
+        """
+        db_update_project_status(project_id, status, timestamp)
+        logger.debug(f"Updated project {project_id} status to {status}")
+    
+    @staticmethod
+    def get_or_create(project_path: str, name: Optional[str] = None) -> Dict[str, Any]:
+        """Get existing project or create new one."""
+        return db_get_or_create_project(project_path, name)
+    
+    @staticmethod
+    def get_stats(project_id: str) -> Dict[str, Any]:
+        """
+        Get project statistics.
+        
+        Args:
+            project_id: Project identifier
+        
+        Returns:
+            Statistics dictionary with file_count and embedding_count
+        
+        Raises:
+            ValueError: If project not found
+        """
+        project = db_get_project_by_id(project_id)
+        if not project:
+            raise ValueError(f"Project not found: {project_id}")
+        
+        db_path = project["database_path"]
+        return get_project_stats(db_path)
+    
+    @staticmethod
+    def is_indexed(project_id: str) -> bool:
+        """
+        Check if project has been indexed.
+        
+        Args:
+            project_id: Project identifier
+        
+        Returns:
+            True if project has indexed files
+        """
+        try:
+            stats = ProjectService.get_stats(project_id)
+            return stats.get("file_count", 0) > 0
+        except ValueError:
+            return False
+    
+    @staticmethod
+    def validate_project_ready(project_id: str) -> tuple:
+        """
+        Validate that project is ready for queries.
+        
+        Args:
+            project_id: Project identifier
+        
+        Returns:
+            Tuple of (is_ready: bool, error_message: Optional[str])
+        """
+        project = db_get_project_by_id(project_id)
+        if not project:
+            return False, "Project not found"
+        
+        if not os.path.exists(project["path"]):
+            return False, "Project path does not exist"
+        
+        if not ProjectService.is_indexed(project_id):
+            return False, "Project not indexed yet"
+        
+        return True, None

services/search_service.py

@@ -0,0 +1,114 @@
+"""
+Service layer for search operations.
+Handles semantic search and query processing.
+"""
+from typing import Dict, Any, List, Optional
+
+from analyzer import search_semantic
+from db import get_project_by_id, get_project_stats
+from cache import search_cache
+from logger import get_logger
+import hashlib
+
+logger = get_logger(__name__)
+
+
+class SearchService:
+    """
+    Service layer for search operations.
+    Provides high-level search functionality with caching.
+    """
+    
+    @staticmethod
+    def semantic_search(
+        project_id: str,
+        query: str,
+        top_k: int = 5,
+        use_cache: bool = True
+    ) -> Dict[str, Any]:
+        """
+        Perform semantic search on a project.
+        
+        Args:
+            project_id: Project identifier
+            query: Search query text
+            top_k: Number of results to return
+            use_cache: Whether to use result caching
+        
+        Returns:
+            Dictionary with results, project_id, and query
+        
+        Raises:
+            ValueError: If project not found or not indexed
+        """
+        # Validate project
+        project = get_project_by_id(project_id)
+        if not project:
+            raise ValueError(f"Project not found: {project_id}")
+        
+        db_path = project["database_path"]
+        
+        # Check if indexed
+        stats = get_project_stats(db_path)
+        if stats.get("file_count", 0) == 0:
+            raise ValueError(f"Project not indexed: {project_id}")
+        
+        # Check cache
+        if use_cache:
+            cache_key = SearchService._make_cache_key(project_id, query, top_k)
+            cached = search_cache.get(cache_key)
+            if cached is not None:
+                logger.debug(f"Cache hit for query: {query[:50]}")
+                return cached
+        
+        # Perform search
+        try:
+            results = search_semantic(query, db_path, top_k=top_k)
+            
+            response = {
+                "results": results,
+                "project_id": project_id,
+                "query": query,
+                "count": len(results)
+            }
+            
+            # Cache results
+            if use_cache:
+                search_cache.set(cache_key, response)
+            
+            logger.info(f"Search completed: {len(results)} results for '{query[:50]}'")
+            return response
+            
+        except Exception as e:
+            logger.error(f"Search failed: {e}")
+            raise RuntimeError(f"Search failed: {e}") from e
+    
+    @staticmethod
+    def _make_cache_key(project_id: str, query: str, top_k: int) -> str:
+        """Generate cache key for search query."""
+        key_str = f"{project_id}:{query}:{top_k}"
+        key_hash = hashlib.md5(key_str.encode()).hexdigest()
+        return f"search:{key_hash}"
+    
+    @staticmethod
+    def invalidate_cache(project_id: Optional[str] = None):
+        """
+        Invalidate search cache.
+        
+        Args:
+            project_id: If provided, only invalidate for this project.
+                       If None, clear entire cache.
+        """
+        if project_id is None:
+            search_cache.clear()
+            logger.info("Cleared entire search cache")
+        else:
+            # For now, just clear entire cache
+            # Could be optimized to only clear specific project
+            search_cache.clear()
+            logger.info(f"Cleared search cache for project {project_id}")
+    
+    @staticmethod
+    def get_cache_stats() -> Dict[str, Any]:
+        """Get search cache statistics."""
+        return search_cache.stats()