Merge branch 'main' into 365_improve_ui_and_backend

Author: ix-56h

pyproject.toml

@@ -7,12 +7,13 @@ requires-python = ">= 3.8"
 dependencies = [
     "click>=8.0.0",
     "fastapi[standard]>=0.109.1",  # Minimum safe release (https://osv.dev/vulnerability/PYSEC-2024-38)
+    "httpx",
+    "pathspec>=0.12.1",
     "pydantic",
     "python-dotenv",
     "slowapi",
     "starlette>=0.40.0",  # Minimum safe release (https://osv.dev/vulnerability/GHSA-f96h-pmfr-66vw)
     "tiktoken>=0.7.0",  # Support for o200k_base encoding
-    "pathspec>=0.12.1",
     "typing_extensions>= 4.0.0; python_version < '3.10'",
     "uvicorn>=0.11.7",  # Minimum safe release (https://osv.dev/vulnerability/PYSEC-2020-150)
 ]

requirements.txt

@@ -1,5 +1,6 @@
 click>=8.0.0
 fastapi[standard]>=0.109.1  # Vulnerable to https://osv.dev/vulnerability/PYSEC-2024-38
+httpx
 pathspec>=0.12.1
 pydantic
 python-dotenv

src/gitingest/utils/git_utils.py

@@ -4,22 +4,17 @@
 
 import asyncio
 import base64
-import os
 import re
+import sys
 from typing import Final
 from urllib.parse import urlparse
 
-from starlette.status import (
-    HTTP_200_OK,
-    HTTP_301_MOVED_PERMANENTLY,
-    HTTP_302_FOUND,
-    HTTP_401_UNAUTHORIZED,
-    HTTP_403_FORBIDDEN,
-    HTTP_404_NOT_FOUND,
-)
+import httpx
+from starlette.status import HTTP_200_OK, HTTP_401_UNAUTHORIZED, HTTP_403_FORBIDDEN, HTTP_404_NOT_FOUND
 
 from gitingest.utils.compat_func import removesuffix
 from gitingest.utils.exceptions import InvalidGitHubTokenError
+from server.server_utils import Colors
 
 # GitHub Personal-Access tokens (classic + fine-grained).
 #   - ghp_ / gho_ / ghu_ / ghs_ / ghr_  → 36 alphanumerics
@@ -81,6 +76,8 @@ async def run_command(*args: str) -> tuple[bytes, bytes]:
 async def ensure_git_installed() -> None:
     """Ensure Git is installed and accessible on the system.
 
+    On Windows, this also checks whether Git is configured to support long file paths.
+
     Raises
     ------
     RuntimeError
@@ -92,6 +89,20 @@ async def ensure_git_installed() -> None:
     except RuntimeError as exc:
         msg = "Git is not installed or not accessible. Please install Git first."
         raise RuntimeError(msg) from exc
+    if sys.platform == "win32":
+        try:
+            stdout, _ = await run_command("git", "config", "core.longpaths")
+            if stdout.decode().strip().lower() != "true":
+                print(
+                    f"{Colors.BROWN}WARN{Colors.END}: {Colors.RED}Git clone may fail on Windows "
+                    f"due to long file paths:{Colors.END}",
+                )
+                print(f"{Colors.RED}To avoid this issue, consider enabling long path support with:{Colors.END}")
+                print(f"{Colors.RED}    git config --global core.longpaths true{Colors.END}")
+                print(f"{Colors.RED}Note: This command may require administrator privileges.{Colors.END}")
+        except RuntimeError:
+            # Ignore if checking 'core.longpaths' fails.
+            pass
 
 
 async def check_repo_exists(url: str, token: str | None = None) -> bool:
@@ -115,45 +126,28 @@ async def check_repo_exists(url: str, token: str | None = None) -> bool:
         If the host returns an unrecognised status code.
 
     """
-    # TODO: use `requests` instead of `curl`
-    cmd: list[str] = [
-        "curl",
-        "--silent",  # Suppress output
-        "--location",  # Follow redirects
-        "--write-out",
-        "%{http_code}",  # Write the HTTP status code to stdout
-        "-o",
-        os.devnull,
-    ]
+    headers = {}
 
     if token and is_github_host(url):
         host, owner, repo = _parse_github_url(url)
         # Public GitHub vs. GitHub Enterprise
         base_api = "https://api.github.com" if host == "github.com" else f"https://{host}/api/v3"
         url = f"{base_api}/repos/{owner}/{repo}"
-        cmd += ["--header", f"Authorization: Bearer {token}"]
-
-    cmd.append(url)
+        headers["Authorization"] = f"Bearer {token}"
 
-    proc = await asyncio.create_subprocess_exec(
-        *cmd,
-        stdout=asyncio.subprocess.PIPE,
-        stderr=asyncio.subprocess.PIPE,
-    )
-    stdout, _ = await proc.communicate()
+    async with httpx.AsyncClient(follow_redirects=True) as client:
+        try:
+            response = await client.head(url, headers=headers)
+        except httpx.RequestError:
+            return False
 
-    if proc.returncode != 0:
-        return False
+    status_code = response.status_code
 
-    status = int(stdout.decode().strip())
-    if status in {HTTP_200_OK, HTTP_301_MOVED_PERMANENTLY}:
+    if status_code == HTTP_200_OK:
         return True
-    # TODO: handle 302 redirects
-    if status in {HTTP_404_NOT_FOUND, HTTP_302_FOUND}:
-        return False
-    if status in {HTTP_401_UNAUTHORIZED, HTTP_403_FORBIDDEN}:
+    if status_code in {HTTP_401_UNAUTHORIZED, HTTP_403_FORBIDDEN, HTTP_404_NOT_FOUND}:
         return False
-    msg = f"Unexpected HTTP status {status} for {url}"
+    msg = f"Unexpected HTTP status {status_code} for {url}"
     raise RuntimeError(msg)
 
 

src/server/main.py

@@ -89,20 +89,20 @@ async def robots() -> FileResponse:
     return FileResponse("static/robots.txt")
 
 
-@app.get("/llm.txt")
+@app.get("/llms.txt")
 async def llm_txt() -> FileResponse:
     """Serve the llm.txt file to provide information about the site to LLMs.
 
-    **This endpoint serves the ``llm.txt`` file located in the static directory**
+    **This endpoint serves the ``llms.txt`` file located in the static directory**
     to provide information about the site to Large Language Models (LLMs)
     and other AI systems that may be crawling the site.
 
     **Returns**
 
-    - **FileResponse**: The ``llm.txt`` file located in the static directory
+    - **FileResponse**: The ``llms.txt`` file located in the static directory
 
     """
-    return FileResponse("static/llm.txt")
+    return FileResponse("static/llms.txt")
 
 
 @app.get("/docs", response_class=HTMLResponse, include_in_schema=False)

src/server/templates/components/navbar.jinja

@@ -11,9 +11,9 @@
             </div>
             {# Navigation with updated styling #}
             <nav class="flex items-center space-x-6">
-                <a href="/llm.txt" class="link-bounce flex items-center text-gray-900">
+                <a href="/llms.txt" class="link-bounce flex items-center text-gray-900">
                     <span class="badge-new">NEW</span>
-                    /llm.txt
+                    /llms.txt
                 </a>
                 {# GitHub link #}
                 <div class="flex items-center gap-2">

src/static/llm.txt src/static/llms.txtsrc/static/llm.txt renamed to src/static/llms.txt

@@ -9,8 +9,10 @@
 from pathlib import Path
 from unittest.mock import AsyncMock
 
+import httpx
 import pytest
 from pytest_mock import MockerFixture
+from starlette.status import HTTP_200_OK, HTTP_401_UNAUTHORIZED, HTTP_403_FORBIDDEN, HTTP_404_NOT_FOUND
 
 from gitingest.clone import clone_repo
 from gitingest.schemas import CloneConfig
@@ -87,35 +89,24 @@ async def test_clone_nonexistent_repository(repo_exists_true: AsyncMock) -> None
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
-    ("mock_stdout", "return_code", "expected"),
+    ("status_code", "expected"),
     [
-        (b"200\n", 0, True),  # Existing repo
-        (b"404\n", 0, False),  # Non-existing repo
-        (b"200\n", 1, False),  # Failed request
+        (HTTP_200_OK, True),
+        (HTTP_401_UNAUTHORIZED, False),
+        (HTTP_403_FORBIDDEN, False),
+        (HTTP_404_NOT_FOUND, False),
     ],
 )
-async def test_check_repo_exists(
-    mock_stdout: bytes,
-    *,
-    return_code: int,
-    expected: bool,
-    mocker: MockerFixture,
-) -> None:
-    """Test the ``check_repo_exists`` function with different Git HTTP responses.
-
-    Given various stdout lines and return codes:
-    When ``check_repo_exists`` is called,
-    Then it should correctly indicate whether the repository exists.
-    """
-    mock_exec = mocker.patch("asyncio.create_subprocess_exec", new_callable=AsyncMock)
-    mock_process = AsyncMock()
-    mock_process.communicate.return_value = (mock_stdout, b"")
-    mock_process.returncode = return_code
-    mock_exec.return_value = mock_process
+async def test_check_repo_exists(status_code: int, *, expected: bool, mocker: MockerFixture) -> None:
+    """Verify that ``check_repo_exists`` interprets httpx results correctly."""
+    mock_client = AsyncMock()
+    mock_client.__aenter__.return_value = mock_client  # context-manager protocol
+    mock_client.head.return_value = httpx.Response(status_code=status_code)
+    mocker.patch("httpx.AsyncClient", return_value=mock_client)
 
-    repo_exists = await check_repo_exists(DEMO_URL)
+    result = await check_repo_exists(DEMO_URL)
 
-    assert repo_exists is expected
+    assert result is expected
 
 
 @pytest.mark.asyncio
@@ -218,25 +209,6 @@ async def test_check_repo_exists_with_redirect(mocker: MockerFixture) -> None:
     assert repo_exists is False
 
 
-@pytest.mark.asyncio
-async def test_check_repo_exists_with_permanent_redirect(mocker: MockerFixture) -> None:
-    """Test ``check_repo_exists`` when a permanent redirect (301) is returned.
-
-    Given a URL that responds with "301 Found":
-    When ``check_repo_exists`` is called,
-    Then it should return ``True``, indicating the repo may exist at the new location.
-    """
-    mock_exec = mocker.patch("asyncio.create_subprocess_exec", new_callable=AsyncMock)
-    mock_process = AsyncMock()
-    mock_process.communicate.return_value = (b"301\n", b"")
-    mock_process.returncode = 0  # Simulate successful request
-    mock_exec.return_value = mock_process
-
-    repo_exists = await check_repo_exists(DEMO_URL)
-
-    assert repo_exists
-
-
 @pytest.mark.asyncio
 async def test_clone_with_timeout(run_command_mock: AsyncMock) -> None:
     """Test cloning a repository when a timeout occurs.

tests/test_clone.py

@@ -12,12 +12,7 @@
 import pytest
 
 from gitingest.utils.exceptions import InvalidGitHubTokenError
-from gitingest.utils.git_utils import (
-    create_git_auth_header,
-    create_git_command,
-    is_github_host,
-    validate_github_token,
-)
+from gitingest.utils.git_utils import create_git_auth_header, create_git_command, is_github_host, validate_github_token
 
 if TYPE_CHECKING:
     from pathlib import Path