kodit 0.2.8__py3-none-any.whl → 0.3.0__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",
@@ -94,12 +59,17 @@ def cli(
 
 @cli.command()
 @click.argument("sources", nargs=-1)
+@click.option(
+    "--auto-index", is_flag=True, help="Index all configured auto-index sources"
+)
 @with_app_context
 @with_session
 async def index(
     session: AsyncSession,
     app_context: AppContext,
     sources: list[str],
+    *,  # Force keyword-only arguments
+    auto_index: bool,
 ) -> None:
     """List indexes, or index data sources."""
     log = structlog.get_logger(__name__)
@@ -107,14 +77,22 @@ 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 auto_index:
+        log.info("Auto-indexing configuration", config=app_context.auto_indexing)
+        auto_sources = app_context.auto_indexing.sources
+        if not auto_sources:
+            click.echo("No auto-index sources configured.")
+            return
+
+        click.echo(f"Auto-indexing {len(auto_sources)} configured sources...")
+        sources = [source.uri for source in auto_sources]
+
     if not sources:
         log_event("kodit.cli.index.list")
         # No source specified, list all indexes
@@ -173,16 +151,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 +241,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 +271,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 +303,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 +333,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 +368,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 +400,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 +422,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 +434,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 +470,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 +544,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/config.py

@@ -8,7 +8,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Any, Literal, TypeVar
 
 import click
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, field_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 if TYPE_CHECKING:
@@ -37,11 +37,45 @@ class Endpoint(BaseModel):
 
 
 class Search(BaseModel):
-    """Search provides configuration for a search engine."""
+    """Search configuration."""
 
     provider: Literal["sqlite", "vectorchord"] = Field(default="sqlite")
 
 
+class AutoIndexingSource(BaseModel):
+    """Configuration for a single auto-indexing source."""
+
+    uri: str = Field(description="URI of the source to index (git URL or local path)")
+
+
+class AutoIndexingConfig(BaseModel):
+    """Configuration for auto-indexing."""
+
+    sources: list[AutoIndexingSource] = Field(
+        default_factory=list, description="List of sources to auto-index"
+    )
+
+    @field_validator("sources", mode="before")
+    @classmethod
+    def parse_sources(cls, v: Any) -> list[AutoIndexingSource]:
+        """Parse sources from environment variables or other formats."""
+        if v is None:
+            return []
+        if isinstance(v, list):
+            return v
+        if isinstance(v, dict):
+            # Handle case where env vars are numbered keys like {'0': {'uri': '...'}}
+            sources = []
+            i = 0
+            while str(i) in v:
+                source_data = v[str(i)]
+                if isinstance(source_data, dict) and "uri" in source_data:
+                    sources.append(AutoIndexingSource(uri=source_data["uri"]))
+                i += 1
+            return sources
+        return v
+
+
 class AppContext(BaseSettings):
     """Global context for the kodit project. Provides a shared state for the app."""
 
@@ -50,7 +84,7 @@ class AppContext(BaseSettings):
         env_file_encoding="utf-8",
         env_nested_delimiter="_",
         nested_model_default_partial_update=True,
-        env_nested_max_split=1,
+        extra="ignore",
     )
 
     data_dir: Path = Field(default=DEFAULT_BASE_DIR)
@@ -76,6 +110,9 @@ class AppContext(BaseSettings):
     default_search: Search = Field(
         default=Search(),
     )
+    auto_indexing: AutoIndexingConfig | None = Field(
+        default=AutoIndexingConfig(), description="Auto-indexing configuration"
+    )
     _db: Database | None = None
 
     def model_post_init(self, _: Any) -> None:

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)