docsif 0.1.0__py3-none-any.whl

sif/config/__init__.py

@@ -0,0 +1,30 @@
+"""Configuration management for SIF.
+
+This package provides configuration handling:
+- Settings management via Pydantic Settings
+- Environment variable support
+- Configuration file handling
+- Default values and validation
+"""
+
+from sif.config.constants import (
+    APP_NAME,
+    APP_VERSION,
+    DEFAULT_CHUNK_OVERLAP,
+    DEFAULT_CHUNK_SIZE,
+    DEFAULT_DB_PATH,
+    DEFAULT_MODEL_PATH,
+)
+from sif.config.settings import Settings, get_settings
+
+
+__all__ = [
+    "APP_NAME",
+    "APP_VERSION",
+    "DEFAULT_CHUNK_OVERLAP",
+    "DEFAULT_CHUNK_SIZE",
+    "DEFAULT_DB_PATH",
+    "DEFAULT_MODEL_PATH",
+    "Settings",
+    "get_settings",
+]

sif/config/constants.py

@@ -0,0 +1,52 @@
+"""Constants for SIF."""
+
+# Application info
+APP_NAME = "sif"
+APP_VERSION = "0.1.0"
+APP_DESCRIPTION = (
+    "A local CLI search engine for indexing and searching documents (SIF: Search / Index / Find)"
+)
+
+# Default paths
+DEFAULT_DB_PATH = "~/.local/share/sif/sif.db"
+DEFAULT_MODEL_PATH = "~/.local/share/sif/models"
+DEFAULT_CONFIG_PATH = "~/.config/sif"
+
+# Chunking defaults
+DEFAULT_CHUNK_SIZE = 512
+DEFAULT_CHUNK_OVERLAP = 128
+MIN_CHUNK_SIZE = 100
+MAX_CHUNK_SIZE = 2048
+
+# Search defaults
+DEFAULT_SEARCH_LIMIT = 10
+MAX_SEARCH_LIMIT = 100
+DEFAULT_BM25_K1 = 1.5
+DEFAULT_BM25_B = 0.75
+DEFAULT_VECTOR_WEIGHT = 0.7
+DEFAULT_RRF_K = 60
+
+# Embedding defaults
+DEFAULT_EMBEDDING_DIM = 1024
+DEFAULT_MAX_TOKENS = 512
+DEFAULT_BATCH_SIZE = 32
+
+# MCP server defaults
+DEFAULT_MCP_HOST = "127.0.0.1"
+DEFAULT_MCP_PORT = 8080
+MCP_VERSION = "1.0"
+
+# File patterns
+MARKDOWN_EXTENSIONS = {".md", ".markdown", ".mdown", ".mkd", ".mkdn"}
+DEFAULT_IGNORE_PATTERNS = [
+    ".git",
+    "__pycache__",
+    "node_modules",
+    ".obsidian",
+    ".trash",
+    "*.tmp",
+    "*.temp",
+]
+
+# Database schema versions
+CURRENT_SCHEMA_VERSION = 1

sif/config/settings.py

@@ -0,0 +1,217 @@
+"""Configuration settings for SIF."""
+
+from functools import lru_cache
+from pathlib import Path
+
+from pydantic import Field, field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from sif.config.constants import APP_NAME, DEFAULT_CHUNK_OVERLAP, DEFAULT_CHUNK_SIZE
+
+
+class Settings(BaseSettings):
+    """Application settings using Pydantic Settings.
+
+    Settings are loaded from environment variables and .env files.
+    Environment variables should be prefixed with SIF_.
+    """
+
+    model_config = SettingsConfigDict(
+        env_prefix="SIF_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    # Application settings
+    app_name: str = Field(default=APP_NAME, description="Application name")
+    debug: bool = Field(default=False, description="Debug mode")
+    log_level: str = Field(default="INFO", description="Logging level")
+
+    # Database settings
+    db_path: Path | None = Field(
+        default=None,
+        description="Path to SQLite database file",
+    )
+
+    # Model settings
+    model_path: Path | None = Field(
+        default=None,
+        description="Path to embedding model file",
+    )
+    model_name: str = Field(
+        default="Qwen/Qwen3-Embedding-0.6B",
+        description="Embedding model name",
+    )
+    embedding_dim: int = Field(
+        default=1024,
+        ge=1,
+        description="Embedding dimension",
+    )
+    max_tokens: int = Field(
+        default=512,
+        ge=1,
+        description="Maximum tokens per input",
+    )
+    batch_size: int = Field(
+        default=32,
+        ge=1,
+        description="Batch size for inference",
+    )
+    model_type: str = Field(
+        default="modelscope",
+        description="Embedding model type (gguf, sentence_transformers, openai, huggingface, modelscope)",
+    )
+    n_gpu_layers: int = Field(
+        default=0,
+        ge=0,
+        description="Number of GPU layers for GGUF models",
+    )
+    api_key: str | None = Field(
+        default=None,
+        description="API key for remote embedding models",
+        repr=False,
+    )
+    api_base: str | None = Field(
+        default=None,
+        description="Base URL for remote embedding API",
+    )
+
+    # Reranker settings
+    reranker_model_name: str = Field(
+        default="Qwen/Qwen3-Reranker-0.6B",
+        description="Reranker model name",
+    )
+    reranker_model_path: Path | None = Field(
+        default=None,
+        description="Path to local reranker model file",
+    )
+    reranker_model_type: str = Field(
+        default="sentence_transformers",
+        description="Reranker model type (gguf, sentence_transformers)",
+    )
+    reranker_batch_size: int = Field(
+        default=32,
+        ge=1,
+        description="Batch size for reranker inference",
+    )
+
+    # Chunking settings
+    chunk_size: int = Field(
+        default=DEFAULT_CHUNK_SIZE,
+        ge=100,
+        description="Default chunk size in tokens",
+    )
+    chunk_overlap: int = Field(
+        default=DEFAULT_CHUNK_OVERLAP,
+        ge=0,
+        description="Default chunk overlap in tokens",
+    )
+
+    # Search settings
+    default_search_type: str = Field(
+        default="hybrid",
+        description="Default search type (bm25, vector, hybrid)",
+    )
+    default_limit: int = Field(
+        default=10,
+        ge=1,
+        le=100,
+        description="Default search result limit",
+    )
+
+    # MCP server settings
+    mcp_host: str = Field(
+        default="127.0.0.1",
+        description="MCP HTTP server host",
+    )
+    mcp_port: int = Field(
+        default=8080,
+        ge=1,
+        le=65535,
+        description="MCP HTTP server port",
+    )
+    mcp_transport: str = Field(
+        default="stdio",
+        description="MCP transport type (stdio, http)",
+    )
+
+    # Cache settings
+    cache_dir: Path | None = Field(
+        default=None,
+        description="Cache directory path",
+    )
+    cache_embeddings: bool = Field(
+        default=True,
+        description="Whether to cache embeddings",
+    )
+
+    @field_validator("model_type")
+    @classmethod
+    def validate_model_type(cls, v: str) -> str:
+        """Validate model_type is one of the supported backends."""
+        valid_types = {"sentence_transformers", "gguf", "openai", "modelscope", "huggingface"}
+        if v not in valid_types:
+            raise ValueError(f"Invalid model_type: {v}. Must be one of {sorted(valid_types)}")
+        return v
+
+    @field_validator("api_base")
+    @classmethod
+    def validate_api_base(cls, v: str | None) -> str | None:
+        """Validate api_base is an HTTP or HTTPS URL."""
+        if v is None:
+            return None
+        v_lower = v.lower()
+        if not v_lower.startswith("http://") and not v_lower.startswith("https://"):
+            raise ValueError("api_base must be an HTTP or HTTPS URL")
+        return v
+
+    @field_validator("db_path", "cache_dir", mode="before")
+    @classmethod
+    def expand_path(cls, v: str | Path | None) -> Path | None:
+        """Expand user home directory in paths."""
+        if v is None:
+            return None
+        path = Path(v).expanduser()
+        return path
+
+    @field_validator("log_level")
+    @classmethod
+    def validate_log_level(cls, v: str) -> str:
+        """Validate log level."""
+        valid_levels = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+        v_upper = v.upper()
+        if v_upper not in valid_levels:
+            raise ValueError(f"Invalid log level: {v}. Must be one of {valid_levels}")
+        return v_upper
+
+    def get_db_path(self) -> Path:
+        """Get the database path, creating default if not set."""
+        if self.db_path:
+            return self.db_path
+
+        from platformdirs import user_data_dir  # noqa: PLC0415
+
+        data_dir = Path(user_data_dir(self.app_name))
+        data_dir.mkdir(parents=True, exist_ok=True)
+        return data_dir / "sif.db"
+
+    def get_cache_dir(self) -> Path:
+        """Get the cache directory, creating default if not set."""
+        if self.cache_dir:
+            return self.cache_dir
+
+        from platformdirs import user_cache_dir  # noqa: PLC0415
+
+        cache_dir = Path(user_cache_dir(self.app_name))
+        cache_dir.mkdir(parents=True, exist_ok=True)
+        return cache_dir
+
+
+@lru_cache
+def get_settings() -> Settings:
+    """Get cached settings instance.
+
+    Uses lru_cache to ensure settings are loaded only once.
+    """
+    return Settings()

sif/core/__init__.py

@@ -0,0 +1,21 @@
+"""Core domain entities and business logic for SIF.
+
+This package contains the core domain models and business logic
+that define the fundamental concepts of the SIF system.
+"""
+
+from sif.core.collection import Collection, CollectionManager
+from sif.core.context import Context, ContextManager, ContextType
+from sif.core.document import Document, DocumentChunk, DocumentMetadata
+
+
+__all__ = [
+    "Collection",
+    "CollectionManager",
+    "Context",
+    "ContextManager",
+    "ContextType",
+    "Document",
+    "DocumentChunk",
+    "DocumentMetadata",
+]

sif/core/collection.py

@@ -0,0 +1,161 @@
+"""Collection domain entity and manager."""
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any, Protocol
+
+
+@dataclass
+class Collection:
+    """Domain entity representing a document collection.
+
+    A collection is a logical grouping of documents, typically
+    corresponding to a directory or set of directories.
+    """
+
+    id: str
+    name: str
+    description: str | None = None
+    paths: list[str] = field(default_factory=list)
+    document_count: int = 0
+    chunk_count: int = 0
+    metadata: dict[str, Any] = field(default_factory=dict)
+    created_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+    updated_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+    last_indexed_at: datetime | None = None
+
+    def add_path(self, path: str) -> None:
+        """Add a path to the collection if not already present."""
+        if path not in self.paths:
+            self.paths.append(path)
+            self.updated_at = datetime.now(timezone.utc)
+
+    def remove_path(self, path: str) -> None:
+        """Remove a path from the collection."""
+        if path in self.paths:
+            self.paths.remove(path)
+            self.updated_at = datetime.now(timezone.utc)
+
+    def update_metadata(self, **kwargs: Any) -> None:
+        """Update collection metadata."""
+        self.metadata.update(kwargs)
+        self.updated_at = datetime.now(timezone.utc)
+
+    def mark_indexed(self) -> None:
+        """Mark the collection as indexed."""
+        self.last_indexed_at = datetime.now(timezone.utc)
+        self.updated_at = datetime.now(timezone.utc)
+
+
+class CollectionRepository(Protocol):
+    """Protocol for collection repository operations."""
+
+    def get_by_id(self, collection_id: str) -> Collection | None:
+        """Get a collection by ID."""
+        ...
+
+    def get_by_name(self, name: str) -> Collection | None:
+        """Get a collection by name."""
+        ...
+
+    def list_all(self) -> list[Collection]:
+        """List all collections."""
+        ...
+
+    def create(self, collection: Collection) -> Collection:
+        """Create a new collection."""
+        ...
+
+    def update(self, collection: Collection) -> Collection:
+        """Update an existing collection."""
+        ...
+
+    def delete(self, collection_id: str) -> bool:
+        """Delete a collection by ID."""
+        ...
+
+    def exists(self, name: str) -> bool:
+        """Check if a collection with the given name exists."""
+        ...
+
+
+class CollectionManager:
+    """Manager for collection operations.
+
+    This class provides high-level operations for managing collections,
+    coordinating between repositories and other services.
+    """
+
+    def __init__(self, repository: CollectionRepository) -> None:
+        self._repository = repository
+
+    def create_collection(
+        self,
+        name: str,
+        description: str | None = None,
+        paths: list[str] | None = None,
+        metadata: dict[str, Any] | None = None,
+    ) -> Collection:
+        """Create a new collection."""
+        import uuid  # noqa: PLC0415
+
+        if self._repository.exists(name):
+            raise ValueError(f"Collection '{name}' already exists")
+
+        collection = Collection(
+            id=str(uuid.uuid4()),
+            name=name,
+            description=description,
+            paths=paths or [],
+            metadata=metadata or {},
+        )
+        return self._repository.create(collection)
+
+    def get_collection(self, collection_id: str) -> Collection | None:
+        """Get a collection by ID."""
+        return self._repository.get_by_id(collection_id)
+
+    def list_collections(self) -> list[Collection]:
+        """List all collections."""
+        return self._repository.list_all()
+
+    def update_collection(
+        self,
+        collection_id: str,
+        name: str | None = None,
+        description: str | None = None,
+    ) -> Collection:
+        """Update a collection."""
+        collection = self._repository.get_by_id(collection_id)
+        if not collection:
+            raise ValueError(f"Collection '{collection_id}' not found")
+
+        if name is not None:
+            collection.name = name
+        if description is not None:
+            collection.description = description
+
+        collection.updated_at = datetime.now(timezone.utc)
+        return self._repository.update(collection)
+
+    def delete_collection(self, collection_id: str) -> bool:
+        """Delete a collection."""
+        return self._repository.delete(collection_id)
+
+    def add_path(self, collection_id: str, path: str) -> Collection:
+        """Add a path to a collection."""
+        collection = self._repository.get_by_id(collection_id)
+        if not collection:
+            raise ValueError(f"Collection '{collection_id}' not found")
+
+        collection.add_path(path)
+        return self._repository.update(collection)
+
+    def remove_path(self, collection_id: str, path: str) -> Collection:
+        """Remove a path from a collection."""
+        collection = self._repository.get_by_id(collection_id)
+        if not collection:
+            raise ValueError(f"Collection '{collection_id}' not found")
+
+        collection.remove_path(path)
+        return self._repository.update(collection)

sif/core/context.py

@@ -0,0 +1,167 @@
+"""Context domain entity and manager."""
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from enum import Enum, auto
+from typing import Protocol
+
+
+class ContextType(Enum):
+    """Type of context."""
+
+    COLLECTION = auto()
+    PATH = auto()
+    DOCUMENT = auto()
+    GLOBAL = auto()
+
+
+@dataclass
+class Context:
+    """Domain entity representing contextual information.
+
+    Context provides descriptive metadata that can be attached to
+    collections, paths, or documents to improve search relevance.
+    """
+
+    id: str
+    content: str
+    context_type: ContextType
+    target_id: str
+    created_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+    updated_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+
+    def update_content(self, content: str) -> None:
+        """Update the context content."""
+        self.content = content
+        self.updated_at = datetime.now(timezone.utc)
+
+
+class ContextRepository(Protocol):
+    """Protocol for context repository operations."""
+
+    def get_by_id(self, context_id: str) -> Context | None:
+        """Get a context by ID."""
+        ...
+
+    def get_by_target(self, target_id: str, context_type: ContextType) -> Context | None:
+        """Get context by target ID and type."""
+        ...
+
+    def list_by_type(self, context_type: ContextType) -> list[Context]:
+        """List all contexts of a specific type."""
+        ...
+
+    def list_all(self) -> list[Context]:
+        """List all contexts."""
+        ...
+
+    def create(self, context: Context) -> Context:
+        """Create a new context."""
+        ...
+
+    def update(self, context: Context) -> Context:
+        """Update an existing context."""
+        ...
+
+    def delete(self, context_id: str) -> bool:
+        """Delete a context by ID."""
+        ...
+
+    def delete_by_target(self, target_id: str) -> bool:
+        """Delete all contexts for a target."""
+        ...
+
+
+class ContextManager:
+    """Manager for context operations.
+
+    Provides high-level operations for managing contextual information
+    attached to collections, paths, and documents.
+    """
+
+    def __init__(self, repository: ContextRepository) -> None:
+        self._repository = repository
+
+    def add_context(
+        self,
+        target_id: str,
+        content: str,
+        context_type: ContextType,
+    ) -> Context:
+        """Add context to a target."""
+        import uuid  # noqa: PLC0415
+
+        # Check if context already exists for this target
+        existing = self._repository.get_by_target(target_id, context_type)
+        if existing:
+            existing.update_content(content)
+            return self._repository.update(existing)
+
+        context = Context(
+            id=str(uuid.uuid4()),
+            content=content,
+            context_type=context_type,
+            target_id=target_id,
+        )
+        return self._repository.create(context)
+
+    def get_context(self, context_id: str) -> Context | None:
+        """Get context by ID."""
+        return self._repository.get_by_id(context_id)
+
+    def get_context_for_target(self, target_id: str, context_type: ContextType) -> Context | None:
+        """Get context for a specific target."""
+        return self._repository.get_by_target(target_id, context_type)
+
+    def update_context(self, context_id: str, content: str) -> Context:
+        """Update context content."""
+        context = self._repository.get_by_id(context_id)
+        if not context:
+            raise ValueError(f"Context '{context_id}' not found")
+
+        context.update_content(content)
+        return self._repository.update(context)
+
+    def remove_context(self, context_id: str) -> bool:
+        """Remove a context."""
+        return self._repository.delete(context_id)
+
+    def list_contexts(self, context_type: ContextType | None = None) -> list[Context]:
+        """List contexts, optionally filtered by type."""
+        if context_type:
+            return self._repository.list_by_type(context_type)
+        return self._repository.list_all()
+
+    def build_search_context(
+        self,
+        collection_ids: list[str] | None = None,
+        path_prefixes: list[str] | None = None,
+    ) -> str:
+        """Build a combined context string for search.
+
+        This aggregates all relevant contexts for the given collections
+        and paths to provide additional context for search queries.
+        """
+        contexts: list[str] = []
+
+        # Get global context
+        global_contexts = self._repository.list_by_type(ContextType.GLOBAL)
+        contexts.extend([c.content for c in global_contexts])
+
+        # Get collection contexts
+        if collection_ids:
+            for collection_id in collection_ids:
+                ctx = self._repository.get_by_target(collection_id, ContextType.COLLECTION)
+                if ctx:
+                    contexts.append(ctx.content)
+
+        # Get path contexts
+        if path_prefixes:
+            all_path_contexts = self._repository.list_by_type(ContextType.PATH)
+            for ctx in all_path_contexts:
+                for prefix in path_prefixes:
+                    if ctx.target_id.startswith(prefix):
+                        contexts.append(ctx.content)
+                        break
+
+        return "\n\n".join(contexts) if contexts else ""