kodit 0.3.2__tar.gz → 0.3.3__tar.gz

{kodit-0.3.2 → kodit-0.3.3}/.dockerignore

@@ -188,6 +188,6 @@ docs/
 .vscode/
 .gitignore
 LICENSE
-.python-version
+.python-version # Set in the Dockerfile
 .dockerignore
 tests/

{kodit-0.3.2 → kodit-0.3.3}/.github/workflows/docker.yaml

@@ -45,6 +45,9 @@ jobs:
     needs: test-build
     # Only run on main branch or when explicitly triggered
     if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name == github.repository
+    strategy:
+      matrix:
+        python-version: ["3.12.8", "3.13.5"]
     steps:
       - name: Free up disk space
         run: sudo rm -rf /usr/local/lib/android /usr/share/dotnet || true
@@ -65,11 +68,28 @@ jobs:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
 
+      - name: Set short Python version
+        id: pyver
+        run: |
+          echo "SHORT_PY=$(echo '${{ matrix.python-version }}' | cut -d. -f1,2)" >> $GITHUB_OUTPUT
+          echo "ENABLE_DEFAULT=$([ \"$(echo '${{ matrix.python-version }}' | cut -d. -f1,2)\" = \"3.13\" ] && echo true || echo false)" >> $GITHUB_OUTPUT
+
       - name: Extract metadata (tags, labels) for Docker
         id: meta
         uses: docker/metadata-action@9ec57ed1fcdbf14dcef7dfbe97b2010124a938b7
         with:
           images: ${{ vars.REGISTRY }}/${{ vars.REGISTRY_ORG }}/${{ github.event.repository.name }}
+          tags: |
+            type=semver,pattern={{version}},enable=${{ steps.pyver.outputs.ENABLE_DEFAULT }}
+            type=semver,pattern={{version}},suffix=-py${{ steps.pyver.outputs.SHORT_PY }}
+            type=semver,pattern={{major}}.{{minor}},enable=${{ steps.pyver.outputs.ENABLE_DEFAULT }}
+            type=semver,pattern={{major}}.{{minor}},suffix=-py${{ steps.pyver.outputs.SHORT_PY }}
+            type=ref,event=branch,enable=${{ steps.pyver.outputs.ENABLE_DEFAULT }}
+            type=ref,event=branch,suffix=-py${{ steps.pyver.outputs.SHORT_PY }}
+            type=ref,event=pr,enable=${{ steps.pyver.outputs.ENABLE_DEFAULT }}
+            type=ref,event=pr,suffix=-py${{ steps.pyver.outputs.SHORT_PY }}
+            type=sha,enable=${{ steps.pyver.outputs.ENABLE_DEFAULT }}
+            type=sha,suffix=-py${{ steps.pyver.outputs.SHORT_PY }}
 
       - name: Build and push Docker image
         id: push
@@ -81,6 +101,8 @@ jobs:
           push: true
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
+          build-args: |
+            PYTHON_VERSION=${{ matrix.python-version }}
 
       - name: Generate artifact attestation
         uses: actions/attest-build-provenance@v2

{kodit-0.3.2 → kodit-0.3.3}/CLAUDE.md

@@ -96,4 +96,5 @@ Migrations managed with Alembic in `migrations/` directory. DO NOT EDIT THESE FI
 - Smoke tests for deployment validation
 - Performance tests for similarity search
 
-Test files mirror source structure under `tests/` directory.
+Test file names should mirror the source structure under `tests/` directory and end in
+the name `_test.py`.

{kodit-0.3.2 → kodit-0.3.3}/Dockerfile

@@ -30,9 +30,11 @@ COPY --from=ghcr.io/astral-sh/uv:0.7.2 /uv /usr/local/bin/uv
 ENV UV_LINK_MODE=copy \
     UV_COMPILE_BYTECODE=1 \
     UV_PYTHON_DOWNLOADS=never \
-    UV_PYTHON=python3.13 \
     UV_PROJECT_ENVIRONMENT=/app
 
+# Write the PYTHON_VERSION to a .python-version
+RUN echo ${PYTHON_VERSION} > .python-version
+
 # Synchronize DEPENDENCIES without the application itself.
 # This layer is cached until uv.lock or pyproject.toml change, which are
 # only temporarily mounted into the build container since we don't need
@@ -43,6 +45,7 @@ ENV UV_LINK_MODE=copy \
 RUN --mount=type=cache,target=/root/.cache/uv \
     --mount=type=bind,source=uv.lock,target=uv.lock \
     --mount=type=bind,source=pyproject.toml,target=pyproject.toml \
+    UV_PYTHON="python$(echo ${PYTHON_VERSION} | cut -d. -f1-2)" \
     uv sync \
         --locked \
         --no-dev \
@@ -54,6 +57,7 @@ RUN --mount=type=cache,target=/root/.cache/uv \
 COPY . /src
 WORKDIR /src
 RUN --mount=type=cache,target=/root/.cache/uv \
+    UV_PYTHON="python$(echo ${PYTHON_VERSION} | cut -d. -f1-2)" \
     uv sync \
         --locked \
         --no-dev \

{kodit-0.3.2 → kodit-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kodit
-Version: 0.3.2
+Version: 0.3.3
 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.3/docs/MIGRATION_TO_INDEX_AGGREGATE.md

@@ -0,0 +1,222 @@
+# 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

{kodit-0.3.2 → kodit-0.3.3}/src/kodit/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.3.2'
-__version_tuple__ = version_tuple = (0, 3, 2)
+__version__ = version = '0.3.3'
+__version_tuple__ = version_tuple = (0, 3, 3)

{kodit-0.3.2 → kodit-0.3.3}/src/kodit/application/factories/code_indexing_factory.py

@@ -6,17 +6,20 @@ from kodit.application.services.code_indexing_application_service import (
     CodeIndexingApplicationService,
 )
 from kodit.config import AppContext
-from kodit.domain.entities import EmbeddingType
 from kodit.domain.services.bm25_service import BM25DomainService
 from kodit.domain.services.embedding_service import EmbeddingDomainService
 from kodit.domain.services.enrichment_service import EnrichmentDomainService
-from kodit.domain.services.source_service import SourceService
+from kodit.domain.services.index_query_service import IndexQueryService
+from kodit.domain.services.index_service import (
+    IndexDomainService,
+)
+from kodit.domain.value_objects import LanguageMapping, SnippetExtractionStrategy
 from kodit.infrastructure.bm25.bm25_factory import bm25_repository_factory
 from kodit.infrastructure.embedding.embedding_factory import (
     embedding_domain_service_factory,
 )
-from kodit.infrastructure.embedding.embedding_providers import (
-    hash_embedding_provider,
+from kodit.infrastructure.embedding.embedding_providers.hash_embedding_provider import (
+    HashEmbeddingProvider,
 )
 from kodit.infrastructure.embedding.local_vector_search_repository import (
     LocalVectorSearchRepository,
@@ -27,36 +30,63 @@ from kodit.infrastructure.enrichment.enrichment_factory import (
 from kodit.infrastructure.enrichment.null_enrichment_provider import (
     NullEnrichmentProvider,
 )
-from kodit.infrastructure.indexing.indexing_factory import (
-    indexing_domain_service_factory,
+from kodit.infrastructure.indexing.fusion_service import ReciprocalRankFusionService
+from kodit.infrastructure.snippet_extraction.factories import (
+    create_snippet_query_provider,
+)
+from kodit.infrastructure.snippet_extraction.language_detection_service import (
+    FileSystemLanguageDetectionService,
 )
-from kodit.infrastructure.indexing.snippet_domain_service_factory import (
-    snippet_domain_service_factory,
+from kodit.infrastructure.snippet_extraction.tree_sitter_snippet_extractor import (
+    TreeSitterSnippetExtractor,
 )
 from kodit.infrastructure.sqlalchemy.embedding_repository import (
     SqlAlchemyEmbeddingRepository,
 )
+from kodit.infrastructure.sqlalchemy.entities import EmbeddingType
+from kodit.infrastructure.sqlalchemy.index_repository import SqlAlchemyIndexRepository
 
 
 def create_code_indexing_application_service(
     app_context: AppContext,
     session: AsyncSession,
-    source_service: SourceService,
 ) -> CodeIndexingApplicationService:
     """Create a unified code indexing application service with all dependencies."""
     # Create domain services
-    indexing_domain_service = indexing_domain_service_factory(session)
-    snippet_domain_service = snippet_domain_service_factory(session)
     bm25_service = BM25DomainService(bm25_repository_factory(app_context, session))
     code_search_service = embedding_domain_service_factory("code", app_context, session)
     text_search_service = embedding_domain_service_factory("text", app_context, session)
     enrichment_service = enrichment_domain_service_factory(app_context)
+    index_repository = SqlAlchemyIndexRepository(session=session)
+    # Use the unified language mapping from the domain layer
+    language_map = LanguageMapping.get_extension_to_language_map()
+
+    # Create infrastructure services
+    language_detector = FileSystemLanguageDetectionService(language_map)
+    query_provider = create_snippet_query_provider()
+
+    # Create snippet extractors
+    method_extractor = TreeSitterSnippetExtractor(query_provider)
+
+    snippet_extractors = {
+        SnippetExtractionStrategy.METHOD_BASED: method_extractor,
+    }
+    index_domain_service = IndexDomainService(
+        language_detector=language_detector,
+        snippet_extractors=snippet_extractors,
+        enrichment_service=enrichment_service,
+        clone_dir=app_context.get_clone_dir(),
+    )
+    index_query_service = IndexQueryService(
+        index_repository=index_repository,
+        fusion_service=ReciprocalRankFusionService(),
+    )
 
     # Create and return the unified application service
     return CodeIndexingApplicationService(
-        indexing_domain_service=indexing_domain_service,
-        snippet_domain_service=snippet_domain_service,
-        source_service=source_service,
+        indexing_domain_service=index_domain_service,
+        index_repository=index_repository,
+        index_query_service=index_query_service,
         bm25_service=bm25_service,
         code_search_service=code_search_service,
         text_search_service=text_search_service,
@@ -68,36 +98,30 @@ def create_code_indexing_application_service(
 def create_fast_test_code_indexing_application_service(
     app_context: AppContext,
     session: AsyncSession,
-    source_service: SourceService,
 ) -> CodeIndexingApplicationService:
-    """Create a fast test version of CodeIndexingApplicationService."""
+    """Create a fast test code indexing application service."""
     # Create domain services
-    indexing_domain_service = indexing_domain_service_factory(session)
-    snippet_domain_service = snippet_domain_service_factory(session)
     bm25_service = BM25DomainService(bm25_repository_factory(app_context, session))
-
-    # Create fast embedding services using HashEmbeddingProvider
     embedding_repository = SqlAlchemyEmbeddingRepository(session=session)
 
-    # Fast code search service
     code_search_repository = LocalVectorSearchRepository(
         embedding_repository=embedding_repository,
-        embedding_provider=hash_embedding_provider.HashEmbeddingProvider(),
+        embedding_provider=HashEmbeddingProvider(),
         embedding_type=EmbeddingType.CODE,
     )
     code_search_service = EmbeddingDomainService(
-        embedding_provider=hash_embedding_provider.HashEmbeddingProvider(),
+        embedding_provider=HashEmbeddingProvider(),
         vector_search_repository=code_search_repository,
     )
 
     # Fast text search service
     text_search_repository = LocalVectorSearchRepository(
         embedding_repository=embedding_repository,
-        embedding_provider=hash_embedding_provider.HashEmbeddingProvider(),
+        embedding_provider=HashEmbeddingProvider(),
         embedding_type=EmbeddingType.TEXT,
     )
     text_search_service = EmbeddingDomainService(
-        embedding_provider=hash_embedding_provider.HashEmbeddingProvider(),
+        embedding_provider=HashEmbeddingProvider(),
         vector_search_repository=text_search_repository,
     )
 
@@ -106,11 +130,36 @@ def create_fast_test_code_indexing_application_service(
         enrichment_provider=NullEnrichmentProvider()
     )
 
+    index_repository = SqlAlchemyIndexRepository(session=session)
+    # Use the unified language mapping from the domain layer
+    language_map = LanguageMapping.get_extension_to_language_map()
+
+    # Create infrastructure services
+    language_detector = FileSystemLanguageDetectionService(language_map)
+    query_provider = create_snippet_query_provider()
+
+    # Create snippet extractors
+    method_extractor = TreeSitterSnippetExtractor(query_provider)
+
+    snippet_extractors = {
+        SnippetExtractionStrategy.METHOD_BASED: method_extractor,
+    }
+    index_domain_service = IndexDomainService(
+        language_detector=language_detector,
+        snippet_extractors=snippet_extractors,
+        enrichment_service=enrichment_service,
+        clone_dir=app_context.get_clone_dir(),
+    )
+    index_query_service = IndexQueryService(
+        index_repository=index_repository,
+        fusion_service=ReciprocalRankFusionService(),
+    )
+
     # Create and return the unified application service
     return CodeIndexingApplicationService(
-        indexing_domain_service=indexing_domain_service,
-        snippet_domain_service=snippet_domain_service,
-        source_service=source_service,
+        indexing_domain_service=index_domain_service,
+        index_repository=index_repository,
+        index_query_service=index_query_service,
         bm25_service=bm25_service,
         code_search_service=code_search_service,
         text_search_service=text_search_service,