kodit 0.2.7__py3-none-any.whl → 0.2.9__py3-none-any.whl

kodit/cli.py

@@ -1,6 +1,5 @@
 """Command line interface for kodit."""
 
-import asyncio
 import signal
 from pathlib import Path
 from typing import Any
@@ -11,8 +10,8 @@ import uvicorn
 from pytable_formatter import Cell, Table
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from kodit.application.services.snippet_application_service import (
-    SnippetApplicationService,
+from kodit.application.factories.code_indexing_factory import (
+    create_code_indexing_application_service,
 )
 from kodit.config import (
     AppContext,
@@ -21,14 +20,7 @@ from kodit.config import (
 )
 from kodit.domain.errors import EmptySourceError
 from kodit.domain.services.source_service import SourceService
-from kodit.domain.value_objects import MultiSearchRequest
-from kodit.infrastructure.indexing.indexing_factory import (
-    create_indexing_application_service,
-)
-from kodit.infrastructure.snippet_extraction.snippet_extraction_factory import (
-    create_snippet_extraction_domain_service,
-    create_snippet_repositories,
-)
+from kodit.domain.value_objects import MultiSearchRequest, SnippetSearchFilters
 from kodit.infrastructure.ui.progress import (
     create_lazy_progress_callback,
     create_multi_stage_progress_callback,
@@ -36,33 +28,6 @@ from kodit.infrastructure.ui.progress import (
 from kodit.log import configure_logging, configure_telemetry, log_event
 
 
-def create_snippet_application_service(
-    session: AsyncSession,
-) -> SnippetApplicationService:
-    """Create a snippet application service with all dependencies.
-
-    Args:
-        session: SQLAlchemy session
-
-    Returns:
-        Configured snippet application service
-
-    """
-    # Create domain service
-    snippet_extraction_service = create_snippet_extraction_domain_service()
-
-    # Create repositories
-    snippet_repository, file_repository = create_snippet_repositories(session)
-
-    # Create application service
-    return SnippetApplicationService(
-        snippet_extraction_service=snippet_extraction_service,
-        snippet_repository=snippet_repository,
-        file_repository=file_repository,
-        session=session,
-    )
-
-
 @click.group(context_settings={"max_content_width": 100})
 @click.option(
     "--env-file",
@@ -107,12 +72,10 @@ async def index(
         clone_dir=app_context.get_clone_dir(),
         session_factory=lambda: session,
     )
-    snippet_service = create_snippet_application_service(session)
-    service = create_indexing_application_service(
+    service = create_code_indexing_application_service(
         app_context=app_context,
         session=session,
         source_service=source_service,
-        snippet_application_service=snippet_service,
     )
 
     if not sources:
@@ -173,16 +136,86 @@ def search() -> None:
     """Search for snippets in the database."""
 
 
+# Utility for robust filter parsing
+def _parse_filters(
+    language: str | None,
+    author: str | None,
+    created_after: str | None,
+    created_before: str | None,
+    source_repo: str | None,
+) -> SnippetSearchFilters | None:
+    from datetime import datetime
+
+    # Normalize language to lowercase if provided
+    norm_language = language.lower() if language else None
+    # Try to parse dates, raise error if invalid
+    parsed_created_after = None
+    if created_after:
+        try:
+            parsed_created_after = datetime.fromisoformat(created_after)
+        except ValueError as err:
+            raise ValueError(
+                f"Invalid date format for --created-after: {created_after}. "
+                "Expected ISO 8601 format (YYYY-MM-DD)"
+            ) from err
+    parsed_created_before = None
+    if created_before:
+        try:
+            parsed_created_before = datetime.fromisoformat(created_before)
+        except ValueError as err:
+            raise ValueError(
+                f"Invalid date format for --created-before: {created_before}. "
+                "Expected ISO 8601 format (YYYY-MM-DD)"
+            ) from err
+    # Return None if no filters provided, otherwise return SnippetSearchFilters
+    # Check if any original parameters were provided (not just the parsed values)
+    if any(
+        [
+            language,
+            author,
+            created_after,
+            created_before,
+            source_repo,
+        ]
+    ):
+        return SnippetSearchFilters(
+            language=norm_language,
+            author=author,
+            created_after=parsed_created_after,
+            created_before=parsed_created_before,
+            source_repo=source_repo,
+        )
+    return None
+
+
 @search.command()
 @click.argument("query")
 @click.option("--top-k", default=10, help="Number of snippets to retrieve")
+@click.option(
+    "--language", help="Filter by programming language (e.g., python, go, javascript)"
+)
+@click.option("--author", help="Filter by author name")
+@click.option(
+    "--created-after", help="Filter snippets created after this date (YYYY-MM-DD)"
+)
+@click.option(
+    "--created-before", help="Filter snippets created before this date (YYYY-MM-DD)"
+)
+@click.option(
+    "--source-repo", help="Filter by source repository (e.g., github.com/example/repo)"
+)
 @with_app_context
 @with_session
-async def code(
+async def code(  # noqa: PLR0913
     session: AsyncSession,
     app_context: AppContext,
     query: str,
     top_k: int,
+    language: str | None,
+    author: str | None,
+    created_after: str | None,
+    created_before: str | None,
+    source_repo: str | None,
 ) -> None:
     """Search for snippets using semantic code search.
 
@@ -193,15 +226,19 @@ async def code(
         clone_dir=app_context.get_clone_dir(),
         session_factory=lambda: session,
     )
-    snippet_service = create_snippet_application_service(session)
-    service = create_indexing_application_service(
+    service = create_code_indexing_application_service(
         app_context=app_context,
         session=session,
         source_service=source_service,
-        snippet_application_service=snippet_service,
     )
 
-    snippets = await service.search(MultiSearchRequest(code_query=query, top_k=top_k))
+    filters = _parse_filters(
+        language, author, created_after, created_before, source_repo
+    )
+
+    snippets = await service.search(
+        MultiSearchRequest(code_query=query, top_k=top_k, filters=filters)
+    )
 
     if len(snippets) == 0:
         click.echo("No snippets found")
@@ -219,13 +256,31 @@ async def code(
 @search.command()
 @click.argument("keywords", nargs=-1)
 @click.option("--top-k", default=10, help="Number of snippets to retrieve")
+@click.option(
+    "--language", help="Filter by programming language (e.g., python, go, javascript)"
+)
+@click.option("--author", help="Filter by author name")
+@click.option(
+    "--created-after", help="Filter snippets created after this date (YYYY-MM-DD)"
+)
+@click.option(
+    "--created-before", help="Filter snippets created before this date (YYYY-MM-DD)"
+)
+@click.option(
+    "--source-repo", help="Filter by source repository (e.g., github.com/example/repo)"
+)
 @with_app_context
 @with_session
-async def keyword(
+async def keyword(  # noqa: PLR0913
     session: AsyncSession,
     app_context: AppContext,
     keywords: list[str],
     top_k: int,
+    language: str | None,
+    author: str | None,
+    created_after: str | None,
+    created_before: str | None,
+    source_repo: str | None,
 ) -> None:
     """Search for snippets using keyword search."""
     log_event("kodit.cli.search.keyword")
@@ -233,15 +288,19 @@ async def keyword(
         clone_dir=app_context.get_clone_dir(),
         session_factory=lambda: session,
     )
-    snippet_service = create_snippet_application_service(session)
-    service = create_indexing_application_service(
+    service = create_code_indexing_application_service(
         app_context=app_context,
         session=session,
         source_service=source_service,
-        snippet_application_service=snippet_service,
     )
 
-    snippets = await service.search(MultiSearchRequest(keywords=keywords, top_k=top_k))
+    filters = _parse_filters(
+        language, author, created_after, created_before, source_repo
+    )
+
+    snippets = await service.search(
+        MultiSearchRequest(keywords=keywords, top_k=top_k, filters=filters)
+    )
 
     if len(snippets) == 0:
         click.echo("No snippets found")
@@ -259,13 +318,31 @@ async def keyword(
 @search.command()
 @click.argument("query")
 @click.option("--top-k", default=10, help="Number of snippets to retrieve")
+@click.option(
+    "--language", help="Filter by programming language (e.g., python, go, javascript)"
+)
+@click.option("--author", help="Filter by author name")
+@click.option(
+    "--created-after", help="Filter snippets created after this date (YYYY-MM-DD)"
+)
+@click.option(
+    "--created-before", help="Filter snippets created before this date (YYYY-MM-DD)"
+)
+@click.option(
+    "--source-repo", help="Filter by source repository (e.g., github.com/example/repo)"
+)
 @with_app_context
 @with_session
-async def text(
+async def text(  # noqa: PLR0913
     session: AsyncSession,
     app_context: AppContext,
     query: str,
     top_k: int,
+    language: str | None,
+    author: str | None,
+    created_after: str | None,
+    created_before: str | None,
+    source_repo: str | None,
 ) -> None:
     """Search for snippets using semantic text search.
 
@@ -276,15 +353,19 @@ async def text(
         clone_dir=app_context.get_clone_dir(),
         session_factory=lambda: session,
     )
-    snippet_service = create_snippet_application_service(session)
-    service = create_indexing_application_service(
+    service = create_code_indexing_application_service(
         app_context=app_context,
         session=session,
         source_service=source_service,
-        snippet_application_service=snippet_service,
     )
 
-    snippets = await service.search(MultiSearchRequest(text_query=query, top_k=top_k))
+    filters = _parse_filters(
+        language, author, created_after, created_before, source_repo
+    )
+
+    snippets = await service.search(
+        MultiSearchRequest(text_query=query, top_k=top_k, filters=filters)
+    )
 
     if len(snippets) == 0:
         click.echo("No snippets found")
@@ -304,6 +385,19 @@ async def text(
 @click.option("--keywords", required=True, help="Comma separated list of keywords")
 @click.option("--code", required=True, help="Semantic code search query")
 @click.option("--text", required=True, help="Semantic text search query")
+@click.option(
+    "--language", help="Filter by programming language (e.g., python, go, javascript)"
+)
+@click.option("--author", help="Filter by author name")
+@click.option(
+    "--created-after", help="Filter snippets created after this date (YYYY-MM-DD)"
+)
+@click.option(
+    "--created-before", help="Filter snippets created before this date (YYYY-MM-DD)"
+)
+@click.option(
+    "--source-repo", help="Filter by source repository (e.g., github.com/example/repo)"
+)
 @with_app_context
 @with_session
 async def hybrid(  # noqa: PLR0913
@@ -313,6 +407,11 @@ async def hybrid(  # noqa: PLR0913
     keywords: str,
     code: str,
     text: str,
+    language: str | None,
+    author: str | None,
+    created_after: str | None,
+    created_before: str | None,
+    source_repo: str | None,
 ) -> None:
     """Search for snippets using hybrid search."""
     log_event("kodit.cli.search.hybrid")
@@ -320,23 +419,26 @@ async def hybrid(  # noqa: PLR0913
         clone_dir=app_context.get_clone_dir(),
         session_factory=lambda: session,
     )
-    snippet_service = create_snippet_application_service(session)
-    service = create_indexing_application_service(
+    service = create_code_indexing_application_service(
         app_context=app_context,
         session=session,
         source_service=source_service,
-        snippet_application_service=snippet_service,
     )
 
     # Parse keywords into a list of strings
     keywords_list = [k.strip().lower() for k in keywords.split(",")]
 
+    filters = _parse_filters(
+        language, author, created_after, created_before, source_repo
+    )
+
     snippets = await service.search(
         MultiSearchRequest(
             keywords=keywords_list,
             code_query=code,
             text_query=text,
             top_k=top_k,
+            filters=filters,
         )
     )
 
@@ -353,6 +455,40 @@ async def hybrid(  # noqa: PLR0913
         click.echo()
 
 
+@cli.group()
+def show() -> None:
+    """Show information about elements in the database."""
+
+
+@show.command()
+@click.option("--by-path", help="File or directory path to search for snippets")
+@click.option("--by-source", help="Source URI to filter snippets by")
+@with_app_context
+@with_session
+async def snippets(
+    session: AsyncSession,
+    app_context: AppContext,
+    by_path: str | None,
+    by_source: str | None,
+) -> None:
+    """Show snippets with optional filtering by path or source."""
+    log_event("kodit.cli.show.snippets")
+    source_service = SourceService(
+        clone_dir=app_context.get_clone_dir(),
+        session_factory=lambda: session,
+    )
+    service = create_code_indexing_application_service(
+        app_context=app_context,
+        session=session,
+        source_service=source_service,
+    )
+    snippets = await service.list_snippets(file_path=by_path, source_uri=by_source)
+    for snippet in snippets:
+        click.echo(f"{snippet.id}: [{snippet.source_uri}] {snippet.file_path}")
+        click.echo(f"  {snippet.content}")
+        click.echo()
+
+
 @cli.command()
 @click.option("--host", default="127.0.0.1", help="Host to bind the server to")
 @click.option("--port", default=8080, help="Port to bind the server to")
@@ -393,9 +529,10 @@ def version() -> None:
         from kodit import _version
     except ImportError:
         print("unknown, try running `uv build`, which is what happens in ci")  # noqa: T201
-    else:
-        print(_version.version)  # noqa: T201
+        return
+
+    print(f"kodit {_version.__version__}")  # noqa: T201
 
 
 if __name__ == "__main__":
-    asyncio.run(cli())
+    cli()

kodit/domain/entities.py

@@ -121,22 +121,24 @@ class File(Base, CommonMixin):
         created_at: datetime,
         updated_at: datetime,
         source_id: int,
+        mime_type: str,
+        uri: str,
         cloned_path: str,
-        mime_type: str = "",
-        uri: str = "",
-        sha256: str = "",
-        size_bytes: int = 0,
+        sha256: str,
+        size_bytes: int,
+        extension: str,
     ) -> None:
         """Initialize a new File instance for typing purposes."""
         super().__init__()
         self.created_at = created_at
         self.updated_at = updated_at
         self.source_id = source_id
-        self.cloned_path = cloned_path
         self.mime_type = mime_type
         self.uri = uri
+        self.cloned_path = cloned_path
         self.sha256 = sha256
         self.size_bytes = size_bytes
+        self.extension = extension
 
 
 class EmbeddingType(Enum):

kodit/domain/repositories.py

@@ -11,6 +11,10 @@ from kodit.domain.entities import (
     Source,
     SourceType,
 )
+from kodit.domain.value_objects import (
+    MultiSearchRequest,
+    SnippetListItem,
+)
 
 T = TypeVar("T")
 
@@ -86,6 +90,35 @@ class SnippetRepository(GenericRepository[Snippet]):
         """Delete all snippets for an index."""
         raise NotImplementedError
 
+    async def list_snippets(
+        self, file_path: str | None = None, source_uri: str | None = None
+    ) -> Sequence[SnippetListItem]:
+        """List snippets with optional filtering by file path and source URI.
+
+        Args:
+            file_path: Optional file or directory path to filter by. Can be relative
+            (uri) or absolute (cloned_path).
+            source_uri: Optional source URI to filter by. If None, returns snippets from
+            all sources.
+
+        Returns:
+            A sequence of SnippetListItem instances matching the criteria
+
+        """
+        raise NotImplementedError
+
+    async def search(self, request: MultiSearchRequest) -> Sequence[SnippetListItem]:
+        """Search snippets with filters.
+
+        Args:
+            request: The search request containing queries and optional filters.
+
+        Returns:
+            A sequence of SnippetListItem instances matching the search criteria.
+
+        """
+        raise NotImplementedError
+
 
 class FileRepository(GenericRepository[File]):
     """File repository with specific methods."""

kodit/domain/services/bm25_service.py

@@ -4,10 +4,10 @@ from abc import ABC, abstractmethod
 from collections.abc import Sequence
 
 from kodit.domain.value_objects import (
-    BM25DeleteRequest,
-    BM25IndexRequest,
-    BM25SearchRequest,
-    BM25SearchResult,
+    DeleteRequest,
+    IndexRequest,
+    SearchRequest,
+    SearchResult,
 )
 
 
@@ -15,15 +15,15 @@ class BM25Repository(ABC):
     """Abstract interface for BM25 repository."""
 
     @abstractmethod
-    async def index_documents(self, request: BM25IndexRequest) -> None:
+    async def index_documents(self, request: IndexRequest) -> None:
         """Index documents for BM25 search."""
 
     @abstractmethod
-    async def search(self, request: BM25SearchRequest) -> Sequence[BM25SearchResult]:
+    async def search(self, request: SearchRequest) -> Sequence[SearchResult]:
         """Search documents using BM25."""
 
     @abstractmethod
-    async def delete_documents(self, request: BM25DeleteRequest) -> None:
+    async def delete_documents(self, request: DeleteRequest) -> None:
         """Delete documents from the BM25 index."""
 
 
@@ -39,7 +39,7 @@ class BM25DomainService:
         """
         self.repository = repository
 
-    async def index_documents(self, request: BM25IndexRequest) -> None:
+    async def index_documents(self, request: IndexRequest) -> None:
         """Index documents using domain business rules.
 
         Args:
@@ -64,10 +64,10 @@ class BM25DomainService:
             raise ValueError("No valid documents to index")
 
         # Domain logic: create new request with validated documents
-        validated_request = BM25IndexRequest(documents=valid_documents)
+        validated_request = IndexRequest(documents=valid_documents)
         await self.repository.index_documents(validated_request)
 
-    async def search(self, request: BM25SearchRequest) -> Sequence[BM25SearchResult]:
+    async def search(self, request: SearchRequest) -> Sequence[SearchResult]:
         """Search documents using domain business rules.
 
         Args:
@@ -88,14 +88,11 @@ class BM25DomainService:
             raise ValueError("Top-k must be positive")
 
         # Domain logic: normalize query
-        normalized_query = request.query.strip()
-        normalized_request = BM25SearchRequest(
-            query=normalized_query, top_k=request.top_k
-        )
+        request.query = request.query.strip()
 
-        return await self.repository.search(normalized_request)
+        return await self.repository.search(request)
 
-    async def delete_documents(self, request: BM25DeleteRequest) -> None:
+    async def delete_documents(self, request: DeleteRequest) -> None:
         """Delete documents using domain business rules.
 
         Args:
@@ -120,5 +117,5 @@ class BM25DomainService:
             raise ValueError("No valid snippet IDs to delete")
 
         # Domain logic: create new request with validated IDs
-        validated_request = BM25DeleteRequest(snippet_ids=valid_ids)
+        validated_request = DeleteRequest(snippet_ids=valid_ids)
         await self.repository.delete_documents(validated_request)

kodit/domain/services/embedding_service.py

@@ -7,10 +7,10 @@ from kodit.domain.entities import EmbeddingType
 from kodit.domain.value_objects import (
     EmbeddingRequest,
     EmbeddingResponse,
+    IndexRequest,
     IndexResult,
-    VectorIndexRequest,
-    VectorSearchQueryRequest,
-    VectorSearchResult,
+    SearchRequest,
+    SearchResult,
 )
 
 
@@ -29,14 +29,12 @@ class VectorSearchRepository(ABC):
 
     @abstractmethod
     def index_documents(
-        self, request: VectorIndexRequest
+        self, request: IndexRequest
     ) -> AsyncGenerator[list[IndexResult], None]:
         """Index documents for vector search."""
 
     @abstractmethod
-    async def search(
-        self, request: VectorSearchQueryRequest
-    ) -> Sequence[VectorSearchResult]:
+    async def search(self, request: SearchRequest) -> Sequence[SearchResult]:
         """Search documents using vector similarity."""
 
     @abstractmethod
@@ -65,7 +63,7 @@ class EmbeddingDomainService:
         self.vector_search_repository = vector_search_repository
 
     async def index_documents(
-        self, request: VectorIndexRequest
+        self, request: IndexRequest
     ) -> AsyncGenerator[list[IndexResult], None]:
         """Index documents using domain business rules.
 
@@ -94,15 +92,13 @@ class EmbeddingDomainService:
             return
 
         # Domain logic: create new request with validated documents
-        validated_request = VectorIndexRequest(documents=valid_documents)
+        validated_request = IndexRequest(documents=valid_documents)
         async for result in self.vector_search_repository.index_documents(
             validated_request
         ):
             yield result
 
-    async def search(
-        self, request: VectorSearchQueryRequest
-    ) -> Sequence[VectorSearchResult]:
+    async def search(self, request: SearchRequest) -> Sequence[SearchResult]:
         """Search documents using domain business rules.
 
         Args:
@@ -124,8 +120,8 @@ class EmbeddingDomainService:
 
         # Domain logic: normalize query
         normalized_query = request.query.strip()
-        normalized_request = VectorSearchQueryRequest(
-            query=normalized_query, top_k=request.top_k
+        normalized_request = SearchRequest(
+            query=normalized_query, top_k=request.top_k, snippet_ids=request.snippet_ids
         )
 
         return await self.vector_search_repository.search(normalized_request)