Address review: fix strict=True zip, revert serve_spa to sync, eliminate double connections

- Remove strict=True from zip(nodes, edges) in find_paths (both sync
  and async) — nodes intentionally has one more element than edges
- Revert serve_spa to sync def so FastAPI offloads filesystem I/O to
  thread pool instead of blocking the event loop
- Add graph_exists() method to AsyncGraphQuery to reuse the connection
  instead of opening a separate one via async_graph_exists()
- Update all endpoints in api/index.py and tests/index.py to use
  g.graph_exists() on the query instance
- Fix missing trailing newline in api/llm.py

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: gkorland

api/graph.py

@@ -581,7 +581,7 @@ def find_paths(self, src: int, dest: int) -> list[Path]:
             nodes = p.nodes()
             edges = p.edges()
 
-            for n, e in zip(nodes, edges, strict=True):
+            for n, e in zip(nodes, edges):
                 path.append(encode_node(n))
                 path.append(encode_edge(e))
 
@@ -670,9 +670,15 @@ class AsyncGraphQuery:
     """
 
     def __init__(self, name: str) -> None:
+        self.name = name
         self.db = _async_db()
         self.g = self.db.select_graph(name)
 
+    async def graph_exists(self) -> bool:
+        """Check if this graph exists, reusing the current connection."""
+        graphs = await self.db.list_graphs()
+        return self.name in graphs
+
     async def _query(self, q: str, params: Optional[dict] = None):
         return await self.g.query(q, params)
 
@@ -744,7 +750,7 @@ async def find_paths(self, src: int, dest: int) -> list:
             p     = row[0]
             nodes = p.nodes()
             edges = p.edges()
-            for n, e in zip(nodes, edges, strict=True):
+            for n, e in zip(nodes, edges):
                 path.append(encode_node(n))
                 path.append(encode_edge(e))
             path.append(encode_node(nodes[-1]))

api/index.py

@@ -12,11 +12,11 @@
 from api.analyzers.source_analyzer import SourceAnalyzer
 from api.git_utils import git_utils
 from api.git_utils.git_graph import AsyncGitGraph
-from api.graph import Graph, AsyncGraphQuery, async_get_repos, async_graph_exists
+from api.graph import Graph, AsyncGraphQuery, async_get_repos
 from api.info import async_get_repo_info
 from api.llm import ask
 from api.project import Project
-from .auto_complete import async_prefix_search
+
 
 # Load environment variables from .env file
 load_dotenv()
@@ -112,35 +112,34 @@ async def graph_entities(repo: str = Query(None), _=Depends(public_or_auth)):
         logging.error("Missing 'repo' parameter in request.")
         return JSONResponse({"status": "Missing 'repo' parameter"}, status_code=400)
 
-    if not await async_graph_exists(repo):
-        logging.error("Missing project %s", repo)
-        return JSONResponse({"status": f"Missing project {repo}"}, status_code=400)
-
+    g = AsyncGraphQuery(repo)
     try:
-        g = AsyncGraphQuery(repo)
-        try:
-            sub_graph = await g.get_sub_graph(500)
-        finally:
-            await g.close()
+        if not await g.graph_exists():
+            logging.error("Missing project %s", repo)
+            return JSONResponse({"status": f"Missing project {repo}"}, status_code=400)
+
+        sub_graph = await g.get_sub_graph(500)
 
         logging.info("Successfully retrieved sub-graph for repo: %s", repo)
         return {"status": "success", "entities": sub_graph}
 
     except Exception as e:
         logging.exception("Error retrieving sub-graph for repo '%s': %s", repo, e)
         return JSONResponse({"status": "Internal server error"}, status_code=500)
+    finally:
+        await g.close()
 
 
 @app.post('/api/get_neighbors')
 async def get_neighbors(data: NeighborsRequest, _=Depends(public_or_auth)):
     """Get neighbors of a nodes list in the graph."""
 
-    if not await async_graph_exists(data.repo):
-        logging.error("Missing project %s", data.repo)
-        return JSONResponse({"status": f"Missing project {data.repo}"}, status_code=400)
-
     g = AsyncGraphQuery(data.repo)
     try:
+        if not await g.graph_exists():
+            logging.error("Missing project %s", data.repo)
+            return JSONResponse({"status": f"Missing project {data.repo}"}, status_code=400)
+
         neighbors = await g.get_neighbors(data.node_ids)
     finally:
         await g.close()
@@ -154,10 +153,14 @@ async def get_neighbors(data: NeighborsRequest, _=Depends(public_or_auth)):
 async def auto_complete(data: AutoCompleteRequest, _=Depends(public_or_auth)):
     """Process auto-completion requests for a repository based on a prefix."""
 
-    if not await async_graph_exists(data.repo):
-        return JSONResponse({"status": f"Missing project {data.repo}"}, status_code=400)
+    g = AsyncGraphQuery(data.repo)
+    try:
+        if not await g.graph_exists():
+            return JSONResponse({"status": f"Missing project {data.repo}"}, status_code=400)
 
-    completions = await async_prefix_search(data.repo, data.prefix)
+        completions = await g.prefix_search(data.prefix)
+    finally:
+        await g.close()
     return {"status": "success", "completions": completions}
 
 
@@ -191,12 +194,12 @@ async def repo_info(data: RepoRequest, _=Depends(public_or_auth)):
 async def find_paths(data: FindPathsRequest, _=Depends(public_or_auth)):
     """Find all paths between a source and destination node in the graph."""
 
-    if not await async_graph_exists(data.repo):
-        logging.error("Missing project %s", data.repo)
-        return JSONResponse({"status": f"Missing project {data.repo}"}, status_code=400)
-
     g = AsyncGraphQuery(data.repo)
     try:
+        if not await g.graph_exists():
+            logging.error("Missing project %s", data.repo)
+            return JSONResponse({"status": f"Missing project {data.repo}"}, status_code=400)
+
         paths = await g.find_paths(data.src, data.dest)
     finally:
         await g.close()
@@ -291,7 +294,7 @@ async def list_commits(data: RepoRequest, _=Depends(public_or_auth)):
 INDEX_HTML = STATIC_DIR / "index.html"
 
 @app.get("/{full_path:path}")
-async def serve_spa(full_path: str):
+def serve_spa(full_path: str):
     """Serve React SPA — static assets or index.html catch-all."""
     file = (STATIC_DIR / full_path).resolve()
     if not file.is_relative_to(STATIC_DIR):

api/llm.py

@@ -270,4 +270,4 @@ def _ask_sync(repo_name: str, question: str) -> str:
 
 async def ask(repo_name: str, question: str) -> str:
     loop = asyncio.get_running_loop()
-    return await loop.run_in_executor(None, _ask_sync, repo_name, question)
+    return await loop.run_in_executor(None, _ask_sync, repo_name, question)

tests/index.py

@@ -3,15 +3,14 @@
 import logging
 from pathlib import Path
 
-from api.graph import Graph, AsyncGraphQuery, async_get_repos, async_graph_exists
+from api.graph import Graph, AsyncGraphQuery, async_get_repos
 from api.info import async_get_repo_info
 from dotenv import load_dotenv
 from fastapi import Depends, FastAPI, Header, HTTPException, Query
 from fastapi.responses import JSONResponse
 from pydantic import BaseModel
 
 from api.project import Project
-from api.auto_complete import async_prefix_search
 from api.git_utils import git_utils
 
 # Load environment variables from .env file
@@ -92,30 +91,29 @@ async def graph_entities(repo: str = Query(None), _=Depends(token_required)):
             logging.error("Missing 'repo' parameter in request.")
             return JSONResponse({"status": "Missing 'repo' parameter"}, status_code=400)
 
-        if not await async_graph_exists(repo):
-            logging.error("Missing project %s", repo)
-            return JSONResponse({"status": f"Missing project {repo}"}, status_code=400)
-
+        g = AsyncGraphQuery(repo)
         try:
-            g = AsyncGraphQuery(repo)
-            try:
-                sub_graph = await g.get_sub_graph(500)
-            finally:
-                await g.close()
+            if not await g.graph_exists():
+                logging.error("Missing project %s", repo)
+                return JSONResponse({"status": f"Missing project {repo}"}, status_code=400)
+
+            sub_graph = await g.get_sub_graph(500)
             logging.info("Successfully retrieved sub-graph for repo: %s", repo)
             return {"status": "success", "entities": sub_graph}
         except Exception as e:
             logging.error("Error retrieving sub-graph for repo '%s': %s", repo, e)
             return JSONResponse({"status": "Internal server error"}, status_code=500)
+        finally:
+            await g.close()
 
     @app.post('/api/get_neighbors')
     async def get_neighbors(data: NeighborsRequest, _=Depends(token_required)):
-        if not await async_graph_exists(data.repo):
-            logging.error("Missing project %s", data.repo)
-            return JSONResponse({"status": f"Missing project {data.repo}"}, status_code=400)
-
         g = AsyncGraphQuery(data.repo)
         try:
+            if not await g.graph_exists():
+                logging.error("Missing project %s", data.repo)
+                return JSONResponse({"status": f"Missing project {data.repo}"}, status_code=400)
+
             neighbors = await g.get_neighbors(data.node_ids)
         finally:
             await g.close()
@@ -125,10 +123,14 @@ async def get_neighbors(data: NeighborsRequest, _=Depends(token_required)):
 
     @app.post('/api/auto_complete')
     async def auto_complete(data: AutoCompleteRequest, _=Depends(token_required)):
-        if not await async_graph_exists(data.repo):
-            return JSONResponse({"status": f"Missing project {data.repo}"}, status_code=400)
+        g = AsyncGraphQuery(data.repo)
+        try:
+            if not await g.graph_exists():
+                return JSONResponse({"status": f"Missing project {data.repo}"}, status_code=400)
 
-        completions = await async_prefix_search(data.repo, data.prefix)
+            completions = await g.prefix_search(data.prefix)
+        finally:
+            await g.close()
         return {"status": "success", "completions": completions}
 
     @app.get('/api/list_repos')
@@ -151,12 +153,12 @@ async def repo_info(data: RepoRequest, _=Depends(token_required)):
 
     @app.post('/api/find_paths')
     async def find_paths(data: FindPathsRequest, _=Depends(token_required)):
-        if not await async_graph_exists(data.repo):
-            logging.error("Missing project %s", data.repo)
-            return JSONResponse({"status": f"Missing project {data.repo}"}, status_code=400)
-
         g = AsyncGraphQuery(data.repo)
         try:
+            if not await g.graph_exists():
+                logging.error("Missing project %s", data.repo)
+                return JSONResponse({"status": f"Missing project {data.repo}"}, status_code=400)
+
             paths = await g.find_paths(data.src, data.dest)
         finally:
             await g.close()