kodit 0.4.0__tar.gz → 0.4.1__tar.gz

{kodit-0.4.0 → kodit-0.4.1}/Dockerfile

@@ -78,23 +78,8 @@ EOT
 
 ENV PATH=/app/bin:$PATH
 
-# Don't run your app as root.
-RUN <<EOT
-groupadd -r app
-useradd -r -d /app -g app -N app
-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
-
 ENTRYPOINT ["/app/bin/kodit"]
 
 # Copy the pre-built `/app` directory to the runtime container
-# and change the ownership to user app and group app in one step.
-COPY --from=build --chown=app:app /app /app
+COPY --from=build /app /app

{kodit-0.4.0 → kodit-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kodit
-Version: 0.4.0
+Version: 0.4.1
 Summary: Code indexing for better AI code generation
 Project-URL: Homepage, https://docs.helixml.tech/kodit/
 Project-URL: Documentation, https://docs.helixml.tech/kodit/
@@ -35,7 +35,8 @@ Requires-Dist: gitpython>=3.1.44
 Requires-Dist: hf-xet>=1.1.2
 Requires-Dist: httpx-retries>=0.3.2
 Requires-Dist: httpx>=0.28.1
-Requires-Dist: openai>=1.82.0
+Requires-Dist: litellm>=1.75.8
+Requires-Dist: openai==1.99.9
 Requires-Dist: pathspec>=0.12.1
 Requires-Dist: pydantic-settings>=2.9.1
 Requires-Dist: pystemmer>=3.0.0

kodit-0.4.1/docs/demos/go-simple-microservice/index.md

@@ -0,0 +1,112 @@
+---
+title: "Kodit Demo: Simple Go Microservice"
+linkTitle: Microservices
+description: A simple demo of Kodit on a multi-repo microservices example in Go.
+weight: 2
+tags:
+- demo
+- go
+- microservices
+- cline
+---
+
+When code is spread across repositories, like when developing microservices, it can be
+hard for coding assistants to know what APIs to call or what data structures to use.
+
+This example demonstrates using Kodit to index and expose critical microservice
+information to quickly develop new services in a microservice environment.
+
+You'll see that with Kodit the AI assistant delivers:
+
+- Faster overall implementation
+- Fewer mistakes
+- Fewer tokens used
+
+## Example: Building Microservices
+
+Here is the prompt I used to build my new microservice:
+
+> Develop a new Go microservice that exposes functionality for a notional "shipping"
+> department. They need to list current orders from the orders
+> microservice and get the user's information for each order. This should then expose a rest API to list out today's orders and where they need > to be shipped. It should also have an API to update an order status to say it has been shipped.
+>
+> Use internal Go libraries only for this.
+
+## Initial Results in Cline
+
+Without Kodit, the AI assistant attempted to rebuild a new mock microservice to test
+against, despite not asking for it. Here is a short extract from the [full transcript](https://gist.github.com/philwinder/75b0d3120176cf3f17464e2b57c8727e#file-before_cline_without_kodit-txt):
+
+> The Go microservice for the shipping department has been developed and is running on port 8082. It exposes two REST API endpoints:
+>
+> - GET /orders/today: Lists today's orders with user information and shipping addresses by fetching data from the orders microservice.
+> - POST /orders/{id}/ship: Updates the status of an order to "shipped" by sending a request to the orders microservice.
+>
+> A mock orders microservice has also been created and is running on port 8081 to
+> support testing. It provides endpoints to list orders, get user
+> information, and update order status.
+>
+> Both services are running concurrently and ready for integration testing.
+
+Without the knowledge of the other pre-existing microservices the AI
+assistant has incorrectly built new mock microservices to fulfil the original request.
+It has also used incorrect APIs.
+
+## Results When Adding Kodit to Cline
+
+Now let's index the microservices and try again:
+
+1. Start afresh. Delete your data directory or your database.
+2. Index the [users
+   microservice](https://gist.github.com/philwinder/db2e17413332844fa4b14971ae5adb34):
+
+   ```sh
+   kodit index https://gist.github.com/philwinder/db2e17413332844fa4b14971ae5adb34.git
+   ```
+
+3. Index the [orders
+   microservice](https://gist.github.com/philwinder/7aa38185e20433c04c533f2b28f4e217):
+
+   ```sh
+   kodit index https://gist.github.com/philwinder/7aa38185e20433c04c533f2b28f4e217.git
+   ```
+
+4. Launch the MCP server:
+
+   ```sh
+   kodit serve
+   ```
+
+5. [Connect Cline](/kodit/getting-started/integration/index.md).
+
+With Kodit, cline is able to query for relevant microservices. The net result (with a
+few iterations of fixing the code!) is a new microservice that correctly calls the other
+microservices to obtain information. ([Full transcript](https://gist.github.com/philwinder/75b0d3120176cf3f17464e2b57c8727e#file-after_cline_adding_kodit-txt))
+
+For example, here's the code generated to get users:
+
+```go
+// getUsers calls the user microservice to get the list of users.
+// It assumes the user service is running on localhost:8080 and provides a JSON array of users.
+func getUsers() ([]User, error) {
+    resp, err := http.Get("<http://localhost:8080/users>")
+    if err != nil {
+        return nil, err
+    }
+    defer resp.Body.Close()
+    body, err := io.ReadAll(resp.Body)
+    if err != nil {
+        return nil, err
+    }
+
+    var users []User
+    err = json.Unmarshal(body, &users)
+    if err != nil {
+        return nil, err
+    }
+    return users, nil
+}
+```
+
+Note how it knows that users are coming from a separate microservice and has even
+generated compliant structs to parse the response.

kodit-0.4.1/docs/demos/knock-knock-auth/index.md

@@ -0,0 +1,154 @@
+---
+title: "Kodit Demo: Proprietary Auth Patterns"
+linkTitle: Proprietary Code
+description: A demo of Kodit where knowledge of proprietary code is required.
+weight: 1
+tags:
+- demo
+- auth
+- cursor
+---
+
+A common feature of private codebases is proprietary code to achieve a certain
+task. For example, you might a specific way to request data from your data lake, or a
+specific format to use when using a common API.
+
+This example uses the analogy of a proprietary authentication mechanism. I have a super
+secret server with sensitive data. It is protected with a [custom auth implementation](https://gist.github.com/cbf0bd1f3338ddf9f98879148d2d752d)
+that requires the user to "knock three times" before they get access.
+
+You'll see that with Kodit the AI assistant delivers:
+
+- Faster overall implementation
+- Fewer mistakes
+- Fewer tokens used
+
+## Initial Results With Cursor
+
+Without Kodit, an AI assistant makes an average assumption about what the auth might
+look like, based upon the context provided by the user. The transcript is below. You can
+see that Cursor doesn't have a chance.
+
+### Original Cursor Response
+
+> **User**
+>
+> Write a python script that is able to access my super secret knock knock api on localhost:8000/secret.
+>
+> **Cursor**
+>
+> I'll help you create a Python script to interact with your local knock knock API. I'll create a script that makes a > request to the specified endpoint.
+>
+> Let me write a script that uses the `requests` library to make HTTP requests to your local API:
+>
+> ```python
+> import requests
+> 
+> def access_secret_api():
+>     try:
+>         # Make a GET request to the secret endpoint
+>         response = requests.get('http://localhost:8000/secret')
+>         
+>         # Check if the request was successful
+>         response.raise_for_status()
+>         
+>         # Print the response
+>         print("Response from secret API:", response.text)
+>         
+>     except requests.exceptions.RequestException as e:
+>         print(f"Error accessing the API: {e}")
+> 
+> if __name__ == "__main__":
+>     access_secret_api()
+> ```
+>
+> I've created a Python script that will:
+>
+> 1. Make a GET request to `http://localhost:8000/secret`
+> 2. Handle any potential errors that might occur during the request
+> 3. Print the response from the API if successful
+>
+> To run this script, you'll need to have the `requests` library installed. You can install it using pip:
+
+## Results When Adding Kodit to Cursor
+
+Now let's index the code for my secret server and then leverage Kodit in Cursor.
+
+1. Start afresh. Delete your data directory or your database.
+2. Index the [server code](https://gist.github.com/cbf0bd1f3338ddf9f98879148d2d752d): `kodit index https://gist.github.com/cbf0bd1f3338ddf9f98879148d2d752d.git`
+3. Launch the MCP server: `kodit serve`kodit
+4. Connect Cursor.
+
+The results are shown below. Cursor has correctly queried Kodit, which has responded with examples of the super secret auth implementation. This lead to cursor producing valid, working code that adhered to our esoteric auth implementation!
+
+Here is the result of running the generated code:
+
+```sh
+uv run temp.py
+Knock 1: Knock 1 received (token: sAQmj2uFrRxc-e9blSCfFg)
+Knock 2: Knock 2 received (token: sAQmj2uFrRxc-e9blSCfFg)
+Knock 3: Knock 3 received (token: sAQmj2uFrRxc-e9blSCfFg)
+Secret area: {'message': 'Welcome to the secret area!', 'secret': 'The answer is 42'}
+```
+
+### Kodit Cursor Response
+
+> **User**
+>
+> Write a python script that is able to access my super secret knock knock api on localhost:8000/secret.
+>
+> **Cursor**
+>
+> Based on the information found in the codebase, your "super secret knock knock API" on `localhost:8000/secret` requires a > special authentication flow:
+>
+> 1. You must make 3 POST requests to `/knock`. Each time, you use the same token (provided in the response) in the > Authorization header as a Bearer token.
+> 2. After 3 knocks, you can access `/secret` with a GET request, using the same token in the Authorization header.
+>
+> Would you like a Python script that automates this entire process (performs the 3 knocks and then accesses the secret), > or do you want just an example of how to access `/secret` assuming you already have a valid token?
+>
+> **User**
+>
+> the whole process.
+>
+> **Cursor**
+>
+> ```python
+> import requests
+> 
+> BASE_URL = "http://localhost:8000"
+> KNOCKS_REQUIRED = 3
+> 
+> def knock_and_get_secret():
+>     token = None
+>     headers = {}
+>     for i in range(KNOCKS_REQUIRED):
+>         if token:
+>             headers = {"Authorization": f"Bearer {token}"}
+>         else:
+>             headers = {}
+>         resp = requests.post(f"{BASE_URL}/knock", headers=headers)
+>         resp.raise_for_status()
+>         data = resp.json()
+>         token = data["token"]
+>         print(f"Knock {i+1}: {data['message']} (token: {token})")
+> 
+>     # Now access the secret
+>     headers = {"Authorization": f"Bearer {token}"}
+>     resp = requests.get(f"{BASE_URL}/secret", headers=headers)
+>     if resp.status_code == 200:
+>         print("Secret area:", resp.json())
+>     else:
+>         print("Failed to access secret:", resp.status_code, resp.text)
+> 
+> if __name__ == "__main__":
+>     knock_and_get_secret()
+> 
+> ```
+>
+> I've written a Python script in `temp.py` that automates the entire process:
+>
+> - It performs 3 POST requests to `/knock`, passing the token as required.
+> - After the third knock, it makes a GET request to `/secret` with the token.
+> - The script prints out the secret or any error message.
+>
+> You just need to have the `requests` library installed (`pip install requests`) to run this script. Let me know if you > want any adjustments or further explanation!

{kodit-0.4.0 → kodit-0.4.1}/docs/reference/api/index.md

@@ -12,7 +12,7 @@ look at the [hosted version](https://kodit.helix.ml/docs).
 This is the REST API for the Kodit server. Please refer to the
 [Kodit documentation](https://docs.helix.ml/kodit/) for more information.
     
-Current version: 0.3.17
+Current version: 0.3.18
 
 ## Authentication
 
@@ -126,6 +126,58 @@ Delete an index.
 
 - 404: Index not found
 
+### GET /api/v1/queue
+
+List all tasks in the queue.
+
+Optionally filter by task type.
+
+
+#### Parameters
+
+| Name | Type | Required | Description |
+|------|------|----------|-------------|
+| task_type |  | False |  |
+
+
+#### Responses
+
+- 200: Successful Response
+
+[TaskListResponse](#tasklistresponse)
+
+- 500: Internal server error
+
+- 401: Unauthorized
+
+- 422: Invalid request
+
+### GET /api/v1/queue/{task_id}
+
+Get details of a specific task in the queue.
+
+
+#### Parameters
+
+| Name | Type | Required | Description |
+|------|------|----------|-------------|
+| task_id | string | True |  |
+
+
+#### Responses
+
+- 200: Successful Response
+
+[TaskResponse](#taskresponse)
+
+- 500: Internal server error
+
+- 401: Unauthorized
+
+- 422: Invalid request
+
+- 404: Task not found
+
 ### POST /api/v1/search
 
 Search code snippets with filters matching MCP tool.
@@ -351,6 +403,64 @@ Snippet data for JSON:API responses.
 | attributes |  |  |
 
 
+### TaskAttributes
+
+
+Task attributes for JSON:API responses.
+
+
+| Field | Type | Description |
+|-------|------|-------------|
+| type | string |  |
+| priority | integer |  |
+| payload | object |  |
+| created_at |  |  |
+| updated_at |  |  |
+
+
+### TaskData
+
+
+Task data for JSON:API responses.
+
+
+| Field | Type | Description |
+|-------|------|-------------|
+| type | string |  |
+| id | string |  |
+| attributes |  |  |
+
+
+### TaskListResponse
+
+
+JSON:API response for task list.
+
+
+| Field | Type | Description |
+|-------|------|-------------|
+| data | array |  |
+
+
+### TaskResponse
+
+
+JSON:API response for single task.
+
+
+| Field | Type | Description |
+|-------|------|-------------|
+| data |  |  |
+
+
+### TaskType
+
+
+Task type.
+
+
+
+
 ### ValidationError
 
 

{kodit-0.4.0 → kodit-0.4.1}/docs/reference/api/openapi.json

@@ -3,7 +3,7 @@
   "info": {
     "title": "kodit API",
     "description": "\nThis is the REST API for the Kodit server. Please refer to the\n[Kodit documentation](https://docs.helix.ml/kodit/) for more information.\n    ",
-    "version": "0.3.17"
+    "version": "0.3.18"
   },
   "paths": {
     "/healthz": {
@@ -197,6 +197,110 @@
         }
       }
     },
+    "/api/v1/queue": {
+      "get": {
+        "tags": [
+          "queue"
+        ],
+        "summary": "List Queue Tasks",
+        "description": "List all tasks in the queue.\n\nOptionally filter by task type.",
+        "operationId": "list_queue_tasks_api_v1_queue_get",
+        "security": [
+          {
+            "Header (X-API-KEY)": []
+          }
+        ],
+        "parameters": [
+          {
+            "name": "task_type",
+            "in": "query",
+            "required": false,
+            "schema": {
+              "anyOf": [
+                {
+                  "$ref": "#/components/schemas/TaskType"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "title": "Task Type"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/TaskListResponse"
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "Internal server error"
+          },
+          "401": {
+            "description": "Unauthorized"
+          },
+          "422": {
+            "description": "Invalid request"
+          }
+        }
+      }
+    },
+    "/api/v1/queue/{task_id}": {
+      "get": {
+        "tags": [
+          "queue"
+        ],
+        "summary": "Get Queue Task",
+        "description": "Get details of a specific task in the queue.",
+        "operationId": "get_queue_task_api_v1_queue__task_id__get",
+        "security": [
+          {
+            "Header (X-API-KEY)": []
+          }
+        ],
+        "parameters": [
+          {
+            "name": "task_id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "title": "Task Id"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/TaskResponse"
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "Internal server error"
+          },
+          "401": {
+            "description": "Unauthorized"
+          },
+          "422": {
+            "description": "Invalid request"
+          },
+          "404": {
+            "description": "Task not found"
+          }
+        }
+      }
+    },
     "/api/v1/search": {
       "post": {
         "tags": [
@@ -692,6 +796,118 @@
         "title": "SnippetData",
         "description": "Snippet data for JSON:API responses."
       },
+      "TaskAttributes": {
+        "properties": {
+          "type": {
+            "type": "string",
+            "title": "Type"
+          },
+          "priority": {
+            "type": "integer",
+            "title": "Priority"
+          },
+          "payload": {
+            "additionalProperties": true,
+            "type": "object",
+            "title": "Payload"
+          },
+          "created_at": {
+            "anyOf": [
+              {
+                "type": "string",
+                "format": "date-time"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Created At"
+          },
+          "updated_at": {
+            "anyOf": [
+              {
+                "type": "string",
+                "format": "date-time"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Updated At"
+          }
+        },
+        "type": "object",
+        "required": [
+          "type",
+          "priority",
+          "payload",
+          "created_at",
+          "updated_at"
+        ],
+        "title": "TaskAttributes",
+        "description": "Task attributes for JSON:API responses."
+      },
+      "TaskData": {
+        "properties": {
+          "type": {
+            "type": "string",
+            "title": "Type",
+            "default": "task"
+          },
+          "id": {
+            "type": "string",
+            "title": "Id"
+          },
+          "attributes": {
+            "$ref": "#/components/schemas/TaskAttributes"
+          }
+        },
+        "type": "object",
+        "required": [
+          "id",
+          "attributes"
+        ],
+        "title": "TaskData",
+        "description": "Task data for JSON:API responses."
+      },
+      "TaskListResponse": {
+        "properties": {
+          "data": {
+            "items": {
+              "$ref": "#/components/schemas/TaskData"
+            },
+            "type": "array",
+            "title": "Data"
+          }
+        },
+        "type": "object",
+        "required": [
+          "data"
+        ],
+        "title": "TaskListResponse",
+        "description": "JSON:API response for task list."
+      },
+      "TaskResponse": {
+        "properties": {
+          "data": {
+            "$ref": "#/components/schemas/TaskData"
+          }
+        },
+        "type": "object",
+        "required": [
+          "data"
+        ],
+        "title": "TaskResponse",
+        "description": "JSON:API response for single task."
+      },
+      "TaskType": {
+        "type": "integer",
+        "enum": [
+          1
+        ],
+        "title": "TaskType",
+        "description": "Task type."
+      },
       "ValidationError": {
         "properties": {
           "loc": {