fix: Standardize SQLite backend usage across all entity managers (Story #702)

Multiple entity managers were not using SQLite despite having backends available:

1. CITokenManager in routes.py - Fixed wrong DB path (cidx.db → cidx_server.db)
2. CITokenManager in git_state_manager.py - Added use_sqlite=True
3. SSHKeyManager - Created factory functions with SQLite in:
   - web/routes.py (5 locations)
   - routers/ssh_keys.py
   - mcp/handlers.py
   - services/committer_resolution_service.py
   - services/migration_orchestrator.py
4. SyncJobManager - Updated create_sync_job_manager() factory

All managers now consistently use ~/.cidx-server/data/cidx_server.db

Added unit tests for SQLite factory functions.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: jsbattig

src/code_indexer/server/jobs/manager.py

@@ -2311,7 +2311,7 @@ def update_phase_details(
 
 def create_sync_job_manager(server_dir_path: Optional[str] = None) -> SyncJobManager:
     """
-    Create a properly configured SyncJobManager.
+    Create a properly configured SyncJobManager with SQLite backend (Story #702).
 
     Factory function that creates a SyncJobManager with appropriate
     storage configuration based on CIDX server settings.
@@ -2328,4 +2328,13 @@ def create_sync_job_manager(server_dir_path: Optional[str] = None) -> SyncJobMan
     storage_path = config.get_jobs_storage_path()
     concurrency_config = config.get_concurrency_limits()
 
-    return SyncJobManager(storage_path=storage_path, **concurrency_config)
+    # Calculate database path for SQLite backend
+    server_dir = Path(server_dir_path or "~/.cidx-server").expanduser()
+    db_path = str(server_dir / "data" / "cidx_server.db")
+
+    return SyncJobManager(
+        storage_path=storage_path,
+        use_sqlite=True,
+        db_path=db_path,
+        **concurrency_config,
+    )

src/code_indexer/server/mcp/handlers.py

@@ -4004,10 +4004,21 @@ async def handle_authenticate(
 
 
 def get_ssh_key_manager() -> SSHKeyManager:
-    """Get or create the SSH key manager instance."""
+    """Get or create the SSH key manager instance with SQLite backend (Story #702)."""
     global _ssh_key_manager
     if _ssh_key_manager is None:
-        _ssh_key_manager = SSHKeyManager()
+        from ..services.config_service import get_config_service
+
+        config_service = get_config_service()
+        server_dir = config_service.config_manager.server_dir
+        db_path = server_dir / "data" / "cidx_server.db"
+        metadata_dir = server_dir / "data" / "ssh_keys"
+
+        _ssh_key_manager = SSHKeyManager(
+            metadata_dir=metadata_dir,
+            use_sqlite=True,
+            db_path=db_path,
+        )
     return _ssh_key_manager
 
 

src/code_indexer/server/routers/ssh_keys.py

@@ -99,25 +99,31 @@ class KeyWithHostsResponse(BaseModel):
 
 
 def get_ssh_key_manager() -> SSHKeyManager:
-    """Get or create the SSH key manager instance."""
+    """Get or create the SSH key manager instance with SQLite backend (Story #702)."""
     global _ssh_key_manager
     if _ssh_key_manager is None:
         # Allow override via environment variables for testing
         ssh_dir = os.environ.get("CIDX_SSH_DIR")
         metadata_dir_env = os.environ.get("CIDX_SSH_METADATA_DIR")
-        server_data_dir = os.environ.get(
-            "CIDX_SERVER_DATA_DIR", str(Path.home() / ".code-indexer-server")
-        )
+
+        # Get server directory from config service
+        from ..services.config_service import get_config_service
+
+        config_service = get_config_service()
+        server_dir = config_service.config_manager.server_dir
+        db_path = server_dir / "data" / "cidx_server.db"
 
         # Use server data dir for metadata if not explicitly overridden
         if metadata_dir_env:
             metadata_dir = Path(metadata_dir_env)
         else:
-            metadata_dir = Path(server_data_dir) / "ssh_keys"
+            metadata_dir = server_dir / "data" / "ssh_keys"
 
         _ssh_key_manager = SSHKeyManager(
             ssh_dir=Path(ssh_dir) if ssh_dir else None,
             metadata_dir=metadata_dir,
+            use_sqlite=True,
+            db_path=db_path,
         )
     return _ssh_key_manager
 

src/code_indexer/server/services/committer_resolution_service.py

@@ -16,6 +16,22 @@
 from .remote_discovery_service import RemoteDiscoveryService
 
 
+def _create_default_ssh_key_manager() -> SSHKeyManager:
+    """Create SSHKeyManager with SQLite backend (Story #702 migration)."""
+    from .config_service import get_config_service
+
+    config_service = get_config_service()
+    server_dir = config_service.config_manager.server_dir
+    db_path = server_dir / "data" / "cidx_server.db"
+    metadata_dir = server_dir / "data" / "ssh_keys"
+
+    return SSHKeyManager(
+        metadata_dir=metadata_dir,
+        use_sqlite=True,
+        db_path=db_path,
+    )
+
+
 class CommitterResolutionService:
     """
     Service for resolving git committer email based on SSH key authentication.
@@ -44,7 +60,7 @@ def __init__(
         self.logger = logging.getLogger(__name__)
 
         # Initialize dependencies with defaults if not provided
-        self.ssh_key_manager = ssh_key_manager or SSHKeyManager()
+        self.ssh_key_manager = ssh_key_manager or _create_default_ssh_key_manager()
         self.key_to_remote_tester = key_to_remote_tester or KeyToRemoteTester()
         self.remote_discovery_service = (
             remote_discovery_service or RemoteDiscoveryService()

src/code_indexer/server/services/git_state_manager.py

@@ -582,7 +582,16 @@ def resolve_token(platform: str) -> Optional[str]:
             from .ci_token_manager import CITokenManager
 
             server_dir = Path.home() / ".cidx-server"
-            token_manager = CITokenManager(server_dir_path=str(server_dir))
+            db_path = server_dir / "data" / "cidx_server.db"
+
+            # Ensure database directory exists before opening SQLite
+            db_path.parent.mkdir(parents=True, exist_ok=True)
+
+            token_manager = CITokenManager(
+                server_dir_path=str(server_dir),
+                use_sqlite=True,
+                db_path=str(db_path),
+            )
             token_data = token_manager.get_token(platform)
 
             if token_data:

src/code_indexer/server/services/migration_orchestrator.py

@@ -58,16 +58,21 @@ def __init__(
             cidx_config_path: Path to CIDX server config.
             skip_key_testing: If True, skip SSH authentication testing.
         """
+        # Get server directory from config service for consistent paths
+        from .config_service import get_config_service
+
+        config_service = get_config_service()
+        server_dir = config_service.config_manager.server_dir
+        db_path = server_dir / "data" / "cidx_server.db"
+
         if ssh_dir is None:
             ssh_dir = Path.home() / ".ssh"
         if metadata_dir is None:
-            metadata_dir = Path.home() / ".code-indexer-server" / "ssh_keys"
+            metadata_dir = server_dir / "data" / "ssh_keys"
         if migration_metadata_path is None:
-            migration_metadata_path = (
-                Path.home() / ".code-indexer-server" / "ssh_migration.json"
-            )
+            migration_metadata_path = server_dir / "ssh_migration.json"
         if cidx_config_path is None:
-            cidx_config_path = Path.home() / ".code-indexer-server" / "config.json"
+            cidx_config_path = server_dir / "config.json"
 
         self.ssh_dir = ssh_dir
         self.metadata_dir = metadata_dir
@@ -84,6 +89,8 @@ def __init__(
         self.key_manager = SSHKeyManager(
             ssh_dir=ssh_dir,
             metadata_dir=metadata_dir,
+            use_sqlite=True,
+            db_path=db_path,
         )
 
     def should_run_migration(self) -> bool:

src/code_indexer/server/web/routes.py

@@ -36,7 +36,7 @@ def _get_token_manager() -> CITokenManager:
 
     config_service = get_config_service()
     server_dir = config_service.config_manager.server_dir
-    db_path = server_dir / "cidx.db"
+    db_path = server_dir / "data" / "cidx_server.db"
 
     return CITokenManager(
         server_dir_path=str(server_dir),
@@ -45,6 +45,23 @@ def _get_token_manager() -> CITokenManager:
     )
 
 
+def _get_ssh_key_manager():
+    """Create SSHKeyManager with SQLite backend (Story #702 migration)."""
+    from ..services.config_service import get_config_service
+    from ..services.ssh_key_manager import SSHKeyManager
+
+    config_service = get_config_service()
+    server_dir = config_service.config_manager.server_dir
+    db_path = server_dir / "data" / "cidx_server.db"
+    metadata_dir = server_dir / "data" / "ssh_keys"
+
+    return SSHKeyManager(
+        metadata_dir=metadata_dir,
+        use_sqlite=True,
+        db_path=db_path,
+    )
+
+
 # Get templates directory path
 TEMPLATES_DIR = Path(__file__).parent / "templates"
 templates = Jinja2Templates(directory=str(TEMPLATES_DIR))
@@ -4628,9 +4645,7 @@ async def ssh_keys_page(request: Request):
     managed_keys = []
     unmanaged_keys = []
     try:
-        from ..services.ssh_key_manager import SSHKeyManager
-
-        manager = SSHKeyManager()
+        manager = _get_ssh_key_manager()
         key_list = manager.list_keys()
         managed_keys = key_list.managed
         unmanaged_keys = key_list.unmanaged
@@ -4675,9 +4690,7 @@ def _create_ssh_keys_page_response(
     managed_keys = []
     unmanaged_keys = []
     try:
-        from ..services.ssh_key_manager import SSHKeyManager
-
-        manager = SSHKeyManager()
+        manager = _get_ssh_key_manager()
         key_list = manager.list_keys()
         managed_keys = key_list.managed
         unmanaged_keys = key_list.unmanaged
@@ -4730,13 +4743,12 @@ async def create_ssh_key(
         )
 
     try:
-        from ..services.ssh_key_manager import SSHKeyManager
         from ..services.ssh_key_generator import (
             InvalidKeyNameError,
             KeyAlreadyExistsError,
         )
 
-        manager = SSHKeyManager()
+        manager = _get_ssh_key_manager()
         manager.create_key(
             name=key_name,
             key_type=key_type,
@@ -4785,9 +4797,7 @@ async def delete_ssh_key(
         )
 
     try:
-        from ..services.ssh_key_manager import SSHKeyManager
-
-        manager = SSHKeyManager()
+        manager = _get_ssh_key_manager()
         manager.delete_key(key_name)
 
         return _create_ssh_keys_page_response(
@@ -4824,9 +4834,9 @@ async def assign_host_to_key(
         )
 
     try:
-        from ..services.ssh_key_manager import SSHKeyManager, HostConflictError
+        from ..services.ssh_key_manager import HostConflictError
 
-        manager = SSHKeyManager()
+        manager = _get_ssh_key_manager()
         manager.assign_key_to_host(key_name, hostname)
 
         return _create_ssh_keys_page_response(