kodit 0.2.6__tar.gz → 0.2.7__tar.gz

{kodit-0.2.6 → kodit-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kodit
-Version: 0.2.6
+Version: 0.2.7
 Summary: Code indexing for better AI code generation
 Project-URL: Homepage, https://docs.helixml.tech/kodit/
 Project-URL: Documentation, https://docs.helixml.tech/kodit/

{kodit-0.2.6 → kodit-0.2.7}/src/kodit/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.2.6'
-__version_tuple__ = version_tuple = (0, 2, 6)
+__version__ = version = '0.2.7'
+__version_tuple__ = version_tuple = (0, 2, 7)

{kodit-0.2.6 → kodit-0.2.7}/src/kodit/infrastructure/cloning/git/factory.py

@@ -17,6 +17,7 @@ from kodit.infrastructure.cloning.metadata import (
     GitAuthorExtractor,
     GitFileMetadataExtractor,
 )
+from kodit.infrastructure.git.git_utils import sanitize_git_url
 from kodit.infrastructure.ignore.ignore_pattern_provider import GitIgnorePatternProvider
 
 
@@ -46,28 +47,33 @@ class GitSourceFactory:
             progress_callback = NullProgressCallback()
 
         # Normalize the URI
-        self.log.debug("Normalising git uri", uri=uri)
+        # Never log the raw URI in production
+        self.log.debug("Normalising git uri", uri="[REDACTED]" + uri[-4:])
         with tempfile.TemporaryDirectory() as temp_dir:
             git.Repo.clone_from(uri, temp_dir)
             remote = git.Repo(temp_dir).remote()
             uri = remote.url
 
+        # Sanitize the URI to remove any credentials
+        sanitized_uri = sanitize_git_url(uri)
+        self.log.debug("Sanitized git uri", sanitized_uri=sanitized_uri)
+
         # Check if source already exists
-        self.log.debug("Checking if source already exists", uri=uri)
-        source = await self.repository.get_by_uri(uri)
+        self.log.debug("Checking if source already exists", uri=sanitized_uri)
+        source = await self.repository.get_by_uri(sanitized_uri)
 
         if source:
             self.log.info("Source already exists, reusing...", source_id=source.id)
             return source
 
-        # Prepare working copy
+        # Prepare working copy (use original URI for cloning, sanitized for storage)
         clone_path = await self.working_copy.prepare(uri)
 
         # Create source record
-        self.log.debug("Creating source", uri=uri, clone_path=str(clone_path))
+        self.log.debug("Creating source", uri=sanitized_uri, clone_path=str(clone_path))
         source = await self.repository.save(
             Source(
-                uri=uri,
+                uri=sanitized_uri,
                 cloned_path=str(clone_path),
                 source_type=SourceType.GIT,
             )

{kodit-0.2.6 → kodit-0.2.7}/src/kodit/infrastructure/cloning/git/working_copy.py

@@ -5,6 +5,8 @@ from pathlib import Path
 import git
 import structlog
 
+from kodit.infrastructure.git.git_utils import sanitize_git_url
+
 
 class GitWorkingCopyProvider:
     """Working copy provider for git-based sources."""
@@ -16,17 +18,23 @@ class GitWorkingCopyProvider:
 
     async def prepare(self, uri: str) -> Path:
         """Prepare a Git working copy."""
-        # Create a unique directory name for the clone
-        clone_path = self.clone_dir / uri.replace("/", "_").replace(":", "_")
+        # Sanitize the URI for directory name to prevent credential leaks
+        sanitized_uri = sanitize_git_url(uri)
+
+        # Create a unique directory name for the clone using the sanitized URI
+        clone_path = self.clone_dir / sanitized_uri.replace("/", "_").replace(":", "_")
         clone_path.mkdir(parents=True, exist_ok=True)
 
         try:
-            self.log.info("Cloning repository", uri=uri, clone_path=str(clone_path))
+            self.log.info(
+                "Cloning repository", uri=sanitized_uri, clone_path=str(clone_path)
+            )
+            # Use the original URI for cloning (with credentials if present)
             git.Repo.clone_from(uri, clone_path)
         except git.GitCommandError as e:
             if "already exists and is not an empty directory" not in str(e):
                 msg = f"Failed to clone repository: {e}"
                 raise ValueError(msg) from e
-            self.log.info("Repository already exists, reusing...", uri=uri)
+            self.log.info("Repository already exists, reusing...", uri=sanitized_uri)
 
         return clone_path

kodit-0.2.7/src/kodit/infrastructure/git/git_utils.py

@@ -0,0 +1,87 @@
+"""Git utilities for infrastructure operations."""
+
+import tempfile
+from urllib.parse import urlparse, urlunparse
+
+import git
+
+
+def is_valid_clone_target(target: str) -> bool:
+    """Return True if the target is clonable.
+
+    Args:
+        target: The git repository URL or path to validate.
+
+    Returns:
+        True if the target can be cloned, False otherwise.
+
+    """
+    with tempfile.TemporaryDirectory() as temp_dir:
+        try:
+            git.Repo.clone_from(target, temp_dir)
+        except git.GitCommandError:
+            return False
+        else:
+            return True
+
+
+def sanitize_git_url(url: str) -> str:
+    """Remove credentials from a git URL while preserving the rest of the URL structure.
+
+    This function handles various git URL formats:
+    - HTTPS URLs with username:password@host
+    - HTTPS URLs with username@host (no password)
+    - SSH URLs (left unchanged)
+    - File URLs (left unchanged)
+
+    Args:
+        url: The git URL that may contain credentials.
+
+    Returns:
+        The sanitized URL with credentials removed.
+
+    Examples:
+        >>> sanitize_git_url("https://phil:token@dev.azure.com/org/project/_git/repo")
+        "https://dev.azure.com/org/project/_git/repo"
+        >>> sanitize_git_url("https://username@github.com/user/repo.git")
+        "https://github.com/user/repo.git"
+        >>> sanitize_git_url("git@github.com:user/repo.git")
+        "git@github.com:user/repo.git"
+
+    """
+    # Handle SSH URLs (they don't have credentials in the URL format)
+    if url.startswith(("git@", "ssh://")):
+        return url
+
+    # Handle file URLs
+    if url.startswith("file://"):
+        return url
+
+    try:
+        # Parse the URL
+        parsed = urlparse(url)
+
+        # If there are no credentials, return the URL as-is
+        if not parsed.username:
+            return url
+
+        # Reconstruct the URL without credentials
+        # Keep scheme, netloc (without username/password), path, params, query, fragment
+        sanitized_netloc = parsed.hostname
+        if parsed.port:
+            sanitized_netloc = f"{parsed.hostname}:{parsed.port}"
+
+        return urlunparse(
+            (
+                parsed.scheme,
+                sanitized_netloc,
+                parsed.path,
+                parsed.params,
+                parsed.query,
+                parsed.fragment,
+            )
+        )
+
+    except Exception:  # noqa: BLE001
+        # If URL parsing fails, return the original URL
+        return url

kodit-0.2.7/tests/kodit/infrastructure/cloning/git/factory_test.py

@@ -0,0 +1,225 @@
+"""Tests for the git source factory module."""
+
+import tempfile
+from pathlib import Path
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import git
+import pytest
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from kodit.domain.entities import Source, SourceType
+from kodit.domain.interfaces import NullProgressCallback
+from kodit.domain.repositories import SourceRepository
+from kodit.infrastructure.cloning.git.factory import GitSourceFactory
+from kodit.infrastructure.cloning.git.working_copy import GitWorkingCopyProvider
+
+
+@pytest.fixture
+def mock_repository() -> AsyncMock:
+    """Create a mock repository."""
+    return AsyncMock(spec=SourceRepository)
+
+
+@pytest.fixture
+def mock_working_copy() -> AsyncMock:
+    """Create a mock working copy provider."""
+    return AsyncMock(spec=GitWorkingCopyProvider)
+
+
+@pytest.fixture
+def mock_session() -> AsyncMock:
+    """Create a mock database session."""
+    return AsyncMock(spec=AsyncSession)
+
+
+@pytest.fixture
+def factory(
+    mock_repository: AsyncMock,
+    mock_working_copy: AsyncMock,
+    mock_session: AsyncMock,
+) -> GitSourceFactory:
+    """Create a GitSourceFactory instance with mocked dependencies."""
+    return GitSourceFactory(
+        repository=mock_repository,
+        working_copy=mock_working_copy,
+        session=mock_session,
+    )
+
+
+@pytest.mark.asyncio
+async def test_url_normalization_with_pat_should_sanitize_credentials(
+    factory: GitSourceFactory, tmp_path: Path
+) -> None:
+    """Test that URLs with personal access tokens are properly sanitized."""
+    # URLs with PATs that should be sanitized
+    pat_urls = [
+        "https://phil:7lKCobJPAY1ekOS5kxxxxxxxx@dev.azure.com/winderai/private-test/_git/private-test",
+        "https://winderai@dev.azure.com/winderai/private-test/_git/private-test",
+        "https://username:token123@github.com/username/repo.git",
+        "https://user:pass@gitlab.com/user/repo.git",
+    ]
+
+    expected_sanitized = [
+        "https://dev.azure.com/winderai/private-test/_git/private-test",
+        "https://dev.azure.com/winderai/private-test/_git/private-test",
+        "https://github.com/username/repo.git",
+        "https://gitlab.com/user/repo.git",
+    ]
+
+    for i, pat_url in enumerate(pat_urls):
+        # Mock the repository to return None (source doesn't exist)
+        factory.repository.get_by_uri = AsyncMock(return_value=None)
+
+        # Mock the working copy to return a temporary path
+        temp_clone_path = tmp_path / f"clone_{i}"
+        temp_clone_path.mkdir()
+        factory.working_copy.prepare = AsyncMock(return_value=temp_clone_path)
+
+        # Mock the source creation - return a real Source object with the URI that was passed to save
+        def mock_save(source_arg):
+            # Return the actual Source object that was passed in
+            return source_arg
+
+        factory.repository.save = AsyncMock(side_effect=mock_save)
+
+        # Create a temporary git repo to simulate the clone
+        with tempfile.TemporaryDirectory() as temp_dir:
+            repo = git.Repo.init(temp_dir)
+
+            # Mock the remote URL to return the PAT URL (this simulates the current bug)
+            with patch.object(repo, "remote") as mock_remote:
+                mock_remote.return_value.url = pat_url
+
+                with patch("git.Repo.clone_from") as mock_clone:
+                    with patch("git.Repo") as mock_git_repo:
+                        mock_git_repo.return_value = repo
+
+                        # Call the create method
+                        result = await factory.create(pat_url)
+
+                        # Verify that the URL was sanitized by checking what was passed to repository.save
+                        assert result.uri == expected_sanitized[i], (
+                            f"URL should be sanitized: {pat_url} -> {expected_sanitized[i]}"
+                        )
+
+                        # Also verify that repository.save was called with the correct URI
+                        save_call_args = factory.repository.save.call_args
+                        assert save_call_args is not None, (
+                            "repository.save should have been called"
+                        )
+                        saved_source = save_call_args[0][0]  # First positional argument
+                        assert saved_source.uri == expected_sanitized[i], (
+                            f"repository.save was called with wrong URI: {saved_source.uri}"
+                        )
+
+
+@pytest.mark.asyncio
+async def test_url_normalization_without_credentials_should_remain_unchanged(
+    factory: GitSourceFactory, tmp_path: Path
+) -> None:
+    """Test that URLs without credentials remain unchanged."""
+    clean_urls = [
+        "https://github.com/username/repo.git",
+        "https://dev.azure.com/winderai/public-test/_git/public-test",
+        "git@github.com:username/repo.git",
+    ]
+
+    for i, clean_url in enumerate(clean_urls):
+        # Mock the repository to return None (source doesn't exist)
+        factory.repository.get_by_uri = AsyncMock(return_value=None)
+
+        # Mock the working copy to return a temporary path
+        temp_clone_path = tmp_path / f"clone_{i}"
+        temp_clone_path.mkdir()
+        factory.working_copy.prepare = AsyncMock(return_value=temp_clone_path)
+
+        # Mock the source creation - return a real Source object with the URI that was passed to save
+        def mock_save(source_arg):
+            # Return the actual Source object that was passed in
+            return source_arg
+
+        factory.repository.save = AsyncMock(side_effect=mock_save)
+
+        # Create a temporary git repo to simulate the clone
+        with tempfile.TemporaryDirectory() as temp_dir:
+            repo = git.Repo.init(temp_dir)
+
+            # Mock the remote URL to return the clean URL
+            with patch.object(repo, "remote") as mock_remote:
+                mock_remote.return_value.url = clean_url
+
+                with patch("git.Repo.clone_from") as mock_clone:
+                    with patch("git.Repo") as mock_git_repo:
+                        mock_git_repo.return_value = repo
+
+                        # Call the create method
+                        result = await factory.create(clean_url)
+
+                        # Verify that the URL remains unchanged
+                        assert result.uri == clean_url
+
+                        # Also verify that repository.save was called with the correct URI
+                        save_call_args = factory.repository.save.call_args
+                        assert save_call_args is not None, (
+                            "repository.save should have been called"
+                        )
+                        saved_source = save_call_args[0][0]  # First positional argument
+                        assert saved_source.uri == clean_url, (
+                            f"repository.save was called with wrong URI: {saved_source.uri}"
+                        )
+
+
+@pytest.mark.asyncio
+async def test_url_normalization_ssh_urls_should_remain_unchanged(
+    factory: GitSourceFactory, tmp_path: Path
+) -> None:
+    """Test that SSH URLs remain unchanged."""
+    ssh_urls = [
+        "git@github.com:username/repo.git",
+        "ssh://git@github.com:2222/username/repo.git",
+    ]
+
+    for i, ssh_url in enumerate(ssh_urls):
+        # Mock the repository to return None (source doesn't exist)
+        factory.repository.get_by_uri = AsyncMock(return_value=None)
+
+        # Mock the working copy to return a temporary path
+        temp_clone_path = tmp_path / f"clone_{i}"
+        temp_clone_path.mkdir()
+        factory.working_copy.prepare = AsyncMock(return_value=temp_clone_path)
+
+        # Mock the source creation - return a real Source object with the URI that was passed to save
+        def mock_save(source_arg):
+            # Return the actual Source object that was passed in
+            return source_arg
+
+        factory.repository.save = AsyncMock(side_effect=mock_save)
+
+        # Create a temporary git repo to simulate the clone
+        with tempfile.TemporaryDirectory() as temp_dir:
+            repo = git.Repo.init(temp_dir)
+
+            # Mock the remote URL to return the SSH URL
+            with patch.object(repo, "remote") as mock_remote:
+                mock_remote.return_value.url = ssh_url
+
+                with patch("git.Repo.clone_from") as mock_clone:
+                    with patch("git.Repo") as mock_git_repo:
+                        mock_git_repo.return_value = repo
+
+                        # Call the create method
+                        result = await factory.create(ssh_url)
+
+                        # Verify that the SSH URL remains unchanged
+                        assert result.uri == ssh_url
+
+                        # Also verify that repository.save was called with the correct URI
+                        save_call_args = factory.repository.save.call_args
+                        assert save_call_args is not None, (
+                            "repository.save should have been called"
+                        )
+                        saved_source = save_call_args[0][0]  # First positional argument
+                        assert saved_source.uri == ssh_url, (
+                            f"repository.save was called with wrong URI: {saved_source.uri}"
+                        )

kodit-0.2.7/tests/kodit/infrastructure/cloning/git/working_copy_test.py

@@ -0,0 +1,168 @@
+"""Tests for the git working copy provider module."""
+
+from pathlib import Path
+from unittest.mock import patch
+
+import git
+import pytest
+
+from kodit.infrastructure.cloning.git.working_copy import GitWorkingCopyProvider
+
+
+@pytest.fixture
+def working_copy(tmp_path: Path) -> GitWorkingCopyProvider:
+    """Create a GitWorkingCopyProvider instance."""
+    return GitWorkingCopyProvider(tmp_path)
+
+
+@pytest.mark.asyncio
+async def test_prepare_should_not_leak_credentials_in_directory_name(
+    working_copy: GitWorkingCopyProvider, tmp_path: Path
+) -> None:
+    """Test that directory names don't contain sensitive credentials."""
+    # URLs with PATs that should not appear in directory names
+    pat_urls = [
+        "https://phil:7lKCobJPAY1ekOS5kxxxxxxxx@dev.azure.com/winderai/private-test/_git/private-test",
+        "https://winderai@dev.azure.com/winderai/private-test/_git/private-test",
+        "https://username:token123@github.com/username/repo.git",
+        "https://user:pass@gitlab.com/user/repo.git",
+    ]
+
+    expected_safe_directories = [
+        "https___dev.azure.com_winderai_private-test__git_private-test",
+        "https___dev.azure.com_winderai_private-test__git_private-test",
+        "https___github.com_username_repo.git",
+        "https___gitlab.com_user_repo.git",
+    ]
+
+    for i, pat_url in enumerate(pat_urls):
+        # Mock git.Repo.clone_from to avoid actual cloning
+        with patch("git.Repo.clone_from") as mock_clone:
+            # Call the prepare method
+            result_path = await working_copy.prepare(pat_url)
+
+            # Verify that the directory name doesn't contain credentials
+            directory_name = result_path.name
+            assert directory_name == expected_safe_directories[i], (
+                f"Directory name should not contain credentials: {directory_name}"
+            )
+
+            # Verify that the directory name doesn't contain the PAT/token
+            assert "7lKCobJPAY1ekOS5kxxxxxxxx" not in directory_name, (
+                f"Directory name contains PAT: {directory_name}"
+            )
+            assert "token123" not in directory_name, (
+                f"Directory name contains token: {directory_name}"
+            )
+            assert "pass" not in directory_name, (
+                f"Directory name contains password: {directory_name}"
+            )
+
+            # Verify that the directory was created
+            assert result_path.exists()
+            assert result_path.is_dir()
+
+
+@pytest.mark.asyncio
+async def test_prepare_clean_urls_should_work_normally(
+    working_copy: GitWorkingCopyProvider, tmp_path: Path
+) -> None:
+    """Test that clean URLs work normally without any issues."""
+    clean_urls = [
+        "https://github.com/username/repo.git",
+        "https://dev.azure.com/winderai/public-test/_git/public-test",
+        "git@github.com:username/repo.git",
+    ]
+
+    expected_directories = [
+        "https___github.com_username_repo.git",
+        "https___dev.azure.com_winderai_public-test__git_public-test",
+        "git@github.com_username_repo.git",
+    ]
+
+    for i, clean_url in enumerate(clean_urls):
+        # Mock git.Repo.clone_from to avoid actual cloning
+        with patch("git.Repo.clone_from") as mock_clone:
+            # Call the prepare method
+            result_path = await working_copy.prepare(clean_url)
+
+            # Verify that the directory name is as expected
+            directory_name = result_path.name
+            assert directory_name == expected_directories[i], (
+                f"Directory name should match expected: {directory_name}"
+            )
+
+            # Verify that the directory was created
+            assert result_path.exists()
+            assert result_path.is_dir()
+
+
+@pytest.mark.asyncio
+async def test_prepare_ssh_urls_should_work_normally(
+    working_copy: GitWorkingCopyProvider, tmp_path: Path
+) -> None:
+    """Test that SSH URLs work normally."""
+    ssh_urls = [
+        "git@github.com:username/repo.git",
+        "ssh://git@github.com:2222/username/repo.git",
+    ]
+
+    expected_directories = [
+        "git@github.com_username_repo.git",
+        "ssh___git@github.com_2222_username_repo.git",
+    ]
+
+    for i, ssh_url in enumerate(ssh_urls):
+        # Mock git.Repo.clone_from to avoid actual cloning
+        with patch("git.Repo.clone_from") as mock_clone:
+            # Call the prepare method
+            result_path = await working_copy.prepare(ssh_url)
+
+            # Verify that the directory name is as expected
+            directory_name = result_path.name
+            assert directory_name == expected_directories[i], (
+                f"Directory name should match expected: {directory_name}"
+            )
+
+            # Verify that the directory was created
+            assert result_path.exists()
+            assert result_path.is_dir()
+
+
+@pytest.mark.asyncio
+async def test_prepare_handles_clone_errors_gracefully(
+    working_copy: GitWorkingCopyProvider, tmp_path: Path
+) -> None:
+    """Test that clone errors are handled gracefully."""
+    url = "https://github.com/username/repo.git"
+
+    # Mock git.Repo.clone_from to raise an error
+    with patch("git.Repo.clone_from") as mock_clone:
+        mock_clone.side_effect = git.GitCommandError(
+            "git", "clone", "Repository not found"
+        )
+
+        # Should raise ValueError for clone errors
+        with pytest.raises(ValueError, match="Failed to clone repository"):
+            await working_copy.prepare(url)
+
+
+@pytest.mark.asyncio
+async def test_prepare_handles_already_exists_error(
+    working_copy: GitWorkingCopyProvider, tmp_path: Path
+) -> None:
+    """Test that 'already exists' errors are handled gracefully."""
+    url = "https://github.com/username/repo.git"
+
+    # Mock git.Repo.clone_from to raise an "already exists" error
+    with patch("git.Repo.clone_from") as mock_clone:
+        mock_clone.side_effect = git.GitCommandError(
+            "git", "clone", "already exists and is not an empty directory"
+        )
+
+        # Should not raise an error for "already exists"
+        result_path = await working_copy.prepare(url)
+
+        # Verify that the directory was created
+        assert result_path.exists()
+        assert result_path.is_dir()