Merge branch 'main' into improve-env

Cheelax · Cheelax · commit b11aafa3cd1c · 2025-07-07T14:50:03.000+02:00
diff --git a/.github/workflows/docker_image.yml b/.github/workflows/docker_image.yml
@@ -0,0 +1,24 @@
+name: Build Docker Image
+
+on:
+  pull_request:
+    branches: [ main ]
+  workflow_dispatch:
+
+jobs:
+  docker:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Build
+        uses: docker/build-push-action@v6
+        with:
+          push: false
+          context: .
+          file: Dockerfile
+          tags: "${{ github.sha }}"
diff --git a/.github/workflows/publish_to_pypi.yml b/.github/workflows/publish_to_pypi.yml
diff --git a/pyproject.toml b/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)
 ]
@@ -44,7 +45,7 @@ dev = [
 ]
 
 [project.scripts]
-gitingest = "gitingest.cli:main"
+gitingest = "gitingest.__main__:main"
 
 [project.urls]
 homepage = "https://gitingest.com"
diff --git a/requirements.txt b/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
diff --git a/src/gitingest/__main__.py b/src/gitingest/__main__.py
diff --git a/src/gitingest/utils/git_utils.py b/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)
 
 
diff --git a/src/server/main.py b/src/server/main.py
@@ -85,17 +85,17 @@ 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.
+    """Serve the ``llms.txt`` file to provide information about the site to LLMs.
 
     Returns
     -------
     FileResponse
-        The ``llm.txt`` file located in the static directory.
+        The ``llms.txt`` file located in the static directory.
 
     """
-    return FileResponse("static/llm.txt")
+    return FileResponse("static/llms.txt")
 
 
 # Include routers for modular endpoints
diff --git a/src/server/templates/components/navbar.jinja b/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">
diff --git a/src/static/llms.txt b/src/static/llms.txt
diff --git a/tests/test_cli.py b/tests/test_cli.py
@@ -8,7 +8,7 @@
 import pytest
 from click.testing import CliRunner, Result
 
-from gitingest.cli import main
+from gitingest.__main__ import main
 from gitingest.config import MAX_FILE_SIZE, OUTPUT_FILE_NAME
 
 
@@ -72,8 +72,8 @@ def test_cli_with_stdout_output() -> None:
         # ─── core expectations (stdout) ────────────────────────────────────-
         assert result.exit_code == 0, f"CLI exited with code {result.exit_code}, stderr: {result.stderr}"
         assert "---" in result.stdout, "Expected file separator '---' not found in STDOUT"
-        assert "src/gitingest/cli.py" in result.stdout, (
-            "Expected content (e.g., src/gitingest/cli.py) not found in STDOUT"
+        assert "src/gitingest/__main__.py" in result.stdout, (
+            "Expected content (e.g., src/gitingest/__main__.py) not found in STDOUT"
         )
         assert not output_file.exists(), f"Output file {output_file} was unexpectedly created."
 
diff --git a/tests/test_clone.py b/tests/test_clone.py
@@ -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.
diff --git a/tests/test_git_utils.py b/tests/test_git_utils.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
