kodit 0.4.2__py3-none-any.whl → 0.5.0__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,
 )
 
@@ -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"
     )
@@ -305,7 +212,7 @@ class AppContext(BaseSettings):
 with_app_context = click.make_pass_decorator(AppContext)
 
 
-def wrap_async(f: Callable[..., Coroutine[Any, Any, T]]) -> Callable[..., T]:
+def wrap_async[T](f: Callable[..., Coroutine[Any, Any, T]]) -> Callable[..., T]:
     """Decorate async Click commands.
 
     This decorator wraps an async function to run it with asyncio.run().
@@ -326,7 +233,7 @@ def wrap_async(f: Callable[..., Coroutine[Any, Any, T]]) -> Callable[..., T]:
     return wrapper
 
 
-def with_session(f: Callable[..., Coroutine[Any, Any, T]]) -> Callable[..., T]:
+def with_session[T](f: Callable[..., Coroutine[Any, Any, T]]) -> Callable[..., T]:
     """Provide a database session to CLI commands."""
 
     @wraps(f)

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/entities/__init__.py

@@ -0,0 +1,276 @@
+"""Pure domain entities using Pydantic."""
+
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any, Protocol
+from urllib.parse import urlparse, urlunparse
+
+from pydantic import AnyUrl, BaseModel
+
+from kodit.domain.value_objects import (
+    ReportingState,
+    TaskOperation,
+    TrackableType,
+)
+
+
+class IgnorePatternProvider(Protocol):
+    """Protocol for ignore pattern providers."""
+
+    def should_ignore(self, path: Path) -> bool:
+        """Check if a path should be ignored."""
+        ...
+
+
+class Author(BaseModel):
+    """Author domain entity."""
+
+    id: int | None = None
+    name: str
+    email: str
+
+
+class WorkingCopy(BaseModel):
+    """Working copy value object representing cloned source location."""
+
+    @classmethod
+    def sanitize_local_path(cls, path: str) -> AnyUrl:
+        """Sanitize a local path."""
+        return AnyUrl(Path(path).resolve().absolute().as_uri())
+
+    @classmethod
+    def sanitize_git_url(cls, url: str) -> AnyUrl:
+        """Remove credentials from a git URL while preserving the rest of the URL.
+
+        This function handles various git URL formats:
+        - HTTPS URLs with username:password@host
+        - HTTPS URLs with username@host (no password)
+        - SSH URLs (left unchanged)
+        - File URLs (left unchanged)
+
+        Args:
+            url: The git URL that may contain credentials.
+
+        Returns:
+            The sanitized URL with credentials removed.
+
+        Examples:
+            >>> sanitize_git_url("https://phil:token@dev.azure.com/org/project/_git/repo")
+            "https://dev.azure.com/org/project/_git/repo"
+            >>> sanitize_git_url("https://username@github.com/user/repo.git")
+            "https://github.com/user/repo.git"
+            >>> sanitize_git_url("git@github.com:user/repo.git")
+            "ssh://git@github.com/user/repo.git"
+
+        """
+        # Handle different URL types
+        if not url:
+            raise ValueError("URL is required")
+
+        if url.startswith("git@"):
+            return cls._handle_ssh_url(url)
+        if url.startswith("ssh://"):
+            return AnyUrl(url)
+        if url.startswith("file://"):
+            return AnyUrl(url)
+
+        # Try local path conversion
+        local_url = cls._try_local_path_conversion(url)
+        if local_url:
+            return local_url
+
+        # Handle HTTPS URLs with credentials
+        return cls._sanitize_https_url(url)
+
+    @classmethod
+    def _handle_ssh_url(cls, url: str) -> AnyUrl:
+        """Handle SSH URL conversion."""
+        if ":" in url and not url.startswith("ssh://"):
+            host_path = url[4:]  # Remove "git@"
+            if ":" in host_path:
+                host, path = host_path.split(":", 1)
+                return AnyUrl(f"ssh://git@{host}/{path}")
+        return AnyUrl(url)
+
+    @classmethod
+    def _try_local_path_conversion(cls, url: str) -> AnyUrl | None:
+        """Try to convert local paths to file:// URLs."""
+        from pathlib import Path
+
+        try:
+            path = Path(url)
+            if path.exists() or url.startswith(("/", "./", "../")) or url == ".":
+                absolute_path = path.resolve()
+                return AnyUrl(f"file://{absolute_path}")
+        except OSError:
+            # Path operations failed, not a local path
+            pass
+        return None
+
+    @classmethod
+    def _sanitize_https_url(cls, url: str) -> AnyUrl:
+        """Remove credentials from HTTPS URLs."""
+        try:
+            parsed = urlparse(url)
+
+            # If there are no credentials, return the URL as-is
+            if not parsed.username:
+                return AnyUrl(url)
+
+            # Reconstruct the URL without credentials
+            sanitized_netloc = parsed.hostname
+            if parsed.port:
+                sanitized_netloc = f"{parsed.hostname}:{parsed.port}"
+
+            return AnyUrl(
+                urlunparse(
+                    (
+                        parsed.scheme,
+                        sanitized_netloc,
+                        parsed.path,
+                        parsed.params,
+                        parsed.query,
+                        parsed.fragment,
+                    )
+                )
+            )
+        except Exception as e:
+            raise ValueError(f"Invalid URL: {url}") from e
+
+
+class Source(BaseModel):
+    """Source domain entity."""
+
+    id: int | None = None  # Is populated by repository
+    created_at: datetime | None = None  # Is populated by repository
+    updated_at: datetime | None = None  # Is populated by repository
+    working_copy: WorkingCopy
+
+
+class Task(BaseModel):
+    """Represents an item in the queue waiting to be processed.
+
+    If the item exists, that means it is in the queue and waiting to be processed. There
+    is no status associated.
+    """
+
+    id: str  # Is a unique key to deduplicate items in the queue
+    type: TaskOperation  # Task operation
+    priority: int  # Priority (higher number = higher priority)
+    payload: dict[str, Any]  # Task-specific data
+
+    created_at: datetime | None = None  # Is populated by repository
+    updated_at: datetime | None = None  # Is populated by repository
+
+    @staticmethod
+    def create(
+        operation: TaskOperation, priority: int, payload: dict[str, Any]
+    ) -> "Task":
+        """Create a task."""
+        return Task(
+            id=Task.create_id(operation, payload),
+            type=operation,
+            priority=priority,
+            payload=payload,
+        )
+
+    @staticmethod
+    def create_id(operation: TaskOperation, payload: dict[str, Any]) -> str:
+        """Create a unique id for a task."""
+        first_id = next(iter(payload.values()), None)
+        return f"{operation}:{first_id}"
+
+
+class TaskStatus(BaseModel):
+    """Task status domain entity."""
+
+    id: str
+    state: ReportingState
+    operation: TaskOperation
+    message: str = ""
+
+    created_at: datetime = datetime.now(UTC)
+    updated_at: datetime = datetime.now(UTC)
+    total: int = 0
+    current: int = 0
+
+    error: str | None = None
+    parent: "TaskStatus | None" = None
+    trackable_id: int | None = None
+    trackable_type: TrackableType | None = None
+
+    @staticmethod
+    def create(
+        operation: TaskOperation,
+        parent: "TaskStatus | None" = None,
+        trackable_type: TrackableType | None = None,
+        trackable_id: int | None = None,
+    ) -> "TaskStatus":
+        """Create a task status."""
+        return TaskStatus(
+            id=TaskStatus._create_id(operation, trackable_type, trackable_id),
+            operation=operation,
+            parent=parent,
+            trackable_type=trackable_type,
+            trackable_id=trackable_id,
+            state=ReportingState.STARTED,
+        )
+
+    @staticmethod
+    def _create_id(
+        step: TaskOperation,
+        trackable_type: TrackableType | None = None,
+        trackable_id: int | None = None,
+    ) -> str:
+        """Create a unique id for a task."""
+        result = []
+        # Nice to be prefixed by tracking information if it exists
+        if trackable_type:
+            result.append(str(trackable_type))
+        if trackable_id:
+            result.append(str(trackable_id))
+        result.append(str(step))
+        return "-".join(result)
+
+    @property
+    def completion_percent(self) -> float:
+        """Calculate the percentage of completion."""
+        if self.total == 0:
+            return 0.0
+        return min(100.0, max(0.0, (self.current / self.total) * 100.0))
+
+    def skip(self, message: str) -> None:
+        """Skip the task."""
+        self.state = ReportingState.SKIPPED
+        self.message = message
+
+    def fail(self, error: str) -> None:
+        """Fail the task."""
+        self.state = ReportingState.FAILED
+        self.error = error
+
+    def set_total(self, total: int) -> None:
+        """Set the total for the step."""
+        self.total = total
+
+    def set_current(self, current: int, message: str | None = None) -> None:
+        """Progress the step."""
+        self.state = ReportingState.IN_PROGRESS
+        self.current = current
+        if message:
+            self.message = message
+
+    def set_tracking_info(
+        self, trackable_id: int, trackable_type: TrackableType
+    ) -> None:
+        """Set the tracking info."""
+        self.trackable_id = trackable_id
+        self.trackable_type = trackable_type
+
+    def complete(self) -> None:
+        """Complete the task."""
+        if ReportingState.is_terminal(self.state):
+            return  # Already in terminal state
+
+        self.state = ReportingState.COMPLETED
+        self.current = self.total  # Ensure progress shows 100%