kodit 0.3.7__tar.gz → 0.3.8__tar.gz

{kodit-0.3.7 → 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.7 → 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.7 → kodit-0.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kodit
-Version: 0.3.7
+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/

{kodit-0.3.7 → 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.7 → kodit-0.3.8}/docs/reference/mcp/index.md

@@ -95,7 +95,8 @@ claude mcp add kodit -- kodit stdio
 
 #### Cursor Streaming HTTP Mode (recommended)
 
-[![Install MCP Server](cursor://anysphere.cursor-deeplink/mcp/install?name=kodit&config=eyJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjgwODAvbWNwIn0%3D)
+![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`:
 
@@ -114,7 +115,8 @@ where Kodit is hosted.
 
 #### Cursor STDIO
 
-[![Install MCP Server](cursor://anysphere.cursor-deeplink/mcp/install?name=kodit&config=eyJjb21tYW5kIjoicGlweCBydW4ga29kaXQgc3RkaW8ifQ%3D%3D)
+![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"}
 
 Add the following to `$HOME/.cursor/mcp.json`:
 

{kodit-0.3.7 → 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.7'
-__version_tuple__ = version_tuple = (0, 3, 7)
+__version__ = version = '0.3.8'
+__version_tuple__ = version_tuple = (0, 3, 8)

{kodit-0.3.7 → 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.7 → 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

{kodit-0.3.7 → kodit-0.3.8}/src/kodit/infrastructure/slicing/slicer.py

@@ -399,7 +399,10 @@ class Slicer:
         """Get tag name from start_tag node."""
         for child in start_tag.children:
             if child.type == "tag_name" and child.text:
-                return child.text.decode("utf-8")
+                try:
+                    return child.text.decode("utf-8")
+                except UnicodeDecodeError:
+                    return None
         return None
 
     def _get_element_id(self, start_tag: Node) -> str | None:
@@ -424,7 +427,10 @@ class Slicer:
         """Get attribute name."""
         for child in attr_node.children:
             if child.type == "attribute_name" and child.text:
-                return child.text.decode("utf-8")
+                try:
+                    return child.text.decode("utf-8")
+                except UnicodeDecodeError:
+                    return None
         return None
 
     def _get_attr_value(self, attr_node: Node) -> str | None:
@@ -433,7 +439,10 @@ class Slicer:
             if child.type == "quoted_attribute_value":
                 for val_child in child.children:
                     if val_child.type == "attribute_value" and val_child.text:
-                        return val_child.text.decode("utf-8")
+                        try:
+                            return val_child.text.decode("utf-8")
+                        except UnicodeDecodeError:
+                            return None
         return None
 
     def _extract_css_rule_name(self, node: Node) -> str | None:

{kodit-0.3.7 → kodit-0.3.8}/tests/kodit/infrastructure/cloning/git_cloning/working_copy_test.py

@@ -2,7 +2,7 @@
 
 import hashlib
 from pathlib import Path
-from unittest.mock import patch
+from unittest.mock import MagicMock, patch
 
 import git
 import pytest
@@ -199,3 +199,139 @@ async def test_prepare_handles_already_exists_error(
         # Verify that the directory was created
         assert result_path.exists()
         assert result_path.is_dir()
+
+
+@pytest.mark.asyncio
+async def test_sync_directory_does_not_exist_should_call_prepare(
+    working_copy: GitWorkingCopyProvider,
+) -> None:
+    """Test that sync() calls prepare() when directory doesn't exist."""
+    url = "https://github.com/username/repo.git"
+
+    # Mock prepare method to avoid actual cloning
+    with patch.object(working_copy, "prepare") as mock_prepare:
+        mock_prepare.return_value = Path("/fake/path")
+
+        # Call sync method
+        result_path = await working_copy.sync(url)
+
+        # Verify prepare was called
+        mock_prepare.assert_called_once_with(url)
+        assert result_path == Path("/fake/path")
+
+
+@pytest.mark.asyncio
+async def test_sync_directory_exists_but_no_git_should_call_prepare(
+    working_copy: GitWorkingCopyProvider,
+) -> None:
+    """Test that sync() calls prepare() when directory exists but is not a Git repo."""
+    url = "https://github.com/username/repo.git"
+
+    # Create a directory that exists but is not a git repo
+    clone_path = working_copy.get_clone_path(url)
+    clone_path.mkdir(parents=True, exist_ok=True)
+
+    # Mock prepare method to avoid actual cloning
+    with patch.object(working_copy, "prepare") as mock_prepare:
+        mock_prepare.return_value = clone_path
+
+        # Call sync method
+        result_path = await working_copy.sync(url)
+
+        # Verify prepare was called
+        mock_prepare.assert_called_once_with(url)
+        assert result_path == clone_path
+
+
+@pytest.mark.asyncio
+async def test_sync_valid_git_repository_should_pull(
+    working_copy: GitWorkingCopyProvider,
+) -> None:
+    """Test that sync() pulls from origin when repository is valid."""
+    url = "https://github.com/username/repo.git"
+
+    # Create a directory that exists with .git subdirectory
+    clone_path = working_copy.get_clone_path(url)
+    clone_path.mkdir(parents=True, exist_ok=True)
+    (clone_path / ".git").mkdir(parents=True, exist_ok=True)
+
+    # Mock git.Repo and origin.pull
+    mock_repo = MagicMock()
+    mock_origin = MagicMock()
+    mock_repo.remotes.origin = mock_origin
+
+    with patch("git.Repo") as mock_git_repo:
+        mock_git_repo.return_value = mock_repo
+
+        # Call sync method
+        result_path = await working_copy.sync(url)
+
+        # Verify git.Repo was called with the correct path
+        mock_git_repo.assert_called_once_with(clone_path)
+
+        # Verify origin.pull was called
+        mock_origin.pull.assert_called_once()
+
+        # Verify the correct path was returned
+        assert result_path == clone_path
+
+
+@pytest.mark.asyncio
+async def test_sync_invalid_git_repository_should_reclone(
+    working_copy: GitWorkingCopyProvider,
+) -> None:
+    """Test that sync() re-clones when repository is invalid."""
+    url = "https://github.com/username/repo.git"
+
+    # Create a directory that exists with .git subdirectory
+    clone_path = working_copy.get_clone_path(url)
+    clone_path.mkdir(parents=True, exist_ok=True)
+    (clone_path / ".git").mkdir(parents=True, exist_ok=True)
+
+    # Mock git.Repo to raise InvalidGitRepositoryError
+    with patch("git.Repo") as mock_git_repo:
+        mock_git_repo.side_effect = git.InvalidGitRepositoryError("Invalid repo")
+
+        # Mock shutil.rmtree to track directory removal
+        with (
+            patch("shutil.rmtree") as mock_rmtree,
+            patch.object(working_copy, "prepare") as mock_prepare,
+        ):
+            mock_prepare.return_value = clone_path
+
+            # Call sync method
+            result_path = await working_copy.sync(url)
+
+            # Verify git.Repo was called with the correct path
+            mock_git_repo.assert_called_once_with(clone_path)
+
+            # Verify the invalid directory was removed
+            mock_rmtree.assert_called_once_with(clone_path)
+
+            # Verify prepare was called to re-clone
+            mock_prepare.assert_called_once_with(url)
+
+            # Verify the correct path was returned
+            assert result_path == clone_path
+
+
+@pytest.mark.asyncio
+async def test_sync_get_clone_path_should_match_prepare(
+    working_copy: GitWorkingCopyProvider,
+) -> None:
+    """Test that sync() and prepare() use the same clone path."""
+    url = "https://github.com/username/repo.git"
+
+    # Get clone paths from both methods
+    sync_path = working_copy.get_clone_path(url)
+
+    # Mock prepare to return the expected path
+    with patch.object(working_copy, "prepare") as mock_prepare:
+        mock_prepare.return_value = sync_path
+
+        # Call sync method (will call prepare since directory doesn't exist)
+        result_path = await working_copy.sync(url)
+
+        # Verify paths match
+        assert result_path == sync_path
+        mock_prepare.assert_called_once_with(url)

{kodit-0.3.7 → kodit-0.3.8}/tests/kodit/infrastructure/slicing/slicer_test.py

@@ -828,3 +828,27 @@ class TestErrorHandling:
 
         error_msg = str(exc_info.value)
         assert "File not found" in error_msg
+
+    def test_binary_file_handling_in_html_parser(self) -> None:
+        """Test that binary files don't crash HTML parser with UnicodeDecodeError."""
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            # Create a binary file that looks like an image
+            binary_file = Path(tmp_dir, "test.html")
+            # Write binary data that would cause UnicodeDecodeError if decoded as UTF-8
+            binary_data = b"\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
+            binary_file.write_bytes(binary_data)
+
+            file_obj = create_file_from_path(binary_file)
+
+            slicer = Slicer()
+
+            # This should not raise UnicodeDecodeError
+            try:
+                snippets = slicer.extract_snippets([file_obj], "html")
+                # Should return empty list or handle gracefully
+                assert isinstance(snippets, list)
+            except UnicodeDecodeError:
+                pytest.fail("UnicodeDecodeError should not be raised for binary files")
+            except RuntimeError:
+                # Tree-sitter setup issues are acceptable
+                pytest.skip("Tree-sitter setup not available")

{kodit-0.3.7 → kodit-0.3.8}/tests/smoke.sh

@@ -9,6 +9,9 @@ if [ -n "$CI" ]; then
     prefix=""
 fi
 
+# Disable telemetry
+export DISABLE_TELEMETRY=true
+
 # Check that the kodit data_dir does not exist
 if [ -d "$HOME/.kodit" ]; then
     echo "Kodit data_dir is not empty, please rm -rf $HOME/.kodit"

kodit-0.3.7/docs/MIGRATION_TO_INDEX_AGGREGATE.md

@@ -1,222 +0,0 @@
-# Migration to Index Aggregate Architecture
-
-This document outlines the strategy for migrating from the current multiple-service architecture to the new Index aggregate root design.
-
-## Current Architecture Issues
-
-### Code Analysis of `CodeIndexingApplicationService`
-
-The current application service has several problems:
-
-1. **Service Proliferation**: 7+ domain services injected
-2. **Manual Orchestration**: Application layer contains complex business logic
-3. **Leaky Abstractions**: SQLAlchemy session management at application level
-4. **Scattered State**: Snippet state tracked across multiple services
-
-### Current Workflow Complexity
-
-```python
-# Current approach - complex orchestration
-async def run_index(self, index_id: int) -> None:
-    # 1. Get index from indexing service
-    index = await self.indexing_domain_service.get_index(index_id)
-    
-    # 2. Delete old snippets via snippet service
-    await self.snippet_domain_service.delete_snippets_for_index(index.id)
-    
-    # 3. Extract snippets via snippet service
-    snippets = await self.snippet_domain_service.extract_and_create_snippets(...)
-    
-    # 4. Manual transaction management
-    await self.session.commit()
-    
-    # 5. Create BM25 index via separate service
-    await self._create_bm25_index(snippets, progress_callback)
-    
-    # 6. Create embeddings via separate service
-    await self._create_code_embeddings(snippets, progress_callback)
-    
-    # 7. Enrich snippets via separate service
-    await self._enrich_snippets(snippets, progress_callback)
-    
-    # 8. More embeddings via separate service
-    await self._create_text_embeddings(snippets, progress_callback)
-    
-    # 9. Update timestamp via indexing service
-    await self.indexing_domain_service.update_index_timestamp(index.id)
-    
-    # 10. Final commit
-    await self.session.commit()
-```
-
-## New Architecture Benefits
-
-### Simplified Application Service
-
-```python
-# New approach - aggregate root handles complexity
-async def run_complete_indexing_workflow(
-    self, uri: AnyUrl, local_path: Path
-) -> domain_entities.Index:
-    # 1. Create index (aggregate root)
-    index = await self._index_domain_service.create_index(uri)
-    
-    # 2. Populate working copy (aggregate method)
-    index = await self._index_domain_service.clone_and_populate_working_copy(
-        index, local_path, SourceType.GIT
-    )
-    
-    # 3. Extract snippets (aggregate method)
-    index = await self._index_domain_service.extract_snippets(index)
-    
-    # 4. Simple transaction management
-    await self._session.commit()
-    
-    return index
-```
-
-## Migration Strategy
-
-### Phase 1: Parallel Implementation ✅
-
-- [x] Create new domain entities (`domain/models/entities.py`)
-- [x] Create repository protocol (`domain/models/protocols.py`)
-- [x] Create mapping layer (`infrastructure/mappers/index_mapper.py`)
-- [x] Create repository implementation (`infrastructure/sqlalchemy/index_repository.py`)
-- [x] Create domain service (`domain/services/index_service.py`)
-- [x] Create simplified application service (`application/services/simplified_indexing_service.py`)
-
-### Phase 2: Feature Parity (Next Steps)
-
-#### 2.1 Complete Index Domain Service
-- [ ] Implement actual cloning logic in `clone_and_populate_working_copy`
-- [ ] Complete snippet enrichment in `enrich_snippets_with_summaries`
-- [ ] Add snippet search capabilities to Index aggregate
-- [ ] Add BM25/embedding integration
-
-#### 2.2 Application Service Integration
-- [ ] Update application factories to create new services
-- [ ] Add legacy compatibility methods
-- [ ] Implement search functionality migration
-
-#### 2.3 CLI Integration
-- [ ] Update CLI commands to use new application service
-- [ ] Maintain backward compatibility for existing commands
-
-### Phase 3: Gradual Migration
-
-#### 3.1 New Endpoints First
-- [ ] Create new CLI commands using Index aggregate
-- [ ] Add new MCP tools using simplified service
-- [ ] Implement new features with aggregate root
-
-#### 3.2 Legacy Adaptation
-- [ ] Wrap old API calls to use new domain service
-- [ ] Provide compatibility layer for existing integrations
-- [ ] Migrate tests gradually
-
-#### 3.3 Search Migration
-- [ ] Move search logic into Index aggregate
-- [ ] Create search value objects in domain
-- [ ] Simplify search application service
-
-### Phase 4: Complete Migration
-
-#### 4.1 Remove Old Services
-- [ ] Remove `IndexingDomainService` 
-- [ ] Remove `SnippetDomainService`
-- [ ] Remove `SourceService`
-- [ ] Clean up old value objects
-
-#### 4.2 Final Cleanup
-- [ ] Remove legacy compatibility methods
-- [ ] Update all tests to use new architecture
-- [ ] Remove old application service
-
-## Code Examples
-
-### Before: Current Complexity
-
-```python
-class CodeIndexingApplicationService:
-    def __init__(self, 
-        indexing_domain_service: IndexingDomainService,
-        snippet_domain_service: SnippetDomainService,
-        source_service: SourceService,
-        bm25_service: BM25DomainService,
-        code_search_service: EmbeddingDomainService,
-        text_search_service: EmbeddingDomainService,
-        enrichment_service: EnrichmentDomainService,
-        session: AsyncSession,  # Leaky abstraction!
-    ):
-        # 7+ services to coordinate
-```
-
-### After: Aggregate Root Simplicity
-
-```python
-class SimplifiedIndexingApplicationService:
-    def __init__(self,
-        index_domain_service: IndexDomainService,
-        session: AsyncSession,
-    ):
-        # Single domain service + session
-        # All business logic in domain
-```
-
-## Benefits of Migration
-
-### 1. **Reduced Complexity**
-- Single domain service instead of 7+
-- Business logic moves to domain layer
-- Application layer focuses on coordination
-
-### 2. **Better Domain Modeling**
-- Index as true aggregate root
-- Rich domain objects with behavior
-- Proper encapsulation of business rules
-
-### 3. **Improved Testability**
-- Domain service can be tested in isolation
-- No SQLAlchemy dependencies in domain tests
-- Cleaner mocking for application tests
-
-### 4. **Enhanced Maintainability**
-- Clear boundaries between layers
-- Easier to add new features
-- Reduced coupling between services
-
-### 5. **Better Performance**
-- Fewer repository round trips
-- Optimized aggregate loading
-- Reduced object mapping overhead
-
-## Risks and Mitigation
-
-### Risk: Breaking Changes
-**Mitigation**: Implement compatibility layer during transition
-
-### Risk: Feature Regression
-**Mitigation**: Comprehensive test coverage for both old and new
-
-### Risk: Performance Impact
-**Mitigation**: Benchmark and optimize aggregate loading
-
-### Risk: Complex Migration
-**Mitigation**: Gradual, phase-by-phase approach
-
-## Success Metrics
-
-- [ ] Reduced lines of code in application service (target: 50% reduction)
-- [ ] Improved test coverage for domain logic
-- [ ] Faster indexing workflow execution
-- [ ] Fewer bugs related to state management
-- [ ] Easier onboarding for new developers
-
-## Next Immediate Steps
-
-1. **Complete Domain Service**: Finish implementing cloning and enrichment
-2. **Factory Integration**: Update application factories
-3. **Simple CLI Command**: Create one new command using aggregate
-4. **Performance Test**: Benchmark against current implementation
-5. **Migration Plan**: Detail specific steps for first legacy endpoint