kodit 0.2.7__tar.gz → 0.2.8__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kodit
-Version: 0.2.7
+Version: 0.2.8
 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.7 → kodit-0.2.8}/src/kodit/_version.py

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

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

@@ -1,5 +1,6 @@
 """Working copy provider for git-based sources."""
 
+import hashlib
 from pathlib import Path
 
 import git
@@ -21,8 +22,10 @@ class GitWorkingCopyProvider:
         # 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(":", "_")
+        # Use a repeatable, short sha256 hash of the sanitized URI for the directory
+        dir_hash = hashlib.sha256(sanitized_uri.encode("utf-8")).hexdigest()[:16]
+        dir_name = f"repo-{dir_hash}"
+        clone_path = self.clone_dir / dir_name
         clone_path.mkdir(parents=True, exist_ok=True)
 
         try:

{kodit-0.2.7 → kodit-0.2.8}/tests/kodit/infrastructure/cloning/git/working_copy_test.py

@@ -1,5 +1,6 @@
 """Tests for the git working copy provider module."""
 
+import hashlib
 from pathlib import Path
 from unittest.mock import patch
 
@@ -7,6 +8,7 @@ import git
 import pytest
 
 from kodit.infrastructure.cloning.git.working_copy import GitWorkingCopyProvider
+from kodit.infrastructure.git.git_utils import sanitize_git_url
 
 
 @pytest.fixture
@@ -15,6 +17,13 @@ def working_copy(tmp_path: Path) -> GitWorkingCopyProvider:
     return GitWorkingCopyProvider(tmp_path)
 
 
+def get_expected_directory_name(uri: str) -> str:
+    """Get the expected directory name for a given URI."""
+    sanitized_uri = sanitize_git_url(uri)
+    dir_hash = hashlib.sha256(sanitized_uri.encode("utf-8")).hexdigest()[:16]
+    return f"repo-{dir_hash}"
+
+
 @pytest.mark.asyncio
 async def test_prepare_should_not_leak_credentials_in_directory_name(
     working_copy: GitWorkingCopyProvider, tmp_path: Path
@@ -28,14 +37,7 @@ async def test_prepare_should_not_leak_credentials_in_directory_name(
         "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):
+    for pat_url in pat_urls:
         # Mock git.Repo.clone_from to avoid actual cloning
         with patch("git.Repo.clone_from") as mock_clone:
             # Call the prepare method
@@ -43,8 +45,9 @@ async def test_prepare_should_not_leak_credentials_in_directory_name(
 
             # 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}"
+            expected_name = get_expected_directory_name(pat_url)
+            assert directory_name == expected_name, (
+                f"Directory name should match expected hash: {directory_name}"
             )
 
             # Verify that the directory name doesn't contain the PAT/token
@@ -63,6 +66,47 @@ async def test_prepare_should_not_leak_credentials_in_directory_name(
             assert result_path.is_dir()
 
 
+@pytest.mark.asyncio
+async def test_prepare_should_not_exceed_windows_path_limit(
+    working_copy: GitWorkingCopyProvider, tmp_path: Path
+) -> None:
+    """Test that directory names never exceed Windows 256 character path limit."""
+    # Create a URL that, when sanitized and converted to directory name, would exceed 256 characters
+    # This URL is designed to be extremely long to trigger the Windows path limit issue
+    long_url = (
+        "https://extremely-long-domain-name-that-will-definitely-exceed-windows-path-limits-and-cause-issues.com/"
+        "very-long-organization-name-with-many-words-and-descriptive-text/"
+        "very-long-project-name-with-additional-descriptive-text/"
+        "_git/"
+        "extremely-long-repository-name-with-many-subdirectories-and-deeply-nested-paths-that-cause-issues-on-windows-systems-and-this-is-just-the-beginning-of-the-very-long-name-that-continues-for-many-more-characters-to-ensure-we-hit-the-limit"
+    )
+
+    # 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(long_url)
+
+        # Get the directory name that would be created
+        directory_name = result_path.name
+
+        # Print the actual directory name and its length for debugging
+        print(f"Directory name: {directory_name}")
+        print(f"Directory name length: {len(directory_name)}")
+
+        # This test should PASS because the directory name is now a short hash
+        # The directory name should be in format "repo-<16-char-hash>" (21 characters total)
+        assert len(directory_name) <= 256, (
+            f"Directory name exceeds Windows 256 character path limit: "
+            f"{len(directory_name)} characters: {directory_name}"
+        )
+        assert directory_name.startswith("repo-"), (
+            f"Directory name should start with 'repo-': {directory_name}"
+        )
+        assert len(directory_name) == 21, (
+            f"Directory name should be exactly 21 characters: {directory_name}"
+        )
+
+
 @pytest.mark.asyncio
 async def test_prepare_clean_urls_should_work_normally(
     working_copy: GitWorkingCopyProvider, tmp_path: Path
@@ -74,13 +118,7 @@ async def test_prepare_clean_urls_should_work_normally(
         "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):
+    for clean_url in clean_urls:
         # Mock git.Repo.clone_from to avoid actual cloning
         with patch("git.Repo.clone_from") as mock_clone:
             # Call the prepare method
@@ -88,8 +126,9 @@ async def test_prepare_clean_urls_should_work_normally(
 
             # 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}"
+            expected_name = get_expected_directory_name(clean_url)
+            assert directory_name == expected_name, (
+                f"Directory name should match expected hash: {directory_name}"
             )
 
             # Verify that the directory was created
@@ -107,12 +146,7 @@ async def test_prepare_ssh_urls_should_work_normally(
         "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):
+    for ssh_url in ssh_urls:
         # Mock git.Repo.clone_from to avoid actual cloning
         with patch("git.Repo.clone_from") as mock_clone:
             # Call the prepare method
@@ -120,8 +154,9 @@ async def test_prepare_ssh_urls_should_work_normally(
 
             # 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}"
+            expected_name = get_expected_directory_name(ssh_url)
+            assert directory_name == expected_name, (
+                f"Directory name should match expected hash: {directory_name}"
             )
 
             # Verify that the directory was created