fix(t17): address PR #675 review comments

- pyproject + uv.lock: drop pytest-anyio 0.0.0 placeholder; anyio's
  pytest plugin (already required via tests extra) provides the
  @pytest.mark.anyio marker. (Copilot review)

- api/graph.py: when listing graphs, apply the internal-suffix filter
  to the *branch* component for parsed names (e.g.
  code:repo:main_git is hidden, but code:repo:release_tmp stays
  visible). Legacy bare names still filtered by full name.
  (CodeRabbit graph.py:99)

- api/graph.py: Graph/AsyncGraphQuery constructors now coerce
  branch="" to DEFAULT_BRANCH alongside branch=None, so self.branch
  matches the actual graph key produced by compose_graph_name.
  (CodeRabbit graph.py:133)

- api/project.py: same coercion for Project.__init__; an explicit
  empty-string branch now autodetects (or falls back to
  DEFAULT_BRANCH) instead of staying "". (CodeRabbit project.py:71)

- api/index.py + api/llm.py: ChatRequest.branch is now threaded
  through ask() / _ask_sync() / _create_kg_agent() and used to
  compose the FalkorDB graph key. Previously it was accepted on the
  request but silently ignored. (CodeRabbit index.py:81)

- api/migrations/per_branch.py: when both src and dst graphs exist
  (interrupted prior migration) the rename helper now deletes the
  leftover legacy src and reports success, so reruns can complete
  cleanly instead of skipping forever. Dry-run path preserved.
  (CodeRabbit per_branch.py:80)

- api/git_utils/git_utils.py: rename CamelCase helpers
  GitRepoName/LegacyGitRepoName -> git_repo_name/legacy_git_repo_name
  (snake_case per api guidelines); keep CamelCase as deprecated
  aliases so the public surface stays backwards compatible. Update
  the in-module callers. switch_commit now guards against a None
  current_hash and raises a clear ValueError instead of silently
  walking off the end. (CodeRabbit git_utils.py:30)

- api/info.py: get_repo_commit return type tightened to
  Optional[str] to reflect the documented None return.
  (CodeRabbit git_utils.py:30)

All 24 tests in tests/test_per_branch_graphs.py still pass.

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

Author: DvirDukhan

api/git_utils/git_utils.py

@@ -14,7 +14,7 @@
 # Configure logging
 logging.basicConfig(level=logging.DEBUG, format='%(filename)s - %(asctime)s - %(levelname)s - %(message)s')
 
-def GitRepoName(repo_name, branch=None):
+def git_repo_name(repo_name, branch=None):
     """ Returns the git transitions graph key for ``(repo_name, branch)``.
 
     Format: ``{repo_name}:{branch}_git``. Hash-tag stays on ``repo_name``
@@ -27,10 +27,15 @@ def GitRepoName(repo_name, branch=None):
     return "{" + repo_name + "}" + ":" + branch + "_git"
 
 
-def LegacyGitRepoName(repo_name):
+def legacy_git_repo_name(repo_name):
     """Pre-T17 git graph key shape — kept for the migration helper."""
     return "{" + repo_name + "}_git"
 
+
+# Backwards-compatible CamelCase aliases (deprecated, will be removed).
+GitRepoName = git_repo_name
+LegacyGitRepoName = legacy_git_repo_name
+
 def is_ignored(file_path: str, ignore_list: List[str]) -> bool:
     """
     Checks if a file should be ignored based on the ignore list.
@@ -108,7 +113,7 @@ def build_commit_graph(path: str, analyzer: SourceAnalyzer, repo_name: str, igno
     g = source.clone(tmp_name)
     g.enable_backlog()
 
-    git_graph       = GitGraph(GitRepoName(repo_name, branch))
+    git_graph       = GitGraph(git_repo_name(repo_name, branch))
     supported_types = analyzer.supported_types()
 
     # Initialize with the current commit
@@ -298,12 +303,22 @@ def switch_commit(repo: str, to: str, branch: Optional[str] = None):
 
     # Initialize the graph and GitGraph objects
     g = Graph(repo, branch=branch)
-    git_graph = GitGraph(GitRepoName(repo, branch))
+    git_graph = GitGraph(git_repo_name(repo, branch))
 
     # Get the current commit hash of the graph
     current_hash = get_repo_commit(repo, branch)
     logging.info(f"Current graph commit: {current_hash}")
 
+    if current_hash is None:
+        logging.error(
+            "Cannot switch commit: no recorded commit for repo=%s branch=%s",
+            repo, branch,
+        )
+        raise ValueError(
+            f"No recorded commit for repo '{repo}' (branch={branch}); "
+            "the repository must be analyzed before switch_commit can run."
+        )
+
     if current_hash == to:
         logging.debug("Current commit: {current_hash} is the requested commit")
         # No change remain at the current commit

api/graph.py

@@ -93,15 +93,21 @@ def get_repos() -> list[dict]:
 
     repos = []
     for g in db.list_graphs():
-        if _is_internal_suffix(g):
-            continue
         parsed = parse_graph_name(g)
         if parsed is None:
-            # Legacy graph (pre-T17): synthesize a virtual entry so it stays
-            # discoverable until the migration helper promotes it.
+            # Legacy graph (pre-T17) or internal helper graph: skip when
+            # the bare name carries an internal suffix; otherwise synthesize
+            # a virtual entry so it stays discoverable.
+            if _is_internal_suffix(g):
+                continue
             repos.append({"project": g, "branch": DEFAULT_BRANCH, "graph": g})
         else:
             project, branch = parsed
+            # Hide per-branch internal companion graphs (e.g. ``branch_git``,
+            # ``branch_schema``, ``branch_tmp``); their suffix lives on the
+            # branch component, so check that explicitly.
+            if _is_internal_suffix(branch):
+                continue
             repos.append({"project": project, "branch": branch, "graph": g})
     return repos
 
@@ -129,7 +135,9 @@ def __init__(self, name: str, branch: Optional[str] = None) -> None:
             self.name = name
         else:
             self.project = name
-            self.branch = branch if branch is not None else DEFAULT_BRANCH
+            # Normalize empty / None to DEFAULT_BRANCH so the stored
+            # branch matches the key actually used by compose_graph_name.
+            self.branch = branch or DEFAULT_BRANCH
             self.name = compose_graph_name(self.project, self.branch)
 
         self.db = FalkorDB(host=os.getenv('FALKORDB_HOST', 'localhost'),
@@ -766,13 +774,15 @@ async def async_get_repos() -> list[dict]:
     try:
         repos = []
         for g in await db.list_graphs():
-            if _is_internal_suffix(g):
-                continue
             parsed = parse_graph_name(g)
             if parsed is None:
+                if _is_internal_suffix(g):
+                    continue
                 repos.append({"project": g, "branch": DEFAULT_BRANCH, "graph": g})
             else:
                 project, branch = parsed
+                if _is_internal_suffix(branch):
+                    continue
                 repos.append({"project": project, "branch": branch, "graph": g})
         return repos
     finally:
@@ -796,7 +806,7 @@ def __init__(self, name: str, branch: Optional[str] = None) -> None:
             self.name = name
         else:
             self.project = name
-            self.branch = branch if branch is not None else DEFAULT_BRANCH
+            self.branch = branch or DEFAULT_BRANCH
             self.name = compose_graph_name(self.project, self.branch)
         self.db = _async_db()
         self.g = self.db.select_graph(self.name)

api/index.py

@@ -223,7 +223,7 @@ async def chat(data: ChatRequest, _=Depends(public_or_auth)):
     """Chat with the CodeGraph language model."""
 
     try:
-        answer = await ask(data.repo, data.msg)
+        answer = await ask(data.repo, data.msg, branch=data.branch)
     except Exception as e:
         logging.exception("Chat error for repo '%s': %s", data.repo, e)
         return JSONResponse({"status": "error", "response": "Internal server error"},

api/info.py

@@ -67,8 +67,12 @@ def set_repo_commit(repo_name: str, commit_hash: str, branch: Optional[str] = No
         raise
 
 
-def get_repo_commit(repo_name: str, branch: Optional[str] = None) -> str:
-    """Get the current commit the repo is at for ``(repo_name, branch)``."""
+def get_repo_commit(repo_name: str, branch: Optional[str] = None) -> Optional[str]:
+    """Get the current commit the repo is at for ``(repo_name, branch)``.
+
+    Returns ``None`` when no commit has been recorded yet (e.g. the
+    repository has not been analyzed under the given branch).
+    """
 
     try:
         r = get_redis_connection()

api/llm.py

@@ -1,6 +1,7 @@
 import os
 import asyncio
 import logging
+from typing import Optional
 
 from graphrag_sdk.models.litellm import LiteModel
 from graphrag_sdk import (
@@ -235,14 +236,23 @@ def _define_ontology() -> Ontology:
 # Global ontology
 ontology = _define_ontology()
 
-def _create_kg_agent(repo_name: str):
+def _create_kg_agent(repo_name: str, branch: Optional[str] = None):
+    from .graph import compose_graph_name, DEFAULT_BRANCH
+
     model_name = os.getenv('MODEL_NAME', 'gemini/gemini-flash-lite-latest')
 
     model = LiteModel(model_name)
 
+    # Resolve the actual FalkorDB graph key: callers may pass either a
+    # bare project name + branch or an already-composed ``code:p:b`` name.
+    if repo_name.startswith("code:") and ":" in repo_name[5:]:
+        graph_name = repo_name
+    else:
+        graph_name = compose_graph_name(repo_name, branch or DEFAULT_BRANCH)
+
     #ontology = _define_ontology()
     code_graph_kg = KnowledgeGraph(
-        name=repo_name,
+        name=graph_name,
         ontology=ontology,
         model_config=KnowledgeGraphModelConfig.with_model(model),
         host=os.getenv('FALKORDB_HOST', 'localhost'),
@@ -257,8 +267,8 @@ def _create_kg_agent(repo_name: str):
 
     return code_graph_kg.chat_session()
 
-def _ask_sync(repo_name: str, question: str) -> str:
-    chat = _create_kg_agent(repo_name)
+def _ask_sync(repo_name: str, question: str, branch: Optional[str] = None) -> str:
+    chat = _create_kg_agent(repo_name, branch=branch)
 
     logging.debug(f"Question: {question}")
     print(f"Question: {question}")
@@ -268,6 +278,6 @@ def _ask_sync(repo_name: str, question: str) -> str:
     return response['response']
 
 
-async def ask(repo_name: str, question: str) -> str:
+async def ask(repo_name: str, question: str, branch: Optional[str] = None) -> 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, branch)

api/migrations/per_branch.py

@@ -68,6 +68,22 @@ def _rename_graph(db: FalkorDB, src: str, dst: str, *, dry_run: bool) -> bool:
     """
 
     if db.connection.exists(dst):
+        # Recovery path: a previous migration may have copied ``src`` to
+        # ``dst`` but crashed before deleting ``src``. If both still exist,
+        # finish the job rather than skipping forever.
+        if db.connection.exists(src):
+            if dry_run:
+                logger.info(
+                    "[dry-run] would delete leftover legacy graph %s (dst %s already exists)",
+                    src, dst,
+                )
+                return True
+            db.select_graph(src).delete()
+            logger.info(
+                "Deleted leftover legacy graph %s (dst %s already exists)",
+                src, dst,
+            )
+            return True
         logger.warning("Target graph %s already exists — skipping rename of %s", dst, src)
         return False
     if dry_run:

api/project.py

@@ -66,7 +66,10 @@ def __init__(self, name: str, path: Path, url: Optional[str], branch: Optional[s
         self.name   = name
         self.path   = path
         # Auto-detect branch from the working tree when not explicitly given.
-        if branch is None:
+        # Treat the empty string the same as ``None`` so the project never
+        # reports a branch that disagrees with the graph/info keys it writes
+        # (which coerce empty branch to DEFAULT_BRANCH).
+        if not branch:
             branch = detect_branch(path) if path is not None and Path(path).exists() else DEFAULT_BRANCH
         self.branch = branch
         self.graph  = Graph(name, branch=self.branch)