kodit 0.2.2__py3-none-any.whl → 0.2.3__py3-none-any.whl

kodit/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.2.2'
-__version_tuple__ = version_tuple = (0, 2, 2)
+__version__ = version = '0.2.3'
+__version_tuple__ = version_tuple = (0, 2, 3)

kodit/app.py

@@ -21,6 +21,12 @@ async def root() -> dict[str, str]:
     return {"message": "Hello, World!"}
 
 
+@app.get("/healthz")
+async def healthz() -> dict[str, str]:
+    """Return a health check for the kodit API."""
+    return {"status": "ok"}
+
+
 # Add mcp routes last, otherwise previous routes aren't added
 app.mount("", mcp_app)
 

kodit/cli.py

@@ -81,6 +81,7 @@ async def index(
     )
 
     if not sources:
+        log_event("kodit.cli.index.list")
         # No source specified, list all indexes
         indexes = await service.list_indexes()
         headers: list[str | Cell] = [
@@ -108,7 +109,8 @@ async def index(
             msg = "File indexing is not implemented yet"
             raise click.UsageError(msg)
 
-        # Index directory
+        # Index source
+        log_event("kodit.cli.index.create")
         s = await source_service.create(source)
         index = await service.create(s.id)
         await service.run(index.id)
@@ -134,6 +136,7 @@ async def code(
 
     This works best if your query is code.
     """
+    log_event("kodit.cli.search.code")
     source_repository = SourceRepository(session)
     source_service = SourceService(app_context.get_clone_dir(), source_repository)
     repository = IndexRepository(session)
@@ -177,6 +180,7 @@ async def keyword(
     top_k: int,
 ) -> None:
     """Search for snippets using keyword search."""
+    log_event("kodit.cli.search.keyword")
     source_repository = SourceRepository(session)
     source_service = SourceService(app_context.get_clone_dir(), source_repository)
     repository = IndexRepository(session)
@@ -223,6 +227,7 @@ async def text(
 
     This works best if your query is text.
     """
+    log_event("kodit.cli.search.text")
     source_repository = SourceRepository(session)
     source_service = SourceService(app_context.get_clone_dir(), source_repository)
     repository = IndexRepository(session)
@@ -270,6 +275,7 @@ async def hybrid(  # noqa: PLR0913
     text: str,
 ) -> None:
     """Search for snippets using hybrid search."""
+    log_event("kodit.cli.search.hybrid")
     source_repository = SourceRepository(session)
     source_service = SourceService(app_context.get_clone_dir(), source_repository)
     repository = IndexRepository(session)
@@ -321,7 +327,7 @@ def serve(
     """Start the kodit server, which hosts the MCP server and the kodit API."""
     log = structlog.get_logger(__name__)
     log.info("Starting kodit server", host=host, port=port)
-    log_event("kodit_server_started")
+    log_event("kodit.cli.serve")
 
     # Configure uvicorn with graceful shutdown
     config = uvicorn.Config(

kodit/embedding/embedding_factory.py

@@ -19,6 +19,7 @@ from kodit.embedding.vectorchord_vector_search_service import (
     TaskName,
     VectorChordVectorSearchService,
 )
+from kodit.log import log_event
 
 
 def _get_endpoint_configuration(app_context: AppContext) -> Endpoint | None:
@@ -34,6 +35,7 @@ def embedding_factory(
     endpoint = _get_endpoint_configuration(app_context)
 
     if endpoint and endpoint.type == "openai":
+        log_event("kodit.embedding", {"provider": "openai"})
         from openai import AsyncOpenAI
 
         embedding_provider = OpenAIEmbeddingProvider(
@@ -44,11 +46,14 @@ def embedding_factory(
             model_name=endpoint.model or "text-embedding-3-small",
         )
     else:
+        log_event("kodit.embedding", {"provider": "local"})
         embedding_provider = LocalEmbeddingProvider(CODE)
 
     if app_context.default_search.provider == "vectorchord":
+        log_event("kodit.database", {"provider": "vectorchord"})
         return VectorChordVectorSearchService(task_name, session, embedding_provider)
     if app_context.default_search.provider == "sqlite":
+        log_event("kodit.database", {"provider": "sqlite"})
         return LocalVectorSearchService(
             embedding_repository=embedding_repository,
             embedding_provider=embedding_provider,

kodit/embedding/embedding_provider/embedding_provider.py

@@ -39,14 +39,14 @@ def split_sub_batches(
 
         while data_to_process:
             next_item = data_to_process[0]
-            item_tokens = len(encoding.encode(next_item))
+            item_tokens = len(encoding.encode(next_item, disallowed_special=()))
 
             if item_tokens > max_context_window:
                 # Loop around trying to truncate the snippet until it fits in the max
                 # embedding size
                 while item_tokens > max_context_window:
                     next_item = next_item[:-1]
-                    item_tokens = len(encoding.encode(next_item))
+                    item_tokens = len(encoding.encode(next_item, disallowed_special=()))
 
                 data_to_process[0] = next_item
 

kodit/enrichment/enrichment_factory.py

@@ -11,6 +11,7 @@ from kodit.enrichment.enrichment_service import (
     EnrichmentService,
     LLMEnrichmentService,
 )
+from kodit.log import log_event
 
 
 def _get_endpoint_configuration(app_context: AppContext) -> Endpoint | None:
@@ -24,6 +25,7 @@ def enrichment_factory(app_context: AppContext) -> EnrichmentService:
     endpoint = app_context.enrichment_endpoint or app_context.default_endpoint or None
 
     if endpoint and endpoint.type == "openai":
+        log_event("kodit.enrichment", {"provider": "openai"})
         from openai import AsyncOpenAI
 
         enrichment_provider = OpenAIEnrichmentProvider(
@@ -34,6 +36,7 @@ def enrichment_factory(app_context: AppContext) -> EnrichmentService:
             model_name=endpoint.model or "gpt-4o-mini",
         )
     else:
+        log_event("kodit.enrichment", {"provider": "local"})
         enrichment_provider = LocalEnrichmentProvider()
 
     return LLMEnrichmentService(enrichment_provider=enrichment_provider)

kodit/indexing/indexing_service.py

@@ -26,6 +26,7 @@ from kodit.enrichment.enrichment_service import EnrichmentService
 from kodit.indexing.fusion import FusionRequest, reciprocal_rank_fusion
 from kodit.indexing.indexing_models import Snippet
 from kodit.indexing.indexing_repository import IndexRepository
+from kodit.log import log_event
 from kodit.snippets.snippets import SnippetService
 from kodit.source.source_service import SourceService
 from kodit.util.spinner import Spinner
@@ -45,7 +46,7 @@ class IndexView(pydantic.BaseModel):
     created_at: datetime
     updated_at: datetime | None = None
     source: str | None = None
-    num_snippets: int | None = None
+    num_snippets: int
 
 
 class SearchRequest(pydantic.BaseModel):
@@ -119,6 +120,8 @@ class IndexService:
             ValueError: If the source doesn't exist or already has an index.
 
         """
+        log_event("kodit.index.create")
+
         # Check if the source exists
         source = await self.source_service.get(source_id)
 
@@ -129,6 +132,8 @@ class IndexService:
         return IndexView(
             id=index.id,
             created_at=index.created_at,
+            num_snippets=await self.repository.num_snippets_for_index(index.id),
+            source=source.uri,
         )
 
     async def list_indexes(self) -> list[IndexView]:
@@ -142,19 +147,33 @@ class IndexService:
         indexes = await self.repository.list_indexes()
 
         # Transform database results into DTOs
-        return [
+        indexes = [
             IndexView(
                 id=index.id,
                 created_at=index.created_at,
                 updated_at=index.updated_at,
-                num_snippets=await self.repository.num_snippets_for_index(index.id),
+                num_snippets=await self.repository.num_snippets_for_index(index.id)
+                or 0,
                 source=source.uri,
             )
             for index, source in indexes
         ]
 
+        # Help Kodit by measuring how much people are using indexes
+        log_event(
+            "kodit.index.list",
+            {
+                "num_indexes": len(indexes),
+                "num_snippets": sum([index.num_snippets for index in indexes]),
+            },
+        )
+
+        return indexes
+
     async def run(self, index_id: int) -> None:
         """Run the indexing process for a specific index."""
+        log_event("kodit.index.run")
+
         # Get and validate index
         index = await self.repository.get_by_id(index_id)
         if not index:
@@ -218,6 +237,8 @@ class IndexService:
 
     async def search(self, request: SearchRequest) -> list[SearchResult]:
         """Search for relevant data."""
+        log_event("kodit.index.search")
+
         fusion_list: list[list[FusionRequest]] = []
         if request.keywords:
             # Gather results for each keyword

kodit/log.py

@@ -1,20 +1,33 @@
 """Logging configuration for kodit."""
 
 import logging
+import platform
+import re
+import shutil
+import subprocess
 import sys
 import uuid
 from enum import Enum
 from functools import lru_cache
+from pathlib import Path
 from typing import Any
 
+import rudderstack.analytics as rudder_analytics
 import structlog
-from posthog import Posthog
 from structlog.types import EventDict
 
+from kodit import _version
 from kodit.config import AppContext
 
+_MAC_RE = re.compile(r"(?:[0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}")
+
 log = structlog.get_logger(__name__)
 
+rudder_analytics.write_key = "2wm1RmV2GnO92NGSs8yYtmSI0mi"
+rudder_analytics.dataPlaneUrl = (
+    "https://danbmedefzavzlslreyxjgcjwlf.dataplane.rudderstack.com"
+)
+
 
 def drop_color_message_key(_, __, event_dict: EventDict) -> EventDict:  # noqa: ANN001
     """Drop the `color_message` key from the event dict."""
@@ -131,35 +144,124 @@ def configure_logging(app_context: AppContext) -> None:
     sys.excepthook = handle_exception
 
 
-posthog = Posthog(
-    project_api_key="phc_JsX0yx8NLPcIxamfp4Zc7xyFykXjwmekKUQz060cSt3",
-    host="https://eu.i.posthog.com",
-)
+def configure_telemetry(app_context: AppContext) -> None:
+    """Configure telemetry for the application."""
+    if app_context.disable_telemetry:
+        structlog.stdlib.get_logger(__name__).info("Telemetry has been disabled")
+        rudder_analytics.send = False
 
+    rudder_analytics.identify(
+        anonymous_id=get_stable_mac_str(),
+        traits={},
+    )
 
-@lru_cache(maxsize=1)
-def get_mac_address() -> str:
-    """Get the MAC address of the primary network interface.
 
-    Returns:
-        str: The MAC address or a fallback UUID if not available
+def log_event(event: str, properties: dict[str, Any] | None = None) -> None:
+    """Log an event to Rudderstack."""
+    p = properties or {}
+    # Set default posthog properties
+    p["$app_name"] = "kodit"
+    p["$app_version"] = _version.version
+    p["$os"] = sys.platform
+    p["$os_version"] = sys.version
+    rudder_analytics.track(
+        anonymous_id=get_stable_mac_str(),
+        event=event,
+        properties=properties or {},
+    )
+
 
+# ----------------------------------------------------------------------
+# Helper functions
+# ----------------------------------------------------------------------
+def _mac_int(mac: str) -> int:
+    return int(mac.replace(":", "").replace("-", ""), 16)
+
+
+def _is_globally_administered(mac_int: int) -> bool:
+    first_octet = (mac_int >> 40) & 0xFF
+    return not (first_octet & 0b11)  # both bits must be 0
+
+
+def _from_sysfs() -> list[int]:
+    base = Path("/sys/class/net")
+    if not base.is_dir():
+        return []
+    macs: list[int] = []
+    for iface in base.iterdir():
+        try:
+            with (base / iface / "address").open() as f:
+                content = f.read().strip()
+            if _MAC_RE.fullmatch(content):
+                macs.append(_mac_int(content))
+        except (FileNotFoundError, PermissionError):
+            pass
+    return macs
+
+
+def _from_command(cmd: str) -> list[int]:
+    try:
+        out = subprocess.check_output(  # noqa: S602
+            cmd,
+            shell=True,
+            text=True,
+            stderr=subprocess.DEVNULL,
+            encoding="utf-8",
+        )
+    except Exception:  # noqa: BLE001
+        return []
+    return [_mac_int(m.group()) for m in _MAC_RE.finditer(out)]
+
+
+@lru_cache(maxsize=1)
+def get_stable_mac_int() -> int | None:
+    """Return a *hardware* MAC as an int, or None if none can be found.
+
+    Search order:
+        1. /sys/class/net (Linux)
+        2. `ip link show` (Linux), `ifconfig -a` (Linux+macOS)
+        3. `getmac` and `wmic nic` (Windows)
+    The first globally-administered, non-multicast address wins.
     """
-    # Get the MAC address of the primary network interface
-    mac = uuid.getnode()
-    return f"{mac:012x}" if mac != uuid.getnode() else str(uuid.uuid4())
+    system = platform.system()
+    candidates: list[int] = []
+
+    if system == "Linux":
+        candidates += _from_sysfs()
+        if not candidates and shutil.which("ip"):
+            candidates += _from_command("ip link show")
+        if not candidates:  # fall back to ifconfig
+            candidates += _from_command("ifconfig -a")
+
+    elif system == "Darwin":  # macOS
+        candidates += _from_command("ifconfig -a")
+
+    elif system == "Windows":
+        # getmac is present on every supported Windows version
+        candidates += _from_command("getmac /v /fo list")
+        # wmic still exists through at least Win 11
+        candidates += _from_command(
+            'wmic nic where "MACAddress is not null" get MACAddress /format:list'
+        )
 
+    # Prefer globally administered, non-multicast addresses
+    for mac in candidates:
+        if _is_globally_administered(mac):
+            return mac
 
-def configure_telemetry(app_context: AppContext) -> None:
-    """Configure telemetry for the application."""
-    if app_context.disable_telemetry:
-        structlog.stdlib.get_logger(__name__).info("Telemetry has been disabled")
-        posthog.disabled = True
+    # If all we saw were locally-administered MACs, just return the first one
+    if candidates:
+        return candidates[0]
 
+    return None
 
-def log_event(event: str, properties: dict[str, Any] | None = None) -> None:
-    """Log an event to PostHog."""
-    log.debug(
-        "Logging event", id=get_mac_address(), ph_event=event, ph_properties=properties
-    )
-    posthog.capture(get_mac_address(), event, properties or {})
+
+def get_stable_mac_str() -> str:
+    """Return a *stable* 12-digit hex string (lower-case, no separators).
+
+    Falls back to uuid.getnode() if necessary, so it never raises.
+    """
+    mac_int = get_stable_mac_int()
+    if mac_int is None:
+        mac_int = uuid.getnode()  # may still be random in VMs
+    return f"{mac_int:012x}"

kodit/migrations/versions/9e53ea8bb3b0_add_authors.py

@@ -0,0 +1,103 @@
+# ruff: noqa
+"""add authors
+
+Revision ID: 9e53ea8bb3b0
+Revises: c3f5137d30f5
+Create Date: 2025-06-14 10:50:36.058114
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = "9e53ea8bb3b0"
+down_revision: Union[str, None] = "c3f5137d30f5"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # Define the enum type separately so we can explicitly create it when needed
+    source_type = sa.Enum("UNKNOWN", "FOLDER", "GIT", name="sourcetype")
+
+    # Explicitly create the enum type for PostgreSQL (no-op on SQLite)
+    source_type.create(op.get_bind(), checkfirst=True)
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table(
+        "authors",
+        sa.Column("name", sa.String(length=255), nullable=False),
+        sa.Column("email", sa.String(length=255), nullable=False),
+        sa.Column("id", sa.Integer(), autoincrement=True, nullable=False),
+        sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("name", "email", name="uix_author"),
+    )
+    op.create_index(op.f("ix_authors_email"), "authors", ["email"], unique=False)
+    op.create_index(op.f("ix_authors_name"), "authors", ["name"], unique=False)
+    op.create_table(
+        "author_file_mappings",
+        sa.Column("author_id", sa.Integer(), nullable=False),
+        sa.Column("file_id", sa.Integer(), nullable=False),
+        sa.Column("id", sa.Integer(), autoincrement=True, nullable=False),
+        sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
+        sa.ForeignKeyConstraint(
+            ["author_id"],
+            ["authors.id"],
+        ),
+        sa.ForeignKeyConstraint(
+            ["file_id"],
+            ["files.id"],
+        ),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("author_id", "file_id", name="uix_author_file_mapping"),
+    )
+    op.create_index(
+        op.f("ix_author_file_mappings_author_id"),
+        "author_file_mappings",
+        ["author_id"],
+        unique=False,
+    )
+    op.create_index(
+        op.f("ix_author_file_mappings_file_id"),
+        "author_file_mappings",
+        ["file_id"],
+        unique=False,
+    )
+    op.add_column(
+        "files", sa.Column("extension", sa.String(length=255), nullable=False)
+    )
+    op.create_index(op.f("ix_files_extension"), "files", ["extension"], unique=False)
+    op.add_column("sources", sa.Column("type", source_type, nullable=False))
+    op.create_index(op.f("ix_sources_type"), "sources", ["type"], unique=False)
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index(op.f("ix_sources_type"), table_name="sources")
+    op.drop_column("sources", "type")
+    op.drop_index(op.f("ix_files_extension"), table_name="files")
+    op.drop_column("files", "extension")
+    op.drop_index(
+        op.f("ix_author_file_mappings_file_id"), table_name="author_file_mappings"
+    )
+    op.drop_index(
+        op.f("ix_author_file_mappings_author_id"), table_name="author_file_mappings"
+    )
+    op.drop_table("author_file_mappings")
+    op.drop_index(op.f("ix_authors_name"), table_name="authors")
+    op.drop_index(op.f("ix_authors_email"), table_name="authors")
+    op.drop_table("authors")
+
+    # Explicitly drop the enum type (PostgreSQL)
+    source_type = sa.Enum("UNKNOWN", "FOLDER", "GIT", name="sourcetype")
+    source_type.drop(op.get_bind(), checkfirst=True)
+    # ### end Alembic commands ###