kodit 0.4.0__py3-none-any.whl → 0.4.2__py3-none-any.whl

kodit/infrastructure/sqlalchemy/task_repository.py

@@ -1,5 +1,7 @@
 """Task repository for the task queue."""
 
+from collections.abc import Callable
+
 import structlog
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -9,14 +11,23 @@ from kodit.domain.protocols import TaskRepository
 from kodit.domain.value_objects import TaskType
 from kodit.infrastructure.mappers.task_mapper import TaskMapper, TaskTypeMapper
 from kodit.infrastructure.sqlalchemy import entities as db_entities
+from kodit.infrastructure.sqlalchemy.unit_of_work import SqlAlchemyUnitOfWork
+
+
+def create_task_repository(
+    session_factory: Callable[[], AsyncSession],
+) -> TaskRepository:
+    """Create an index repository."""
+    uow = SqlAlchemyUnitOfWork(session_factory=session_factory)
+    return SqlAlchemyTaskRepository(uow)
 
 
 class SqlAlchemyTaskRepository(TaskRepository):
     """Repository for task persistence using the existing Task entity."""
 
-    def __init__(self, session: AsyncSession) -> None:
+    def __init__(self, uow: SqlAlchemyUnitOfWork) -> None:
         """Initialize the repository."""
-        self.session = session
+        self.uow = uow
         self.log = structlog.get_logger(__name__)
 
     async def add(
@@ -24,58 +35,63 @@ class SqlAlchemyTaskRepository(TaskRepository):
         task: Task,
     ) -> None:
         """Create a new task in the database."""
-        self.session.add(TaskMapper.from_domain_task(task))
+        async with self.uow:
+            self.uow.session.add(TaskMapper.from_domain_task(task))
 
     async def get(self, task_id: str) -> Task | None:
         """Get a task by ID."""
-        stmt = select(db_entities.Task).where(db_entities.Task.dedup_key == task_id)
-        result = await self.session.execute(stmt)
-        db_task = result.scalar_one_or_none()
-        if not db_task:
-            return None
-        return TaskMapper.to_domain_task(db_task)
+        async with self.uow:
+            stmt = select(db_entities.Task).where(db_entities.Task.dedup_key == task_id)
+            result = await self.uow.session.execute(stmt)
+            db_task = result.scalar_one_or_none()
+            if not db_task:
+                return None
+            return TaskMapper.to_domain_task(db_task)
 
     async def take(self) -> Task | None:
         """Take a task for processing and remove it from the database."""
-        stmt = (
-            select(db_entities.Task)
-            .order_by(db_entities.Task.priority.desc(), db_entities.Task.created_at)
-            .limit(1)
-        )
-        result = await self.session.execute(stmt)
-        db_task = result.scalar_one_or_none()
-        if not db_task:
-            return None
-        await self.session.delete(db_task)
-        return TaskMapper.to_domain_task(db_task)
+        async with self.uow:
+            stmt = (
+                select(db_entities.Task)
+                .order_by(db_entities.Task.priority.desc(), db_entities.Task.created_at)
+                .limit(1)
+            )
+            result = await self.uow.session.execute(stmt)
+            db_task = result.scalar_one_or_none()
+            if not db_task:
+                return None
+            await self.uow.session.delete(db_task)
+            return TaskMapper.to_domain_task(db_task)
 
     async def update(self, task: Task) -> None:
         """Update a task in the database."""
-        stmt = select(db_entities.Task).where(db_entities.Task.dedup_key == task.id)
-        result = await self.session.execute(stmt)
-        db_task = result.scalar_one_or_none()
+        async with self.uow:
+            stmt = select(db_entities.Task).where(db_entities.Task.dedup_key == task.id)
+            result = await self.uow.session.execute(stmt)
+            db_task = result.scalar_one_or_none()
 
-        if not db_task:
-            raise ValueError(f"Task not found: {task.id}")
+            if not db_task:
+                raise ValueError(f"Task not found: {task.id}")
 
-        db_task.priority = task.priority
-        db_task.payload = task.payload
+            db_task.priority = task.priority
+            db_task.payload = task.payload
 
     async def list(self, task_type: TaskType | None = None) -> list[Task]:
         """List tasks with optional status filter."""
-        stmt = select(db_entities.Task)
+        async with self.uow:
+            stmt = select(db_entities.Task)
 
-        if task_type:
-            stmt = stmt.where(
-                db_entities.Task.type == TaskTypeMapper.from_domain_type(task_type)
-            )
+            if task_type:
+                stmt = stmt.where(
+                    db_entities.Task.type == TaskTypeMapper.from_domain_type(task_type)
+                )
 
-        stmt = stmt.order_by(
-            db_entities.Task.priority.desc(), db_entities.Task.created_at
-        )
+            stmt = stmt.order_by(
+                db_entities.Task.priority.desc(), db_entities.Task.created_at
+            )
 
-        result = await self.session.execute(stmt)
-        records = result.scalars().all()
+            result = await self.uow.session.execute(stmt)
+            records = result.scalars().all()
 
-        # Convert to domain entities
-        return [TaskMapper.to_domain_task(record) for record in records]
+            # Convert to domain entities
+            return [TaskMapper.to_domain_task(record) for record in records]

kodit/infrastructure/sqlalchemy/unit_of_work.py

@@ -0,0 +1,59 @@
+"""SQLAlchemy implementation of Unit of Work pattern."""
+
+from collections.abc import Callable
+from types import TracebackType
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+
+class SqlAlchemyUnitOfWork:
+    """SQLAlchemy implementation of Unit of Work pattern."""
+
+    def __init__(self, session_factory: Callable[[], AsyncSession]) -> None:
+        """Initialize the unit of work with a session factory."""
+        self._session_factory = session_factory
+        self._session: AsyncSession | None = None
+
+    @property
+    def session(self) -> AsyncSession:
+        """Get the current session."""
+        if self._session is None:
+            raise RuntimeError("UnitOfWork must be used within async context")
+        return self._session
+
+    async def __aenter__(self) -> "SqlAlchemyUnitOfWork":
+        """Enter the unit of work context."""
+        self._session = self._session_factory()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        """Exit the unit of work context."""
+        if self._session:
+            if exc_type is not None:
+                await self._session.rollback()
+            await self._session.commit()
+            await self._session.close()
+            self._session = None
+
+    async def commit(self) -> None:
+        """Commit the current transaction."""
+        if self._session is None:
+            raise RuntimeError("UnitOfWork must be used within async context")
+        await self._session.commit()
+
+    async def rollback(self) -> None:
+        """Rollback the current transaction."""
+        if self._session is None:
+            raise RuntimeError("UnitOfWork must be used within async context")
+        await self._session.rollback()
+
+    async def flush(self) -> None:
+        """Flush pending changes to the database without committing."""
+        if self._session is None:
+            raise RuntimeError("UnitOfWork must be used within async context")
+        await self._session.flush()

kodit/log.py

@@ -11,6 +11,7 @@ from functools import lru_cache
 from pathlib import Path
 from typing import Any
 
+import litellm
 import rudderstack.analytics as rudder_analytics  # type: ignore[import-untyped]
 import structlog
 from structlog.types import EventDict
@@ -99,6 +100,7 @@ def configure_logging(app_context: AppContext) -> None:
         "bm25s",
         "sentence_transformers.SentenceTransformer",
         "httpx",
+        "LiteLLM",
     ]:
         if root_logger.getEffectiveLevel() == logging.DEBUG:
             logging.getLogger(_log).handlers.clear()
@@ -106,6 +108,9 @@ def configure_logging(app_context: AppContext) -> None:
         else:
             logging.getLogger(_log).disabled = True
 
+    # More litellm logging cruft
+    litellm.suppress_debug_info = True
+
     # Configure SQLAlchemy loggers to use our structlog setup
     for _log in ["sqlalchemy.engine", "alembic"]:
         engine_logger = logging.getLogger(_log)
@@ -138,6 +143,7 @@ def configure_logging(app_context: AppContext) -> None:
 
 def configure_telemetry(app_context: AppContext) -> None:
     """Configure telemetry for the application."""
+    litellm.telemetry = False  # Disable litellm telemetry by default
     if app_context.disable_telemetry:
         structlog.stdlib.get_logger(__name__).info("Telemetry has been disabled")
         rudder_analytics.send = False

kodit/mcp.py

@@ -1,6 +1,6 @@
 """MCP server for kodit."""
 
-from collections.abc import AsyncIterator
+from collections.abc import AsyncIterator, Callable
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
 from pathlib import Path
@@ -15,6 +15,7 @@ from kodit._version import version
 from kodit.application.factories.code_indexing_factory import (
     create_code_indexing_application_service,
 )
+from kodit.application.factories.reporting_factory import create_server_operation
 from kodit.config import AppContext
 from kodit.database import Database
 from kodit.domain.value_objects import (
@@ -32,6 +33,7 @@ class MCPContext:
     """Context for the MCP server."""
 
     session: AsyncSession
+    session_factory: Callable[[], AsyncSession]
     app_context: AppContext
 
 
@@ -55,7 +57,11 @@ async def mcp_lifespan(_: FastMCP) -> AsyncIterator[MCPContext]:
     if _mcp_db is None:
         _mcp_db = await app_context.get_db()
     async with _mcp_db.session_factory() as session:
-        yield MCPContext(session=session, app_context=app_context)
+        yield MCPContext(
+            session=session,
+            app_context=app_context,
+            session_factory=_mcp_db.session_factory,
+        )
 
 
 def create_mcp_server(name: str, instructions: str | None = None) -> FastMCP:
@@ -174,6 +180,8 @@ def register_mcp_tools(mcp_server: FastMCP) -> None:
         service = create_code_indexing_application_service(
             app_context=mcp_context.app_context,
             session=mcp_context.session,
+            session_factory=mcp_context.session_factory,
+            operation=create_server_operation(),
         )
 
         log.debug("Searching for snippets")

{kodit-0.4.0.dist-info → kodit-0.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kodit
-Version: 0.4.0
+Version: 0.4.2
 Summary: Code indexing for better AI code generation
 Project-URL: Homepage, https://docs.helixml.tech/kodit/
 Project-URL: Documentation, https://docs.helixml.tech/kodit/
@@ -35,7 +35,8 @@ Requires-Dist: gitpython>=3.1.44
 Requires-Dist: hf-xet>=1.1.2
 Requires-Dist: httpx-retries>=0.3.2
 Requires-Dist: httpx>=0.28.1
-Requires-Dist: openai>=1.82.0
+Requires-Dist: litellm>=1.75.8
+Requires-Dist: openai==1.99.9
 Requires-Dist: pathspec>=0.12.1
 Requires-Dist: pydantic-settings>=2.9.1
 Requires-Dist: pystemmer>=3.0.0

{kodit-0.4.0.dist-info → kodit-0.4.2.dist-info}/RECORD

@@ -1,36 +1,36 @@
 kodit/.gitignore,sha256=ztkjgRwL9Uud1OEi36hGQeDGk3OLK1NfDEO8YqGYy8o,11
 kodit/__init__.py,sha256=aEKHYninUq1yh6jaNfvJBYg-6fenpN132nJt1UU6Jxs,59
-kodit/_version.py,sha256=l5eo51MdCumDFCp44TFT1JH8yCDo1krag-GJubLxnVo,511
-kodit/app.py,sha256=r0w0JJsOacrQ5aAQ1yf-BK1CrYZPrvtUoH1LACd9FaA,4262
-kodit/cli.py,sha256=VUZD4cPRgAnrKEWUl2PbS-nOA0FkDVqmJ2SR0g1yJsk,28202
+kodit/_version.py,sha256=A45grTqzrHuDn1CT9K5GVUbY4_Q3OSTcXAl3zdHzcEI,704
+kodit/app.py,sha256=xLy0cM3fduXSQSws3wq9fWg5eJB1xD6vrMpkVFYpnhA,4468
+kodit/cli.py,sha256=ugy0L9m5lVgudLebD5FpmZfJEAVAtvxbCvUTfJvU46Y,27948
 kodit/cli_utils.py,sha256=bW4rIm-elrsyM_pSGHh30zV0_oX7V-64pL3YSaBcOt0,2810
-kodit/config.py,sha256=YYo36lBi3auCssyCVrpw3Z3ZXSzXKTDo45nIsUjkzfs,10305
-kodit/database.py,sha256=kI9yBm4uunsgV4-QeVoCBL0wLzU4kYmYv5qZilGnbPE,1740
-kodit/log.py,sha256=XyuseZk90gUBj1B7np2UO2EW9eE_ApayIpPRvI19KCE,8651
-kodit/mcp.py,sha256=aEcPc8dQiZaR0AswCZZNxcm_rhhUZNsEBimYti0ibSI,7221
+kodit/config.py,sha256=wKXUb06j7VbpD7ydCARd6_DNeAY5tLeJqHvhWozFhyI,11052
+kodit/database.py,sha256=k93byjVUX1VjAb0hLZxUo4liEKKxAWUBJNw2e7rzaiI,1771
+kodit/log.py,sha256=ZpM0eMo_DVGQqrHxg0VV6dMrN2AAmu_3C0I3G7p2nMw,8828
+kodit/mcp.py,sha256=GWh9krkcP37wh8ZmvfXaGJPknhaautBxzvbMMr5FRdg,7555
 kodit/middleware.py,sha256=TiwebNpaEmiP7QRuZrfZcCL51IUefQyNLSPuzVyk8UM,2813
-kodit/reporting.py,sha256=icce1ZyiADsA_Qz-mSjgn2H4SSqKuGfLKnw-yrl9nsg,2722
 kodit/application/__init__.py,sha256=mH50wTpgP9dhbKztFsL8Dda9Hi18TSnMVxXtpp4aGOA,35
 kodit/application/factories/__init__.py,sha256=bU5CvEnaBePZ7JbkCOp1MGTNP752bnU2uEqmfy5FdRk,37
-kodit/application/factories/code_indexing_factory.py,sha256=R9f0wsj4-3NJFS5SEt_-OIGR_s_01gJXaL3PkZd8MlU,5911
+kodit/application/factories/code_indexing_factory.py,sha256=4c5LS2t7FOHiNS_Xb5sPRngf3we-VbTWKa-NcjZmf0Q,7300
+kodit/application/factories/reporting_factory.py,sha256=Plf3c1KIx36eM5YefU5svPr9QeaNcKFH5UlmDuET8R0,1013
 kodit/application/services/__init__.py,sha256=p5UQNw-H5sxQvs5Etfte93B3cJ1kKW6DNxK34uFvU1E,38
-kodit/application/services/auto_indexing_service.py,sha256=O5BNR5HypgghzUFG4ykIWMl9mxHCUExnBmJuITIhECk,3457
-kodit/application/services/code_indexing_application_service.py,sha256=nrnd_Md-D0AfNKku7Aqt3YHDbXsBV9f44Z6XsjhiF3E,15877
-kodit/application/services/indexing_worker_service.py,sha256=Un4PytnWJU4uwROcxOMUFkt4cD7nmPezaBLsEHrMN6U,5185
-kodit/application/services/queue_service.py,sha256=GaixRoCUaDhLYfwZLVED8C3w_NPiy_QbuVp_jhwP4GI,1727
-kodit/application/services/sync_scheduler.py,sha256=aLpEczZdTM8ubfAEY0Ajdh3MLfDcB9s-0ILZJrtIuZs,3504
+kodit/application/services/auto_indexing_service.py,sha256=rJPWiV755eskFNKjYliPr1WMFylXlG8BWPpFcwwOhm0,3973
+kodit/application/services/code_indexing_application_service.py,sha256=tLbbo-fyAc3iZoCOJU9lIfhNI_6Lz9SqQdfjeN5m8yA,16213
+kodit/application/services/indexing_worker_service.py,sha256=B8MdXrzjaYVS7zVTTz8cXUQItkGb8Fk1aXeim2dfCJw,5311
+kodit/application/services/queue_service.py,sha256=G42lR31maFRZ9cSvnWZrzeyb4P1R6yFqrcHWVKAqc9U,1924
+kodit/application/services/reporting.py,sha256=hDisTU_XUBTfiOtnJ5-6x0jj8rHSlq9zZgeNnBT7W5Y,2834
+kodit/application/services/sync_scheduler.py,sha256=FUUpDtxUh7Eg-lnzOrUHzmSWGpzdpYJQYgPhnQYwTcg,3446
 kodit/domain/__init__.py,sha256=TCpg4Xx-oF4mKV91lo4iXqMEfBT1OoRSYnbG-zVWolA,66
 kodit/domain/entities.py,sha256=QsCzKXT7gF9jTPAjJo5lqjFGRsIklAFC2qRy_Gt3RbA,10377
 kodit/domain/errors.py,sha256=yIsgCjM_yOFIg8l7l-t7jM8pgeAX4cfPq0owf7iz3DA,106
-kodit/domain/interfaces.py,sha256=Jkd0Ob4qSvhZHI9jRPFQ1n5Cv0SvU-y3Z-HCw2ikc4I,742
-kodit/domain/protocols.py,sha256=GA0CCvmhvQ3F4MseeQUVw3NeIgUoaV7V_7TdAaU70Is,2587
-kodit/domain/value_objects.py,sha256=dkfbg99PSCrfj6nJ7tZ2UzDG3QUgNa_Cpj2gLakDM5k,17512
+kodit/domain/protocols.py,sha256=RGNOlHyvNq6Nx_95ETTO9DkzeZmjtubfC7qdGvA5iPk,2753
+kodit/domain/value_objects.py,sha256=uIpAdIvq6VefEGa8yq5Uqyuyit72SHtDptnoOUd73u0,18882
 kodit/domain/services/__init__.py,sha256=Q1GhCK_PqKHYwYE4tkwDz5BIyXkJngLBBOHhzvX8nzo,42
-kodit/domain/services/bm25_service.py,sha256=nsfTan3XtDwXuuAu1LUv-6Jukm6qFKVqqCVymjyepZQ,3625
+kodit/domain/services/bm25_service.py,sha256=seRo0V-zW6Uq-Y67j0-zp1xz93gbfQgvlEbpQeYHN1U,3529
 kodit/domain/services/embedding_service.py,sha256=7drYRC2kjg0WJmo06a2E9N0vDnwInUlBB96twjz2BT8,4526
 kodit/domain/services/enrichment_service.py,sha256=XsXg3nV-KN4rqtC7Zro_ZiZ6RSq-1eA1MG6IDzFGyBA,1316
 kodit/domain/services/index_query_service.py,sha256=cDQkgpJ3JbyeZ3z3GTIqH1JzhhKE_LBIwYE6b-lakwU,2172
-kodit/domain/services/index_service.py,sha256=uVwDUEQWfZ5yJRvcjaWW7P9gCZttmnlkI51IHz52eew,11554
+kodit/domain/services/index_service.py,sha256=TSvM-UuOtq30hz6eNPgu9AEVFrLDugdYoBgBf1xZDcI,10377
 kodit/infrastructure/__init__.py,sha256=HzEYIjoXnkz_i_MHO2e0sIVYweUcRnl2RpyBiTbMObU,28
 kodit/infrastructure/api/__init__.py,sha256=U0TSMPpHrlj1zbAtleuZjU3nXGwudyMe-veNBgvODwM,34
 kodit/infrastructure/api/client/__init__.py,sha256=6RSYqeuxjDe_zTUq48D0F-VfBBUvDmTkO3K3vD61q3I,349
@@ -41,14 +41,16 @@ kodit/infrastructure/api/client/index_client.py,sha256=OxsakDQBEulwmqZVzwOSSI0Lk
 kodit/infrastructure/api/client/search_client.py,sha256=f4mM5ZJpAuR7w-i9yASbh4SYMxOq7_f4hXgaQesGquI,2614
 kodit/infrastructure/api/middleware/__init__.py,sha256=6m7eE5k5buboJbuzyX5E9-Tf99yNwFaeJF0f_6HwLyM,30
 kodit/infrastructure/api/middleware/auth.py,sha256=QSnMcMLWvfumqN1iG4ePj2vEZb2Dlsgr-WHptkEkkhE,1064
-kodit/infrastructure/api/v1/__init__.py,sha256=XYv4_9Z6fo69oMvC2mEbtD6DaMqHth29KHUOelmQFwM,121
-kodit/infrastructure/api/v1/dependencies.py,sha256=jaM000IfSnvU8uzwnC1cBZsfsMC-19jWFjObHfqBYuM,2475
-kodit/infrastructure/api/v1/routers/__init__.py,sha256=L8hT_SkDzmCXIiWrFQWCkZXQ3UDy_ZMxPr8AIhjSWK0,160
+kodit/infrastructure/api/v1/__init__.py,sha256=hQ03es21FSgzQlmdP5xWZzK80woIvuYGjiZLwFYuYwk,151
+kodit/infrastructure/api/v1/dependencies.py,sha256=MBmCpTtwDAtdsLjJ06Bzod3Vwqon8mMASknZobdoaMU,2919
+kodit/infrastructure/api/v1/routers/__init__.py,sha256=YYyeiuyphIPc-Q_2totF8zfR0BoseOH4ZYFdHP0ed_M,218
 kodit/infrastructure/api/v1/routers/indexes.py,sha256=_lUir1M0SW6kPHeGqjiPjtSa50rY4PN2es5TZEpSHYE,3442
+kodit/infrastructure/api/v1/routers/queue.py,sha256=EZbR-G0qDO9W5ajV_75GRk2pW1Qdgc0ggOwrGKlBE2A,2138
 kodit/infrastructure/api/v1/routers/search.py,sha256=da9YTR6VTzU85_6X3aaZemdTHGCEvcPNeKuMFBgmT_A,2452
 kodit/infrastructure/api/v1/schemas/__init__.py,sha256=_5BVqv4EUi_vvWlAQOE_VfRulUDAF21ZQ7z27y7YOdw,498
 kodit/infrastructure/api/v1/schemas/context.py,sha256=NlsIn9j1R3se7JkGZivS_CUN4gGP5NYaAtkRe3QH6dk,214
 kodit/infrastructure/api/v1/schemas/index.py,sha256=NtL09YtO50h-ddpAFxNf-dyxu_Xi5v3yOpKW0W4xsAM,1950
+kodit/infrastructure/api/v1/schemas/queue.py,sha256=oa4wumWOvGzi53Q3cjwIrQJRoentp5nsQSsaj-l-B4U,652
 kodit/infrastructure/api/v1/schemas/search.py,sha256=CWzg5SIMUJ_4yM-ZfgSLWCanMxov6AyGgQQcOMkRlGw,5618
 kodit/infrastructure/bm25/__init__.py,sha256=DmGbrEO34FOJy4e685BbyxLA7gPW1eqs2gAxsp6JOuM,34
 kodit/infrastructure/bm25/bm25_factory.py,sha256=I4eo7qRslnyXIRkBf-StZ5ga2Evrr5J5YFocTChFD3g,884
@@ -57,42 +59,43 @@ kodit/infrastructure/bm25/vectorchord_bm25_repository.py,sha256=p6ht5K-jlDTvEkmo
 kodit/infrastructure/cloning/__init__.py,sha256=IzIvX-yeRRFZ-lfvPVSEe_qXszO6DGQdjKwwDigexyQ,30
 kodit/infrastructure/cloning/metadata.py,sha256=GD2UnCC1oR82RD0SVUqk9CJOqzXPxhOAHVOp7jqN6Qc,3571
 kodit/infrastructure/cloning/git/__init__.py,sha256=20ePcp0qE6BuLsjsv4KYB1DzKhMIMsPXwEqIEZtjTJs,34
-kodit/infrastructure/cloning/git/working_copy.py,sha256=qYcrR5qP1rhWZiYGMT1p-1Alavi_YvQLXx4MgIV7eXs,2611
+kodit/infrastructure/cloning/git/working_copy.py,sha256=Lt_NWSoQ1pZAi0u_MKUhrwGeul4XWf3zqCuzG3dn70s,3608
 kodit/infrastructure/embedding/__init__.py,sha256=F-8nLlWAerYJ0MOIA4tbXHLan8bW5rRR84vzxx6tRKI,39
-kodit/infrastructure/embedding/embedding_factory.py,sha256=8LC2jKf2vx-P-TCh8ZanxwF3hT5PSjWA3vuSR6ggcXk,3731
+kodit/infrastructure/embedding/embedding_factory.py,sha256=BNhrrYQAkcnXkuuQy-Q-lwJhyoGONsTsbgN4t0UdGeY,3395
 kodit/infrastructure/embedding/local_vector_search_repository.py,sha256=ExweyNEL5cP-g3eDhGqZSih7zhdOrop2WdFPPJL-tB4,3505
 kodit/infrastructure/embedding/vectorchord_vector_search_repository.py,sha256=PIoU0HsDlaoXDXnGjOR0LAkAcW4JiE3ymJy_SBhEopc,8030
 kodit/infrastructure/embedding/embedding_providers/__init__.py,sha256=qeZ-oAIAxMl5QqebGtO1lq-tHjl_ucAwOXePklcwwGk,34
 kodit/infrastructure/embedding/embedding_providers/batching.py,sha256=a8CL9PX2VLmbeg616fc_lQzfC4BWTVn32m4SEhXpHxc,3279
 kodit/infrastructure/embedding/embedding_providers/hash_embedding_provider.py,sha256=V6OdCuWyQQOvo3OJGRi-gBKDApIcrELydFg7T696P5s,2257
+kodit/infrastructure/embedding/embedding_providers/litellm_embedding_provider.py,sha256=9Q5he_MI8xXENODwCvYCbhVawTjTv1bArGQrmxoWLas,5297
 kodit/infrastructure/embedding/embedding_providers/local_embedding_provider.py,sha256=9aLV1Zg4KMhYWlGRwgAUtswW4aIabNqbsipWhAn64RI,4133
-kodit/infrastructure/embedding/embedding_providers/openai_embedding_provider.py,sha256=CE86s8IicieUjIDWn2xzswteHXCzmw1Qz6Kp4GBIcus,6316
 kodit/infrastructure/enrichment/__init__.py,sha256=8acZKNzql8Fs0lceFu9U3KoUrOptRBtVIxr_Iw6lz3Y,40
-kodit/infrastructure/enrichment/enrichment_factory.py,sha256=jZWGgAvFjEuRUc1oW3iGhgipvX-EnVJZpw6ybzp9NGM,2016
+kodit/infrastructure/enrichment/enrichment_factory.py,sha256=NFGY6u9SJ_GOgiB_RtotbQmte0kGFQUymwzZCbbsx34,1530
+kodit/infrastructure/enrichment/litellm_enrichment_provider.py,sha256=AM4-4KApDndzWzQzzKAedy21iGMhkwylR5VCmV9K-uI,6040
 kodit/infrastructure/enrichment/local_enrichment_provider.py,sha256=aVU3_kbLJ0BihwGIwvJ00DBe0voHkiKdFSjPxxkVfVA,4150
 kodit/infrastructure/enrichment/null_enrichment_provider.py,sha256=DhZkJBnkvXg_XSAs-oKiFnKqYFPnmTl3ikdxrqeEfbc,713
-kodit/infrastructure/enrichment/openai_enrichment_provider.py,sha256=C0y0NEPu1GpFr22TGi1voxYGsYTV0ZITYuDzvRJ5vW4,5573
 kodit/infrastructure/enrichment/utils.py,sha256=FE9UCuxxzSdoHrmAC8Si2b5D6Nf6kVqgM1yjUVyCvW0,930
 kodit/infrastructure/git/__init__.py,sha256=0iMosFzudj4_xNIMe2SRbV6l5bWqkjnUsZoFsoZFuM8,33
-kodit/infrastructure/git/git_utils.py,sha256=KERwmhWDR4ooMQKS-nSPxjvdCzoWF9NS6nhdeXyzdtY,571
+kodit/infrastructure/git/git_utils.py,sha256=5lH94AcF7Hac4h6kBzo_B9pzC1S6AK2-Dy13gz--Zf0,781
 kodit/infrastructure/ignore/__init__.py,sha256=VzFv8XOzHmsu0MEGnWVSF6KsgqLBmvHlRqAkT1Xb1MY,36
 kodit/infrastructure/ignore/ignore_pattern_provider.py,sha256=zdxun3GodLfXxyssBK8QDUK58xb4fBJ0SKcHUyn3pzM,2131
 kodit/infrastructure/indexing/__init__.py,sha256=7UPRa2jwCAsa0Orsp6PqXSF8iIXJVzXHMFmrKkI9yH8,38
 kodit/infrastructure/indexing/fusion_service.py,sha256=2B0guBsuKz19uWcs18sIJpUJPzXoRvULgl7UNWQGysA,1809
 kodit/infrastructure/mappers/__init__.py,sha256=QPHOjNreXmBPPovZ6elnYFS0vD-IsmrGl4TT01FCKro,77
-kodit/infrastructure/mappers/index_mapper.py,sha256=ZSfu8kjTaa8_UY0nTqr4b02NS3VrjqZYkduCN71AL2g,12743
+kodit/infrastructure/mappers/index_mapper.py,sha256=XWtv_him2Sd9dR-Jy_ndy9jYXVtv3LttzmmUGzNK6CE,12825
 kodit/infrastructure/mappers/task_mapper.py,sha256=QW7uL8rji6QJ7RRdHwbvkWqmwDcUDGTYPLwbwiKlViY,2919
+kodit/infrastructure/reporting/__init__.py,sha256=4Qu38YbDOaeDqLdT_CbK8tOZHTKGrHRXncVKlGRzOeQ,32
+kodit/infrastructure/reporting/log_progress.py,sha256=sNF0oeg56NaTfO3DVg1AXQWwgrHSTaZrOWqPDq-FhVE,2180
+kodit/infrastructure/reporting/tdqm_progress.py,sha256=g01P7PItQqqSXzM5jjXL6uOUIKJQ6O9zaO1WZZ7XKSM,2512
 kodit/infrastructure/slicing/__init__.py,sha256=x7cjvHA9Ay2weUYE_dpdAaPaStp20M-4U2b5MLgT5KM,37
 kodit/infrastructure/slicing/language_detection_service.py,sha256=JGJXrq9bLyfnisWJXeP7y1jbZMmKAISdPBlRBCosUcE,684
 kodit/infrastructure/slicing/slicer.py,sha256=GOqJykd00waOTO1WJHyE5KUgJ2RLx2rOQ7M7T_u5LLg,35600
 kodit/infrastructure/sqlalchemy/__init__.py,sha256=UXPMSF_hgWaqr86cawRVqM8XdVNumQyyK5B8B97GnlA,33
-kodit/infrastructure/sqlalchemy/embedding_repository.py,sha256=dC2Wzj_zQiWExwfScE1LAGiiyxPyg0YepwyLOgDwcs4,7905
-kodit/infrastructure/sqlalchemy/entities.py,sha256=2iG_2NoKS26rJXimLFL8whRqFsUvKNGFAXCkQYK5GtE,6951
-kodit/infrastructure/sqlalchemy/index_repository.py,sha256=QQNsyLBI09YLUPLguB9qvqPZMxtg1p2twpm7sO_gNlo,23598
-kodit/infrastructure/sqlalchemy/task_repository.py,sha256=yazMO6Kw0Pb2b3L8wlGKOFA0QuMFcWBUXYFGZdtZo0w,2874
-kodit/infrastructure/ui/__init__.py,sha256=CzbLOBwIZ6B6iAHEd1L8cIBydCj-n_kobxJAhz2I9_Y,32
-kodit/infrastructure/ui/progress.py,sha256=SHEUoQA_x36z4nqHrQduVrrWIvFfX6QxAawC7zQ50pw,6433
-kodit/infrastructure/ui/spinner.py,sha256=GcP115qtR0VEnGfMEtsGoAUpRzVGUSfiUXfoJJERngA,2357
+kodit/infrastructure/sqlalchemy/embedding_repository.py,sha256=YYxbUEdzDdlKdy0FyAP4EzhJMAIdEnNZiXT6hzPHk9I,7731
+kodit/infrastructure/sqlalchemy/entities.py,sha256=P3BitWqnTxMVXmyez7OX-SB3-UG66XorqvPMjXspwoM,7894
+kodit/infrastructure/sqlalchemy/index_repository.py,sha256=x8MPl0j7GrW_lEZh464EZyb0w935p_EHv2NIMNxjJu0,25680
+kodit/infrastructure/sqlalchemy/task_repository.py,sha256=60ECbxiXC2_UR80f4uPSmJiP_so7PTBzZG_w1WXSiuE,3546
+kodit/infrastructure/sqlalchemy/unit_of_work.py,sha256=gK-C8yk2HYBrAEDrblWxBrldrGb83SBHn-8lURkFeMg,2093
 kodit/migrations/README,sha256=ISVtAOvqvKk_5ThM5ioJE-lMkvf9IbknFUFVU_vPma4,58
 kodit/migrations/__init__.py,sha256=lP5MuwlyWRMO6UcDWnQcQ3G-GYHcFb6rl9gYPHJ1sjo,40
 kodit/migrations/env.py,sha256=m57TkFLYjQ4w2aw1YICXkeek27M6qjwRDMHvThWqIL0,2383
@@ -109,8 +112,8 @@ kodit/utils/__init__.py,sha256=DPEB1i8evnLF4Ns3huuAYg-0pKBFKUFuiDzOKG9r-sw,33
 kodit/utils/dump_openapi.py,sha256=29VdjHpNSaGAg7RjQw0meq1OLhljCx1ElgBlTC8xoF4,1247
 kodit/utils/generate_api_paths.py,sha256=TMtx9v55podDfUmiWaHgJHLtEWLV2sLL-5ejGFMPzAo,3569
 kodit/utils/path_utils.py,sha256=thK6YGGNvQThdBaCYCCeCvS1L8x-lwl3AoGht2jnjGw,1645
-kodit-0.4.0.dist-info/METADATA,sha256=bwViEYL092ciMPsday_wvQgIEheDQ1frFv26RxsTxcI,7671
-kodit-0.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-kodit-0.4.0.dist-info/entry_points.txt,sha256=hoTn-1aKyTItjnY91fnO-rV5uaWQLQ-Vi7V5et2IbHY,40
-kodit-0.4.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-kodit-0.4.0.dist-info/RECORD,,
+kodit-0.4.2.dist-info/METADATA,sha256=bC5eza2ORs3v3w5-bwW1uybuk8b4JdNI13GZQvrP4ps,7702
+kodit-0.4.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+kodit-0.4.2.dist-info/entry_points.txt,sha256=hoTn-1aKyTItjnY91fnO-rV5uaWQLQ-Vi7V5et2IbHY,40
+kodit-0.4.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+kodit-0.4.2.dist-info/RECORD,,

kodit/domain/interfaces.py

@@ -1,27 +0,0 @@
-"""Domain interfaces."""
-
-from abc import ABC, abstractmethod
-
-from kodit.domain.value_objects import ProgressEvent
-
-
-class ProgressCallback(ABC):
-    """Abstract interface for progress callbacks."""
-
-    @abstractmethod
-    async def on_progress(self, event: ProgressEvent) -> None:
-        """On progress hook."""
-
-    @abstractmethod
-    async def on_complete(self, operation: str) -> None:
-        """On complete hook."""
-
-
-class NullProgressCallback(ProgressCallback):
-    """Null implementation of progress callback that does nothing."""
-
-    async def on_progress(self, event: ProgressEvent) -> None:
-        """Do nothing on progress."""
-
-    async def on_complete(self, operation: str) -> None:
-        """Do nothing on complete."""

kodit/infrastructure/embedding/embedding_providers/openai_embedding_provider.py

@@ -1,183 +0,0 @@
-"""OpenAI embedding provider implementation using httpx."""
-
-import asyncio
-from collections.abc import AsyncGenerator
-from typing import Any
-
-import httpx
-import structlog
-import tiktoken
-from tiktoken import Encoding
-
-from kodit.domain.services.embedding_service import EmbeddingProvider
-from kodit.domain.value_objects import EmbeddingRequest, EmbeddingResponse
-
-from .batching import split_sub_batches
-
-# Constants
-MAX_TOKENS = 8192  # Conservative token limit for the embedding model
-BATCH_SIZE = (
-    10  # Maximum number of items per API call (keeps existing test expectations)
-)
-OPENAI_NUM_PARALLEL_TASKS = 10  # Semaphore limit for concurrent OpenAI requests
-
-
-class OpenAIEmbeddingProvider(EmbeddingProvider):
-    """OpenAI embedding provider that uses OpenAI's embedding API via httpx."""
-
-    def __init__(  # noqa: PLR0913
-        self,
-        api_key: str | None = None,
-        base_url: str = "https://api.openai.com",
-        model_name: str = "text-embedding-3-small",
-        num_parallel_tasks: int = OPENAI_NUM_PARALLEL_TASKS,
-        socket_path: str | None = None,
-        timeout: float = 30.0,
-    ) -> None:
-        """Initialize the OpenAI embedding provider.
-
-        Args:
-            api_key: The OpenAI API key.
-            base_url: The base URL for the OpenAI API.
-            model_name: The model name to use for embeddings.
-            num_parallel_tasks: Maximum number of concurrent requests.
-            socket_path: Optional Unix socket path for local communication.
-            timeout: Request timeout in seconds.
-
-        """
-        self.model_name = model_name
-        self.num_parallel_tasks = num_parallel_tasks
-        self.log = structlog.get_logger(__name__)
-        self.api_key = api_key
-        self.base_url = base_url
-        self.socket_path = socket_path
-        self.timeout = timeout
-
-        # Lazily initialised token encoding
-        self._encoding: Encoding | None = None
-
-        # Create httpx client with optional Unix socket support
-        if socket_path:
-            transport = httpx.AsyncHTTPTransport(uds=socket_path)
-            self.http_client = httpx.AsyncClient(
-                transport=transport,
-                base_url="http://localhost",  # Base URL for Unix socket
-                timeout=timeout,
-            )
-        else:
-            self.http_client = httpx.AsyncClient(
-                base_url=base_url,
-                timeout=timeout,
-            )
-
-    # ---------------------------------------------------------------------
-    # Helper utilities
-    # ---------------------------------------------------------------------
-
-    def _get_encoding(self) -> "Encoding":
-        """Return (and cache) the tiktoken encoding for the chosen model."""
-        if self._encoding is None:
-            try:
-                self._encoding = tiktoken.encoding_for_model(self.model_name)
-            except KeyError:
-                # If the model is not supported by tiktoken, use a default encoding
-                self.log.info(
-                    "Model not supported by tiktoken, using default encoding",
-                    model_name=self.model_name,
-                    default_encoding="o200k_base",
-                )
-                self._encoding = tiktoken.get_encoding("o200k_base")
-
-        return self._encoding
-
-    def _split_sub_batches(
-        self, encoding: "Encoding", data: list[EmbeddingRequest]
-    ) -> list[list[EmbeddingRequest]]:
-        """Proxy to the shared batching utility (kept for backward-compat)."""
-        return split_sub_batches(
-            encoding,
-            data,
-            max_tokens=MAX_TOKENS,
-            batch_size=BATCH_SIZE,
-        )
-
-    async def _call_embeddings_api(
-        self, texts: list[str]
-    ) -> dict[str, Any]:
-        """Call the embeddings API using httpx.
-
-        Args:
-            texts: The texts to embed.
-
-        Returns:
-            The API response as a dictionary.
-
-        """
-        headers = {
-            "Content-Type": "application/json",
-        }
-        if self.api_key:
-            headers["Authorization"] = f"Bearer {self.api_key}"
-
-        data = {
-            "model": self.model_name,
-            "input": texts,
-        }
-
-        response = await self.http_client.post(
-            "/v1/embeddings",
-            json=data,
-            headers=headers,
-        )
-        response.raise_for_status()
-        return response.json()
-
-    async def embed(
-        self, data: list[EmbeddingRequest]
-    ) -> AsyncGenerator[list[EmbeddingResponse], None]:
-        """Embed a list of strings using OpenAI's API."""
-        if not data:
-            yield []
-
-        encoding = self._get_encoding()
-
-        # First, split by token limits (and max batch size)
-        batched_data = self._split_sub_batches(encoding, data)
-
-        # -----------------------------------------------------------------
-        # Process batches concurrently (but bounded by a semaphore)
-        # -----------------------------------------------------------------
-
-        sem = asyncio.Semaphore(self.num_parallel_tasks)
-
-        async def _process_batch(
-            batch: list[EmbeddingRequest],
-        ) -> list[EmbeddingResponse]:
-            async with sem:
-                try:
-                    response = await self._call_embeddings_api(
-                        [item.text for item in batch]
-                    )
-                    embeddings_data = response.get("data", [])
-
-                    return [
-                        EmbeddingResponse(
-                            snippet_id=item.snippet_id,
-                            embedding=emb_data.get("embedding", []),
-                        )
-                        for item, emb_data in zip(batch, embeddings_data, strict=True)
-                    ]
-                except Exception as e:
-                    self.log.exception("Error embedding batch", error=str(e))
-                    # Return no embeddings for this batch if there was an error
-                    return []
-
-        tasks = [_process_batch(batch) for batch in batched_data]
-        for task in asyncio.as_completed(tasks):
-            yield await task
-
-    async def close(self) -> None:
-        """Close the HTTP client."""
-        if hasattr(self, "http_client"):
-            await self.http_client.aclose()
-