fix(tools): Fix find_current_source_id when the current directory is not a git repo or has no remote url

Author: timothedelion

packages/developer_mcp_server/src/developer_mcp_server/register_tools.py

@@ -84,9 +84,10 @@ def register_developer_tools(mcp: FastMCP):
 
     mcp.tool(
         find_current_source_id,
-        description="Find the GitGuardian source_id for the current repository. "
-        "This tool automatically detects the current git repository and searches for its source_id in GitGuardian. "
-        "Useful when you need to reference the repository in other API calls.",
+        description="Find the GitGuardian source_id for a repository. "
+        "This tool attempts to detect the repository name from git remote URL, or falls back to using the directory name. "
+        "By default it uses the current directory ('.'), but you can specify a custom repository_path parameter "
+        "to analyze a different repository. Useful when you need to reference the repository in other API calls.",
         required_scopes=["sources:read"],
     )
 

packages/gg_api_core/src/gg_api_core/tools/find_current_source_id.py

@@ -1,5 +1,7 @@
 import logging
+import os
 import subprocess
+from pathlib import Path
 from typing import Any
 
 from pydantic import BaseModel, Field
@@ -42,17 +44,24 @@ class FindCurrentSourceIdError(BaseModel):
     suggestion: str | None = Field(default=None, description="Suggestions for resolving the error")
 
 
-async def find_current_source_id() -> FindCurrentSourceIdResult | FindCurrentSourceIdError:
+async def find_current_source_id(repository_path: str = ".") -> FindCurrentSourceIdResult | FindCurrentSourceIdError:
     """
-    Find the GitGuardian source_id for the current repository.
+    Find the GitGuardian source_id for a repository.
 
     This tool:
-    1. Gets the current repository information from git
-    2. Extracts the repository name from the remote URL
+    1. Attempts to get the repository name from git remote URL
+    2. If git fails, falls back to using the directory name
     3. Searches GitGuardian for matching sources
     4. Returns the source_id if an exact match is found
     5. If no exact match, returns all search results for the model to choose from
 
+    Args:
+        repository_path: Path to the repository directory. Defaults to "." (current directory).
+                        If you're working in a specific repository, provide the full path to ensure
+                        the correct repository is analyzed (e.g., "/home/user/my-project").
+                        Note: If the directory is not a git repository, the tool will use the
+                        directory name as the repository name.
+
     Returns:
         FindCurrentSourceIdResult: Pydantic model containing:
             - repository_name: The detected repository name
@@ -70,38 +79,44 @@ async def find_current_source_id() -> FindCurrentSourceIdResult | FindCurrentSou
             - suggestion: Suggestions for resolving the error
     """
     client = get_client()
-    logger.debug("Finding source_id for current repository")
+    logger.debug(f"Finding source_id for repository at path: {repository_path}")
+
+    repository_name = None
+    remote_url = None
+    detection_method = None
 
     try:
-        # Get current repository remote URL
+        # Try Method 1: Get repository name from git remote URL
         try:
             result = subprocess.run(
                 ["git", "config", "--get", "remote.origin.url"],
                 capture_output=True,
                 text=True,
                 check=True,
                 timeout=5,
+                cwd=repository_path,
             )
             remote_url = result.stdout.strip()
-            logger.debug(f"Found remote URL: {remote_url}")
-        except subprocess.CalledProcessError as e:
-            return FindCurrentSourceIdError(
-                error="Not a git repository or no remote 'origin' configured",
-                details=str(e),
-            )
-        except subprocess.TimeoutExpired:
-            return FindCurrentSourceIdError(error="Git command timed out")
-
-        # Parse repository name from remote URL
-        repository_name = parse_repo_url(remote_url).split("/")[-1]
+            repository_name = parse_repo_url(remote_url).split("/")[-1]
+            detection_method = "git remote URL"
+            logger.debug(f"Found remote URL: {remote_url}, parsed repository name: {repository_name}")
+        except (subprocess.CalledProcessError, subprocess.TimeoutExpired) as e:
+            logger.debug(f"Git remote detection failed: {e}, falling back to directory name")
+
+            # Fallback Method 2: Use the directory name as repository name
+            abs_path = os.path.abspath(repository_path)
+            repository_name = Path(abs_path).name
+            detection_method = "directory name"
+            logger.info(f"Using directory name as repository name: {repository_name}")
 
         if not repository_name:
             return FindCurrentSourceIdError(
-                error=f"Could not parse repository URL: {remote_url}",
-                details="The URL format is not recognized. Supported platforms: GitHub, GitLab (Cloud & Self-hosted), Bitbucket (Cloud & Data Center), Azure DevOps",
+                error="Could not determine repository name",
+                message="Failed to determine repository name from both git remote and directory name.",
+                suggestion="Please ensure you're in a valid directory or provide a valid repository_path parameter.",
             )
 
-        logger.info(f"Detected repository name: {repository_name}")
+        logger.info(f"Detected repository name: {repository_name} (method: {detection_method})")
 
         # Search for the source in GitGuardian with robust non-exact matching
         result = await client.get_source_by_name(repository_name, return_all_on_no_match=True)
@@ -110,19 +125,29 @@ async def find_current_source_id() -> FindCurrentSourceIdResult | FindCurrentSou
         if isinstance(result, dict):
             source_id = result.get("id")
             logger.info(f"Found exact match with source_id: {source_id}")
+
+            message = f"Successfully found exact match for GitGuardian source: {repository_name}"
+            if detection_method == "directory name":
+                message += f" (repository name inferred from {detection_method})"
+
             return FindCurrentSourceIdResult(
                 repository_name=repository_name,
                 source_id=source_id,
                 source=result,
-                message=f"Successfully found exact match for GitGuardian source: {repository_name}",
+                message=message,
             )
 
         # Handle multiple candidates (list result)
         elif isinstance(result, list) and len(result) > 0:
             logger.info(f"Found {len(result)} candidate sources for repository: {repository_name}")
+
+            message = f"No exact match found for '{repository_name}', but found {len(result)} potential matches."
+            if detection_method == "directory name":
+                message += f" (repository name inferred from {detection_method})"
+
             return FindCurrentSourceIdResult(
                 repository_name=repository_name,
-                message=f"No exact match found for '{repository_name}', but found {len(result)} potential matches.",
+                message=message,
                 suggestion="Review the candidates below and determine which source best matches the current repository based on the name and URL.",
                 candidates=[
                     SourceCandidate(
@@ -148,17 +173,27 @@ async def find_current_source_id() -> FindCurrentSourceIdResult | FindCurrentSou
                 if isinstance(fallback_result, dict):
                     source_id = fallback_result.get("id")
                     logger.info(f"Found match using repo name only, source_id: {source_id}")
+
+                    message = f"Found match using repository name '{repo_only}' (without organization prefix)"
+                    if detection_method == "directory name":
+                        message += f" (repository name inferred from {detection_method})"
+
                     return FindCurrentSourceIdResult(
                         repository_name=repository_name,
                         source_id=source_id,
                         source=fallback_result,
-                        message=f"Found match using repository name '{repo_only}' (without organization prefix)",
+                        message=message,
                     )
                 elif isinstance(fallback_result, list) and len(fallback_result) > 0:
                     logger.info(f"Found {len(fallback_result)} candidates using repo name only")
+
+                    message = f"No exact match for '{repository_name}', but found {len(fallback_result)} potential matches using repo name '{repo_only}'."
+                    if detection_method == "directory name":
+                        message += f" (repository name inferred from {detection_method})"
+
                     return FindCurrentSourceIdResult(
                         repository_name=repository_name,
-                        message=f"No exact match for '{repository_name}', but found {len(fallback_result)} potential matches using repo name '{repo_only}'.",
+                        message=message,
                         suggestion="Review the candidates below and determine which source best matches the current repository.",
                         candidates=[
                             SourceCandidate(
@@ -174,10 +209,15 @@ async def find_current_source_id() -> FindCurrentSourceIdResult | FindCurrentSou
 
             # Absolutely no matches found
             logger.warning(f"No sources found for repository: {repository_name}")
+
+            message = "The repository may not be connected to GitGuardian, or you may not have access to it."
+            if detection_method == "directory name":
+                message += f" Note: repository name was inferred from {detection_method}, which may not match the actual GitGuardian source name."
+
             return FindCurrentSourceIdError(
                 repository_name=repository_name,
                 error=f"Repository '{repository_name}' not found in GitGuardian",
-                message="The repository may not be connected to GitGuardian, or you may not have access to it.",
+                message=message,
                 suggestion="Check that the repository is properly connected to GitGuardian and that your account has access to it.",
             )
 

tests/tools/test_find_current_source_id.py

@@ -41,6 +41,7 @@ async def test_find_current_source_id_exact_match(self, mock_gitguardian_client)
                 text=True,
                 check=True,
                 timeout=5,
+                cwd=".",
             )
 
             # Verify client was called with parsed repository name (just repo name, not org/repo)
@@ -147,40 +148,78 @@ async def test_find_current_source_id_no_match_at_all(self, mock_gitguardian_cli
             assert "not found in GitGuardian" in result.error
 
     @pytest.mark.asyncio
-    async def test_find_current_source_id_not_a_git_repo(self, mock_gitguardian_client):
+    async def test_find_current_source_id_not_a_git_repo_fallback_to_dir_name(self, mock_gitguardian_client):
         """
         GIVEN: The current directory is not a git repository
         WHEN: Attempting to find the source_id
-        THEN: An error is returned
+        THEN: The tool falls back to using the directory name and searches GitGuardian
         """
         # Mock git command to raise an error
-        with patch("subprocess.run") as mock_run:
+        with (
+            patch("subprocess.run") as mock_run,
+            patch("os.path.abspath") as mock_abspath,
+            patch("pathlib.Path") as mock_path,
+        ):
             mock_run.side_effect = subprocess.CalledProcessError(128, "git", stderr="not a git repository")
+            mock_abspath.return_value = "/some/path/my-repo-name"
+
+            # Mock Path to return the directory name
+            mock_path_instance = MagicMock()
+            mock_path_instance.name = "my-repo-name"
+            mock_path.return_value = mock_path_instance
+
+            # Mock GitGuardian client to return a match
+            mock_response = {
+                "id": "source_fallback",
+                "full_name": "org/my-repo-name",
+                "url": "https://github.com/org/my-repo-name",
+            }
+            mock_gitguardian_client.get_source_by_name = AsyncMock(return_value=mock_response)
 
             # Call the function
             result = await find_current_source_id()
 
-            # Verify error response
-            assert hasattr(result, "error")
-            assert "Not a git repository" in result.error
+            # Verify it used directory name and found a match
+            assert result.repository_name == "my-repo-name"
+            assert result.source_id == "source_fallback"
+            assert "directory name" in result.message
 
     @pytest.mark.asyncio
-    async def test_find_current_source_id_git_timeout(self, mock_gitguardian_client):
+    async def test_find_current_source_id_git_timeout_fallback(self, mock_gitguardian_client):
         """
         GIVEN: The git command times out
         WHEN: Attempting to find the source_id
-        THEN: An error is returned
+        THEN: The tool falls back to using the directory name
         """
         # Mock git command to timeout
-        with patch("subprocess.run") as mock_run:
+        with (
+            patch("subprocess.run") as mock_run,
+            patch("os.path.abspath") as mock_abspath,
+            patch("pathlib.Path") as mock_path,
+        ):
             mock_run.side_effect = subprocess.TimeoutExpired("git", 5)
+            mock_abspath.return_value = "/some/path/timeout-repo"
+
+            # Mock Path to return the directory name
+            mock_path_instance = MagicMock()
+            mock_path_instance.name = "timeout-repo"
+            mock_path.return_value = mock_path_instance
+
+            # Mock GitGuardian client to return a match
+            mock_response = {
+                "id": "source_timeout",
+                "full_name": "org/timeout-repo",
+                "url": "https://github.com/org/timeout-repo",
+            }
+            mock_gitguardian_client.get_source_by_name = AsyncMock(return_value=mock_response)
 
             # Call the function
             result = await find_current_source_id()
 
-            # Verify error response
-            assert hasattr(result, "error")
-            assert "timed out" in result.error
+            # Verify it used directory name fallback
+            assert result.repository_name == "timeout-repo"
+            assert result.source_id == "source_timeout"
+            assert "directory name" in result.message
 
     @pytest.mark.asyncio
     async def test_find_current_source_id_invalid_url(self, mock_gitguardian_client):
@@ -284,3 +323,77 @@ async def test_find_current_source_id_client_error(self, mock_gitguardian_client
             # Verify error response
             assert hasattr(result, "error")
             assert "Failed to find source_id" in result.error
+
+    @pytest.mark.asyncio
+    async def test_find_current_source_id_custom_path(self, mock_gitguardian_client):
+        """
+        GIVEN: A custom repository path is provided
+        WHEN: Finding the source_id
+        THEN: The git command runs in the specified directory
+        """
+        custom_path = "/path/to/custom/repo"
+
+        # Mock git command
+        with patch("subprocess.run") as mock_run:
+            mock_run.return_value = MagicMock(
+                stdout="https://github.com/GitGuardian/custom-repo.git\n",
+                returncode=0,
+            )
+
+            # Mock the client response
+            mock_response = {
+                "id": "source_custom",
+                "full_name": "GitGuardian/custom-repo",
+                "url": "https://github.com/GitGuardian/custom-repo",
+            }
+            mock_gitguardian_client.get_source_by_name = AsyncMock(return_value=mock_response)
+
+            # Call the function with custom path
+            result = await find_current_source_id(repository_path=custom_path)
+
+            # Verify git command was called with custom path
+            mock_run.assert_called_once_with(
+                ["git", "config", "--get", "remote.origin.url"],
+                capture_output=True,
+                text=True,
+                check=True,
+                timeout=5,
+                cwd=custom_path,
+            )
+
+            # Verify response
+            assert result.repository_name == "custom-repo"
+            assert result.source_id == "source_custom"
+
+    @pytest.mark.asyncio
+    async def test_find_current_source_id_fallback_no_match(self, mock_gitguardian_client):
+        """
+        GIVEN: The directory is not a git repo and the directory name doesn't match any source
+        WHEN: Attempting to find the source_id
+        THEN: An error is returned with helpful information about the fallback
+        """
+        # Mock git command to raise an error
+        with (
+            patch("subprocess.run") as mock_run,
+            patch("os.path.abspath") as mock_abspath,
+            patch("pathlib.Path") as mock_path,
+        ):
+            mock_run.side_effect = subprocess.CalledProcessError(128, "git", stderr="not a git repository")
+            mock_abspath.return_value = "/some/path/unknown-repo"
+
+            # Mock Path to return the directory name
+            mock_path_instance = MagicMock()
+            mock_path_instance.name = "unknown-repo"
+            mock_path.return_value = mock_path_instance
+
+            # Mock GitGuardian client to return no matches
+            mock_gitguardian_client.get_source_by_name = AsyncMock(return_value=[])
+
+            # Call the function
+            result = await find_current_source_id()
+
+            # Verify error response with fallback info
+            assert result.repository_name == "unknown-repo"
+            assert hasattr(result, "error")
+            assert "not found in GitGuardian" in result.error
+            assert "directory name" in result.message