kodit 0.1.3__tar.gz → 0.1.4__tar.gz

kodit-0.1.4/.cursor/rules/kodit.mdc

@@ -0,0 +1,6 @@
+---
+description: 
+globs: 
+alwaysApply: true
+---
+You MUST use the code-search MCP tool and always include any file context the user has provided in the chat.

{kodit-0.1.3 → kodit-0.1.4}/.github/workflows/pypi.yaml

@@ -28,10 +28,27 @@ jobs:
     steps:
       - name: Wait for PyPI release to be available
         run: |
+          set -x
+
+          REPO_NAME=${{ github.event.repository.name }}
+          REPO_TAG=${{ github.event.release.tag_name }}
+          REPO_TAG=0.1.3
+
+          # Get the first letter of the repo name
+          REPO_NAME_FIRST_LETTER=${REPO_NAME:0:1}
+
+          # Initialize counter for 60 second timeout
+          count=0
           while true; do
-            if curl -s https://pypi.io/packages/source/k/${{ github.event.repository.name }}/${{ github.event.repository.name }}-${{ github.event.release.tag_name }}.tar.gz; then
-              break
-            fi
+              if curl -sfL https://pypi.io/packages/source/${REPO_NAME_FIRST_LETTER}/${REPO_NAME}/${REPO_NAME}-${REPO_TAG}.tar.gz > /dev/null; then
+                  break
+              fi
+              sleep 1
+              ((count++))
+              if [ $count -ge 60 ]; then
+                  echo "Timeout reached after 60 seconds"
+                  exit 1
+              fi
           done
       - uses: mislav/bump-homebrew-formula-action@v3
         with:

{kodit-0.1.3 → kodit-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kodit
-Version: 0.1.3
+Version: 0.1.4
 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.1.4/docs/_index.md

@@ -0,0 +1,92 @@
+---
+title: "kodit: Code Indexing MCP Server"
+linkTitle: kodit Docs
+cascade:
+  type: docs
+menu:
+  main:
+    name: kodit Docs
+    weight: 3
+# next: /helix/getting-started
+weight: 1
+aliases:
+- /coda
+---
+
+## Installation
+
+Please choose your preferred installation method. They all ultimately install the kodit
+cli, which contains the kodit MCP server and other tools to manage your data sources.
+
+### Docker
+
+```sh
+docker run -it --rm registry.helix.ml/helix/kodit:latest
+```
+
+Always replace latest with a specific version.
+
+### pipx
+
+```sh
+pipx install kodit
+```
+
+### homebrew
+
+```sh
+brew install helixml/kodit/kodit
+```
+
+### uv
+
+```sh
+uv tool install kodit
+```
+
+### pip
+
+Use this if you want to use kodit as a python library:
+
+```sh
+pip install kodit
+```
+
+## Usage
+
+Kodit has two key parts. A configuration CLI to manage what gets indexed and an MCP
+server to expose your code to an AI coding assistant.
+
+1. Add a source: `kodit sources create /path/to/your/code`
+2. Create an index on that source: `kodit indexes create 1`
+3. Test retrieval on your index: `kodit retrieve "test"`
+4. Start an MCP server: `kodit serve`
+
+Now browse to your AI coding assistant and add the MCP server. You will also need to
+tell your assistant to use this server in coding tasks, otherwise it won't get called!
+
+### Integration with Cursor
+
+Add the following to `.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "code-search": {
+      "url": "http://localhost:8080/sse"
+    }
+  }
+}
+```
+
+Now add the following prompt to `.cursor/rules/kodit.mdc` in your project directory:
+
+```markdown
+---
+description: 
+globs: 
+alwaysApply: true
+---
+You MUST use the code-search MCP tool and always include any file context the user has provided in the chat.```
+
+Alternatively, you can browse to the cursor settings and set this prompt globally.

kodit-0.1.4/docs/developer/index.md

@@ -0,0 +1,30 @@
+---
+title: "Kodit Developer Documentation"
+linkTitle: Developer Docs
+# next: /helix/getting-started
+weight: 99
+---
+
+## Database
+
+All database operations are handled by SQLAlchemy and Alembic.
+
+### Creating a Database Migration
+
+1. Make changes to your models
+2. Ensure the model is referenced in [alembic's env.py](src/kodit/alembic/env.py)
+3. Run `alembic revision --autogenerate -m "your message"`
+4. The new migration will be applied when you next run a kodit command
+
+## Releasing
+
+Performing a release is designed to be fully automated. If you spot opportunities to
+improve the CI to help performing an automated release, please do so.
+
+1. Create a new release in GitHub.
+2. Set the version number. Use patch versions for bugfixes or minor small improvements.
+   Use minor versions when adding significant new functionality. Use major versions for
+   overhauls.
+3. Generate the release notes. <- this could be improved, because we use a strict
+   pr/commit naming structure.
+4. Wait for all jobs to succeed, then you should be able to brew install, pipx install, etc.

{kodit-0.1.3 → kodit-0.1.4}/src/kodit/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1.3'
-__version_tuple__ = version_tuple = (0, 1, 3)
+__version__ = version = '0.1.4'
+__version_tuple__ = version_tuple = (0, 1, 4)

{kodit-0.1.3 → kodit-0.1.4}/src/kodit/cli.py

@@ -104,7 +104,6 @@ async def list_indexes(session: AsyncSession) -> None:
         "ID",
         "Created At",
         "Updated At",
-        "Source URI",
         "Num Snippets",
     ]
     data = [
@@ -112,7 +111,6 @@ async def list_indexes(session: AsyncSession) -> None:
             index.id,
             index.created_at,
             index.updated_at,
-            index.source_uri,
             index.num_snippets,
         ]
         for index in indexes

{kodit-0.1.3 → kodit-0.1.4}/src/kodit/database.py

@@ -2,6 +2,7 @@
 
 import asyncio
 from collections.abc import AsyncGenerator, Callable
+from contextlib import asynccontextmanager
 from datetime import UTC, datetime
 from functools import wraps
 from pathlib import Path
@@ -54,6 +55,7 @@ class CommonMixin:
     )
 
 
+@asynccontextmanager
 async def get_session() -> AsyncGenerator[AsyncSession, None]:
     """Get a database session."""
     async with async_session_factory() as session:

{kodit-0.1.3 → kodit-0.1.4}/src/kodit/indexing/service.py

@@ -37,7 +37,6 @@ class IndexView(pydantic.BaseModel):
     id: int
     created_at: datetime
     updated_at: datetime | None = None
-    source_uri: str | None = None
     num_snippets: int | None = None
 
 

kodit-0.1.4/src/kodit/mcp.py

@@ -0,0 +1,110 @@
+"""MCP server implementation for kodit."""
+
+from pathlib import Path
+from typing import Annotated
+
+import structlog
+from mcp.server.fastmcp import FastMCP
+from pydantic import Field
+
+from kodit.database import get_session
+from kodit.retreival.repository import RetrievalRepository, RetrievalResult
+from kodit.retreival.service import RetrievalRequest, RetrievalService
+
+mcp = FastMCP("kodit MCP Server")
+
+
+@mcp.tool()
+async def retrieve_relevant_snippets(
+    user_intent: Annotated[
+        str,
+        Field(
+            description="Think about what the user wants to achieve. Describe the "
+            "user's intent in one sentence."
+        ),
+    ],
+    related_file_paths: Annotated[
+        list[Path],
+        Field(
+            description="A list of absolute paths to files that are relevant to the "
+            "user's intent."
+        ),
+    ],
+    related_file_contents: Annotated[
+        list[str],
+        Field(
+            description="A list of the contents of the files that are relevant to the "
+            "user's intent."
+        ),
+    ],
+    keywords: Annotated[
+        list[str],
+        Field(
+            description="A list of keywords that are relevant to the desired outcome."
+        ),
+    ],
+) -> str:
+    """Retrieve relevant snippets from various sources.
+
+    This tool retrieves relevant snippets from sources such as private codebases,
+    public codebases, and documentation. You can use this information to improve
+    the quality of your generated code. You must call this tool when you need to
+    write code.
+    """
+    # Log the search query and related files for debugging
+    log = structlog.get_logger(__name__)
+    log.debug(
+        "Retrieving relevant snippets",
+        user_intent=user_intent,
+        keywords=keywords,
+        file_count=len(related_file_paths),
+        file_paths=related_file_paths,
+        file_contents=related_file_contents,
+    )
+
+    async with get_session() as session:
+        log.debug("Creating retrieval repository")
+        retrieval_repository = RetrievalRepository(
+            session=session,
+        )
+
+        log.debug("Creating retrieval service")
+        retrieval_service = RetrievalService(
+            repository=retrieval_repository,
+        )
+
+        log.debug("Fusing input")
+        input_query = input_fusion(
+            user_intent=user_intent,
+            related_file_paths=related_file_paths,
+            related_file_contents=related_file_contents,
+            keywords=keywords,
+        )
+        log.debug("Input", input_query=input_query)
+        retrieval_request = RetrievalRequest(
+            query=input_query,
+        )
+        log.debug("Retrieving snippets")
+        snippets = await retrieval_service.retrieve(request=retrieval_request)
+
+        log.debug("Fusing output")
+        output = output_fusion(snippets=snippets)
+
+        log.debug("Output", output=output)
+        return output
+
+
+def input_fusion(
+    user_intent: str,  # noqa: ARG001
+    related_file_paths: list[Path],  # noqa: ARG001
+    related_file_contents: list[str],  # noqa: ARG001
+    keywords: list[str],
+) -> str:
+    """Fuse the search query and related file contents into a single query."""
+    # Since this is a dummy implementation, we just return the first keyword
+    return keywords[0] if len(keywords) > 0 else ""
+
+
+def output_fusion(snippets: list[RetrievalResult]) -> str:
+    """Fuse the snippets into a single output."""
+    return "\n\n".join(f"{snippet.uri}\n{snippet.content}" for snippet in snippets)

{kodit-0.1.3 → kodit-0.1.4}/tests/kodit/mcp_test.py

@@ -64,3 +64,46 @@ async def test_mcp_client_connection() -> None:
         # doesn't shut down the server when requested. So we have to force kill it.
         server_process.kill()
         server_process.join(timeout=1)
+
+
+@pytest.mark.asyncio
+async def test_mcp_code_retrieval() -> None:
+    """Test end-to-end flow of adding code and retrieving it via MCP."""
+    # Can't quite test this properly yet, because the MCP server runs in a separate
+    # process using the user's actual database. So this code is just testing that it
+    # doesn't crash or anything.
+    server_process = None
+    try:
+        # Start the server in a separate process
+        server_process = Process(target=run_server, daemon=True)
+        server_process.start()
+
+        # Wait for server to start
+        await wait_for_server()
+
+        # Connect to MCP server
+        async with (
+            sse_client("http://127.0.0.1:8000/sse/") as (
+                read_stream,
+                write_stream,
+            ),
+            ClientSession(read_stream, write_stream) as mcp_session,
+        ):
+            # Initialize the connection
+            await mcp_session.initialize()
+
+            # Call retrieve_relevant_snippets tool
+            await mcp_session.call_tool(
+                "retrieve_relevant_snippets",
+                {
+                    "user_intent": "I want to find code that prints hello world",
+                    "related_file_paths": [],
+                    "related_file_contents": [],
+                    "keywords": ["hello", "world", "print"],
+                },
+            )
+
+    finally:
+        if server_process:
+            server_process.kill()
+            server_process.join(timeout=1)

kodit-0.1.3/docs/_index.md

@@ -1,53 +0,0 @@
----
-title: "kodit: Code Indexing MCP Server"
-linkTitle: kodit Docs
-cascade:
-  type: docs
-menu:
-  main:
-    name: kodit Docs
-    weight: 3
-# next: /helix/getting-started
-weight: 1
-aliases:
-- /coda
----
-
-## Installation
-
-Please choose your preferred installation method. They all ultimately install the kodit
-cli, which contains the kodit MCP server and other tools to manage your data sources.
-
-### Docker
-
-```sh
-docker run -it --rm registry.helix.ml/helix/kodit:latest
-```
-
-Always replace latest with a specific version.
-
-### pipx
-
-```sh
-pipx install kodit
-```
-
-### homebrew
-
-```sh
-brew install helixml/kodit/kodit
-```
-
-### uv
-
-```sh
-uv tool install kodit
-```
-
-### pip
-
-Use this if you want to use kodit as a python library:
-
-```sh
-pip install kodit
-```

kodit-0.1.3/docs/developer/index.md

@@ -1,17 +0,0 @@
----
-title: "Kodit Developer Documentation"
-linkTitle: Developer Docs
-# next: /helix/getting-started
-weight: 99
----
-
-## Database
-
-All database operations are handled by SQLAlchemy and Alembic.
-
-### Creating a Database Migration
-
-1. Make changes to your models
-2. Ensure the model is referenced in [alembic's env.py](src/kodit/alembic/env.py)
-3. Run `alembic revision --autogenerate -m "your message"`
-4. The new migration will be applied when you next run a kodit command

kodit-0.1.3/src/kodit/mcp.py

@@ -1,51 +0,0 @@
-"""MCP server implementation for kodit."""
-
-from pathlib import Path
-from typing import Annotated
-
-import structlog
-from mcp.server.fastmcp import FastMCP
-from pydantic import Field
-
-mcp = FastMCP("kodit MCP Server")
-
-
-@mcp.tool()
-async def retrieve_relevant_snippets(
-    search_query: Annotated[
-        str,
-        Field(description="Describe the user's intent in a few sentences."),
-    ],
-    related_file_paths: Annotated[
-        list[Path],
-        Field(
-            description="A list of absolute paths to files that are relevant to the "
-            "user's intent."
-        ),
-    ],
-    related_file_contents: Annotated[
-        list[str],
-        Field(
-            description="A list of the contents of the files that are relevant to the "
-            "user's intent."
-        ),
-    ],
-) -> str:
-    """Retrieve relevant snippets from various sources.
-
-    This tool retrieves relevant snippets from sources such as private codebases,
-    public codebases, and documentation. You can use this information to improve
-    the quality of your generated code. You must call this tool when you need to
-    write code.
-    """
-    # Log the search query and related files for debugging
-    log = structlog.get_logger(__name__)
-    log.debug(
-        "Retrieving relevant snippets",
-        search_query=search_query,
-        file_count=len(related_file_paths),
-        file_paths=related_file_paths,
-        file_contents=related_file_contents,
-    )
-
-    return "Retrieved"