kodit 0.4.3__py3-none-any.whl → 0.5.1__py3-none-any.whl

kodit/cli_utils.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, Any
 
 import click
 
-from kodit.infrastructure.api.client import IndexClient, SearchClient
+from kodit.infrastructure.api.client import SearchClient
 
 if TYPE_CHECKING:
     from kodit.config import AppContext
@@ -37,7 +37,7 @@ def with_client(f: Callable) -> Callable:
             inner_func = getattr(
                 getattr(session_wrapped, "__wrapped__", session_wrapped),
                 "__wrapped__",
-                session_wrapped
+                session_wrapped,
             )
 
             # Get database session manually
@@ -47,13 +47,6 @@ def with_client(f: Callable) -> Callable:
         else:
             # Remote mode - use API clients
             clients = {
-                "index_client": IndexClient(
-                    base_url=app_context.remote.server_url or "",
-                    api_key=app_context.remote.api_key,
-                    timeout=app_context.remote.timeout,
-                    max_retries=app_context.remote.max_retries,
-                    verify_ssl=app_context.remote.verify_ssl,
-                ),
                 "search_client": SearchClient(
                     base_url=app_context.remote.server_url or "",
                     api_key=app_context.remote.api_key,

kodit/config.py

@@ -14,9 +14,7 @@ import structlog
 from pydantic import BaseModel, Field, field_validator
 from pydantic_settings import (
     BaseSettings,
-    EnvSettingsSource,
     NoDecode,
-    PydanticBaseSettingsSource,
     SettingsConfigDict,
 )
 
@@ -68,9 +66,9 @@ class Endpoint(BaseModel):
         default=None,
         description="Unix socket path for local communication (e.g., /tmp/openai.sock)",
     )
-    timeout: float | None = Field(
-        default=None,
-        description="Request timeout in seconds (default: 30.0)",
+    timeout: float = Field(
+        default=60,
+        description="Request timeout in seconds",
     )
     extra_params: dict[str, Any] | None = Field(
         default=None,
@@ -91,46 +89,12 @@ class Search(BaseModel):
     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) -> Any:
-        """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 PeriodicSyncConfig(BaseModel):
     """Configuration for periodic/scheduled syncing."""
 
     enabled: bool = Field(default=True, description="Enable periodic sync")
     interval_seconds: float = Field(
-        default=1800, description="Interval between automatic syncs in seconds"
+        default=1800, description="Interval between periodic syncs in seconds"
     )
     retry_attempts: int = Field(
         default=3, description="Number of retry attempts for failed syncs"
@@ -147,36 +111,6 @@ class RemoteConfig(BaseModel):
     verify_ssl: bool = Field(default=True, description="Verify SSL certificates")
 
 
-class CustomAutoIndexingEnvSource(EnvSettingsSource):
-    """Custom environment source for parsing AutoIndexingConfig."""
-
-    def __call__(self) -> dict[str, Any]:
-        """Load settings from env vars with custom auto-indexing parsing."""
-        d: dict[str, Any] = {}
-
-        # First get the standard env vars
-        env_vars = super().__call__()
-        d.update(env_vars)
-
-        # Custom parsing for auto-indexing sources
-        auto_indexing_sources = []
-        i = 0
-        while True:
-            # Note: env_vars keys are lowercase due to Pydantic Settings normalization
-            uri_key = f"auto_indexing_sources_{i}_uri"
-            if uri_key in self.env_vars:
-                uri_value = self.env_vars[uri_key]
-                auto_indexing_sources.append({"uri": uri_value})
-                i += 1
-            else:
-                break
-
-        if auto_indexing_sources:
-            d["auto_indexing"] = {"sources": auto_indexing_sources}
-
-        return d
-
-
 class AppContext(BaseSettings):
     """Global context for the kodit project. Provides a shared state for the app."""
 
@@ -189,30 +123,6 @@ class AppContext(BaseSettings):
         extra="ignore",
     )
 
-    @classmethod
-    def settings_customise_sources(
-        cls,
-        settings_cls: type[BaseSettings],
-        init_settings: PydanticBaseSettingsSource,
-        env_settings: PydanticBaseSettingsSource,  # noqa: ARG003
-        dotenv_settings: PydanticBaseSettingsSource,
-        file_secret_settings: PydanticBaseSettingsSource,
-    ) -> tuple[PydanticBaseSettingsSource, ...]:
-        """Customize settings sources to use custom auto-indexing parsing."""
-        custom_env_settings = CustomAutoIndexingEnvSource(
-            settings_cls,
-            env_nested_delimiter=settings_cls.model_config.get("env_nested_delimiter"),
-            env_ignore_empty=settings_cls.model_config.get("env_ignore_empty", False),
-            env_parse_none_str=settings_cls.model_config.get("env_parse_none_str", ""),
-            env_parse_enums=settings_cls.model_config.get("env_parse_enums", None),
-        )
-        return (
-            init_settings,
-            custom_env_settings,
-            dotenv_settings,
-            file_secret_settings,
-        )
-
     data_dir: Path = Field(default=DEFAULT_BASE_DIR)
     db_url: str = Field(
         default_factory=lambda data: f"sqlite+aiosqlite:///{data['data_dir']}/kodit.db"
@@ -231,9 +141,6 @@ class AppContext(BaseSettings):
     default_search: Search = Field(
         default=Search(),
     )
-    auto_indexing: AutoIndexingConfig | None = Field(
-        default=AutoIndexingConfig(), description="Auto-indexing configuration"
-    )
     periodic_sync: PeriodicSyncConfig = Field(
         default=PeriodicSyncConfig(), description="Periodic sync configuration"
     )

kodit/database.py

@@ -2,10 +2,12 @@
 
 from collections.abc import Callable
 from pathlib import Path
+from typing import Any
 
 import structlog
 from alembic import command
 from alembic.config import Config as AlembicConfig
+from sqlalchemy import event
 from sqlalchemy.ext.asyncio import (
     AsyncSession,
     async_sessionmaker,
@@ -21,7 +23,42 @@ class Database:
     def __init__(self, db_url: str) -> None:
         """Initialize the database."""
         self.log = structlog.get_logger(__name__)
-        self.db_engine = create_async_engine(db_url, echo=False)
+
+        # Configure SQLite-specific connection arguments to prevent locking issues
+        connect_args = {}
+        if "sqlite" in db_url.lower():
+            connect_args = {
+                "timeout": 20,  # 20 second timeout for database operations
+                "check_same_thread": False,  # Allow use from different threads
+            }
+
+        self.db_engine = create_async_engine(
+            db_url,
+            echo=False,
+            connect_args=connect_args,
+        )
+
+        # Configure SQLite pragmas for better concurrency and performance
+        if "sqlite" in db_url.lower():
+
+            @event.listens_for(self.db_engine.sync_engine, "connect")
+            def set_sqlite_pragma(
+                dbapi_connection: Any, connection_record: Any
+            ) -> None:
+                del (
+                    connection_record
+                )  # Unused but required by SQLAlchemy event interface
+                cursor = dbapi_connection.cursor()
+                # Enable WAL mode for better concurrency
+                cursor.execute("PRAGMA journal_mode=WAL")
+                # Set busy timeout to prevent immediate locking failures
+                cursor.execute("PRAGMA busy_timeout=20000")
+                # Enable foreign key constraints
+                cursor.execute("PRAGMA foreign_keys=ON")
+                # Optimize for speed over safety (acceptable for indexing workloads)
+                cursor.execute("PRAGMA synchronous=NORMAL")
+                cursor.close()
+
         self.db_session_factory = async_sessionmaker(
             self.db_engine,
             class_=AsyncSession,

kodit/domain/enrichments/__init__.py

@@ -0,0 +1 @@
+"""Enrichment domain package."""

kodit/domain/enrichments/architecture/__init__.py

@@ -0,0 +1 @@
+"""Architecture enrichment package."""

kodit/domain/enrichments/architecture/architecture.py

@@ -0,0 +1,20 @@
+"""Architecture enrichment domain entity."""
+
+from abc import ABC
+from dataclasses import dataclass
+
+from kodit.domain.enrichments.enrichment import (
+    CommitEnrichment,
+)
+
+ENRICHMENT_TYPE_ARCHITECTURE = "architecture"
+
+
+@dataclass
+class ArchitectureEnrichment(CommitEnrichment, ABC):
+    """Enrichment containing physical architecture discovery for a commit."""
+
+    @property
+    def type(self) -> str:
+        """Return the enrichment type."""
+        return ENRICHMENT_TYPE_ARCHITECTURE

kodit/domain/enrichments/architecture/physical/__init__.py

@@ -0,0 +1 @@
+"""Physical architecture enrichment package."""

kodit/domain/enrichments/architecture/physical/discovery_notes.py

@@ -0,0 +1,14 @@
+"""Physical architecture domain value objects."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class ArchitectureDiscoveryNotes:
+    """Rich, narrative observations about repository architecture for LLM consumption."""  # noqa: E501
+
+    repository_context: str  # High-level overview and discovery scope
+    component_observations: list[str]  # Detailed findings about each component
+    connection_observations: list[str]  # How components interact and communicate
+    infrastructure_observations: list[str]  # Deployment, config, operational patterns
+    discovery_metadata: str  # Methodology, confidence, limitations, timestamp

kodit/domain/enrichments/architecture/physical/formatter.py

@@ -0,0 +1,11 @@
+"""Physical architecture formatter protocol."""
+
+from typing import Any, Protocol
+
+
+class PhysicalArchitectureFormatter(Protocol):
+    """Formatter for converting architecture discovery notes to LLM-optimized text."""
+
+    def format_for_llm(self, notes: Any) -> str:
+        """Format architecture discovery notes for LLM consumption."""
+        ...

kodit/domain/enrichments/architecture/physical/physical.py

@@ -0,0 +1,17 @@
+"""Physical architecture enrichment domain entity."""
+
+from dataclasses import dataclass
+
+from kodit.domain.enrichments.architecture.architecture import ArchitectureEnrichment
+
+ENRICHMENT_SUBTYPE_PHYSICAL = "physical"
+
+
+@dataclass
+class PhysicalArchitectureEnrichment(ArchitectureEnrichment):
+    """Enrichment containing physical architecture discovery for a commit."""
+
+    @property
+    def subtype(self) -> str | None:
+        """Return the enrichment subtype."""
+        return ENRICHMENT_SUBTYPE_PHYSICAL

kodit/domain/enrichments/development/__init__.py

@@ -0,0 +1 @@
+"""Development enrichment package."""

kodit/domain/enrichments/development/development.py

@@ -0,0 +1,18 @@
+"""Development enrichment domain entity."""
+
+from abc import ABC
+from dataclasses import dataclass
+
+from kodit.domain.enrichments.enrichment import CommitEnrichment
+
+ENRICHMENT_TYPE_DEVELOPMENT = "development"
+
+
+@dataclass
+class DevelopmentEnrichment(CommitEnrichment, ABC):
+    """Enrichment containing development discovery for a commit."""
+
+    @property
+    def type(self) -> str:
+        """Return the enrichment type."""
+        return ENRICHMENT_TYPE_DEVELOPMENT

kodit/domain/enrichments/development/snippet/__init__.py

@@ -0,0 +1 @@
+"""Snippet enrichment package."""

kodit/domain/enrichments/development/snippet/snippet.py

@@ -0,0 +1,21 @@
+"""Snippet enrichment domain entity."""
+
+from dataclasses import dataclass
+
+from kodit.domain.enrichments.development.development import DevelopmentEnrichment
+
+ENRICHMENT_SUBTYPE_SNIPPET_SUMMARY = "snippet_summary"
+
+
+@dataclass
+class SnippetEnrichment(DevelopmentEnrichment):
+    """Enrichment specific to code snippets."""
+
+    @property
+    def subtype(self) -> str | None:
+        """Return the enrichment subtype."""
+        return ENRICHMENT_SUBTYPE_SNIPPET_SUMMARY
+
+    def entity_type_key(self) -> str:
+        """Return the entity type key this enrichment is for."""
+        return "snippet_v2"

kodit/domain/enrichments/enricher.py

@@ -0,0 +1,17 @@
+"""Enricher interface."""
+
+from collections.abc import AsyncGenerator
+from typing import Protocol
+
+from kodit.domain.enrichments.request import EnrichmentRequest
+from kodit.domain.enrichments.response import EnrichmentResponse
+
+
+class Enricher(Protocol):
+    """Interface for text enrichment with custom prompts."""
+
+    def enrich(
+        self, requests: list[EnrichmentRequest]
+    ) -> AsyncGenerator[EnrichmentResponse, None]:
+        """Enrich a list of requests with custom system prompts."""
+        ...

kodit/domain/enrichments/enrichment.py

@@ -0,0 +1,39 @@
+"""Enrichment domain entities."""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from datetime import datetime
+
+
+@dataclass
+class EnrichmentV2(ABC):
+    """Generic enrichment that can be attached to any entity."""
+
+    entity_id: str
+    content: str = ""
+    id: int | None = None
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
+
+    @property
+    @abstractmethod
+    def type(self) -> str:
+        """Return the enrichment type."""
+
+    @property
+    @abstractmethod
+    def subtype(self) -> str | None:
+        """Return the enrichment subtype (optional for hierarchical types)."""
+
+    @abstractmethod
+    def entity_type_key(self) -> str:
+        """Return the entity type key this enrichment is for."""
+
+
+@dataclass
+class CommitEnrichment(EnrichmentV2, ABC):
+    """Enrichment specific to commits."""
+
+    def entity_type_key(self) -> str:
+        """Return the entity type key this enrichment is for."""
+        return "git_commit"

kodit/domain/enrichments/request.py

@@ -0,0 +1,12 @@
+"""Generic enrichment request value object."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class EnrichmentRequest:
+    """Domain model for generic enrichment request with custom prompt."""
+
+    id: str
+    text: str
+    system_prompt: str

kodit/domain/enrichments/response.py

@@ -0,0 +1,11 @@
+"""Generic enrichment response value object."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class EnrichmentResponse:
+    """Domain model for generic enrichment response."""
+
+    id: str
+    text: str

kodit/domain/enrichments/usage/__init__.py

@@ -0,0 +1 @@
+"""Usage enrichment domain entities."""

kodit/domain/enrichments/usage/api_docs.py

@@ -0,0 +1,19 @@
+"""API documentation enrichment entity."""
+
+from dataclasses import dataclass
+
+from kodit.domain.enrichments.usage.usage import UsageEnrichment
+
+ENRICHMENT_SUBTYPE_API_DOCS = "api_docs"
+
+
+@dataclass
+class APIDocEnrichment(UsageEnrichment):
+    """API documentation enrichment for a module."""
+
+    language: str = ""
+
+    @property
+    def subtype(self) -> str | None:
+        """Return the enrichment subtype."""
+        return ENRICHMENT_SUBTYPE_API_DOCS

kodit/domain/enrichments/usage/usage.py

@@ -0,0 +1,18 @@
+"""Usage enrichment domain entity."""
+
+from abc import ABC
+from dataclasses import dataclass
+
+from kodit.domain.enrichments.enrichment import CommitEnrichment
+
+ENRICHMENT_TYPE_USAGE = "usage"
+
+
+@dataclass
+class UsageEnrichment(CommitEnrichment, ABC):
+    """Enrichment containing development discovery for a commit."""
+
+    @property
+    def type(self) -> str:
+        """Return the enrichment type."""
+        return ENRICHMENT_TYPE_USAGE