kodit 0.4.1__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/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.1.dist-info → kodit-0.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kodit
-Version: 0.4.1
+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/

{kodit-0.4.1.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=k7cu0JKra64gmMNU_UfA5sw2eNc_GRvf3QmesiYAy8g,704
-kodit/app.py,sha256=FKqHbJNoHpnBb5KLJaUINDm0a5cHpxlrQ5qNoWnHsBc,4326
-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=EOyB3BfSDfGJeOts2vrOyX8lhGXbAHVUl69kzjqGHXE,10326
-kodit/database.py,sha256=kI9yBm4uunsgV4-QeVoCBL0wLzU4kYmYv5qZilGnbPE,1740
+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=aEcPc8dQiZaR0AswCZZNxcm_rhhUZNsEBimYti0ibSI,7221
+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=vf_TEl76B0F0RSvfCeGDuM-QFzW-VUuj3zQaRmDPEYI,1921
-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
@@ -42,7 +42,7 @@ kodit/infrastructure/api/client/search_client.py,sha256=f4mM5ZJpAuR7w-i9yASbh4SY
 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=hQ03es21FSgzQlmdP5xWZzK80woIvuYGjiZLwFYuYwk,151
-kodit/infrastructure/api/v1/dependencies.py,sha256=jaM000IfSnvU8uzwnC1cBZsfsMC-19jWFjObHfqBYuM,2475
+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
@@ -59,15 +59,15 @@ 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=wngBD2g6NniHDq_-KcYhhwSvmcMYyI8yIzoXvGQvu1U,3287
+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=5LCrPSQn3ZaLZ1XTKzJV_LzANH7FdaR4NL-gJupaiDE,5579
+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/enrichment/__init__.py,sha256=8acZKNzql8Fs0lceFu9U3KoUrOptRBtVIxr_Iw6lz3Y,40
 kodit/infrastructure/enrichment/enrichment_factory.py,sha256=NFGY6u9SJ_GOgiB_RtotbQmte0kGFQUymwzZCbbsx34,1530
@@ -76,25 +76,26 @@ kodit/infrastructure/enrichment/local_enrichment_provider.py,sha256=aVU3_kbLJ0Bi
 kodit/infrastructure/enrichment/null_enrichment_provider.py,sha256=DhZkJBnkvXg_XSAs-oKiFnKqYFPnmTl3ikdxrqeEfbc,713
 kodit/infrastructure/enrichment/utils.py,sha256=FE9UCuxxzSdoHrmAC8Si2b5D6Nf6kVqgM1yjUVyCvW0,930
 kodit/infrastructure/git/__init__.py,sha256=0iMosFzudj4_xNIMe2SRbV6l5bWqkjnUsZoFsoZFuM8,33
-kodit/infrastructure/git/git_utils.py,sha256=3Fg2ZX9pkp8Mk1mWuW30PSO_ZKXrPL7wTCS9TMTfIUM,765
+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
@@ -111,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.1.dist-info/METADATA,sha256=Mf4UuPg2D08hfp1STtsZ1DwOHA2a1J4ba5_-T7Pifr4,7702
-kodit-0.4.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-kodit-0.4.1.dist-info/entry_points.txt,sha256=hoTn-1aKyTItjnY91fnO-rV5uaWQLQ-Vi7V5et2IbHY,40
-kodit-0.4.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-kodit-0.4.1.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/ui/__init__.py

@@ -1 +0,0 @@
-"""UI infrastructure module."""

kodit/infrastructure/ui/progress.py

@@ -1,170 +0,0 @@
-"""Progress UI implementations."""
-
-from collections.abc import Callable
-
-import structlog
-from tqdm import tqdm  # type: ignore[import-untyped]
-
-from kodit.domain.interfaces import ProgressCallback
-from kodit.domain.value_objects import ProgressEvent
-
-
-class TQDMProgressCallback(ProgressCallback):
-    """TQDM-based progress callback implementation."""
-
-    def __init__(self, pbar: "tqdm") -> None:
-        """Initialize with a TQDM progress bar."""
-        self.pbar = pbar
-
-    async def on_progress(self, event: ProgressEvent) -> None:
-        """Update the TQDM progress bar."""
-        # Update total if it changes
-        if event.total != self.pbar.total:
-            self.pbar.total = event.total
-
-        # Update the progress bar
-        self.pbar.n = event.current
-        self.pbar.refresh()
-
-        # Update description if message is provided
-        if event.message:
-            # Fix the event message to a specific size so it's not jumping around
-            # If it's too small, add spaces
-            # If it's too large, truncate
-            if len(event.message) < 30:
-                self.pbar.set_description(
-                    event.message + " " * (30 - len(event.message))
-                )
-            else:
-                self.pbar.set_description(event.message[-30:])
-
-    async def on_complete(self, operation: str) -> None:
-        """Complete the progress bar."""
-        # TQDM will handle cleanup with leave=False
-
-
-class LogProgressCallback(ProgressCallback):
-    """Log-based progress callback for server environments."""
-
-    def __init__(self, milestone_interval: int = 10) -> None:
-        """Initialize with milestone logging interval.
-
-        Args:
-            milestone_interval: Percentage interval for logging (default: 10%)
-
-        """
-        self.milestone_interval = milestone_interval
-        self._last_logged_percentage = -1
-        self.log = structlog.get_logger()
-
-    async def on_progress(self, event: ProgressEvent) -> None:
-        """Log progress at milestone intervals."""
-        percentage = int(event.percentage)
-
-        # Log at milestone intervals (0%, 10%, 20%, etc.)
-        milestone = (percentage // self.milestone_interval) * self.milestone_interval
-
-        if milestone > self._last_logged_percentage and milestone <= percentage:
-            self.log.info(
-                "Progress milestone reached",
-                operation=event.operation,
-                percentage=milestone,
-                current=event.current,
-                total=event.total,
-                message=event.message,
-            )
-            self._last_logged_percentage = milestone
-
-    async def on_complete(self, operation: str) -> None:
-        """Log completion of the operation."""
-        self.log.info("Operation completed", operation=operation)
-
-
-class LazyProgressCallback(ProgressCallback):
-    """Progress callback that only shows progress when there's actual work to do."""
-
-    def __init__(self, create_pbar_func: Callable[[], tqdm]) -> None:
-        """Initialize with a function that creates a progress bar."""
-        self.create_pbar_func = create_pbar_func
-        self._callback: ProgressCallback | None = None
-        self._has_work = False
-
-    async def on_progress(self, event: ProgressEvent) -> None:
-        """Update progress, creating the actual callback if needed."""
-        if not self._has_work:
-            self._has_work = True
-            # Only create the progress bar when we actually have work to do
-            pbar = self.create_pbar_func()
-            self._callback = TQDMProgressCallback(pbar)
-
-        if self._callback:
-            await self._callback.on_progress(event)
-
-    async def on_complete(self, operation: str) -> None:
-        """Complete the progress operation."""
-        if self._callback:
-            await self._callback.on_complete(operation)
-
-
-class MultiStageProgressCallback(ProgressCallback):
-    """Progress callback that handles multiple stages with separate progress bars."""
-
-    def __init__(self, create_pbar_func: Callable[[str], tqdm]) -> None:
-        """Initialize with a function that creates progress bars."""
-        self.create_pbar_func = create_pbar_func
-        self._current_callback: ProgressCallback | None = None
-        self._current_operation: str | None = None
-
-    async def on_progress(self, event: ProgressEvent) -> None:
-        """Update progress for the current operation."""
-        # If this is a new operation, create a new progress bar
-        if self._current_operation != event.operation:
-            # Create a new progress bar for this operation
-            pbar = self.create_pbar_func(event.operation)
-            self._current_callback = TQDMProgressCallback(pbar)
-            self._current_operation = event.operation
-
-        # Update the current progress bar
-        if self._current_callback:
-            await self._current_callback.on_progress(event)
-
-    async def on_complete(self, operation: str) -> None:
-        """Complete the current operation."""
-        if self._current_callback and self._current_operation == operation:
-            await self._current_callback.on_complete(operation)
-            self._current_callback = None
-            self._current_operation = None
-
-
-def create_progress_bar(desc: str = "Processing", unit: str = "items") -> "tqdm":
-    """Create a progress bar with the given description and unit."""
-    from tqdm import tqdm
-
-    return tqdm(
-        desc=desc,
-        unit=unit,
-        leave=False,
-        dynamic_ncols=True,
-        total=None,  # Will be set dynamically
-        position=0,  # Position at top
-        mininterval=0.1,  # Update at most every 0.1 seconds
-    )
-
-
-def create_lazy_progress_callback() -> LazyProgressCallback:
-    """Create a lazy progress callback that only shows progress when needed."""
-    return LazyProgressCallback(
-        lambda: create_progress_bar("Processing files", "files")
-    )
-
-
-def create_multi_stage_progress_callback() -> MultiStageProgressCallback:
-    """Create a multi-stage progress callback for indexing operations."""
-    return MultiStageProgressCallback(
-        lambda operation: create_progress_bar(operation, "items")
-    )
-
-
-def create_log_progress_callback(milestone_interval: int = 10) -> LogProgressCallback:
-    """Create a log-based progress callback for server environments."""
-    return LogProgressCallback(milestone_interval=milestone_interval)