kodit 0.3.6__tar.gz → 0.3.8__tar.gz

{kodit-0.3.6 → kodit-0.3.8}/.github/workflows/docker.yaml

@@ -1,9 +1,9 @@
 name: Publish Docker image
 
 on:
+  workflow_dispatch:
   push:
-  pull_request_target:
-    types: [opened, synchronize, reopened]
+  workflow_call:
 
 env:
   TEST_TAG: user/app:test

{kodit-0.3.6 → kodit-0.3.8}/.github/workflows/test.yaml

@@ -35,6 +35,9 @@ jobs:
       - name: Lint
         run: uv run ruff check
 
+      - name: Run type checks
+        run: uv run mypy --config-file pyproject.toml .
+
       - name: Run tests
         run: uv run pytest -s --cov=src --cov-report=xml tests/kodit
 

{kodit-0.3.6 → kodit-0.3.8}/CLAUDE.md

@@ -14,11 +14,10 @@ Kodit is a code indexing MCP (Model Context Protocol) server that connects AI co
 - `uv run pytest tests/path/to/test.py` - Run specific test file
 - `uv run pytest -k "test_name"` - Run specific test by name
 
-### Code Quality
+### Linting and Typing
 
-- `uv run ruff check --fix` - Run linting
-- `uv run ruff format` - Format code
-- `uv run mypy src/` - Type checking
+- `uv run ruff check --fix --unsafe-fixes` - Run linting and format code
+- `uv run mypy --config-file pyproject.toml ...` - Type checking
 
 ### Application
 

{kodit-0.3.6 → kodit-0.3.8}/Dockerfile

@@ -86,6 +86,10 @@ EOT
 
 STOPSIGNAL SIGINT
 
+# Configure a default data directory so the app can write to it and volumes can be mounted to it
+RUN mkdir -p /data && chown -R app:app /data
+ENV DATA_DIR=/data
+
 USER app
 WORKDIR /app
 

{kodit-0.3.6 → kodit-0.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kodit
-Version: 0.3.6
+Version: 0.3.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/
@@ -30,7 +30,7 @@ Requires-Dist: click>=8.1.8
 Requires-Dist: colorama>=0.4.6
 Requires-Dist: dotenv>=0.9.9
 Requires-Dist: fastapi[standard]>=0.115.12
-Requires-Dist: fastmcp>=2.3.3
+Requires-Dist: fastmcp>=2.10.4
 Requires-Dist: gitpython>=3.1.44
 Requires-Dist: hf-xet>=1.1.2
 Requires-Dist: httpx-retries>=0.3.2
@@ -38,6 +38,7 @@ Requires-Dist: httpx>=0.28.1
 Requires-Dist: openai>=1.82.0
 Requires-Dist: pathspec>=0.12.1
 Requires-Dist: pydantic-settings>=2.9.1
+Requires-Dist: pystemmer>=3.0.0
 Requires-Dist: pytable-formatter>=0.1.1
 Requires-Dist: rudder-sdk-python>=2.1.4
 Requires-Dist: sentence-transformers>=4.1.0

kodit-0.3.8/docs/getting-started/integration/index.md

@@ -0,0 +1,58 @@
+---
+title: Integration With Coding Assistants
+description: How to integrate Kodit with AI coding assistants.
+weight: 3
+---
+
+The core goal of Kodit is to make your AI coding experience more accurate by providing better context. That means you need to integrate Kodit with your favourite assistant.
+
+## MCP Connection Methods
+
+Kodit supports three different ways to run the MCP server, depending on your integration
+needs. Each method exposes the same code search capabilities, but differs in how the
+connection is established and which assistants/tools it is compatible with.
+
+See the [MCP Reference](../../reference/mcp/index.md) for comprehensive integration
+instructions for popular coding assistants like Cursor, Claude, Cline, etc.
+
+### 1. HTTP Streaming (Recommended)
+
+This is the default and recommended method for most users. Kodit runs an HTTP server
+that streams responses to connected AI coding assistants over the `/mcp` endpoint.
+
+1. Start the Kodit server:
+  
+  ```sh
+  kodit serve
+  ```
+
+  _The Kodit container runs this command by default._
+
+2. Configure your AI coding assistant to connect to `http://localhost:8080/mcp`
+
+### 2. STDIO Mode
+
+Kodit can run as an MCP server over standard input/output (STDIO) for direct integration
+with local AI coding assistants that support MCP stdio transport. No network port is
+opened.
+
+1. Configure your AI coding assistant to start Kodit's STDIO server:
+
+  ```sh
+  kodit stdio
+  ```
+
+### 3. SSE (Server-Sent Events) [Deprecated]
+
+Kodit also supports the older SSE protocol on the `/sse` endpoint. This is provided for
+backward compatibility with tools that require SSE.
+
+1. Start the Kodit server:
+  
+  ```sh
+  kodit serve
+  ```
+
+  _The Kodit container runs this command by default._
+
+2. Configure your AI coding assistant to connect to `http://localhost:8080/sse`

{kodit-0.3.6 → kodit-0.3.8}/docs/reference/deployment/docker-compose.yaml

@@ -2,9 +2,9 @@ version: "3.9"
 
 services:
   kodit:
-    image: registry.helix.ml/helix/kodit:latest # Replace with a version
+    image: test:latest
     ports:
-      - "8080:8080" # Expose the MCP server
+      - "8080:8080" # You may wish to pick a less common port
     # Start the Kodit MCP server and bind to all interfaces
     command: ["serve", "--host", "0.0.0.0", "--port", "8080"]
     restart: unless-stopped
@@ -39,11 +39,20 @@ services:
       SYNC_PERIODIC_INTERVAL_SECONDS: 1800  # 30 minutes
       SYNC_PERIODIC_RETRY_ATTEMPTS: 3
 
+      # Logging configuration
+      LOG_LEVEL: INFO # Set to DEBUG for more detailed logging
+
+    volumes:
+      - kodit-data:/data
+
   vectorchord:
     image: tensorchord/vchord-suite:pg17-20250601
     environment:
       - POSTGRES_DB=kodit
       - POSTGRES_PASSWORD=mysecretpassword
     ports:
-      - "5432:5432"
+      - "5432"
     restart: unless-stopped
+
+volumes:
+  kodit-data:

{kodit-0.3.6 → kodit-0.3.8}/docs/reference/mcp/index.md

@@ -4,43 +4,226 @@ description: Model Context Protocol (MCP) server implementation for AI coding as
 weight: 2
 ---
 
-Kodit provides an MCP (Model Context Protocol) server that enables AI coding assistants to search and retrieve relevant code snippets from your indexed codebases. This allows AI assistants to provide more accurate and contextually relevant code suggestions.
+The [Model Context Protocol](https://modelcontextprotocol.io/introduction) (MCP) is a
+standard that enables AI assistants to communicate with external tools and data sources.
 
-## What is MCP?
+Kodit provides an MCP (Model Context Protocol) server that enables AI coding assistants
+to search and retrieve relevant code snippets from your indexed codebases. This allows
+AI assistants to provide more accurate and contextually relevant code suggestions.
 
-The Model Context Protocol (MCP) is a standard that enables AI assistants to communicate with external tools and data sources. Kodit implements an MCP server that exposes your indexed codebases to AI assistants, allowing them to:
+## MCP Server Connection Methods
 
-- Search for relevant code examples
-- Retrieve specific code snippets
-- Filter results by various criteria
-- Provide context-aware code suggestions
+Kodit supports three different ways to run the MCP server, depending on your integration
+needs. Each method exposes the same code search capabilities, but differs in how the
+connection is established and which assistants/tools it is compatible with.
 
-## How Kodit MCP Works
+### HTTP Streaming (Recommended)
 
-The Kodit MCP server runs as a separate service that:
+This is the default and recommended method for most users. Kodit runs an HTTP server
+that streams responses to connected AI coding assistants over the `/mcp` endpoint.
 
-1. **Connects to your indexed codebases** - Uses the same database and indexes created by the `kodit index` command
-2. **Exposes search functionality** - Provides a `search` tool that AI assistants can call
-3. **Handles filtering** - Supports filtering by language, author, date range, and source repository
-4. **Returns relevant snippets** - Combines keyword, semantic code, and semantic text search for optimal results
+- **How it works:** Kodit starts a local web server and listens for HTTP requests from
+  your AI assistant. Responses are streamed for low-latency, real-time results.
+- **When to use:** Most modern AI coding assistants (like Cursor, Cline, etc.) support
+  HTTP streaming. Use this for best compatibility and performance.
+- **How to start:**
+
+  ```sh
+  kodit serve
+  ```
+
+  The server will listen on `http://localhost:8080/mcp` by default. If you're using the
+  Kodit container, `kodit serve` is the default command.
+
+### STDIO
+
+Kodit can run as an MCP server over standard input/output (STDIO) for direct integration
+with local AI coding assistants that support MCP stdio transport. No network port is
+opened.
+
+- **How it works:** Kodit communicates with your AI assistant via standard input and
+  output streams, making it ideal for local, low-latency, and networkless setups.
+- **When to use:** Use this mode if your coding assistant supports MCP stdio (for
+  example, some local LLM tools or advanced IDE integrations), or if you want to avoid
+  network configuration entirely.
+- **How to start:**
+
+  Configure your AI assistant to run the following command:
+  
+  ```sh
+  kodit stdio
+  ```
+
+### SSE (Server-Sent Events) [Deprecated]
+
+Kodit also supports the older SSE protocol on the `/sse` endpoint. This is provided for
+backward compatibility with tools that require SSE.
+
+- **How it works:** Kodit starts a local web server and streams results using the SSE
+  protocol, which is less efficient and less widely supported than HTTP streaming.
+- **When to use:** Only if your assistant specifically requires SSE and does not support
+  HTTP streaming.
+- **How to start:**
+
+  ```sh
+  kodit serve
+  ```
+
+  The server will listen on `http://localhost:8080/sse`.
 
 ## Integration with AI Assistants
 
-To use Kodit with your AI coding assistant, you need to:
+You need to connect your AI coding assistant to take advantage of Kodit. The
+instructions to do this depend on how you've deployed it. This section provides
+comprehensive instructions for all popular coding assistants.
+
+### Integration With Claude Code
+
+#### Claude Code Streaming HTTP Mode (recommended)
+
+```sh
+claude mcp add --transport http kodit http://localhost:8080/mcp
+```
+
+#### Claude Code STDIO Mode
+
+```sh
+claude mcp add kodit -- kodit stdio
+```
+
+### Integration With Cursor
+
+#### Cursor Streaming HTTP Mode (recommended)
+
+![Install MCP Server](https://cursor.com/deeplink/mcp-install-light.svg)
+{class="h-8 inline-block" href="cursor://anysphere.cursor-deeplink/mcp/install?name=kodit&config=eyJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwODAvbWNwIn0%3D"}
+
+Add the following to `$HOME/.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "kodit": {
+      "url": "http://localhost:8080/mcp"
+    }
+  }
+}
+```
+
+Or find this configuration in `Cursor Settings` -> `MCP`. Replace localhost with domain
+where Kodit is hosted.
 
-1. **Start the Kodit MCP server**:
+#### Cursor STDIO
 
-   ```sh
-   kodit serve
-   ```
+![Install MCP Server](https://cursor.com/deeplink/mcp-install-light.svg)
+{class="h-8 inline-block" href="cursor://anysphere.cursor-deeplink/mcp/install?name=kodit&config=eyJjb21tYW5kIjoicGlweCBydW4ga29kaXQgc3RkaW8ifQ%3D%3D"}
 
-2. **Configure your AI assistant** to connect to the MCP server. See the [Integration Guide](../../getting-started/integration/index.md) for detailed instructions for:
-   - Cursor
-   - Cline
-   - Other MCP-compatible assistants
+Add the following to `$HOME/.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "kodit": {
+      "command": "kodit stdio"
+    }
+  }
+}
+```
+
+### Integration With Cline
+
+1. Open Cline from the side menu
+2. Click the `MCP Servers` button at the top right of the Cline window (the icon looks
+   like a server)
+3. Click the `Remote Servers` tab.
+4. Click `Edit Configuration`
+
+#### Cline Streaming HTTP Mode (recommended)
+
+Add the following configuration:
+
+```json
+{
+  "mcpServers": {
+    "kodit": {
+      "autoApprove": [],
+      "disabled": true,
+      "timeout": 60,
+      "url": "http://localhost:8080/mcp",
+      "transportType": "http"
+    }
+  }
+}
+```
+
+Note that some cline users are still [reporting issues with HTTP
+streaming](https://github.com/cline/cline/issues/3315), so you may need to use sse
+instead.
+
+#### Cline STDIO Mode
+
+For STDIO mode, please use:
+
+```json
+{
+  "mcpServers": {
+    "kodit": {
+      "autoApprove": [],
+      "command": "kodit",
+      "args": ["stdio"],
+      "disabled": false,
+    }
+  }
+}
+```
+
+## Forcing AI Assistants to use Kodit
+
+Although Kodit has been developed to work well out of the box with popular AI coding
+assistants, they sometimes still think they know better.
+
+You can force your assistant to use Kodit by editing the system prompt used by the
+assistant. Each assistant exposes this slightly differently, but it's usually in the
+settings.
+
+Try using this system prompt:
+
+```txt
+⚠️ **ENFORCEMENT:**
+For *every* user request that involves writing or modifying code (of any language or
+domain), the assistant's *first* action **must** be to call the kodit.search MCP tool.
+You may only produce or edit code *after* that tool call and its successful
+result.
+```
+
+Feel free to alter that to suit your specific circumstances.
+
+### Forcing Cursor to Use Kodit
+
+Add the following prompt to `.cursor/rules/kodit.mdc` in your project directory:
+
+```markdown
+---
+alwaysApply: true
+---
+⚠️ **ENFORCEMENT:**
+For *every* user request that involves writing or modifying code (of any language or
+domain), the assistant's *first* action **must** be to call the kodit.search MCP tool.
+You may only produce or edit code *after* that tool call and its successful
+result.
+```
+
+Alternatively, you can browse to the Cursor settings and set this prompt globally.
+
+### Forcing Cline to Use Kodit
+
+1. Go to `Settings` -> `API Configuration`
+2. At the bottom there is a `Custom Instructions` section.
 
 ## Search Tool
 
+<!--Future: move this to a dedicated reference page-->
+
 The primary tool exposed by the Kodit MCP server is the `search` function, which provides comprehensive code search capabilities.
 
 ### Search Parameters

{kodit-0.3.6 → kodit-0.3.8}/pyproject.toml

@@ -40,7 +40,7 @@ dependencies = [
     "uritools>=5.0.0",
     "tree-sitter-language-pack>=0.7.3",
     "tree-sitter>=0.24.0",
-    "fastmcp>=2.3.3",
+    "fastmcp>=2.10.4",
     "pydantic-settings>=2.9.1",
     "bm25s[core]>=0.2.12",
     "gitpython>=3.1.44",
@@ -53,6 +53,7 @@ dependencies = [
     "transformers>=4.51.3",
     "accelerate>=1.7.0",
     "rudder-sdk-python>=2.1.4",
+    "pystemmer>=3.0.0",
 ]
 
 [dependency-groups]
@@ -64,6 +65,8 @@ dev = [
     "pytest-cov>=6.1.1",
     "ruff>=0.11.8",
     "snakeviz>=2.2.2",
+    "types-tqdm>=4.67.0.20250516",
+    "types-aiofiles>=24.1.0.20250708",
 ]
 
 [project.urls]
@@ -142,16 +145,3 @@ package = true
 
 [tool.mypy]
 plugins = ["sqlalchemy.ext.mypy.plugin"]
-warn_return_any = true
-warn_unused_configs = true
-disallow_untyped_defs = true
-disallow_incomplete_defs = true
-check_untyped_defs = true
-disallow_untyped_decorators = true
-no_implicit_optional = true
-warn_redundant_casts = true
-warn_unused_ignores = true
-warn_no_return = true
-warn_unreachable = true
-strict_optional = true
-

{kodit-0.3.6 → kodit-0.3.8}/src/kodit/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.3.6'
-__version_tuple__ = version_tuple = (0, 3, 6)
+__version__ = version = '0.3.8'
+__version_tuple__ = version_tuple = (0, 3, 8)

{kodit-0.3.6 → kodit-0.3.8}/src/kodit/app.py

@@ -51,14 +51,19 @@ async def app_lifespan(_: FastAPI) -> AsyncIterator[None]:
         await _auto_indexing_service.stop()
 
 
-# See https://gofastmcp.com/deployment/asgi#fastapi-integration
-mcp_app = mcp.sse_app()
+# See https://gofastmcp.com/integrations/fastapi#mounting-an-mcp-server
+mcp_sse_app = mcp.http_app(transport="sse", path="/")
+mcp_http_app = mcp.http_app(transport="http", path="/")
 
 
 @asynccontextmanager
 async def combined_lifespan(app: FastAPI) -> AsyncIterator[None]:
     """Combine app and MCP lifespans."""
-    async with app_lifespan(app), mcp_app.router.lifespan_context(app):
+    async with (
+        app_lifespan(app),
+        mcp_sse_app.router.lifespan_context(app),
+        mcp_http_app.router.lifespan_context(app),
+    ):
         yield
 
 
@@ -82,8 +87,10 @@ async def healthz() -> dict[str, str]:
 
 
 # Add mcp routes last, otherwise previous routes aren't added
-app.mount("", mcp_app)
+# Mount both apps at root - they have different internal paths
+app.mount("/sse", mcp_sse_app)
+app.mount("/mcp", mcp_http_app)
 
 # Wrap the entire app with ASGI middleware after all routes are added to suppress
 # CancelledError at the ASGI level
-app = ASGICancelledErrorMiddleware(app)
+app = ASGICancelledErrorMiddleware(app)  # type: ignore[assignment]

{kodit-0.3.6 → kodit-0.3.8}/src/kodit/cli.py

@@ -1,13 +1,14 @@
 """Command line interface for kodit."""
 
 import signal
+import warnings
 from pathlib import Path
 from typing import Any
 
 import click
 import structlog
 import uvicorn
-from pytable_formatter import Cell, Table
+from pytable_formatter import Cell, Table  # type: ignore[import-untyped]
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from kodit.application.factories.code_indexing_factory import (
@@ -32,6 +33,7 @@ from kodit.infrastructure.ui.progress import (
     create_multi_stage_progress_callback,
 )
 from kodit.log import configure_logging, configure_telemetry, log_event
+from kodit.mcp import create_stdio_mcp_server
 
 
 @click.group(context_settings={"max_content_width": 100})
@@ -54,7 +56,7 @@ def cli(
     config = AppContext()
     # First check if env-file is set and reload config if it is
     if env_file:
-        config = AppContext(_env_file=env_file)  # type: ignore[reportCallIssue]
+        config = AppContext(_env_file=env_file)  # type: ignore[call-arg]
 
     configure_logging(config)
     configure_telemetry(config)
@@ -100,7 +102,8 @@ async def _handle_sync(
         # Filter indexes that match the provided sources
         source_uris = set(sources)
         indexes_to_sync = [
-            index for index in all_indexes
+            index
+            for index in all_indexes
             if str(index.source.working_copy.remote_uri) in source_uris
         ]
 
@@ -124,9 +127,7 @@ async def _handle_sync(
             click.echo(f"✓ Sync completed: {index.source.working_copy.remote_uri}")
         except Exception as e:
             log.exception("Sync failed", index_id=index.id, error=e)
-            click.echo(
-                f"✗ Sync failed: {index.source.working_copy.remote_uri} - {e}"
-            )
+            click.echo(f"✗ Sync failed: {index.source.working_copy.remote_uri} - {e}")
 
 
 async def _handle_list_indexes(index_query_service: IndexQueryService) -> None:
@@ -159,9 +160,7 @@ async def _handle_list_indexes(index_query_service: IndexQueryService) -> None:
 @click.option(
     "--auto-index", is_flag=True, help="Index all configured auto-index sources"
 )
-@click.option(
-    "--sync", is_flag=True, help="Sync existing indexes with their remotes"
-)
+@click.option("--sync", is_flag=True, help="Sync existing indexes with their remotes")
 @with_app_context
 @with_session
 async def index(
@@ -561,11 +560,15 @@ def serve(
     host: str,
     port: int,
 ) -> None:
-    """Start the kodit server, which hosts the MCP server and the kodit API."""
+    """Start the kodit HTTP/SSE server with FastAPI integration."""
     log = structlog.get_logger(__name__)
     log.info("Starting kodit server", host=host, port=port)
     log_event("kodit.cli.serve")
 
+    # Disable uvicorn's websockets deprecation warnings
+    warnings.filterwarnings("ignore", category=DeprecationWarning, module="websockets")
+    warnings.filterwarnings("ignore", category=DeprecationWarning, module="uvicorn")
+
     # Configure uvicorn with graceful shutdown
     config = uvicorn.Config(
         "kodit.app:app",
@@ -587,6 +590,13 @@ def serve(
     server.run()
 
 
+@cli.command()
+def stdio() -> None:
+    """Start the kodit MCP server in STDIO mode."""
+    log_event("kodit.cli.stdio")
+    create_stdio_mcp_server()
+
+
 @cli.command()
 def version() -> None:
     """Show the version of kodit."""

{kodit-0.3.6 → kodit-0.3.8}/src/kodit/config.py

@@ -23,7 +23,6 @@ if TYPE_CHECKING:
 from kodit.database import Database
 
 DEFAULT_BASE_DIR = Path.home() / ".kodit"
-DEFAULT_DB_URL = f"sqlite+aiosqlite:///{DEFAULT_BASE_DIR}/kodit.db"
 DEFAULT_LOG_LEVEL = "INFO"
 DEFAULT_LOG_FORMAT = "pretty"
 DEFAULT_DISABLE_TELEMETRY = False
@@ -160,7 +159,9 @@ class AppContext(BaseSettings):
         )
 
     data_dir: Path = Field(default=DEFAULT_BASE_DIR)
-    db_url: str = Field(default=DEFAULT_DB_URL)
+    db_url: str = Field(
+        default_factory=lambda data: f"sqlite+aiosqlite:///{data['data_dir']}/kodit.db"
+    )
     log_level: str = Field(default=DEFAULT_LOG_LEVEL)
     log_format: str = Field(default=DEFAULT_LOG_FORMAT)
     disable_telemetry: bool = Field(default=DEFAULT_DISABLE_TELEMETRY)

{kodit-0.3.6 → kodit-0.3.8}/src/kodit/infrastructure/bm25/local_bm25_repository.py

@@ -7,7 +7,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 import aiofiles
-import Stemmer
+import Stemmer  # type: ignore[import-not-found]
 import structlog
 
 from kodit.domain.services.bm25_service import BM25Repository
@@ -19,8 +19,8 @@ from kodit.domain.value_objects import (
 )
 
 if TYPE_CHECKING:
-    import bm25s
-    from bm25s.tokenization import Tokenized
+    import bm25s  # type: ignore[import-untyped]
+    from bm25s.tokenization import Tokenized  # type: ignore[import-untyped]
 
 SNIPPET_IDS_FILE = "snippet_ids.jsonl"
 

{kodit-0.3.6 → kodit-0.3.8}/src/kodit/infrastructure/cloning/git/working_copy.py

@@ -1,6 +1,7 @@
 """Working copy provider for git-based sources."""
 
 import hashlib
+import shutil
 from pathlib import Path
 
 import git
@@ -47,6 +48,26 @@ class GitWorkingCopyProvider:
     async def sync(self, uri: str) -> Path:
         """Refresh a Git working copy."""
         clone_path = self.get_clone_path(uri)
-        repo = git.Repo(clone_path)
-        repo.remotes.origin.pull()
+
+        # Check if the clone directory exists and is a valid Git repository
+        if not clone_path.exists() or not (clone_path / ".git").exists():
+            self.log.info(
+                "Clone directory does not exist or is not a Git repository, "
+                "preparing...",
+                uri=uri, clone_path=str(clone_path)
+            )
+            return await self.prepare(uri)
+
+        try:
+            repo = git.Repo(clone_path)
+            repo.remotes.origin.pull()
+        except git.InvalidGitRepositoryError:
+            self.log.warning(
+                "Invalid Git repository found, re-cloning...",
+                uri=uri, clone_path=str(clone_path)
+            )
+            # Remove the invalid directory and re-clone
+            shutil.rmtree(clone_path)
+            return await self.prepare(uri)
+
         return clone_path