Fix code review issues: add constants, improve change detection, avoid circular imports

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

Author: Copilot

endpoints/project_endpoints.py

@@ -48,9 +48,10 @@ def api_create_project(request: CreateProjectRequest):
 
         # Add project to file watcher if available
         try:
-            from main import _file_watcher
-            if _file_watcher and _file_watcher.is_running():
-                _file_watcher.add_project(project["id"], project["path"])
+            from utils.app_state import get_file_watcher
+            watcher = get_file_watcher()
+            if watcher and watcher.is_running():
+                watcher.add_project(project["id"], project["path"])
         except Exception as e:
             logger.warning(f"Could not add project to file watcher: {e}")
 

endpoints/web_endpoints.py

@@ -40,7 +40,7 @@ def api_health():
     - Monitoring systems
     - Service availability verification
     """
-    from main import _file_watcher
+    from utils.app_state import get_file_watcher
 
     health_data = {
         "status": "ok",
@@ -49,8 +49,9 @@ def api_health():
     }
 
     # Add file watcher status if available
-    if _file_watcher:
-        health_data["file_watcher"] = _file_watcher.get_status()
+    watcher = get_file_watcher()
+    if watcher:
+        health_data["file_watcher"] = watcher.get_status()
 
     return JSONResponse(health_data)
 

main.py

@@ -12,22 +12,18 @@
 from db.operations import get_or_create_project
 from utils.config import CFG
 from utils.logger import get_logger
+from utils import app_state
 from endpoints.project_endpoints import router as project_router
 from endpoints.query_endpoints import router as query_router
 from endpoints.web_endpoints import router as web_router
 from utils.file_watcher import FileWatcher
 
 logger = get_logger(__name__)
 
-# Global FileWatcher instance
-_file_watcher = None
-
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     """Application lifespan handler."""
-    global _file_watcher
-    
     # Project registry is auto-initialized when needed via create_project
 
     # Auto-create default project from configured local_path if it exists
@@ -41,7 +37,7 @@ async def lifespan(app: FastAPI):
     # Start FileWatcher if enabled
     if CFG.get("file_watcher_enabled", True):
         try:
-            _file_watcher = FileWatcher(
+            watcher = FileWatcher(
                 logger=logger,
                 enabled=True,
                 debounce_seconds=CFG.get("file_watcher_debounce", 5),
@@ -53,24 +49,25 @@ async def lifespan(app: FastAPI):
                 projects = db_operations.list_projects()
                 for project in projects:
                     if project.get("path") and os.path.exists(project["path"]):
-                        _file_watcher.add_project(project["id"], project["path"])
+                        watcher.add_project(project["id"], project["path"])
             except Exception as e:
                 logger.warning(f"Could not add projects to file watcher: {e}")
 
-            _file_watcher.start()
+            watcher.start()
+            app_state.set_file_watcher(watcher)
             logger.info("FileWatcher started successfully")
         except Exception as e:
             logger.error(f"Failed to start FileWatcher: {e}")
-            _file_watcher = None
     else:
         logger.info("FileWatcher is disabled in configuration")
 
     yield
 
     # Stop FileWatcher on shutdown
-    if _file_watcher:
+    watcher = app_state.get_file_watcher()
+    if watcher:
         try:
-            _file_watcher.stop()
+            watcher.stop()
             logger.info("FileWatcher stopped successfully")
         except Exception as e:
             logger.error(f"Error stopping FileWatcher: {e}")

utils/app_state.py

@@ -0,0 +1,32 @@
+"""
+Shared application state module.
+
+This module provides a central location for shared application state
+to avoid circular dependencies between modules.
+"""
+
+from typing import Optional
+
+# Global FileWatcher instance
+file_watcher: Optional[object] = None
+
+
+def set_file_watcher(watcher):
+    """
+    Set the global file watcher instance.
+    
+    Args:
+        watcher: FileWatcher instance
+    """
+    global file_watcher
+    file_watcher = watcher
+
+
+def get_file_watcher():
+    """
+    Get the global file watcher instance.
+    
+    Returns:
+        FileWatcher instance or None if not initialized
+    """
+    return file_watcher

utils/file_watcher.py

@@ -41,6 +41,10 @@ class FileWatcher:
     automatic re-indexing when changes are detected.
     """
 
+    # Class constants for configuration limits
+    MIN_DEBOUNCE_SECONDS = 1
+    MIN_CHECK_INTERVAL = 5
+    
     def __init__(
         self,
         logger: Optional[logging.Logger] = None,
@@ -58,8 +62,8 @@ def __init__(
             check_interval: Seconds between directory scans (default: 10)
         """
         self.enabled = enabled
-        self.debounce_seconds = max(1, debounce_seconds)
-        self.check_interval = max(5, check_interval)
+        self.debounce_seconds = max(self.MIN_DEBOUNCE_SECONDS, debounce_seconds)
+        self.check_interval = max(self.MIN_CHECK_INTERVAL, check_interval)
 
         # Set up logger
         if logger:
@@ -285,13 +289,15 @@ def _check_project(self, project_id: str, project_info: Dict) -> None:
 
     def _scan_directory(self, directory: str) -> Dict[str, str]:
         """
-        Scan a directory and return a dictionary of file paths to modification times.
+        Scan a directory and return a dictionary of file paths to file signatures.
+        
+        Uses both modification time and file size for better change detection.
         
         Args:
             directory: Directory path to scan
         
         Returns:
-            Dictionary mapping relative file paths to modification time hashes
+            Dictionary mapping relative file paths to signature (mtime:size)
         """
         file_hashes = {}
 
@@ -309,10 +315,12 @@ def _scan_directory(self, directory: str) -> Dict[str, str]:
                     filepath = os.path.join(root, filename)
 
                     try:
-                        # Use modification time as a simple hash
-                        mtime = os.path.getmtime(filepath)
+                        # Use both modification time and file size as signature
+                        stat = os.stat(filepath)
+                        mtime = stat.st_mtime
+                        size = stat.st_size
                         relative_path = os.path.relpath(filepath, directory)
-                        file_hashes[relative_path] = str(mtime)
+                        file_hashes[relative_path] = f"{mtime}:{size}"
                     except (OSError, ValueError):
                         # Skip files we can't access
                         continue